Gandalf/sofarr
1
0
Fork 0
Code Issues 1 Pull Requests Actions 1 Packages Projects Releases 17 Wiki Activity

feat: add rtorrent client via PDCA
Some checks failed
Build and Push Docker Image / build (push) Failing after 40s
Details
CI / Security audit (push) Failing after 27s
Details
CI / Tests & coverage (push) Failing after 35s
Details
Docs Check / Markdown lint (push) Successful in 32s
Details
Docs Check / Mermaid diagram parse check (push) Successful in 1m12s
Details
Licence Check / Licence compatibility and copyright header verification (push) Failing after 24s
Details

Browse Source 
- Implement RTorrentClient extending DownloadClient abstract class
- Use xmlrpc package (v1.3.2) for XML-RPC communication
- Support HTTP Basic Auth when credentials are configured
- Map rTorrent states (d.state, d.is_active, d.is_hash_checking) to normalized statuses
- Calculate ETA from download speed and remaining bytes
- Add getRtorrentInstances() to config.js
- Register RTorrentClient in downloadClients.js registry
- Add 8 comprehensive unit tests covering all functionality
- Update .env.sample with rtorrent configuration examples
- Update ARCHITECTURE.md with rtorrent client details
- Update ADDING-A-DOWNLOAD-CLIENT.md with rtorrent-specific notes
This commit is contained in:
Gronod
2026-05-19 11:40:31 +01:00
parent f095e6a2d1
commit a50e5a7d69
8 changed files with 659 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

420
tests/unit/clients/RTorrentClient.test.js Normal file
View File

@@ -0,0 +1,420 @@
// Copyright (c) 2026 Gordon Bolton. MIT License.
const RTorrentClient = require('../../../server/clients/RTorrentClient');
const xmlrpc = require('xmlrpc');
jest.mock('xmlrpc', () => ({
createClient: jest.fn()
}));
jest.mock('../../../server/utils/logger', () => ({
logToFile: jest.fn()
}));
describe('RTorrentClient', () => {
let client;
let mockConfig;
let mockMethodCall;
beforeEach(() => {
mockMethodCall = jest.fn();
xmlrpc.createClient.mockReturnValue({
methodCall: mockMethodCall
});
mockConfig = {
id: 'test-rtorrent',
name: 'Test rTorrent',
url: 'http://localhost:8080',
username: 'rtorrent',
password: 'rtorrent'
};
client = new RTorrentClient(mockConfig);
jest.clearAllMocks();
});
describe('Constructor', () => {
it('should initialize with correct properties', () => {
expect(client.getClientType()).toBe('rtorrent');
expect(client.getInstanceId()).toBe('test-rtorrent');
expect(client.name).toBe('Test rTorrent');
expect(client.url).toBe('http://localhost:8080');
expect(client.rpcUrl).toBe('http://localhost:8080/RPC2');
});
it('should create xmlrpc client with basic auth when credentials provided', () => {
expect(xmlrpc.createClient).toHaveBeenCalledWith({
url: 'http://localhost:8080/RPC2',
headers: {
Authorization: `Basic ${Buffer.from('rtorrent:rtorrent').toString('base64')}`
}
});
});
it('should create xmlrpc client without auth when no credentials', () => {
xmlrpc.createClient.mockClear();
const noAuthConfig = {
id: 'test-rtorrent-noauth',
name: 'Test rTorrent No Auth',
url: 'http://localhost:8080'
};
new RTorrentClient(noAuthConfig);
expect(xmlrpc.createClient).toHaveBeenCalledWith({
url: 'http://localhost:8080/RPC2'
});
});
});
describe('Connection Test', () => {
it('should test connection successfully', async () => {
mockMethodCall.mockImplementation((method, params, callback) => {
callback(null, '0.9.8');
});
const result = await client.testConnection();
expect(result).toBe(true);
expect(mockMethodCall).toHaveBeenCalledWith(
'system.client_version',
[],
expect.any(Function)
);
});
it('should handle connection test failure', async () => {
mockMethodCall.mockImplementation((method, params, callback) => {
callback(new Error('Connection refused'));
});
const result = await client.testConnection();
expect(result).toBe(false);
});
});
describe('getActiveDownloads', () => {
it('should fetch and normalize torrents', async () => {
const mockTorrents = [
[
'abc123def456',
'Test Torrent 1',
1000000000,
750000000,
1048576,
0,
1,
1,
0,
'/downloads/test',
'movies'
],
[
'def789abc012',
'Test Torrent 2',
2000000000,
2000000000,
0,
512000,
1,
1,
0,
'/downloads/complete',
'tv'
]
];
mockMethodCall.mockImplementation((method, params, callback) => {
callback(null, mockTorrents);
});
const downloads = await client.getActiveDownloads();
expect(downloads).toHaveLength(2);
expect(downloads[0].id).toBe('abc123def456');
expect(downloads[0].title).toBe('Test Torrent 1');
expect(downloads[0].status).toBe('Downloading');
expect(downloads[0].progress).toBe(75);
expect(downloads[0].category).toBe('movies');
expect(downloads[1].status).toBe('Seeding');
expect(downloads[1].category).toBe('tv');
});
it('should handle empty torrent list', async () => {
mockMethodCall.mockImplementation((method, params, callback) => {
callback(null, []);
});
const downloads = await client.getActiveDownloads();
expect(downloads).toEqual([]);
});
it('should handle XML-RPC errors gracefully', async () => {
mockMethodCall.mockImplementation((method, params, callback) => {
callback(new Error('XML-RPC fault'));
});
const downloads = await client.getActiveDownloads();
expect(downloads).toEqual([]);
});
});
describe('normalizeDownload', () => {
it('should normalize a downloading torrent', () => {
const torrent = [
'hash123',
'Downloading Torrent',
1000000000,
500000000,
1048576,
0,
1,
1,
0,
'/downloads',
''
];
const normalized = client.normalizeDownload(torrent);
expect(normalized).toEqual({
id: 'hash123',
title: 'Downloading Torrent',
type: 'torrent',
client: 'rtorrent',
instanceId: 'test-rtorrent',
instanceName: 'Test rTorrent',
status: 'Downloading',
progress: 50,
size: 1000000000,
downloaded: 500000000,
speed: 1048576,
eta: 476,
category: undefined,
tags: [],
savePath: '/downloads',
addedOn: undefined,
arrQueueId: undefined,
arrType: undefined,
raw: torrent
});
});
it('should normalize a seeding torrent', () => {
const torrent = [
'hash456',
'Seeding Torrent',
500000000,
500000000,
0,
204800,
1,
1,
0,
'/downloads/complete',
'movies'
];
const normalized = client.normalizeDownload(torrent);
expect(normalized.status).toBe('Seeding');
expect(normalized.progress).toBe(100);
expect(normalized.speed).toBe(204800);
expect(normalized.eta).toBeNull();
expect(normalized.category).toBe('movies');
expect(normalized.tags).toEqual(['movies']);
});
it('should normalize a paused torrent', () => {
const torrent = [
'hash789',
'Paused Torrent',
1000000000,
250000000,
0,
0,
1,
0,
0,
'/downloads',
''
];
const normalized = client.normalizeDownload(torrent);
expect(normalized.status).toBe('Paused');
expect(normalized.speed).toBe(0);
expect(normalized.eta).toBeNull();
});
it('should normalize a stopped torrent', () => {
const torrent = [
'hashabc',
'Stopped Torrent',
1000000000,
0,
0,
0,
0,
0,
0,
'/downloads',
''
];
const normalized = client.normalizeDownload(torrent);
expect(normalized.status).toBe('Stopped');
});
it('should normalize a checking torrent', () => {
const torrent = [
'hashdef',
'Checking Torrent',
1000000000,
500000000,
0,
0,
1,
0,
1,
'/downloads',
''
];
const normalized = client.normalizeDownload(torrent);
expect(normalized.status).toBe('Checking');
});
it('should handle zero-size torrent', () => {
const torrent = [
'hash000',
'Zero Size',
0,
0,
0,
0,
1,
1,
0,
'/downloads',
''
];
const normalized = client.normalizeDownload(torrent);
expect(normalized.progress).toBe(0);
expect(normalized.size).toBe(0);
expect(normalized.downloaded).toBe(0);
});
});
describe('Status Mapping', () => {
const testCases = [
{ state: 0, isActive: 0, isHashChecking: 0, completed: 0, size: 100, expected: 'Stopped' },
{ state: 1, isActive: 1, isHashChecking: 0, completed: 50, size: 100, expected: 'Downloading' },
{ state: 1, isActive: 1, isHashChecking: 0, completed: 100, size: 100, expected: 'Seeding' },
{ state: 1, isActive: 0, isHashChecking: 0, completed: 50, size: 100, expected: 'Paused' },
{ state: 1, isActive: 0, isHashChecking: 0, completed: 100, size: 100, expected: 'Paused' },
{ state: 1, isActive: 0, isHashChecking: 1, completed: 50, size: 100, expected: 'Checking' },
{ state: 1, isActive: 1, isHashChecking: 1, completed: 50, size: 100, expected: 'Checking' }
];
testCases.forEach(({ state, isActive, isHashChecking, completed, size, expected }) => {
it(`should map state=${state} isActive=${isActive} isHashChecking=${isHashChecking} to ${expected}`, () => {
const status = client._mapStatus(state, isActive, isHashChecking, completed, size);
expect(status).toBe(expected);
});
});
});
describe('ARR Info Extraction', () => {
it('should extract series info from filename', () => {
const torrent = [
'hash123',
'Show Name - S01E02 - Episode Title',
1000000000,
500000000,
1048576,
0,
1,
1,
0,
'/downloads',
''
];
const normalized = client.normalizeDownload(torrent);
expect(normalized.arrType).toBe('series');
});
it('should extract movie info from filename', () => {
const torrent = [
'hash456',
'Movie Title (2023) 1080p',
2000000000,
1000000000,
1048576,
0,
1,
1,
0,
'/downloads',
''
];
const normalized = client.normalizeDownload(torrent);
expect(normalized.arrType).toBe('movie');
});
it('should not extract ARR info from generic filename', () => {
const torrent = [
'hash789',
'Generic File Name.mkv',
1000000000,
500000000,
1048576,
0,
1,
1,
0,
'/downloads',
''
];
const normalized = client.normalizeDownload(torrent);
expect(normalized.arrType).toBeUndefined();
});
});
describe('Client Status', () => {
it('should get client status', async () => {
mockMethodCall.mockImplementation((method, params, callback) => {
if (method === 'throttle.global_down.rate') {
callback(null, 1048576);
} else if (method === 'throttle.global_up.rate') {
callback(null, 512000);
}
});
const status = await client.getClientStatus();
expect(status).toEqual({
globalDownRate: 1048576,
globalUpRate: 512000
});
});
it('should handle status request errors', async () => {
mockMethodCall.mockImplementation((method, params, callback) => {
callback(new Error('Status error'));
});
const status = await client.getClientStatus();
expect(status).toBeNull();
});
});
});