streamify-audio 2.2.5 → 2.2.7

package/tests/integration.test.js

@@ -0,0 +1,325 @@
+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/
+        );
+    });
+});

package/tests/spotify.test.js

@@ -0,0 +1,238 @@
+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');
+        });
+    });
+});