+131

tests/components/input/common/test.ts

reviewed

··· 1 1 + import { describe, it } from "@std/testing/bdd"; 2 2 + import { expect } from "@std/expect"; 3 3 + 4 4 + import { testWeb } from "@tests/common/index.ts"; 5 5 + import type { Track } from "~/definitions/types.d.ts"; 6 6 + 7 7 + describe("components/input/common", () => { 8 8 + it("isAudioFile returns truthy for audio extensions", async () => { 9 9 + const results = await testWeb(async () => { 10 10 + const mod = await import("~/components/input/common.js"); 11 11 + return [ 12 12 + !!mod.isAudioFile("track.mp3"), 13 13 + !!mod.isAudioFile("track.flac"), 14 14 + !!mod.isAudioFile("track.ogg"), 15 15 + !!mod.isAudioFile("track.opus"), 16 16 + !!mod.isAudioFile("track.wav"), 17 17 + !!mod.isAudioFile("track.m4a"), 18 18 + !!mod.isAudioFile("track.webm"), 19 19 + ]; 20 20 + }); 21 21 + 22 22 + expect(results).toEqual([true, true, true, true, true, true, true]); 23 23 + }); 24 24 + 25 25 + it("isAudioFile returns falsy for non-audio extensions", async () => { 26 26 + const results = await testWeb(async () => { 27 27 + const mod = await import("~/components/input/common.js"); 28 28 + return [ 29 29 + !!mod.isAudioFile("track.txt"), 30 30 + !!mod.isAudioFile("track.jpg"), 31 31 + !!mod.isAudioFile("track.pdf"), 32 32 + !!mod.isAudioFile("track"), 33 33 + ]; 34 34 + }); 35 35 + 36 36 + expect(results).toEqual([false, false, false, false]); 37 37 + }); 38 38 + 39 39 + it("groupKey returns scheme://groupId", async () => { 40 40 + const result = await testWeb(async () => { 41 41 + const mod = await import("~/components/input/common.js"); 42 42 + return mod.groupKey("https", "example.com"); 43 43 + }); 44 44 + 45 45 + expect(result).toBe("https://example.com"); 46 46 + }); 47 47 + 48 48 + it("detach with matching scheme removes all tracks", async () => { 49 49 + const result = await testWeb(async () => { 50 50 + const mod = await import("~/components/input/common.js"); 51 51 + 52 52 + const tracks: Track[] = [ 53 53 + { $type: "sh.diffuse.output.track", id: "1", uri: "https://a.com/1.mp3" }, 54 54 + { $type: "sh.diffuse.output.track", id: "2", uri: "https://b.com/2.mp3" }, 55 55 + ]; 56 56 + 57 57 + return mod.detach({ 58 58 + fileUriOrScheme: "https", 59 59 + inputScheme: "https", 60 60 + handleFileUri: () => [], 61 61 + tracks, 62 62 + }); 63 63 + }); 64 64 + 65 65 + expect(result).toEqual([]); 66 66 + }); 67 67 + 68 68 + it("detach with non-matching scheme returns all tracks unchanged", async () => { 69 69 + const result = await testWeb(async () => { 70 70 + const mod = await import("~/components/input/common.js"); 71 71 + 72 72 + const tracks: Track[] = [ 73 73 + { $type: "sh.diffuse.output.track", id: "1", uri: "https://a.com/1.mp3" }, 74 74 + { $type: "sh.diffuse.output.track", id: "2", uri: "https://b.com/2.mp3" }, 75 75 + ]; 76 76 + 77 77 + return mod.detach({ 78 78 + fileUriOrScheme: "ftp", 79 79 + inputScheme: "https", 80 80 + handleFileUri: () => [], 81 81 + tracks, 82 82 + }); 83 83 + }); 84 84 + 85 85 + expect(result.map((t: Track) => t.id)).toEqual(["1", "2"]); 86 86 + }); 87 87 + 88 88 + it("detach delegates to handleFileUri when a full URI is given", async () => { 89 89 + const result = await testWeb(async () => { 90 90 + const mod = await import("~/components/input/common.js"); 91 91 + 92 92 + const tracks: Track[] = [ 93 93 + { $type: "sh.diffuse.output.track", id: "1", uri: "https://a.com/1.mp3" }, 94 94 + { $type: "sh.diffuse.output.track", id: "2", uri: "https://b.com/2.mp3" }, 95 95 + ]; 96 96 + 97 97 + return mod.detach({ 98 98 + fileUriOrScheme: "https://a.com/1.mp3", 99 99 + inputScheme: "https", 100 100 + handleFileUri: ({ tracks }) => tracks.filter((t) => t.id !== "1"), 101 101 + tracks, 102 102 + }); 103 103 + }); 104 104 + 105 105 + expect(result.map((t: Track) => t.id)).toEqual(["2"]); 106 106 + }); 107 107 + 108 108 + it("cachedConsult caches and returns result", async () => { 109 109 + const result = await testWeb(async () => { 110 110 + const mod = await import("~/components/input/common.js"); 111 111 + 112 112 + let callCount = 0; 113 113 + const cached = mod.cachedConsult( 114 114 + async (_uri: string) => { 115 115 + callCount++; 116 116 + return true; 117 117 + }, 118 118 + (uri: string) => uri, 119 119 + ); 120 120 + 121 121 + const r1 = await cached("https://example.com/stream"); 122 122 + const r2 = await cached("https://example.com/stream"); 123 123 + 124 124 + return { r1, r2, callCount }; 125 125 + }); 126 126 + 127 127 + expect(result.r1).toBe(true); 128 128 + expect(result.r2).toBe(true); 129 129 + expect(result.callCount).toBe(1); 130 130 + }); 131 131 + });

+169

tests/components/input/icecast/test.ts

reviewed

··· 1 1 + import { describe, it } from "@std/testing/bdd"; 2 2 + import { expect } from "@std/expect"; 3 3 + 4 4 + import { testWeb } from "@tests/common/index.ts"; 5 5 + import type { Track } from "~/definitions/types.d.ts"; 6 6 + 7 7 + describe("components/input/icecast", () => { 8 8 + it("has correct SCHEME property", async () => { 9 9 + const scheme = await testWeb(async () => { 10 10 + const mod = await import("~/components/input/icecast/element.js"); 11 11 + const input = new mod.CLASS(); 12 12 + document.body.append(input); 13 13 + return input.SCHEME; 14 14 + }); 15 15 + 16 16 + expect(scheme).toBe("icecast"); 17 17 + }); 18 18 + 19 19 + it("consult returns undetermined for scheme only", async () => { 20 20 + const result = await testWeb(async () => { 21 21 + const mod = await import("~/components/input/icecast/element.js"); 22 22 + const input = new mod.CLASS(); 23 23 + document.body.append(input); 24 24 + return await input.consult("icecast"); 25 25 + }); 26 26 + 27 27 + expect(result.supported).toBe(true); 28 28 + if (result.supported) { 29 29 + expect(result.consult).toBe("undetermined"); 30 30 + } 31 31 + }); 32 32 + 33 33 + it("consult returns unsupported for a non-icecast URI", async () => { 34 34 + const result = await testWeb(async () => { 35 35 + const mod = await import("~/components/input/icecast/element.js"); 36 36 + const input = new mod.CLASS(); 37 37 + document.body.append(input); 38 38 + return await input.consult("https://example.com/stream.mp3"); 39 39 + }); 40 40 + 41 41 + expect(result.supported).toBe(false); 42 42 + }); 43 43 + 44 44 + it("resolve returns a URL containing the host and path for an icecast URI", async () => { 45 45 + const result = await testWeb(async () => { 46 46 + const mod = await import("~/components/input/icecast/element.js"); 47 47 + const input = new mod.CLASS(); 48 48 + document.body.append(input); 49 49 + return await input.resolve({ uri: "icecast://radio.example.com/stream.mp3" }); 50 50 + }); 51 51 + 52 52 + // Chrome's URL parser treats non-special schemes (icecast://) with empty 53 53 + // host, so the reconstructed streamUrl embeds the authority in the path. 54 54 + // Test the observable contract: the url contains the domain and path and 55 55 + // uses the https: protocol. 56 56 + expect(result).not.toBe(null); 57 57 + if (result && "url" in result) { 58 58 + expect(result.url).toContain("radio.example.com"); 59 59 + expect(result.url).toContain("stream.mp3"); 60 60 + expect(result.url).toContain("https:"); 61 61 + expect(result.expiresAt).toBeGreaterThan(Date.now() / 1000); 62 62 + } 63 63 + }); 64 64 + 65 65 + it("resolve uses http: for an icecast URI with tls=0", async () => { 66 66 + const result = await testWeb(async () => { 67 67 + const mod = await import("~/components/input/icecast/element.js"); 68 68 + const input = new mod.CLASS(); 69 69 + document.body.append(input); 70 70 + return await input.resolve({ 71 71 + uri: "icecast://radio.example.com:8000/live?tls=0", 72 72 + }); 73 73 + }); 74 74 + 75 75 + expect(result).not.toBe(null); 76 76 + if (result && "url" in result) { 77 77 + expect(result.url).toContain("radio.example.com"); 78 78 + expect(result.url).toContain("/live"); 79 79 + expect(result.url).toContain("http:"); 80 80 + } 81 81 + }); 82 82 + 83 83 + it("resolve returns undefined for a non-icecast URI", async () => { 84 84 + const result = await testWeb(async () => { 85 85 + const mod = await import("~/components/input/icecast/element.js"); 86 86 + const input = new mod.CLASS(); 87 87 + document.body.append(input); 88 88 + const r = await input.resolve({ uri: "https://example.com/stream.mp3" }); 89 89 + return r ?? null; 90 90 + }); 91 91 + 92 92 + expect(result).toBe(null); 93 93 + }); 94 94 + 95 95 + it("detach with icecast scheme removes all icecast tracks", async () => { 96 96 + const remaining = await testWeb(async () => { 97 97 + const mod = await import("~/components/input/icecast/element.js"); 98 98 + const input = new mod.CLASS(); 99 99 + document.body.append(input); 100 100 + 101 101 + const tracks: Track[] = [ 102 102 + { 103 103 + $type: "sh.diffuse.output.track", 104 104 + id: "1", 105 105 + uri: "icecast://radio.example.com/stream.mp3", 106 106 + }, 107 107 + { 108 108 + $type: "sh.diffuse.output.track", 109 109 + id: "2", 110 110 + uri: "icecast://other.example.com/live", 111 111 + }, 112 112 + ]; 113 113 + 114 114 + return await input.detach({ fileUriOrScheme: "icecast", tracks }); 115 115 + }); 116 116 + 117 117 + expect(remaining.length).toBe(0); 118 118 + }); 119 119 + 120 120 + it("detach with a non-icecast URI returns all tracks unchanged", async () => { 121 121 + const remaining = await testWeb(async () => { 122 122 + const mod = await import("~/components/input/icecast/element.js"); 123 123 + const input = new mod.CLASS(); 124 124 + document.body.append(input); 125 125 + 126 126 + const tracks: Track[] = [ 127 127 + { 128 128 + $type: "sh.diffuse.output.track", 129 129 + id: "1", 130 130 + uri: "icecast://radio.example.com/stream.mp3", 131 131 + }, 132 132 + { 133 133 + $type: "sh.diffuse.output.track", 134 134 + id: "2", 135 135 + uri: "icecast://other.example.com/live", 136 136 + }, 137 137 + ]; 138 138 + 139 139 + return await input.detach({ 140 140 + fileUriOrScheme: "https://example.com/something.mp3", 141 141 + tracks, 142 142 + }); 143 143 + }); 144 144 + 145 145 + // parseURI returns undefined for non-icecast URIs, so all tracks are kept 146 146 + expect(remaining.length).toBe(2); 147 147 + }); 148 148 + 149 149 + it("sources returns an entry with icecast:// URI for each track", async () => { 150 150 + const sources = await testWeb(async () => { 151 151 + const mod = await import("~/components/input/icecast/element.js"); 152 152 + const input = new mod.CLASS(); 153 153 + document.body.append(input); 154 154 + 155 155 + const tracks: Track[] = [ 156 156 + { 157 157 + $type: "sh.diffuse.output.track", 158 158 + id: "1", 159 159 + uri: "icecast://radio.example.com/stream.mp3", 160 160 + }, 161 161 + ]; 162 162 + 163 163 + return input.sources(tracks); 164 164 + }); 165 165 + 166 166 + expect(sources.length).toBeGreaterThan(0); 167 167 + expect(sources[0].uri).toContain("icecast://"); 168 168 + }); 169 169 + });

+141

tests/components/input/local/test.ts

reviewed

··· 1 1 + import { describe, it } from "@std/testing/bdd"; 2 2 + import { expect } from "@std/expect"; 3 3 + 4 4 + import { testWeb } from "@tests/common/index.ts"; 5 5 + import type { Track } from "~/definitions/types.d.ts"; 6 6 + 7 7 + describe("components/input/local", () => { 8 8 + it("has correct SCHEME property", async () => { 9 9 + const scheme = await testWeb(async () => { 10 10 + const mod = await import("~/components/input/local/element.js"); 11 11 + const input = new mod.CLASS(); 12 12 + document.body.append(input); 13 13 + return input.SCHEME; 14 14 + }); 15 15 + 16 16 + expect(scheme).toBe("local"); 17 17 + }); 18 18 + 19 19 + it("consult returns unsupported for an unknown TID URI", async () => { 20 20 + const result = await testWeb(async () => { 21 21 + const mod = await import("~/components/input/local/element.js"); 22 22 + const input = new mod.CLASS(); 23 23 + document.body.append(input); 24 24 + return await input.consult("local://unknown-tid-abc123/"); 25 25 + }); 26 26 + 27 27 + // Either no browser support or unknown handle — both return supported: false 28 28 + expect(result.supported).toBe(false); 29 29 + }); 30 30 + 31 31 + it("listCached returns empty array initially", async () => { 32 32 + const result = await testWeb(async () => { 33 33 + const mod = await import("~/components/input/local/element.js"); 34 34 + const input = new mod.CLASS(); 35 35 + document.body.append(input); 36 36 + return await input.list([]); 37 37 + }); 38 38 + 39 39 + expect(result).toEqual([]); 40 40 + }); 41 41 + 42 42 + it("detach with local scheme removes all local tracks", async () => { 43 43 + const remaining = await testWeb(async () => { 44 44 + const mod = await import("~/components/input/local/element.js"); 45 45 + const input = new mod.CLASS(); 46 46 + document.body.append(input); 47 47 + 48 48 + const tracks: Track[] = [ 49 49 + { 50 50 + $type: "sh.diffuse.output.track", 51 51 + id: "1", 52 52 + uri: "local://tid-aaa/track1.mp3", 53 53 + }, 54 54 + { 55 55 + $type: "sh.diffuse.output.track", 56 56 + id: "2", 57 57 + uri: "local://tid-bbb/track2.mp3", 58 58 + }, 59 59 + ]; 60 60 + 61 61 + return await input.detach({ fileUriOrScheme: "local", tracks }); 62 62 + }); 63 63 + 64 64 + expect(remaining.length).toBe(0); 65 65 + }); 66 66 + 67 67 + it("detach with non-matching scheme returns all tracks", async () => { 68 68 + const remaining = await testWeb(async () => { 69 69 + const mod = await import("~/components/input/local/element.js"); 70 70 + const input = new mod.CLASS(); 71 71 + document.body.append(input); 72 72 + 73 73 + const tracks: Track[] = [ 74 74 + { 75 75 + $type: "sh.diffuse.output.track", 76 76 + id: "1", 77 77 + uri: "local://tid-aaa/track1.mp3", 78 78 + }, 79 79 + ]; 80 80 + 81 81 + return await input.detach({ fileUriOrScheme: "https", tracks }); 82 82 + }); 83 83 + 84 84 + expect(remaining.length).toBe(1); 85 85 + }); 86 86 + 87 87 + it("detach with a non-local URI returns all tracks unchanged", async () => { 88 88 + const remaining = await testWeb(async () => { 89 89 + const mod = await import("~/components/input/local/element.js"); 90 90 + const input = new mod.CLASS(); 91 91 + document.body.append(input); 92 92 + 93 93 + const tracks: Track[] = [ 94 94 + { 95 95 + $type: "sh.diffuse.output.track", 96 96 + id: "1", 97 97 + uri: "local://tid-aaa/track1.mp3", 98 98 + }, 99 99 + { 100 100 + $type: "sh.diffuse.output.track", 101 101 + id: "2", 102 102 + uri: "local://tid-bbb/track2.mp3", 103 103 + }, 104 104 + ]; 105 105 + 106 106 + return await input.detach({ 107 107 + fileUriOrScheme: "icecast://some-host/stream", 108 108 + tracks, 109 109 + }); 110 110 + }); 111 111 + 112 112 + // fileUriOrScheme has "://" but scheme doesn't match "local" → tracks unchanged 113 113 + expect(remaining.length).toBe(2); 114 114 + }); 115 115 + 116 116 + it("resolve returns undefined for an unknown TID", async () => { 117 117 + const result = await testWeb(async () => { 118 118 + const mod = await import("~/components/input/local/element.js"); 119 119 + const input = new mod.CLASS(); 120 120 + document.body.append(input); 121 121 + const r = await input.resolve({ uri: "local://unknown-tid/track.mp3" }); 122 122 + return r ?? null; 123 123 + }); 124 124 + 125 125 + expect(result).toBe(null); 126 126 + }); 127 127 + 128 128 + it("groupConsult returns empty object for unknown TIDs", async () => { 129 129 + const result = await testWeb(async () => { 130 130 + const mod = await import("~/components/input/local/element.js"); 131 131 + const input = new mod.CLASS(); 132 132 + document.body.append(input); 133 133 + return await input.groupConsult([ 134 134 + "local://tid-unknown-1/track.mp3", 135 135 + "local://tid-unknown-2/song.flac", 136 136 + ]); 137 137 + }); 138 138 + 139 139 + expect(Object.keys(result).length).toBe(0); 140 140 + }); 141 141 + });

+121

tests/components/input/opensubsonic/test.ts

reviewed

··· 1 1 + import { describe, it } from "@std/testing/bdd"; 2 2 + import { expect } from "@std/expect"; 3 3 + 4 4 + import { testWeb } from "@tests/common/index.ts"; 5 5 + import type { Track } from "~/definitions/types.d.ts"; 6 6 + 7 7 + describe("components/input/opensubsonic", () => { 8 8 + it("has correct SCHEME property", async () => { 9 9 + const scheme = await testWeb(async () => { 10 10 + const mod = await import("~/components/input/opensubsonic/element.js"); 11 11 + const input = new mod.CLASS(); 12 12 + document.body.append(input); 13 13 + return input.SCHEME; 14 14 + }); 15 15 + 16 16 + expect(scheme).toBe("opensubsonic"); 17 17 + }); 18 18 + 19 19 + it("consult returns undetermined for scheme only", async () => { 20 20 + const result = await testWeb(async () => { 21 21 + const mod = await import("~/components/input/opensubsonic/element.js"); 22 22 + const input = new mod.CLASS(); 23 23 + document.body.append(input); 24 24 + return await input.consult("opensubsonic"); 25 25 + }); 26 26 + 27 27 + expect(result.supported).toBe(true); 28 28 + if (result.supported) { 29 29 + expect(result.consult).toBe("undetermined"); 30 30 + } 31 31 + }); 32 32 + 33 33 + it("consult returns undetermined for a full URI (defers to network check)", async () => { 34 34 + const result = await testWeb(async () => { 35 35 + const mod = await import("~/components/input/opensubsonic/element.js"); 36 36 + const input = new mod.CLASS(); 37 37 + document.body.append(input); 38 38 + return await input.consult( 39 39 + "opensubsonic://user:pass@localhost:4040?tls=0", 40 40 + ); 41 41 + }); 42 42 + 43 43 + // consultServerCached will fail to reach the server and return false 44 44 + expect(result.supported).toBe(true); 45 45 + }); 46 46 + 47 47 + it("detach with opensubsonic scheme removes all opensubsonic tracks", async () => { 48 48 + const remaining = await testWeb(async () => { 49 49 + const mod = await import("~/components/input/opensubsonic/element.js"); 50 50 + const input = new mod.CLASS(); 51 51 + document.body.append(input); 52 52 + 53 53 + const tracks: Track[] = [ 54 54 + { 55 55 + $type: "sh.diffuse.output.track", 56 56 + id: "1", 57 57 + uri: "opensubsonic://user:pass@subsonic.example.com?tls=t", 58 58 + }, 59 59 + { 60 60 + $type: "sh.diffuse.output.track", 61 61 + id: "2", 62 62 + uri: "opensubsonic://user:pass@other.example.com?tls=t", 63 63 + }, 64 64 + ]; 65 65 + 66 66 + return await input.detach({ fileUriOrScheme: "opensubsonic", tracks }); 67 67 + }); 68 68 + 69 69 + expect(remaining.length).toBe(0); 70 70 + }); 71 71 + 72 72 + it("detach with non-matching scheme returns all tracks", async () => { 73 73 + const remaining = await testWeb(async () => { 74 74 + const mod = await import("~/components/input/opensubsonic/element.js"); 75 75 + const input = new mod.CLASS(); 76 76 + document.body.append(input); 77 77 + 78 78 + const tracks: Track[] = [ 79 79 + { 80 80 + $type: "sh.diffuse.output.track", 81 81 + id: "1", 82 82 + uri: "opensubsonic://user:pass@subsonic.example.com?tls=t", 83 83 + }, 84 84 + ]; 85 85 + 86 86 + return await input.detach({ fileUriOrScheme: "https", tracks }); 87 87 + }); 88 88 + 89 89 + expect(remaining.length).toBe(1); 90 90 + }); 91 91 + 92 92 + it("detach with specific server URI removes only matching tracks", async () => { 93 93 + const remaining = await testWeb(async () => { 94 94 + const mod = await import("~/components/input/opensubsonic/element.js"); 95 95 + const input = new mod.CLASS(); 96 96 + document.body.append(input); 97 97 + 98 98 + const tracks: Track[] = [ 99 99 + { 100 100 + $type: "sh.diffuse.output.track", 101 101 + id: "1", 102 102 + uri: "opensubsonic://user:pass@server-a.example.com?tls=t", 103 103 + }, 104 104 + { 105 105 + $type: "sh.diffuse.output.track", 106 106 + id: "2", 107 107 + uri: "opensubsonic://user:pass@server-b.example.com?tls=t", 108 108 + }, 109 109 + ]; 110 110 + 111 111 + return await input.detach({ 112 112 + fileUriOrScheme: 113 113 + "opensubsonic://user:pass@server-a.example.com?tls=t", 114 114 + tracks, 115 115 + }); 116 116 + }); 117 117 + 118 118 + expect(remaining.length).toBe(1); 119 119 + expect(remaining[0].id).toBe("2"); 120 120 + }); 121 121 + });

+143

tests/components/input/s3/test.ts

reviewed

··· 1 1 + import { describe, it } from "@std/testing/bdd"; 2 2 + import { expect } from "@std/expect"; 3 3 + 4 4 + import { testWeb } from "@tests/common/index.ts"; 5 5 + import type { Track } from "~/definitions/types.d.ts"; 6 6 + 7 7 + describe("components/input/s3", () => { 8 8 + it("has correct SCHEME property", async () => { 9 9 + const scheme = await testWeb(async () => { 10 10 + const mod = await import("~/components/input/s3/element.js"); 11 11 + const input = new mod.CLASS(); 12 12 + document.body.append(input); 13 13 + return input.SCHEME; 14 14 + }); 15 15 + 16 16 + expect(scheme).toBe("s3"); 17 17 + }); 18 18 + 19 19 + it("consult returns undetermined for scheme only", async () => { 20 20 + const result = await testWeb(async () => { 21 21 + const mod = await import("~/components/input/s3/element.js"); 22 22 + const input = new mod.CLASS(); 23 23 + document.body.append(input); 24 24 + return await input.consult("s3"); 25 25 + }); 26 26 + 27 27 + expect(result.supported).toBe(true); 28 28 + if (result.supported) { 29 29 + expect(result.consult).toBe("undetermined"); 30 30 + } 31 31 + }); 32 32 + 33 33 + it("consult returns undetermined for an invalid S3 URI", async () => { 34 34 + const result = await testWeb(async () => { 35 35 + const mod = await import("~/components/input/s3/element.js"); 36 36 + const input = new mod.CLASS(); 37 37 + document.body.append(input); 38 38 + return await input.consult("s3://notvalid"); 39 39 + }); 40 40 + 41 41 + expect(result.supported).toBe(true); 42 42 + if (result.supported) { 43 43 + expect(result.consult).toBe("undetermined"); 44 44 + } 45 45 + }); 46 46 + 47 47 + it("detach with s3 scheme removes all s3 tracks", async () => { 48 48 + const remaining = await testWeb(async () => { 49 49 + const mod = await import("~/components/input/s3/element.js"); 50 50 + const input = new mod.CLASS(); 51 51 + document.body.append(input); 52 52 + 53 53 + const tracks: Track[] = [ 54 54 + { 55 55 + $type: "sh.diffuse.output.track", 56 56 + id: "1", 57 57 + uri: "s3://key:secret@s3.amazonaws.com/music/track1.mp3?bucketName=my-bucket&region=us-east-1", 58 58 + }, 59 59 + { 60 60 + $type: "sh.diffuse.output.track", 61 61 + id: "2", 62 62 + uri: "s3://key:secret@s3.amazonaws.com/music/track2.mp3?bucketName=my-bucket&region=us-east-1", 63 63 + }, 64 64 + ]; 65 65 + 66 66 + return await input.detach({ fileUriOrScheme: "s3", tracks }); 67 67 + }); 68 68 + 69 69 + expect(remaining.length).toBe(0); 70 70 + }); 71 71 + 72 72 + it("detach with non-matching scheme returns all tracks", async () => { 73 73 + const remaining = await testWeb(async () => { 74 74 + const mod = await import("~/components/input/s3/element.js"); 75 75 + const input = new mod.CLASS(); 76 76 + document.body.append(input); 77 77 + 78 78 + const tracks: Track[] = [ 79 79 + { 80 80 + $type: "sh.diffuse.output.track", 81 81 + id: "1", 82 82 + uri: "s3://key:secret@s3.amazonaws.com/music/track1.mp3?bucketName=my-bucket&region=us-east-1", 83 83 + }, 84 84 + ]; 85 85 + 86 86 + return await input.detach({ fileUriOrScheme: "https", tracks }); 87 87 + }); 88 88 + 89 89 + expect(remaining.length).toBe(1); 90 90 + }); 91 91 + 92 92 + it("detach with specific bucket URI removes only matching tracks", async () => { 93 93 + const remaining = await testWeb(async () => { 94 94 + const mod = await import("~/components/input/s3/element.js"); 95 95 + const input = new mod.CLASS(); 96 96 + document.body.append(input); 97 97 + 98 98 + // bucketId is keyed by accessKey:secretKey@host — use different hosts 99 99 + const tracks: Track[] = [ 100 100 + { 101 101 + $type: "sh.diffuse.output.track", 102 102 + id: "1", 103 103 + uri: "s3://key:secret@s3-host-a.amazonaws.com/track1.mp3?bucketName=bucket-a&region=us-east-1", 104 104 + }, 105 105 + { 106 106 + $type: "sh.diffuse.output.track", 107 107 + id: "2", 108 108 + uri: "s3://key:secret@s3-host-b.amazonaws.com/track2.mp3?bucketName=bucket-b&region=us-east-1", 109 109 + }, 110 110 + ]; 111 111 + 112 112 + return await input.detach({ 113 113 + fileUriOrScheme: 114 114 + "s3://key:secret@s3-host-a.amazonaws.com/?bucketName=bucket-a&region=us-east-1", 115 115 + tracks, 116 116 + }); 117 117 + }); 118 118 + 119 119 + expect(remaining.length).toBe(1); 120 120 + expect(remaining[0].id).toBe("2"); 121 121 + }); 122 122 + 123 123 + it("sources returns labels with bucket name and host", async () => { 124 124 + const sources = await testWeb(async () => { 125 125 + const mod = await import("~/components/input/s3/element.js"); 126 126 + const input = new mod.CLASS(); 127 127 + document.body.append(input); 128 128 + 129 129 + const tracks: Track[] = [ 130 130 + { 131 131 + $type: "sh.diffuse.output.track", 132 132 + id: "1", 133 133 + uri: "s3://key:secret@s3.amazonaws.com/music/track1.mp3?bucketName=my-bucket&region=us-east-1", 134 134 + }, 135 135 + ]; 136 136 + 137 137 + return input.sources(tracks); 138 138 + }); 139 139 + 140 140 + expect(sources.length).toBe(1); 141 141 + expect(sources[0].label).toContain("my-bucket"); 142 142 + }); 143 143 + });