streamify-audio 2.3.0 → 2.3.2

package/tests/local.test.js

@@ -1,37 +0,0 @@
-const test = require('node:test');
-const assert = require('node:assert');
-const path = require('node:path');
-const fs = require('node:fs');
-const local = require('../src/providers/local');
-const { loadConfig } = require('../src/config');
-
-test('local provider: getInfo', async (t) => {
-    const config = loadConfig();
-    const testFile = path.resolve(__dirname, 'test-audio.mp3');
-    
-    // Create a dummy file for testing
-    fs.writeFileSync(testFile, 'dummy audio content');
-
-    try {
-        await t.test('should return correct info for a local file', async () => {
-            const info = await local.getInfo(testFile, config);
-            
-            assert.strictEqual(info.source, 'local');
-            assert.strictEqual(info.title, 'test-audio.mp3');
-            assert.ok(info.absolutePath.endsWith('tests/test-audio.mp3'));
-            assert.strictEqual(info.uri, `file://${info.absolutePath}`);
-        });
-
-        await t.test('should throw error if file does not exist', async () => {
-            await assert.rejects(
-                local.getInfo('non-existent-file.mp3', config),
-                { message: /File not found/ }
-            );
-        });
-    } finally {
-        // Cleanup
-        if (fs.existsSync(testFile)) {
-            fs.unlinkSync(testFile);
-        }
-    }
-});

package/tests/queue.test.js

@@ -1,94 +0,0 @@
-const test = require('node:test');
-const assert = require('node:assert');
-const Queue = require('../src/discord/Queue');
-
-test('Queue: management', async (t) => {
-    await t.test('should add tracks', () => {
-        const queue = new Queue();
-        queue.add({ id: '1', title: 'Track 1' });
-        queue.add({ id: '2', title: 'Track 2' });
-        assert.strictEqual(queue.size, 2);
-        assert.strictEqual(queue.tracks[0].id, '1');
-    });
-
-    await t.test('should add many tracks', () => {
-        const queue = new Queue();
-        queue.addMany([{ id: '1' }, { id: '2' }]);
-        assert.strictEqual(queue.size, 2);
-    });
-
-    await t.test('should remove tracks', () => {
-        const queue = new Queue();
-        queue.addMany([{ id: '1' }, { id: '2' }]);
-        const removed = queue.remove(0);
-        assert.strictEqual(removed.id, '1');
-        assert.strictEqual(queue.size, 1);
-    });
-
-    await t.test('should move tracks', () => {
-        const queue = new Queue();
-        queue.addMany([{ id: '1' }, { id: '2' }, { id: '3' }]);
-        queue.move(2, 0); // Move '3' to front
-        assert.strictEqual(queue.tracks[0].id, '3');
-        assert.strictEqual(queue.tracks[1].id, '1');
-    });
-
-    await t.test('should shift tracks and track history', () => {
-        const queue = new Queue({ maxPreviousTracks: 2 });
-        const t1 = { id: '1' };
-        const t2 = { id: '2' };
-        const t3 = { id: '3' };
-        
-        queue.addMany([t1, t2, t3]);
-        
-        assert.strictEqual(queue.shift().id, '1');
-        assert.strictEqual(queue.current.id, '1');
-        
-        assert.strictEqual(queue.shift().id, '2');
-        assert.strictEqual(queue.previous[0].id, '1');
-        
-        assert.strictEqual(queue.shift().id, '3');
-        assert.strictEqual(queue.previous[0].id, '2');
-        assert.strictEqual(queue.previous[1].id, '1');
-    });
-
-    await t.test('should handle repeat track mode', () => {
-        const queue = new Queue();
-        const t1 = { id: '1' };
-        queue.add(t1);
-        queue.shift(); // current = t1
-        
-        queue.setRepeatMode('track');
-        assert.strictEqual(queue.shift().id, '1');
-        assert.strictEqual(queue.shift().id, '1');
-    });
-
-    await t.test('should handle repeat queue mode', () => {
-        const queue = new Queue();
-        const t1 = { id: '1' };
-        const t2 = { id: '2' };
-        queue.addMany([t1, t2]);
-        
-        queue.setRepeatMode('queue');
-        queue.shift(); // current = t1
-        queue.shift(); // current = t2
-        
-        assert.strictEqual(queue.shift().id, '1');
-        assert.strictEqual(queue.current.id, '1');
-    });
-
-    await t.test('should unshift (previous)', () => {
-        const queue = new Queue();
-        const t1 = { id: '1' };
-        const t2 = { id: '2' };
-        queue.addMany([t1, t2]);
-        
-        queue.shift(); // current = t1
-        queue.shift(); // current = t2
-        
-        const prev = queue.unshift();
-        assert.strictEqual(prev.id, '1');
-        assert.strictEqual(queue.current.id, '1');
-        assert.strictEqual(queue.tracks[0].id, '2');
-    });
-});

package/tests/spotify.test.js

@@ -1,238 +0,0 @@
-const { describe, it, beforeEach } = require('node:test');
-const assert = require('node:assert');
-
-const spotify = require('../src/providers/spotify');
-
-describe('Spotify Provider', () => {
-    const mockConfig = {
-        ytdlpPath: 'yt-dlp',
-        ffmpegPath: 'ffmpeg',
-        spotify: {
-            clientId: process.env.SPOTIFY_CLIENT_ID || null,
-            clientSecret: process.env.SPOTIFY_CLIENT_SECRET || null
-        },
-        cache: {
-            searchTTL: 300,
-            infoTTL: 600
-        }
-    };
-
-    const hasCredentials = mockConfig.spotify.clientId && mockConfig.spotify.clientSecret;
-
-    describe('search', () => {
-        it('should throw without credentials', async function() {
-            if (hasCredentials) this.skip();
-
-            const badConfig = { ...mockConfig, spotify: {} };
-            await assert.rejects(
-                () => spotify.search('test', 1, badConfig),
-                /credentials/i
-            );
-        });
-
-        it('should return tracks for valid query', async function() {
-            if (!hasCredentials) this.skip();
-
-            const results = await spotify.search('never gonna give you up', 1, mockConfig);
-
-            assert(results.tracks, 'Should have tracks');
-            assert(Array.isArray(results.tracks), 'Tracks should be array');
-            assert.strictEqual(results.source, 'spotify');
-        });
-
-        it('should respect limit', async function() {
-            if (!hasCredentials) this.skip();
-
-            const results = await spotify.search('music', 5, mockConfig);
-            assert(results.tracks.length <= 5, 'Should not exceed limit');
-        });
-
-        it('should return track with required fields', async function() {
-            if (!hasCredentials) this.skip();
-
-            const results = await spotify.search('test', 1, mockConfig);
-
-            if (results.tracks.length > 0) {
-                const track = results.tracks[0];
-                assert(track.id, 'Should have id');
-                assert(track.title, 'Should have title');
-                assert(track.author, 'Should have author');
-                assert(track.album, 'Should have album');
-                assert(typeof track.duration === 'number', 'Should have numeric duration');
-                assert(track.uri, 'Should have uri');
-                assert(track.streamUrl, 'Should have streamUrl');
-                assert.strictEqual(track.source, 'spotify');
-            }
-        });
-
-        it('should handle empty results', async function() {
-            if (!hasCredentials) this.skip();
-
-            const results = await spotify.search('xyznonexistenttrack12345', 1, mockConfig);
-            assert(Array.isArray(results.tracks), 'Should return empty array');
-        });
-
-        it('should handle special characters', async function() {
-            if (!hasCredentials) this.skip();
-
-            const results = await spotify.search('rock & roll "classics"', 1, mockConfig);
-            assert(results.tracks, 'Should handle special chars');
-        });
-    });
-
-    describe('getInfo', () => {
-        it('should throw without credentials', async function() {
-            if (hasCredentials) this.skip();
-
-            const badConfig = { ...mockConfig, spotify: {} };
-            await assert.rejects(
-                () => spotify.getInfo('4uLU6hMCjMI75M1A2tKUQC', badConfig),
-                /credentials/i
-            );
-        });
-
-        it('should return info for valid track ID', async function() {
-            if (!hasCredentials) this.skip();
-
-            const info = await spotify.getInfo('4uLU6hMCjMI75M1A2tKUQC', mockConfig);
-
-            assert(info.id, 'Should have id');
-            assert(info.title, 'Should have title');
-            assert(info.author, 'Should have author');
-            assert(info.album, 'Should have album');
-            assert.strictEqual(info.source, 'spotify');
-        });
-
-        it('should throw for invalid track ID', async function() {
-            if (!hasCredentials) this.skip();
-
-            await assert.rejects(
-                () => spotify.getInfo('invalidtrackid', mockConfig),
-                /Spotify API error/
-            );
-        });
-
-        it('should include duration in seconds', async function() {
-            if (!hasCredentials) this.skip();
-
-            const info = await spotify.getInfo('4uLU6hMCjMI75M1A2tKUQC', mockConfig);
-            assert(typeof info.duration === 'number', 'Duration should be number');
-            assert(info.duration > 0, 'Duration should be positive');
-            assert(info.duration < 3600, 'Duration should be in seconds not ms');
-        });
-    });
-
-    describe('resolveToYouTube', () => {
-        it('should resolve Spotify track to YouTube ID', async function() {
-            if (!hasCredentials) this.skip();
-
-            const youtubeId = await spotify.resolveToYouTube('4uLU6hMCjMI75M1A2tKUQC', mockConfig);
-
-            assert(youtubeId, 'Should return YouTube ID');
-            assert(typeof youtubeId === 'string', 'Should be string');
-            assert(youtubeId.length === 11, 'YouTube IDs are 11 characters');
-        });
-
-        it('should cache resolved IDs', async function() {
-            if (!hasCredentials) this.skip();
-
-            const trackId = '4uLU6hMCjMI75M1A2tKUQC';
-
-            const start1 = Date.now();
-            const id1 = await spotify.resolveToYouTube(trackId, mockConfig);
-            const time1 = Date.now() - start1;
-
-            const start2 = Date.now();
-            const id2 = await spotify.resolveToYouTube(trackId, mockConfig);
-            const time2 = Date.now() - start2;
-
-            assert.strictEqual(id1, id2, 'Should return same ID');
-            assert(time2 < time1 / 2, 'Cached lookup should be faster');
-        });
-
-        it('should throw for invalid track', async function() {
-            if (!hasCredentials) this.skip();
-
-            await assert.rejects(
-                () => spotify.resolveToYouTube('invalidtrack', mockConfig),
-                /Spotify API error/
-            );
-        });
-    });
-
-    describe('getPlaylist', () => {
-        it('should return playlist tracks', async function() {
-            if (!hasCredentials) this.skip();
-
-            const playlist = await spotify.getPlaylist('37i9dQZF1DXcBWIGoYBM5M', mockConfig);
-
-            assert(playlist.id, 'Should have id');
-            assert(playlist.title, 'Should have title');
-            assert(playlist.tracks, 'Should have tracks');
-            assert(Array.isArray(playlist.tracks), 'Tracks should be array');
-            assert.strictEqual(playlist.source, 'spotify');
-        });
-
-        it('should throw for invalid playlist', async function() {
-            if (!hasCredentials) this.skip();
-
-            await assert.rejects(
-                () => spotify.getPlaylist('invalidplaylist', mockConfig),
-                /Spotify API error/
-            );
-        });
-    });
-
-    describe('getAlbum', () => {
-        it('should return album tracks', async function() {
-            if (!hasCredentials) this.skip();
-
-            const album = await spotify.getAlbum('4aawyAB9vmqN3uQ7FjRGTy', mockConfig);
-
-            assert(album.id, 'Should have id');
-            assert(album.title, 'Should have title');
-            assert(album.author, 'Should have author');
-            assert(album.tracks, 'Should have tracks');
-            assert(Array.isArray(album.tracks), 'Tracks should be array');
-            assert.strictEqual(album.source, 'spotify');
-        });
-
-        it('should throw for invalid album', async function() {
-            if (!hasCredentials) this.skip();
-
-            await assert.rejects(
-                () => spotify.getAlbum('invalidalbum', mockConfig),
-                /Spotify API error/
-            );
-        });
-    });
-
-    describe('getRecommendations', () => {
-        it('should return recommended tracks', async function() {
-            if (!hasCredentials) this.skip();
-
-            const recs = await spotify.getRecommendations('4uLU6hMCjMI75M1A2tKUQC', 5, mockConfig);
-
-            assert(recs.tracks, 'Should have tracks');
-            assert(Array.isArray(recs.tracks), 'Tracks should be array');
-            assert.strictEqual(recs.source, 'spotify');
-        });
-
-        it('should mark tracks as autoplay', async function() {
-            if (!hasCredentials) this.skip();
-
-            const recs = await spotify.getRecommendations('4uLU6hMCjMI75M1A2tKUQC', 3, mockConfig);
-
-            if (recs.tracks.length > 0) {
-                assert.strictEqual(recs.tracks[0].isAutoplay, true);
-            }
-        });
-
-        it('should respect limit', async function() {
-            if (!hasCredentials) this.skip();
-
-            const recs = await spotify.getRecommendations('4uLU6hMCjMI75M1A2tKUQC', 3, mockConfig);
-            assert(recs.tracks.length <= 3, 'Should not exceed limit');
-        });
-    });
-});

package/tests/stream.test.js

@@ -1,217 +0,0 @@
-const { describe, it, beforeEach, afterEach, mock } = require('node:test');
-const assert = require('node:assert');
-const { EventEmitter } = require('events');
-
-const { createStream, StreamController } = require('../src/discord/Stream');
-
-describe('StreamController', () => {
-    const mockConfig = {
-        ytdlpPath: 'yt-dlp',
-        ffmpegPath: 'ffmpeg',
-        cookiesPath: null,
-        ytdlp: {
-            format: 'bestaudio/best',
-            additionalArgs: []
-        },
-        audio: {
-            bitrate: '128k',
-            format: 'opus'
-        },
-        sponsorblock: {
-            enabled: false
-        }
-    };
-
-    describe('constructor', () => {
-        it('should initialize with default values', () => {
-            const track = { id: 'test123', title: 'Test Track', source: 'youtube' };
-            const stream = createStream(track, {}, mockConfig);
-
-            assert.strictEqual(stream.track, track);
-            assert.deepStrictEqual(stream.filters, {});
-            assert.strictEqual(stream.destroyed, false);
-            assert.strictEqual(stream.ytdlp, null);
-            assert.strictEqual(stream.ffmpeg, null);
-        });
-
-        it('should accept filters', () => {
-            const track = { id: 'test123', title: 'Test Track', source: 'youtube' };
-            const filters = { bass: 10, speed: 1.25 };
-            const stream = createStream(track, filters, mockConfig);
-
-            assert.deepStrictEqual(stream.filters, filters);
-        });
-
-        it('should handle null filters', () => {
-            const track = { id: 'test123', title: 'Test Track', source: 'youtube' };
-            const stream = createStream(track, null, mockConfig);
-
-            assert.deepStrictEqual(stream.filters, {});
-        });
-    });
-
-    describe('destroy', () => {
-        it('should set destroyed flag', () => {
-            const track = { id: 'test123', title: 'Test Track', source: 'youtube' };
-            const stream = createStream(track, {}, mockConfig);
-
-            stream.destroy();
-
-            assert.strictEqual(stream.destroyed, true);
-        });
-
-        it('should be idempotent', () => {
-            const track = { id: 'test123', title: 'Test Track', source: 'youtube' };
-            const stream = createStream(track, {}, mockConfig);
-
-            stream.destroy();
-            stream.destroy();
-            stream.destroy();
-
-            assert.strictEqual(stream.destroyed, true);
-        });
-
-        it('should nullify resources', () => {
-            const track = { id: 'test123', title: 'Test Track', source: 'youtube' };
-            const stream = createStream(track, {}, mockConfig);
-
-            stream.destroy();
-
-            assert.strictEqual(stream.ytdlp, null);
-            assert.strictEqual(stream.ffmpeg, null);
-            assert.strictEqual(stream.resource, null);
-        });
-    });
-
-    describe('create - edge cases', () => {
-        it('should throw if already destroyed', async () => {
-            const track = { id: 'test123', title: 'Test Track', source: 'youtube' };
-            const stream = createStream(track, {}, mockConfig);
-
-            stream.destroy();
-
-            await assert.rejects(
-                () => stream.create(),
-                { message: 'Stream already destroyed' }
-            );
-        });
-
-        it('should throw for invalid track ID', async () => {
-            const track = { id: undefined, title: 'Test Track', source: 'youtube' };
-            const stream = createStream(track, {}, mockConfig);
-
-            await assert.rejects(
-                () => stream.create(),
-                /Invalid track ID/
-            );
-        });
-
-        it('should throw for null track ID', async () => {
-            const track = { id: null, title: 'Test Track', source: 'youtube' };
-            const stream = createStream(track, {}, mockConfig);
-
-            await assert.rejects(
-                () => stream.create(),
-                /Invalid track ID/
-            );
-        });
-
-        it('should throw for "undefined" string track ID', async () => {
-            const track = { id: 'undefined', title: 'Test Track', source: 'youtube' };
-            const stream = createStream(track, {}, mockConfig);
-
-            await assert.rejects(
-                () => stream.create(),
-                /Invalid track ID/
-            );
-        });
-    });
-
-    describe('source detection', () => {
-        it('should handle youtube source', () => {
-            const track = { id: 'dQw4w9WgXcQ', title: 'Test', source: 'youtube' };
-            const stream = createStream(track, {}, mockConfig);
-            assert.strictEqual(stream.track.source, 'youtube');
-        });
-
-        it('should handle spotify source', () => {
-            const track = { id: '4uLU6hMCjMI75M1A2tKUQC', title: 'Test', source: 'spotify' };
-            const stream = createStream(track, {}, mockConfig);
-            assert.strictEqual(stream.track.source, 'spotify');
-        });
-
-        it('should handle soundcloud source', () => {
-            const track = { id: '123456', title: 'Test', source: 'soundcloud', uri: 'https://soundcloud.com/test/track' };
-            const stream = createStream(track, {}, mockConfig);
-            assert.strictEqual(stream.track.source, 'soundcloud');
-        });
-
-        it('should default to youtube for unknown source', () => {
-            const track = { id: 'test123', title: 'Test' };
-            const stream = createStream(track, {}, mockConfig);
-            assert.strictEqual(stream.track.source || 'youtube', 'youtube');
-        });
-    });
-
-    describe('metrics tracking', () => {
-        it('should initialize metrics to zero', () => {
-            const track = { id: 'test123', title: 'Test', source: 'youtube' };
-            const stream = createStream(track, {}, mockConfig);
-
-            assert.deepStrictEqual(stream.metrics, {
-                metadata: 0,
-                spawn: 0,
-                firstByte: 0,
-                total: 0
-            });
-        });
-    });
-
-    describe('resolved ID handling', () => {
-        it('should use _resolvedId if available', () => {
-            const track = {
-                id: 'spotify123',
-                title: 'Test',
-                source: 'spotify',
-                _resolvedId: 'youtube456'
-            };
-            const stream = createStream(track, {}, mockConfig);
-            assert.strictEqual(stream.track._resolvedId, 'youtube456');
-        });
-    });
-
-    describe('live stream handling', () => {
-        it('should detect live stream from isLive flag', () => {
-            const track = { id: 'live123', title: 'Live Stream', source: 'youtube', isLive: true };
-            const stream = createStream(track, {}, mockConfig);
-            assert.strictEqual(stream.track.isLive, true);
-        });
-
-        it('should detect live stream from zero duration', () => {
-            const track = { id: 'live123', title: 'Live Stream', source: 'youtube', duration: 0 };
-            const stream = createStream(track, {}, mockConfig);
-            assert.strictEqual(stream.track.duration, 0);
-        });
-    });
-});
-
-describe('createStream factory', () => {
-    const mockConfig = {
-        ytdlpPath: 'yt-dlp',
-        ffmpegPath: 'ffmpeg',
-        ytdlp: { format: 'bestaudio/best', additionalArgs: [] },
-        audio: { bitrate: '128k', format: 'opus' }
-    };
-
-    it('should return a StreamController instance', () => {
-        const track = { id: 'test', title: 'Test', source: 'youtube' };
-        const stream = createStream(track, {}, mockConfig);
-
-        assert(stream instanceof StreamController);
-    });
-
-    it('should handle empty track object', () => {
-        const stream = createStream({}, {}, mockConfig);
-        assert(stream instanceof StreamController);
-    });
-});

package/tests/twitch.test.js

@@ -1,42 +0,0 @@
-const test = require('node:test');
-const assert = require('node:assert');
-const twitch = require('../src/providers/twitch');
-const { loadConfig } = require('../src/config');
-
-test('twitch provider: getInfo', async (t) => {
-    const config = loadConfig();
-    
-    // We'll use a real URL but it might fail if yt-dlp has issues or network is restricted.
-    // However, it's better to test the real integration if possible.
-    const url = 'https://www.twitch.tv/monstercat';
-
-    await t.test('should return info for a twitch stream', async () => {
-        try {
-            const info = await twitch.getInfo(url, config);
-            
-            assert.strictEqual(info.source, 'twitch');
-            assert.ok(info.title);
-            assert.ok(info.author);
-            assert.strictEqual(info.isLive, true);
-        } catch (error) {
-            // If it fails because channel is not live, that's expected for this test URL sometimes
-            if (error.message.includes('The channel is not currently live')) {
-                console.warn('Twitch test: channel is offline, skipping validation');
-                return;
-            }
-            // If it fails due to network/yt-dlp issues, we skip it but log it
-            if (error.message.includes('yt-dlp exited with code') || error.message.includes('ERROR:')) {
-                console.warn('Twitch test failed (likely network/yt-dlp issue):', error.message);
-                return;
-            }
-            throw error;
-        }
-    });
-
-    await t.test('should reject on invalid URL', async () => {
-        await assert.rejects(
-            twitch.getInfo('https://not-a-twitch-url.com/abc', config),
-            { message: /ERROR:|yt-dlp exited with code/ }
-        );
-    });
-});

package/tests/utils.test.js

@@ -1,60 +0,0 @@
-const test = require('node:test');
-const assert = require('node:assert');
-const { 
-    registerStream, 
-    unregisterStream, 
-    getActiveStreams, 
-    getStreamPosition,
-    updateStreamFilters,
-    setEventEmitter
-} = require('../src/utils/stream');
-const EventEmitter = require('events');
-
-test('Utils: Stream Management', async (t) => {
-    const emitter = new EventEmitter();
-    setEventEmitter(emitter);
-
-    await t.test('should register a stream and emit event', () => {
-        let eventEmitted = false;
-        emitter.once('streamStart', (data) => {
-            assert.strictEqual(data.id, 'test-stream');
-            eventEmitted = true;
-        });
-
-        registerStream('test-stream', { source: 'youtube', videoId: 'abc' });
-        
-        const active = getActiveStreams();
-        assert.ok(active.has('test-stream'));
-        assert.ok(eventEmitted);
-    });
-
-    await t.test('should update stream filters', () => {
-        updateStreamFilters('test-stream', { volume: 80 });
-        const stream = getActiveStreams().get('test-stream');
-        assert.strictEqual(stream.filters.volume, 80);
-    });
-
-    await t.test('should get stream position', async () => {
-        const pos1 = getStreamPosition('test-stream');
-        assert.ok(typeof pos1 === 'number');
-        
-        await new Promise(r => setTimeout(r, 100));
-        
-        const pos2 = getStreamPosition('test-stream');
-        assert.ok(pos2 > pos1);
-    });
-
-    await t.test('should unregister a stream and emit event', () => {
-        let eventEmitted = false;
-        emitter.once('streamEnd', (data) => {
-            assert.strictEqual(data.id, 'test-stream');
-            eventEmitted = true;
-        });
-
-        unregisterStream('test-stream');
-        
-        const active = getActiveStreams();
-        assert.strictEqual(active.has('test-stream'), false);
-        assert.ok(eventEmitted);
-    });
-});