+181

tests/components/engine/audio/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 + 6 6 + describe("components/engine/audio", () => { 7 7 + it("has default volume of 0.75", async () => { 8 8 + const result = await testWeb(async () => { 9 9 + const mod = await import("~/components/engine/audio/element.js"); 10 10 + const engine = new mod.CLASS(); 11 11 + document.body.append(engine); 12 12 + return engine.volume(); 13 13 + }); 14 14 + 15 15 + expect(result).toBe(0.75); 16 16 + }); 17 17 + 18 18 + it("adjustVolume updates the global volume signal", async () => { 19 19 + const result = await testWeb(async () => { 20 20 + const mod = await import("~/components/engine/audio/element.js"); 21 21 + const engine = new mod.CLASS(); 22 22 + document.body.append(engine); 23 23 + engine.adjustVolume({ volume: 0.5 }); 24 24 + return engine.volume(); 25 25 + }); 26 26 + 27 27 + expect(result).toBe(0.5); 28 28 + }); 29 29 + 30 30 + it("adjustVolume clamps to the provided value", async () => { 31 31 + const result = await testWeb(async () => { 32 32 + const mod = await import("~/components/engine/audio/element.js"); 33 33 + const engine = new mod.CLASS(); 34 34 + document.body.append(engine); 35 35 + engine.adjustVolume({ volume: 1.0 }); 36 36 + return engine.volume(); 37 37 + }); 38 38 + 39 39 + expect(result).toBe(1.0); 40 40 + }); 41 41 + 42 42 + it("isPlaying returns false with no items", async () => { 43 43 + const result = await testWeb(async () => { 44 44 + const mod = await import("~/components/engine/audio/element.js"); 45 45 + const engine = new mod.CLASS(); 46 46 + document.body.append(engine); 47 47 + return engine.isPlaying(); 48 48 + }); 49 49 + 50 50 + expect(result).toBe(false); 51 51 + }); 52 52 + 53 53 + it("supply with URL items updates the items signal", async () => { 54 54 + const result = await testWeb(async () => { 55 55 + const mod = await import("~/components/engine/audio/element.js"); 56 56 + const { trackA, trackB } = await import("~/testing/sample/tracks.js"); 57 57 + const engine = new mod.CLASS(); 58 58 + document.body.append(engine); 59 59 + 60 60 + engine.supply({ 61 61 + audio: [ 62 62 + { id: "audio-a", url: trackA.uri, isPreload: false, track: trackA }, 63 63 + { id: "audio-b", url: trackB.uri, isPreload: false, track: trackB }, 64 64 + ], 65 65 + }); 66 66 + 67 67 + return engine.items().map((i) => i.id); 68 68 + }); 69 69 + 70 70 + expect(result).toEqual(["audio-a", "audio-b"]); 71 71 + }); 72 72 + 73 73 + it("supply with same IDs does not update items signal", async () => { 74 74 + const result = await testWeb(async () => { 75 75 + const mod = await import("~/components/engine/audio/element.js"); 76 76 + const { trackA } = await import("~/testing/sample/tracks.js"); 77 77 + const engine = new mod.CLASS(); 78 78 + document.body.append(engine); 79 79 + 80 80 + const item = { id: "audio-a", url: trackA.uri, isPreload: false, track: trackA }; 81 81 + 82 82 + engine.supply({ audio: [item] }); 83 83 + const itemsAfterFirst = engine.items(); 84 84 + 85 85 + engine.supply({ audio: [item] }); 86 86 + const itemsAfterSecond = engine.items(); 87 87 + 88 88 + // Same reference means the signal was not updated 89 89 + return itemsAfterFirst === itemsAfterSecond; 90 90 + }); 91 91 + 92 92 + expect(result).toBe(true); 93 93 + }); 94 94 + 95 95 + it("supply replaces items when IDs change", async () => { 96 96 + const result = await testWeb(async () => { 97 97 + const mod = await import("~/components/engine/audio/element.js"); 98 98 + const { trackA, trackB } = await import("~/testing/sample/tracks.js"); 99 99 + const engine = new mod.CLASS(); 100 100 + document.body.append(engine); 101 101 + 102 102 + engine.supply({ 103 103 + audio: [ 104 104 + { id: "audio-a", url: trackA.uri, isPreload: false, track: trackA }, 105 105 + ], 106 106 + }); 107 107 + 108 108 + engine.supply({ 109 109 + audio: [ 110 110 + { id: "audio-b", url: trackB.uri, isPreload: false, track: trackB }, 111 111 + ], 112 112 + }); 113 113 + 114 114 + return engine.items().map((i) => i.id); 115 115 + }); 116 116 + 117 117 + expect(result).toEqual(["audio-b"]); 118 118 + }); 119 119 + 120 120 + it("supply with isPreload change triggers items update", async () => { 121 121 + const result = await testWeb(async () => { 122 122 + const mod = await import("~/components/engine/audio/element.js"); 123 123 + const { trackA } = await import("~/testing/sample/tracks.js"); 124 124 + const engine = new mod.CLASS(); 125 125 + document.body.append(engine); 126 126 + 127 127 + engine.supply({ 128 128 + audio: [ 129 129 + { id: "audio-a", url: trackA.uri, isPreload: true, track: trackA }, 130 130 + ], 131 131 + }); 132 132 + 133 133 + engine.supply({ 134 134 + audio: [ 135 135 + { id: "audio-a", url: trackA.uri, isPreload: false, track: trackA }, 136 136 + ], 137 137 + }); 138 138 + 139 139 + return engine.items()[0]?.isPreload; 140 140 + }); 141 141 + 142 142 + expect(result).toBe(false); 143 143 + }); 144 144 + 145 145 + it("persists volume to localStorage", async () => { 146 146 + const stored = await testWeb(async () => { 147 147 + const mod = await import("~/components/engine/audio/element.js"); 148 148 + const engine = new mod.CLASS(); 149 149 + document.body.append(engine); 150 150 + engine.adjustVolume({ volume: 0.3 }); 151 151 + 152 152 + for (let i = 0; i < localStorage.length; i++) { 153 153 + const key = localStorage.key(i)!; 154 154 + if (key.includes("engine/audio") && key.endsWith("/volume")) { 155 155 + return localStorage.getItem(key); 156 156 + } 157 157 + } 158 158 + return null; 159 159 + }); 160 160 + 161 161 + expect(stored).toBe("0.3"); 162 162 + }); 163 163 + 164 164 + it("restores volume from localStorage on connect", async () => { 165 165 + const result = await testWeb(async () => { 166 166 + const mod = await import("~/components/engine/audio/element.js"); 167 167 + 168 168 + // Set volume with first engine instance 169 169 + const engine1 = new mod.CLASS(); 170 170 + document.body.append(engine1); 171 171 + engine1.adjustVolume({ volume: 0.4 }); 172 172 + 173 173 + // Second instance reads from localStorage 174 174 + const engine2 = new mod.CLASS(); 175 175 + document.body.append(engine2); 176 176 + return engine2.volume(); 177 177 + }); 178 178 + 179 179 + expect(result).toBe(0.4); 180 180 + }); 181 181 + });

+176

tests/components/engine/repeat-shuffle/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 + 6 6 + describe("components/engine/repeat-shuffle", () => { 7 7 + it("defaults to false for both repeat and shuffle", async () => { 8 8 + const result = await testWeb(async () => { 9 9 + const mod = await import( 10 10 + "~/components/engine/repeat-shuffle/element.js" 11 11 + ); 12 12 + const engine = new mod.CLASS(); 13 13 + document.body.append(engine); 14 14 + return { repeat: engine.repeat(), shuffle: engine.shuffle() }; 15 15 + }); 16 16 + 17 17 + expect(result.repeat).toBe(false); 18 18 + expect(result.shuffle).toBe(false); 19 19 + }); 20 20 + 21 21 + it("setRepeat sets repeat to true", async () => { 22 22 + const result = await testWeb(async () => { 23 23 + const mod = await import( 24 24 + "~/components/engine/repeat-shuffle/element.js" 25 25 + ); 26 26 + const engine = new mod.CLASS(); 27 27 + document.body.append(engine); 28 28 + await engine.setRepeat(true); 29 29 + return engine.repeat(); 30 30 + }); 31 31 + 32 32 + expect(result).toBe(true); 33 33 + }); 34 34 + 35 35 + it("setRepeat sets repeat back to false", async () => { 36 36 + const result = await testWeb(async () => { 37 37 + const mod = await import( 38 38 + "~/components/engine/repeat-shuffle/element.js" 39 39 + ); 40 40 + const engine = new mod.CLASS(); 41 41 + document.body.append(engine); 42 42 + await engine.setRepeat(true); 43 43 + await engine.setRepeat(false); 44 44 + return engine.repeat(); 45 45 + }); 46 46 + 47 47 + expect(result).toBe(false); 48 48 + }); 49 49 + 50 50 + it("setShuffle sets shuffle to true", async () => { 51 51 + const result = await testWeb(async () => { 52 52 + const mod = await import( 53 53 + "~/components/engine/repeat-shuffle/element.js" 54 54 + ); 55 55 + const engine = new mod.CLASS(); 56 56 + document.body.append(engine); 57 57 + await engine.setShuffle(true); 58 58 + return engine.shuffle(); 59 59 + }); 60 60 + 61 61 + expect(result).toBe(true); 62 62 + }); 63 63 + 64 64 + it("setShuffle sets shuffle back to false", async () => { 65 65 + const result = await testWeb(async () => { 66 66 + const mod = await import( 67 67 + "~/components/engine/repeat-shuffle/element.js" 68 68 + ); 69 69 + const engine = new mod.CLASS(); 70 70 + document.body.append(engine); 71 71 + await engine.setShuffle(true); 72 72 + await engine.setShuffle(false); 73 73 + return engine.shuffle(); 74 74 + }); 75 75 + 76 76 + expect(result).toBe(false); 77 77 + }); 78 78 + 79 79 + it("repeat and shuffle are independent", async () => { 80 80 + const result = await testWeb(async () => { 81 81 + const mod = await import( 82 82 + "~/components/engine/repeat-shuffle/element.js" 83 83 + ); 84 84 + const engine = new mod.CLASS(); 85 85 + document.body.append(engine); 86 86 + await engine.setRepeat(true); 87 87 + return { repeat: engine.repeat(), shuffle: engine.shuffle() }; 88 88 + }); 89 89 + 90 90 + expect(result.repeat).toBe(true); 91 91 + expect(result.shuffle).toBe(false); 92 92 + }); 93 93 + 94 94 + it("persists repeat to localStorage", async () => { 95 95 + const stored = await testWeb(async () => { 96 96 + const mod = await import( 97 97 + "~/components/engine/repeat-shuffle/element.js" 98 98 + ); 99 99 + const engine = new mod.CLASS(); 100 100 + document.body.append(engine); 101 101 + await engine.setRepeat(true); 102 102 + 103 103 + // Find the key by iterating localStorage 104 104 + for (let i = 0; i < localStorage.length; i++) { 105 105 + const key = localStorage.key(i)!; 106 106 + if (key.includes("repeat-shuffle") && key.endsWith("/repeat")) { 107 107 + return localStorage.getItem(key); 108 108 + } 109 109 + } 110 110 + return null; 111 111 + }); 112 112 + 113 113 + expect(stored).toBe("true"); 114 114 + }); 115 115 + 116 116 + it("persists shuffle to localStorage", async () => { 117 117 + const stored = await testWeb(async () => { 118 118 + const mod = await import( 119 119 + "~/components/engine/repeat-shuffle/element.js" 120 120 + ); 121 121 + const engine = new mod.CLASS(); 122 122 + document.body.append(engine); 123 123 + await engine.setShuffle(true); 124 124 + 125 125 + for (let i = 0; i < localStorage.length; i++) { 126 126 + const key = localStorage.key(i)!; 127 127 + if (key.includes("repeat-shuffle") && key.endsWith("/shuffle")) { 128 128 + return localStorage.getItem(key); 129 129 + } 130 130 + } 131 131 + return null; 132 132 + }); 133 133 + 134 134 + expect(stored).toBe("true"); 135 135 + }); 136 136 + 137 137 + it("restores repeat state from localStorage on connect", async () => { 138 138 + const result = await testWeb(async () => { 139 139 + const mod = await import( 140 140 + "~/components/engine/repeat-shuffle/element.js" 141 141 + ); 142 142 + 143 143 + // Set state with first engine instance 144 144 + const engine1 = new mod.CLASS(); 145 145 + document.body.append(engine1); 146 146 + await engine1.setRepeat(true); 147 147 + 148 148 + // Second instance reads same localStorage key 149 149 + const engine2 = new mod.CLASS(); 150 150 + document.body.append(engine2); 151 151 + return engine2.repeat(); 152 152 + }); 153 153 + 154 154 + expect(result).toBe(true); 155 155 + }); 156 156 + 157 157 + it("restores shuffle state from localStorage on connect", async () => { 158 158 + const result = await testWeb(async () => { 159 159 + const mod = await import( 160 160 + "~/components/engine/repeat-shuffle/element.js" 161 161 + ); 162 162 + 163 163 + // Set state with first engine instance 164 164 + const engine1 = new mod.CLASS(); 165 165 + document.body.append(engine1); 166 166 + await engine1.setShuffle(true); 167 167 + 168 168 + // Second instance reads same localStorage key 169 169 + const engine2 = new mod.CLASS(); 170 170 + document.body.append(engine2); 171 171 + return engine2.shuffle(); 172 172 + }); 173 173 + 174 174 + expect(result).toBe(true); 175 175 + }); 176 176 + });

+216

tests/components/engine/scope/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 + 6 6 + describe("components/engine/scope", () => { 7 7 + it("has default sortBy of ['createdAt']", async () => { 8 8 + const result = await testWeb(async () => { 9 9 + const mod = await import("~/components/engine/scope/element.js"); 10 10 + const engine = new mod.CLASS(); 11 11 + document.body.append(engine); 12 12 + return engine.sortBy(); 13 13 + }); 14 14 + 15 15 + expect(result).toEqual(["createdAt"]); 16 16 + }); 17 17 + 18 18 + it("has default sortDirection of 'desc'", async () => { 19 19 + const result = await testWeb(async () => { 20 20 + const mod = await import("~/components/engine/scope/element.js"); 21 21 + const engine = new mod.CLASS(); 22 22 + document.body.append(engine); 23 23 + return engine.sortDirection(); 24 24 + }); 25 25 + 26 26 + expect(result).toBe("desc"); 27 27 + }); 28 28 + 29 29 + it("has default groupBy of undefined", async () => { 30 30 + const result = await testWeb(async () => { 31 31 + const mod = await import("~/components/engine/scope/element.js"); 32 32 + const engine = new mod.CLASS(); 33 33 + document.body.append(engine); 34 34 + return engine.groupBy() ?? null; 35 35 + }); 36 36 + 37 37 + expect(result).toBe(null); 38 38 + }); 39 39 + 40 40 + it("has default playlist of undefined", async () => { 41 41 + const result = await testWeb(async () => { 42 42 + const mod = await import("~/components/engine/scope/element.js"); 43 43 + const engine = new mod.CLASS(); 44 44 + document.body.append(engine); 45 45 + return engine.playlist() ?? null; 46 46 + }); 47 47 + 48 48 + expect(result).toBe(null); 49 49 + }); 50 50 + 51 51 + it("has default searchTerm of undefined", async () => { 52 52 + const result = await testWeb(async () => { 53 53 + const mod = await import("~/components/engine/scope/element.js"); 54 54 + const engine = new mod.CLASS(); 55 55 + document.body.append(engine); 56 56 + return engine.searchTerm() ?? null; 57 57 + }); 58 58 + 59 59 + expect(result).toBe(null); 60 60 + }); 61 61 + 62 62 + it("setGroupBy updates groupBy", async () => { 63 63 + const result = await testWeb(async () => { 64 64 + const mod = await import("~/components/engine/scope/element.js"); 65 65 + const engine = new mod.CLASS(); 66 66 + document.body.append(engine); 67 67 + await engine.setGroupBy("artist"); 68 68 + return engine.groupBy(); 69 69 + }); 70 70 + 71 71 + expect(result).toBe("artist"); 72 72 + }); 73 73 + 74 74 + it("setGroupBy with undefined clears groupBy", async () => { 75 75 + const result = await testWeb(async () => { 76 76 + const mod = await import("~/components/engine/scope/element.js"); 77 77 + const engine = new mod.CLASS(); 78 78 + document.body.append(engine); 79 79 + await engine.setGroupBy("artist"); 80 80 + await engine.setGroupBy(undefined); 81 81 + return engine.groupBy() ?? null; 82 82 + }); 83 83 + 84 84 + expect(result).toBe(null); 85 85 + }); 86 86 + 87 87 + it("setPlaylist updates playlist", async () => { 88 88 + const result = await testWeb(async () => { 89 89 + const mod = await import("~/components/engine/scope/element.js"); 90 90 + const engine = new mod.CLASS(); 91 91 + document.body.append(engine); 92 92 + await engine.setPlaylist("playlist-123"); 93 93 + return engine.playlist(); 94 94 + }); 95 95 + 96 96 + expect(result).toBe("playlist-123"); 97 97 + }); 98 98 + 99 99 + it("setSearchTerm updates searchTerm", async () => { 100 100 + const result = await testWeb(async () => { 101 101 + const mod = await import("~/components/engine/scope/element.js"); 102 102 + const engine = new mod.CLASS(); 103 103 + document.body.append(engine); 104 104 + await engine.setSearchTerm("hello world"); 105 105 + return engine.searchTerm(); 106 106 + }); 107 107 + 108 108 + expect(result).toBe("hello world"); 109 109 + }); 110 110 + 111 111 + it("setSortBy updates sortBy", async () => { 112 112 + const result = await testWeb(async () => { 113 113 + const mod = await import("~/components/engine/scope/element.js"); 114 114 + const engine = new mod.CLASS(); 115 115 + document.body.append(engine); 116 116 + await engine.setSortBy(["title", "artist"]); 117 117 + return engine.sortBy(); 118 118 + }); 119 119 + 120 120 + expect(result).toEqual(["title", "artist"]); 121 121 + }); 122 122 + 123 123 + it("setSortDirection updates sortDirection", async () => { 124 124 + const result = await testWeb(async () => { 125 125 + const mod = await import("~/components/engine/scope/element.js"); 126 126 + const engine = new mod.CLASS(); 127 127 + document.body.append(engine); 128 128 + await engine.setSortDirection("asc"); 129 129 + return engine.sortDirection(); 130 130 + }); 131 131 + 132 132 + expect(result).toBe("asc"); 133 133 + }); 134 134 + 135 135 + it("revertToDefaultSort resets sortBy and sortDirection", async () => { 136 136 + const result = await testWeb(async () => { 137 137 + const mod = await import("~/components/engine/scope/element.js"); 138 138 + const engine = new mod.CLASS(); 139 139 + document.body.append(engine); 140 140 + await engine.setSortBy(["title"]); 141 141 + await engine.setSortDirection("asc"); 142 142 + await engine.revertToDefaultSort(); 143 143 + return { sortBy: engine.sortBy(), sortDirection: engine.sortDirection() }; 144 144 + }); 145 145 + 146 146 + expect(result.sortBy).toEqual(["createdAt"]); 147 147 + expect(result.sortDirection).toBe("desc"); 148 148 + }); 149 149 + 150 150 + it("persists groupBy to localStorage", async () => { 151 151 + const stored = await testWeb(async () => { 152 152 + const mod = await import("~/components/engine/scope/element.js"); 153 153 + const engine = new mod.CLASS(); 154 154 + document.body.append(engine); 155 155 + await engine.setGroupBy("album"); 156 156 + 157 157 + for (let i = 0; i < localStorage.length; i++) { 158 158 + const key = localStorage.key(i)!; 159 159 + if (key.includes("scope") && key.endsWith("/groupBy")) { 160 160 + return localStorage.getItem(key); 161 161 + } 162 162 + } 163 163 + return null; 164 164 + }); 165 165 + 166 166 + expect(stored).toBe("album"); 167 167 + }); 168 168 + 169 169 + it("persists sortBy to localStorage as JSON", async () => { 170 170 + const stored = await testWeb(async () => { 171 171 + const mod = await import("~/components/engine/scope/element.js"); 172 172 + const engine = new mod.CLASS(); 173 173 + document.body.append(engine); 174 174 + await engine.setSortBy(["title", "artist"]); 175 175 + 176 176 + for (let i = 0; i < localStorage.length; i++) { 177 177 + const key = localStorage.key(i)!; 178 178 + if (key.includes("scope") && key.endsWith("/sortBy")) { 179 179 + return localStorage.getItem(key); 180 180 + } 181 181 + } 182 182 + return null; 183 183 + }); 184 184 + 185 185 + expect(stored).toBe('["title","artist"]'); 186 186 + }); 187 187 + 188 188 + it("restores values from localStorage on connect", async () => { 189 189 + const result = await testWeb(async () => { 190 190 + const mod = await import("~/components/engine/scope/element.js"); 191 191 + 192 192 + // Set state with first engine instance 193 193 + const engine1 = new mod.CLASS(); 194 194 + document.body.append(engine1); 195 195 + await engine1.setGroupBy("artist"); 196 196 + await engine1.setSearchTerm("test"); 197 197 + await engine1.setSortBy(["title"]); 198 198 + await engine1.setSortDirection("asc"); 199 199 + 200 200 + // Second instance reads same localStorage keys 201 201 + const engine2 = new mod.CLASS(); 202 202 + document.body.append(engine2); 203 203 + return { 204 204 + groupBy: engine2.groupBy(), 205 205 + searchTerm: engine2.searchTerm(), 206 206 + sortBy: engine2.sortBy(), 207 207 + sortDirection: engine2.sortDirection(), 208 208 + }; 209 209 + }); 210 210 + 211 211 + expect(result.groupBy).toBe("artist"); 212 212 + expect(result.searchTerm).toBe("test"); 213 213 + expect(result.sortBy).toEqual(["title"]); 214 214 + expect(result.sortDirection).toBe("asc"); 215 215 + }); 216 216 + });