streamify-audio 2.3.0 → 2.3.2

package/tests/filters-edge.test.js

@@ -1,333 +0,0 @@
-const { describe, it } = require('node:test');
-const assert = require('node:assert');
-
-const {
-    buildFfmpegArgs,
-    getAvailableFilters,
-    getPresets,
-    getEffectPresets,
-    applyEffectPreset,
-    PRESETS,
-    EFFECT_PRESETS
-} = require('../src/filters/ffmpeg');
-
-describe('FFmpeg Filters - Edge Cases', () => {
-    const mockConfig = {
-        audio: {
-            bitrate: '128k',
-            format: 'opus',
-            vbr: true,
-            compressionLevel: 10,
-            application: 'audio'
-        }
-    };
-
-    describe('buildFfmpegArgs boundary values', () => {
-        it('should clamp bass to -20', () => {
-            const args = buildFfmpegArgs({ bass: -50 }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            const filterStr = args[afIndex + 1];
-            assert(filterStr.includes('bass=g=-20'), 'Should clamp to -20');
-        });
-
-        it('should clamp bass to 20', () => {
-            const args = buildFfmpegArgs({ bass: 100 }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            const filterStr = args[afIndex + 1];
-            assert(filterStr.includes('bass=g=20'), 'Should clamp to 20');
-        });
-
-        it('should clamp treble to -20', () => {
-            const args = buildFfmpegArgs({ treble: -100 }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            const filterStr = args[afIndex + 1];
-            assert(filterStr.includes('treble=g=-20'), 'Should clamp to -20');
-        });
-
-        it('should clamp treble to 20', () => {
-            const args = buildFfmpegArgs({ treble: 50 }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            const filterStr = args[afIndex + 1];
-            assert(filterStr.includes('treble=g=20'), 'Should clamp to 20');
-        });
-
-        it('should clamp speed to 0.5', () => {
-            const args = buildFfmpegArgs({ speed: 0.1 }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            const filterStr = args[afIndex + 1];
-            assert(filterStr.includes('atempo=0.5'), 'Should clamp to 0.5');
-        });
-
-        it('should clamp speed to 2.0', () => {
-            const args = buildFfmpegArgs({ speed: 5 }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            const filterStr = args[afIndex + 1];
-            assert(filterStr.includes('atempo=2'), 'Should clamp to 2.0');
-        });
-
-        it('should clamp pitch to 0.5', () => {
-            const args = buildFfmpegArgs({ pitch: 0.1 }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            const filterStr = args[afIndex + 1];
-            assert(filterStr.includes('asetrate=48000*0.5'), 'Should clamp to 0.5');
-        });
-
-        it('should clamp pitch to 2.0', () => {
-            const args = buildFfmpegArgs({ pitch: 10 }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            const filterStr = args[afIndex + 1];
-            assert(filterStr.includes('asetrate=48000*2'), 'Should clamp to 2.0');
-        });
-
-        it('should clamp volume to 0', () => {
-            const args = buildFfmpegArgs({ volume: -100 }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            const filterStr = args[afIndex + 1];
-            assert(filterStr.includes('volume=0'), 'Should clamp to 0');
-        });
-
-        it('should clamp volume to 200', () => {
-            const args = buildFfmpegArgs({ volume: 500 }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            const filterStr = args[afIndex + 1];
-            assert(filterStr.includes('volume=2'), 'Should clamp to 200% (2x)');
-        });
-
-        it('should clamp lowpass to 100 minimum', () => {
-            const args = buildFfmpegArgs({ lowpass: 10 }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            const filterStr = args[afIndex + 1];
-            assert(filterStr.includes('lowpass=f=100'), 'Should clamp to 100');
-        });
-
-        it('should clamp lowpass to 20000 maximum', () => {
-            const args = buildFfmpegArgs({ lowpass: 50000 }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            const filterStr = args[afIndex + 1];
-            assert(filterStr.includes('lowpass=f=20000'), 'Should clamp to 20000');
-        });
-
-        it('should clamp highpass to 20 minimum', () => {
-            const args = buildFfmpegArgs({ highpass: 5 }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            const filterStr = args[afIndex + 1];
-            assert(filterStr.includes('highpass=f=20'), 'Should clamp to 20');
-        });
-
-        it('should clamp highpass to 10000 maximum', () => {
-            const args = buildFfmpegArgs({ highpass: 50000 }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            const filterStr = args[afIndex + 1];
-            assert(filterStr.includes('highpass=f=10000'), 'Should clamp to 10000');
-        });
-    });
-
-    describe('filter type coercion', () => {
-        it('should handle string numbers for bass', () => {
-            const args = buildFfmpegArgs({ bass: '10' }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            assert(afIndex > -1, 'Should have -af flag');
-            assert(args[afIndex + 1].includes('bass=g=10'), 'Should parse string to number');
-        });
-
-        it('should handle string numbers for volume', () => {
-            const args = buildFfmpegArgs({ volume: '150' }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            assert(args[afIndex + 1].includes('volume=1.5'), 'Should parse string volume');
-        });
-
-        it('should handle string "true" for boolean filters', () => {
-            const args = buildFfmpegArgs({ karaoke: 'true' }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            assert(args[afIndex + 1].includes('pan=stereo'), 'Should handle string true');
-        });
-
-        it('should ignore NaN values', () => {
-            const args = buildFfmpegArgs({ bass: 'notanumber' }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            const filterStr = args[afIndex + 1];
-            assert(!filterStr.includes('bass=g=NaN'), 'Should not include NaN');
-        });
-
-        it('should ignore null values', () => {
-            const args = buildFfmpegArgs({ bass: null }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            const filterStr = args[afIndex + 1];
-            assert(!filterStr.includes('bass'), 'Should skip null bass');
-        });
-
-        it('should ignore undefined values', () => {
-            const args = buildFfmpegArgs({ bass: undefined }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            const filterStr = args[afIndex + 1];
-            assert(!filterStr.includes('bass'), 'Should skip undefined bass');
-        });
-    });
-
-    describe('equalizer edge cases', () => {
-        it('should handle empty equalizer array', () => {
-            const args = buildFfmpegArgs({ equalizer: [] }, mockConfig);
-            assert(args, 'Should not crash');
-        });
-
-        it('should handle partial equalizer array', () => {
-            const args = buildFfmpegArgs({ equalizer: [0.5, 0.3] }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            assert(args[afIndex + 1].includes('equalizer'), 'Should apply partial eq');
-        });
-
-        it('should handle oversized equalizer array', () => {
-            const bigEq = Array(30).fill(0.5);
-            const args = buildFfmpegArgs({ equalizer: bigEq }, mockConfig);
-            assert(args, 'Should not crash with oversized array');
-        });
-
-        it('should clamp equalizer values to -0.25', () => {
-            const args = buildFfmpegArgs({ equalizer: [-1, -1, -1] }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            const filterStr = args[afIndex + 1];
-            assert(filterStr.includes('g=-3'), 'Should clamp gain (12 * -0.25 = -3)');
-        });
-
-        it('should clamp equalizer values to 1.0', () => {
-            const args = buildFfmpegArgs({ equalizer: [2, 2, 2] }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            const filterStr = args[afIndex + 1];
-            assert(filterStr.includes('g=12'), 'Should clamp gain (12 * 1.0 = 12)');
-        });
-
-        it('should skip zero equalizer values', () => {
-            const args = buildFfmpegArgs({ equalizer: [0, 0, 0, 0.5, 0] }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            const filterStr = args[afIndex + 1];
-            const eqCount = (filterStr.match(/equalizer=/g) || []).length;
-            assert.strictEqual(eqCount, 1, 'Should only have one eq band');
-        });
-    });
-
-    describe('tremolo/vibrato edge cases', () => {
-        it('should clamp tremolo frequency', () => {
-            const args = buildFfmpegArgs({ tremolo: { frequency: 100, depth: 0.5 } }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            assert(args[afIndex + 1].includes('tremolo=f=20'), 'Should clamp to 20');
-        });
-
-        it('should clamp tremolo depth', () => {
-            const args = buildFfmpegArgs({ tremolo: { frequency: 5, depth: 5 } }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            assert(args[afIndex + 1].includes('d=1'), 'Should clamp to 1');
-        });
-
-        it('should clamp vibrato frequency', () => {
-            const args = buildFfmpegArgs({ vibrato: { frequency: 100, depth: 0.5 } }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            assert(args[afIndex + 1].includes('vibrato=f=14'), 'Should clamp to 14');
-        });
-
-        it('should use defaults for missing tremolo values', () => {
-            const args = buildFfmpegArgs({ tremolo: {} }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            assert(args[afIndex + 1].includes('tremolo=f=4:d=0.5'), 'Should use defaults');
-        });
-    });
-
-    describe('output format variations', () => {
-        it('should output opus by default', () => {
-            const args = buildFfmpegArgs({}, mockConfig);
-            assert(args.includes('libopus'), 'Should use libopus');
-            assert(args.includes('-f') && args[args.indexOf('-f') + 1] === 'ogg');
-        });
-
-        it('should output mp3 when configured', () => {
-            const mp3Config = { ...mockConfig, audio: { ...mockConfig.audio, format: 'mp3' } };
-            const args = buildFfmpegArgs({}, mp3Config);
-            assert(args.includes('libmp3lame'), 'Should use libmp3lame');
-        });
-
-        it('should output aac when configured', () => {
-            const aacConfig = { ...mockConfig, audio: { ...mockConfig.audio, format: 'aac' } };
-            const args = buildFfmpegArgs({}, aacConfig);
-            assert(args.includes('aac'), 'Should use aac');
-        });
-
-        it('should respect custom bitrate', () => {
-            const customConfig = { ...mockConfig, audio: { ...mockConfig.audio, bitrate: '320k' } };
-            const args = buildFfmpegArgs({}, customConfig);
-            assert(args.includes('320k'), 'Should use custom bitrate');
-        });
-    });
-
-    describe('multiple filters combined', () => {
-        it('should combine all filter types', () => {
-            const filters = {
-                bass: 5,
-                treble: 3,
-                speed: 1.2,
-                volume: 120,
-                karaoke: true,
-                echo: true,
-                compressor: true
-            };
-            const args = buildFfmpegArgs(filters, mockConfig);
-            const afIndex = args.indexOf('-af');
-            const filterStr = args[afIndex + 1];
-
-            assert(filterStr.includes('bass'), 'Should have bass');
-            assert(filterStr.includes('treble'), 'Should have treble');
-            assert(filterStr.includes('atempo'), 'Should have speed');
-            assert(filterStr.includes('volume'), 'Should have volume');
-            assert(filterStr.includes('pan=stereo'), 'Should have karaoke');
-            assert(filterStr.includes('aecho'), 'Should have echo');
-            assert(filterStr.includes('acompressor'), 'Should have compressor');
-        });
-
-        it('should maintain filter order', () => {
-            const args = buildFfmpegArgs({ bass: 5, treble: 5 }, mockConfig);
-            const afIndex = args.indexOf('-af');
-            const filterStr = args[afIndex + 1];
-            const bassPos = filterStr.indexOf('bass');
-            const treblePos = filterStr.indexOf('treble');
-            assert(bassPos < treblePos, 'Bass should come before treble');
-        });
-    });
-
-    describe('preset functions', () => {
-        it('should have all documented presets', () => {
-            const presets = getPresets();
-            const expected = ['flat', 'rock', 'pop', 'jazz', 'classical', 'electronic', 'hiphop', 'acoustic', 'rnb', 'latin', 'loudness', 'piano', 'vocal', 'bass_heavy', 'treble_heavy', 'extra_bass', 'crystal_clear'];
-
-            for (const name of expected) {
-                assert(presets[name], `Should have ${name} preset`);
-            }
-        });
-
-        it('should have all effect presets', () => {
-            const effects = getEffectPresets();
-            const expected = ['bassboost', 'nightcore', 'vaporwave', '8d', 'karaoke', 'trebleboost', 'deep', 'lofi', 'radio', 'telephone', 'soft', 'loud', 'chipmunk', 'darth', 'echo', 'vibrato', 'tremolo', 'reverb', 'surround', 'boost', 'subboost'];
-
-            for (const name of expected) {
-                assert(effects[name], `Should have ${name} effect`);
-            }
-        });
-
-        it('should apply effect preset with intensity', () => {
-            const result = applyEffectPreset('bassboost', 0.5);
-            assert(result, 'Should return filters');
-            assert(typeof result.bass === 'number', 'Should have bass');
-        });
-
-        it('should return null for unknown preset', () => {
-            const result = applyEffectPreset('nonexistent');
-            assert.strictEqual(result, null);
-        });
-
-        it('should scale intensity correctly', () => {
-            const full = applyEffectPreset('bassboost', 1.0);
-            const half = applyEffectPreset('bassboost', 0.5);
-
-            if (full.bass && half.bass) {
-                assert(half.bass < full.bass, 'Half intensity should have less bass');
-            }
-        });
-    });
-});

package/tests/http.test.js

@@ -1,24 +0,0 @@
-const test = require('node:test');
-const assert = require('node:assert');
-const httpProvider = require('../src/providers/http');
-const { loadConfig } = require('../src/config');
-
-test('http provider: getInfo', async (t) => {
-    const config = loadConfig();
-    const testUrl = 'https://example.com/music/track1.mp3?query=1';
-
-    await t.test('should return basic info for a direct URL', async () => {
-        const info = await httpProvider.getInfo(testUrl, config);
-        
-        assert.strictEqual(info.source, 'http');
-        assert.strictEqual(info.title, 'track1.mp3');
-        assert.strictEqual(info.uri, testUrl);
-        assert.strictEqual(info.isLive, true);
-        assert.ok(info.id);
-    });
-
-    await t.test('should handle URLs without clear filenames', async () => {
-        const info = await httpProvider.getInfo('https://example.com/stream', config);
-        assert.strictEqual(info.title, 'stream');
-    });
-});

package/tests/integration.test.js

@@ -1,325 +0,0 @@
-const { describe, it, before, after } = require('node:test');
-const assert = require('node:assert');
-
-const Streamify = require('../index');
-
-describe('Streamify Integration', () => {
-    let streamify;
-
-    before(async () => {
-        streamify = new Streamify({
-            port: 3999,
-            host: '127.0.0.1'
-        });
-        await streamify.start();
-    });
-
-    after(async () => {
-        if (streamify) {
-            await streamify.stop();
-        }
-    });
-
-    describe('lifecycle', () => {
-        it('should start successfully', () => {
-            assert.strictEqual(streamify.running, true);
-        });
-
-        it('should have valid base URL', () => {
-            const url = streamify.getBaseUrl();
-            assert.strictEqual(url, 'http://127.0.0.1:3999');
-        });
-
-        it('should not start twice', async () => {
-            const result = await streamify.start();
-            assert.strictEqual(result, streamify);
-        });
-    });
-
-    describe('detectSource', () => {
-        it('should detect YouTube URLs', () => {
-            const tests = [
-                { input: 'https://www.youtube.com/watch?v=dQw4w9WgXcQ', expected: 'youtube' },
-                { input: 'https://youtu.be/dQw4w9WgXcQ', expected: 'youtube' },
-                { input: 'https://youtube.com/embed/dQw4w9WgXcQ', expected: 'youtube' }
-            ];
-
-            for (const test of tests) {
-                const result = streamify.detectSource(test.input);
-                assert.strictEqual(result.source, test.expected, `Failed for ${test.input}`);
-                assert.strictEqual(result.id, 'dQw4w9WgXcQ');
-                assert.strictEqual(result.isUrl, true);
-            }
-        });
-
-        it('should detect raw YouTube IDs', () => {
-            const result = streamify.detectSource('dQw4w9WgXcQ');
-            assert.strictEqual(result.source, 'youtube');
-            assert.strictEqual(result.id, 'dQw4w9WgXcQ');
-            assert.strictEqual(result.isUrl, false);
-        });
-
-        it('should detect Spotify URLs', () => {
-            const tests = [
-                { input: 'https://open.spotify.com/track/4uLU6hMCjMI75M1A2tKUQC', expected: 'spotify' },
-                { input: 'spotify:track:4uLU6hMCjMI75M1A2tKUQC', expected: 'spotify' }
-            ];
-
-            for (const test of tests) {
-                const result = streamify.detectSource(test.input);
-                assert.strictEqual(result.source, test.expected, `Failed for ${test.input}`);
-                assert.strictEqual(result.id, '4uLU6hMCjMI75M1A2tKUQC');
-            }
-        });
-
-        it('should detect SoundCloud URLs', () => {
-            const result = streamify.detectSource('https://soundcloud.com/artist/track-name');
-            assert.strictEqual(result.source, 'soundcloud');
-        });
-
-        it('should return null for unknown sources', () => {
-            const result = streamify.detectSource('some random text');
-            assert.strictEqual(result.source, null);
-            assert.strictEqual(result.id, null);
-        });
-
-        it('should handle null input', () => {
-            const result = streamify.detectSource(null);
-            assert.strictEqual(result.source, null);
-        });
-
-        it('should handle undefined input', () => {
-            const result = streamify.detectSource(undefined);
-            assert.strictEqual(result.source, null);
-        });
-
-        it('should handle empty string', () => {
-            const result = streamify.detectSource('');
-            assert.strictEqual(result.source, null);
-        });
-    });
-
-    describe('getStreamUrl', () => {
-        it('should generate YouTube stream URL', () => {
-            const url = streamify.getStreamUrl('youtube', 'dQw4w9WgXcQ');
-            assert.strictEqual(url, 'http://127.0.0.1:3999/youtube/stream/dQw4w9WgXcQ');
-        });
-
-        it('should generate Spotify stream URL', () => {
-            const url = streamify.getStreamUrl('spotify', '4uLU6hMCjMI75M1A2tKUQC');
-            assert.strictEqual(url, 'http://127.0.0.1:3999/spotify/stream/4uLU6hMCjMI75M1A2tKUQC');
-        });
-
-        it('should generate SoundCloud stream URL', () => {
-            const url = streamify.getStreamUrl('soundcloud', '123456');
-            assert.strictEqual(url, 'http://127.0.0.1:3999/soundcloud/stream/123456');
-        });
-
-        it('should accept source aliases', () => {
-            const ytUrl = streamify.getStreamUrl('yt', 'test');
-            const spUrl = streamify.getStreamUrl('sp', 'test');
-            const scUrl = streamify.getStreamUrl('sc', 'test');
-
-            assert(ytUrl.includes('/youtube/'), 'Should alias yt to youtube');
-            assert(spUrl.includes('/spotify/'), 'Should alias sp to spotify');
-            assert(scUrl.includes('/soundcloud/'), 'Should alias sc to soundcloud');
-        });
-
-        it('should append filter parameters', () => {
-            const url = streamify.getStreamUrl('youtube', 'test', { bass: 10, speed: 1.25 });
-            assert(url.includes('bass=10'), 'Should include bass');
-            assert(url.includes('speed=1.25'), 'Should include speed');
-        });
-
-        it('should skip null/undefined filter values', () => {
-            const url = streamify.getStreamUrl('youtube', 'test', { bass: 10, treble: null, speed: undefined });
-            assert(url.includes('bass=10'), 'Should include bass');
-            assert(!url.includes('treble'), 'Should skip null');
-            assert(!url.includes('speed'), 'Should skip undefined');
-        });
-
-        it('should throw for unknown source', () => {
-            assert.throws(
-                () => streamify.getStreamUrl('unknown', 'test'),
-                /Unknown source/
-            );
-        });
-    });
-
-    describe('HTTP endpoints', () => {
-        it('should respond to health check', async () => {
-            const res = await fetch('http://127.0.0.1:3999/health');
-            const data = await res.json();
-
-            assert.strictEqual(res.status, 200);
-            assert.strictEqual(data.status, 'ok');
-            assert(typeof data.uptime === 'number');
-            assert(typeof data.activeStreams === 'number');
-        });
-
-        it('should respond to stats', async () => {
-            const res = await fetch('http://127.0.0.1:3999/stats');
-            const data = await res.json();
-
-            assert.strictEqual(res.status, 200);
-            assert(typeof data.uptime === 'number');
-            assert(data.memory);
-            assert(data.cache);
-        });
-
-        it('should respond to streams list', async () => {
-            const res = await fetch('http://127.0.0.1:3999/streams');
-            const data = await res.json();
-
-            assert.strictEqual(res.status, 200);
-            assert(Array.isArray(data.streams));
-        });
-
-        it('should return 404 for unknown stream ID', async () => {
-            const res = await fetch('http://127.0.0.1:3999/streams/nonexistent');
-            assert.strictEqual(res.status, 404);
-        });
-    });
-
-    describe('YouTube search endpoint', () => {
-        it('should search YouTube', async () => {
-            const res = await fetch('http://127.0.0.1:3999/youtube/search?q=test&limit=1');
-            const data = await res.json();
-
-            assert.strictEqual(res.status, 200);
-            assert(data.tracks);
-            assert(Array.isArray(data.tracks));
-        });
-
-        it('should return 400 without query', async () => {
-            const res = await fetch('http://127.0.0.1:3999/youtube/search');
-            assert.strictEqual(res.status, 400);
-        });
-    });
-
-    describe('YouTube info endpoint', () => {
-        it('should get video info', async () => {
-            const res = await fetch('http://127.0.0.1:3999/youtube/info/dQw4w9WgXcQ');
-            const data = await res.json();
-
-            assert.strictEqual(res.status, 200);
-            assert.strictEqual(data.id, 'dQw4w9WgXcQ');
-            assert(data.title);
-        });
-
-        it('should return 500 for invalid video', async () => {
-            const res = await fetch('http://127.0.0.1:3999/youtube/info/invalidvideoid123');
-            assert.strictEqual(res.status, 500);
-        });
-    });
-
-    describe('generic search endpoint', () => {
-        it('should default to YouTube', async () => {
-            const res = await fetch('http://127.0.0.1:3999/search?q=test&limit=1');
-            const data = await res.json();
-
-            assert.strictEqual(res.status, 200);
-            assert(data.tracks);
-        });
-
-        it('should accept source parameter', async () => {
-            const res = await fetch('http://127.0.0.1:3999/search?q=test&source=youtube&limit=1');
-            const data = await res.json();
-
-            assert.strictEqual(res.status, 200);
-        });
-
-        it('should return 400 without query', async () => {
-            const res = await fetch('http://127.0.0.1:3999/search');
-            assert.strictEqual(res.status, 400);
-        });
-    });
-
-    describe('active streams API', () => {
-        it('should return empty array initially', async () => {
-            const streams = await streamify.getActiveStreams();
-            assert(Array.isArray(streams.streams));
-        });
-    });
-
-    describe('resolve method', () => {
-        it('should resolve YouTube URL', async () => {
-            const result = await streamify.resolve('https://www.youtube.com/watch?v=dQw4w9WgXcQ');
-
-            assert.strictEqual(result.source, 'youtube');
-            assert(result.tracks.length > 0);
-            assert.strictEqual(result.fromUrl, true);
-        });
-
-        it('should resolve raw YouTube ID', async () => {
-            const result = await streamify.resolve('dQw4w9WgXcQ');
-
-            assert.strictEqual(result.source, 'youtube');
-            assert(result.tracks.length > 0);
-        });
-
-        it('should search for plain text', async () => {
-            const result = await streamify.resolve('never gonna give you up', 1);
-
-            assert.strictEqual(result.source, 'youtube');
-            assert(result.tracks.length > 0);
-            assert.strictEqual(result.fromUrl, false);
-        });
-    });
-
-    describe('shorthand methods', () => {
-        it('should have youtube.search', async () => {
-            const result = await streamify.youtube.search('test', 1);
-            assert(result.tracks);
-        });
-
-        it('should have youtube.getInfo', async () => {
-            const result = await streamify.youtube.getInfo('dQw4w9WgXcQ');
-            assert(result.id);
-        });
-
-        it('should have youtube.getStreamUrl', () => {
-            const url = streamify.youtube.getStreamUrl('test');
-            assert(url.includes('/youtube/stream/'));
-        });
-    });
-
-    describe('error handling', () => {
-        it('should throw when not started', async () => {
-            const notStarted = new Streamify({ port: 3998 });
-
-            assert.throws(
-                () => notStarted.getBaseUrl(),
-                /not started/
-            );
-
-            await assert.rejects(
-                () => notStarted.search('youtube', 'test'),
-                /not started/
-            );
-
-            await assert.rejects(
-                () => notStarted.resolve('test'),
-                /not started/
-            );
-        });
-    });
-});
-
-describe('Streamify Not Started', () => {
-    it('should throw for getStreamUrl without start', () => {
-        const instance = new Streamify({ port: 3997 });
-        assert.throws(
-            () => instance.getStreamUrl('youtube', 'test'),
-            /not started/
-        );
-    });
-
-    it('should throw for getInfo without start', async () => {
-        const instance = new Streamify({ port: 3996 });
-        await assert.rejects(
-            () => instance.getInfo('youtube', 'test'),
-            /not started/
-        );
-    });
-});