steelseries-sonar-sdk 0.2.0 → 0.2.3

package/tests/e2e/chatmix/get-chat-mix-state.real.test.ts

@@ -1,25 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { getEndpointEndToEnd } from 'tests/helpers/get-endpoint-e2e'
-import { AudioMode, ChatMixState } from '@/enums'
-import { setAudioMode } from '@/functions/audio/set-audio-mode'
-import { getChatMixState } from '@/functions/chatmix/get-chat-mix-state'
-
-describe('getChatMixState', () => {
-	it('returns enabled state when classic', async () => {
-		const sonarEndpoint = await getEndpointEndToEnd()
-		await setAudioMode(sonarEndpoint, AudioMode.Classic)
-		const result = await getChatMixState(sonarEndpoint)
-		expect(result).not.toBeNull()
-		expect(result.state).toBe(ChatMixState.Enabled)
-		expect(result.isEnabled).toBeTrue()
-	})
-
-	it('returns disabled state when streamer', async () => {
-		const sonarEndpoint = await getEndpointEndToEnd()
-		await setAudioMode(sonarEndpoint, AudioMode.Streamer)
-		const result = await getChatMixState(sonarEndpoint)
-		expect(result).not.toBeNull()
-		expect(result.state).toBe(ChatMixState.FiniteWheel)
-		expect(result.isEnabled).toBeFalse()
-	})
-})

package/tests/e2e/chatmix/set-chat-mix-balance.real.test.ts

@@ -1,25 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { getEndpointEndToEnd } from 'tests/helpers/get-endpoint-e2e'
-import { AudioMode, ChatMixState } from '@/enums'
-import { SonarRequestException } from '@/exceptions'
-import { setAudioMode } from '@/functions/audio/set-audio-mode'
-import { setChatMixBalance } from '@/functions/chatmix/set-chat-mix-balance'
-
-describe('setChatBalance', () => {
-	it('returns balance when classic mode', async () => {
-		const expectedBalance = 70
-		const sonarEndpoint = await getEndpointEndToEnd()
-		await setAudioMode(sonarEndpoint, AudioMode.Classic)
-		const result = await setChatMixBalance(sonarEndpoint, expectedBalance)
-		expect(result).not.toBeNull()
-		expect(result.state).toBe(ChatMixState.Enabled)
-		expect(result.isEnabled).toBeTrue()
-		expect(result.chatBalance).toBe(expectedBalance)
-	})
-
-	it('throws when streamer mode enabled', async () => {
-		const sonarEndpoint = await getEndpointEndToEnd()
-		await setAudioMode(sonarEndpoint, AudioMode.Streamer)
-		expect(setChatMixBalance(sonarEndpoint, 0)).rejects.toThrow(SonarRequestException)
-	})
-})

package/tests/e2e/devices/get-audio-devices.real.test.ts

@@ -1,29 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { getEndpointEndToEnd } from 'tests/helpers/get-endpoint-e2e'
-import { DeviceFlow } from '@/enums'
-import { getAudioDevices } from '@/functions/devices/get-audio-devices'
-
-describe('getAudioDevices', () => {
-	it('returns audio devices for input', async () => {
-		const sonarEndpoint = await getEndpointEndToEnd()
-		const result = await getAudioDevices(sonarEndpoint, DeviceFlow.Input)
-		expect(result.length).toBeGreaterThan(0)
-	})
-
-	it('returns audio devices for output', async () => {
-		const sonarEndpoint = await getEndpointEndToEnd()
-		const result = await getAudioDevices(sonarEndpoint, DeviceFlow.Output)
-		expect(result.length).toBeGreaterThan(0)
-	})
-
-	it('returns combined audio devices for all', async () => {
-		const sonarEndpoint = await getEndpointEndToEnd()
-		const resultInput = await getAudioDevices(sonarEndpoint, DeviceFlow.Input)
-		const resultOutput = await getAudioDevices(sonarEndpoint, DeviceFlow.Output)
-		const resultAll = await getAudioDevices(sonarEndpoint)
-		expect(resultInput.length).toBeGreaterThan(0)
-		expect(resultOutput.length).toBeGreaterThan(0)
-		expect(resultAll.length).toBeGreaterThan(0)
-		expect(resultAll.length).toBe(resultInput.length + resultOutput.length)
-	})
-})

package/tests/e2e/devices/set-audio-device.real.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { getEndpointEndToEnd } from 'tests/helpers/get-endpoint-e2e'
-import { DeviceChannel } from '@/enums'
-import { setAudioDevice } from '@/functions/devices/set-audio-device'
-
-const OUTPUT_DEVICE_ID = '{0.0.0.00000000}.{0e5b2eb2-8d10-4e5f-b757-59a3e15def98}'
-const INPUT_DEVICE_ID = '{0.0.1.00000000}.{7b82ae46-28f8-4adb-bdd2-fa08863bc5b7}'
-
-describe('setAudioDevice', () => {
-	it('throws when input set to output', async () => {
-		const sonarEndpoint = await getEndpointEndToEnd()
-		expect(setAudioDevice(sonarEndpoint, DeviceChannel.Mic, OUTPUT_DEVICE_ID)).rejects.toThrow()
-	})
-
-	it('returns set audio devices for all output', async () => {
-		const sonarEndpoint = await getEndpointEndToEnd()
-		const result = await setAudioDevice(sonarEndpoint, DeviceChannel.Output, OUTPUT_DEVICE_ID)
-		expect(result.length).toBe(4)
-	})
-
-	it('returns set audio device for output-aux', async () => {
-		const sonarEndpoint = await getEndpointEndToEnd()
-		const result = await setAudioDevice(sonarEndpoint, DeviceChannel.Aux, OUTPUT_DEVICE_ID)
-		expect(result.length).toBe(1)
-	})
-
-	it('returns set audio device for input', async () => {
-		const sonarEndpoint = await getEndpointEndToEnd()
-		const result = await setAudioDevice(sonarEndpoint, DeviceChannel.Mic, INPUT_DEVICE_ID)
-		expect(result.length).toBe(1)
-	})
-})

package/tests/e2e/enpoint/get-app-endpoint.real.test.ts

@@ -1,19 +0,0 @@
-import { afterEach, describe, expect, it } from 'bun:test'
-import { getAppEndpoint } from '@/functions/endpoint/get-app-endpoint'
-
-const logs: string[] = []
-
-afterEach(() => {
-	for (const log of logs) {
-		console.log(log)
-	}
-	logs.length = 0
-})
-
-describe('getAppEndpoint', () => {
-	it('returns ggEncryptedAddress', async () => {
-		const result = await getAppEndpoint()
-		expect(result).toBeString()
-		logs.push(`> app address: ${result}`)
-	})
-})

package/tests/e2e/enpoint/get-sonar-endpoint-cached.real.test.ts

@@ -1,32 +0,0 @@
-import { afterEach, describe, expect, it, spyOn } from 'bun:test'
-import { getAppEndpoint } from '@/functions/endpoint/get-app-endpoint'
-import { getSonarEndpointCached } from '@/functions/endpoint/get-sonar-endpoint-cached'
-
-const logs: string[] = []
-
-afterEach(() => {
-	for (const log of logs) {
-		console.log(log)
-	}
-	logs.length = 0
-})
-
-const spy = spyOn(globalThis, 'fetch')
-
-describe('getSonarEndpointCached', () => {
-	it('returns sonarAddress', async () => {
-		const appAddress = await getAppEndpoint()
-		const sonarAddress = await getSonarEndpointCached(appAddress)
-		expect(sonarAddress).toBeString()
-		logs.push(`> sonar address: ${sonarAddress}`)
-	})
-
-	it('returns cached sonarAddress', async () => {
-		const appAddress = await getAppEndpoint()
-		await getSonarEndpointCached(appAddress)
-		const sonarAddress = await getSonarEndpointCached(appAddress)
-		expect(sonarAddress).toBeString()
-		expect(spy).toHaveBeenCalledTimes(1)
-		logs.push(`> sonar address: ${sonarAddress}`)
-	})
-})

package/tests/e2e/enpoint/get-sonar-endpoint.real.test.ts

@@ -1,21 +0,0 @@
-import { afterEach, describe, expect, it } from 'bun:test'
-import { getAppEndpoint } from '@/functions/endpoint/get-app-endpoint'
-import { getSonarEndpoint } from '@/functions/endpoint/get-sonar-endpoint'
-
-const logs: string[] = []
-
-afterEach(() => {
-	for (const log of logs) {
-		console.log(log)
-	}
-	logs.length = 0
-})
-
-describe('getSonarEndpoint', () => {
-	it('returns sonarAddress', async () => {
-		const appAddress = await getAppEndpoint()
-		const sonarAddress = await getSonarEndpoint(appAddress)
-		expect(sonarAddress).toBeString()
-		logs.push(`> sonar address: ${sonarAddress}`)
-	})
-})

package/tests/e2e/profiles/get-channel-profiles.real.test.ts

@@ -1,21 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { getEndpointEndToEnd } from 'tests/helpers/get-endpoint-e2e'
-import { ProfileChannel } from '@/enums'
-import { getChannelProfiles } from '@/functions/profile/get-channel-profiles'
-
-describe('getChannelProfiles', () => {
-	it('returns list of profiles', async () => {
-		const sonarEndpoint = await getEndpointEndToEnd()
-		const result = await getChannelProfiles(sonarEndpoint, ProfileChannel.Game)
-		expect(result.length).toBeGreaterThan(1)
-	})
-
-	it('returns list of favorite profiles only', async () => {
-		const sonarEndpoint = await getEndpointEndToEnd()
-		const allProfiles = await getChannelProfiles(sonarEndpoint, ProfileChannel.Game)
-		const favoriteProfiles = await getChannelProfiles(sonarEndpoint, ProfileChannel.Game, true)
-		expect(allProfiles.length).toBeGreaterThan(1)
-		expect(favoriteProfiles.length).toBeGreaterThan(1)
-		expect(favoriteProfiles.length).toBeLessThan(allProfiles.length)
-	})
-})

package/tests/e2e/profiles/get-selected-profiles.real.test.ts

@@ -1,11 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { getEndpointEndToEnd } from 'tests/helpers/get-endpoint-e2e'
-import { getSelectedProfiles } from '@/functions/profile/get-selected-profiles'
-
-describe('getSelectedProfiles', () => {
-	it('returns list of selected profiles', async () => {
-		const sonarEndpoint = await getEndpointEndToEnd()
-		const result = await getSelectedProfiles(sonarEndpoint)
-		expect(result.length).toBeGreaterThanOrEqual(2)
-	})
-})

package/tests/e2e/profiles/set-selected-profile.real.test.ts

@@ -1,17 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { getEndpointEndToEnd } from 'tests/helpers/get-endpoint-e2e'
-import { setSelectedProfile } from '@/functions/profile/set-selected-profile'
-
-const INITIAL_PROFILE = 'e6979db3-3e00-4399-b58c-6f026c9ef6ba'
-const CHANGED_PROFILE = 'c55f5f17-db23-4b0e-805c-02fd3ba39636'
-
-describe('setSelectedProfiles', () => {
-	it('sets profile successfully', async () => {
-		const sonarEndpoint = await getEndpointEndToEnd()
-		const initial = await setSelectedProfile(sonarEndpoint, INITIAL_PROFILE)
-		const changed = await setSelectedProfile(sonarEndpoint, CHANGED_PROFILE)
-		expect(initial.id).toBe(INITIAL_PROFILE)
-		expect(changed.id).toBe(CHANGED_PROFILE)
-		expect(initial.id).not.toBe(changed.id)
-	})
-})

package/tests/helpers/get-endpoint-e2e.ts

@@ -1,8 +0,0 @@
-import { getAppEndpoint } from '../../src/functions/endpoint/get-app-endpoint'
-import { getSonarEndpoint } from '../../src/functions/endpoint/get-sonar-endpoint'
-
-export async function getEndpointEndToEnd() {
-	const appEndpoint = await getAppEndpoint()
-	const sonarEndpoint = await getSonarEndpoint(appEndpoint)
-	return sonarEndpoint
-}

package/tests/unit/audio/get-audio-data-classic.test.ts

@@ -1,57 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
-import { SonarRequestException } from '@/exceptions'
-import { getAudioDataClassic } from '@/functions/audio/get-audio-data-classic'
-
-let originalFetch: typeof fetch
-
-const request = () => getAudioDataClassic('https://localhost')
-
-describe('getAudioDataClassic', () => {
-	beforeEach(() => {
-		originalFetch = globalThis.fetch
-	})
-
-	afterEach(() => {
-		globalThis.fetch = originalFetch
-	})
-
-	it('throws SonarException when response not 200', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: false,
-				json: async () => 'Some error occurred'
-			}) as Response) as unknown as typeof fetch
-
-		expect(request()).rejects.toThrow(SonarRequestException)
-	})
-
-	it('throws SonarException when response 200 but not data', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: true,
-				json: async () => ({})
-			}) as Response) as unknown as typeof fetch
-
-		expect(request()).rejects.toThrow(SonarRequestException)
-	})
-
-	it('return data when response 200', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: true,
-				json: async () => ({
-					masters: {
-						classic: {
-							volume: 0.49,
-							muted: false
-						}
-					},
-					devices: {}
-				})
-			}) as Response) as unknown as typeof fetch
-
-		const response = await request()
-		expect(response.master.volume).toBe(49)
-		expect(response.master.isMuted).toBe(false)
-	})
-})

package/tests/unit/audio/get-audio-data-stream.test.ts

@@ -1,65 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
-import { SonarRequestException } from '@/exceptions'
-import { getAudioDataStream } from '@/functions/audio/get-audio-data-stream'
-
-let originalFetch: typeof fetch
-
-const request = () => getAudioDataStream('https://localhost')
-
-describe('getAudioDataStream', () => {
-	beforeEach(() => {
-		originalFetch = globalThis.fetch
-	})
-
-	afterEach(() => {
-		globalThis.fetch = originalFetch
-	})
-
-	it('throws SonarException when response not 200', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: false,
-				json: async () => 'Some error occurred'
-			}) as Response) as unknown as typeof fetch
-
-		expect(request()).rejects.toThrow(SonarRequestException)
-	})
-
-	it('throws SonarException when response 200 but not data', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: true,
-				json: async () => ({})
-			}) as Response) as unknown as typeof fetch
-
-		expect(request()).rejects.toThrow(SonarRequestException)
-	})
-
-	it('return data when response 200', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: true,
-				json: async () => ({
-					masters: {
-						stream: {
-							streaming: {
-								volume: 0.49,
-								muted: true
-							},
-							monitoring: {
-								volume: 0.48,
-								muted: false
-							}
-						}
-					},
-					devices: {}
-				})
-			}) as Response) as unknown as typeof fetch
-
-		const response = await request()
-		expect(response.master.streaming.volume).toBe(49)
-		expect(response.master.streaming.isMuted).toBe(true)
-		expect(response.master.monitoring.volume).toBe(48)
-		expect(response.master.monitoring.isMuted).toBe(false)
-	})
-})

package/tests/unit/audio/get-audio-mode.test.ts

@@ -1,58 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
-import { AudioMode } from '@/enums'
-import { SonarRequestException } from '@/exceptions'
-import { getAudioMode } from '@/functions/audio/get-audio-mode'
-
-let originalFetch: typeof fetch
-
-const request = () => getAudioMode('https://localhost')
-
-describe('getAudioMode', () => {
-	beforeEach(() => {
-		originalFetch = globalThis.fetch
-	})
-
-	afterEach(() => {
-		globalThis.fetch = originalFetch
-	})
-
-	it('throws SonarException when response not 200', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: false,
-				text: async () => 'Some error occurred'
-			}) as Response) as unknown as typeof fetch
-
-		expect(request()).rejects.toThrow(SonarRequestException)
-	})
-
-	it('throws SonarException when response 200 but not data', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: true,
-				json: async () => ({})
-			}) as Response) as unknown as typeof fetch
-
-		expect(request()).rejects.toThrow(SonarRequestException)
-	})
-
-	it('return classic when response 200', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: true,
-				json: async () => AudioMode.Classic
-			}) as Response) as unknown as typeof fetch
-
-		expect(request()).resolves.toBe(AudioMode.Classic)
-	})
-
-	it('return streamer when response 200', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: true,
-				json: async () => AudioMode.Streamer
-			}) as Response) as unknown as typeof fetch
-
-		expect(request()).resolves.toBe(AudioMode.Streamer)
-	})
-})

package/tests/unit/audio/set-audio-mode.test.ts

@@ -1,66 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
-import { AudioMode } from '@/enums'
-import { SonarRequestException } from '@/exceptions'
-import { setAudioMode } from '@/functions/audio/set-audio-mode'
-
-let originalFetch: typeof fetch
-
-const request = (mode: AudioMode) => setAudioMode('https://localhost', mode)
-
-describe('setAudioMode', () => {
-	beforeEach(() => {
-		originalFetch = globalThis.fetch
-	})
-
-	afterEach(() => {
-		globalThis.fetch = originalFetch
-	})
-
-	it('throws SonarException when response not 200', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: false,
-				text: async () => 'Some error occurred'
-			}) as Response) as unknown as typeof fetch
-
-		const method = request(AudioMode.Classic)
-
-		expect(method).rejects.toThrow(SonarRequestException)
-	})
-
-	it('throws SonarException when response 200 but not data', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: true,
-				json: async () => ({})
-			}) as Response) as unknown as typeof fetch
-
-		const method = request(AudioMode.Classic)
-
-		expect(method).rejects.toThrow(SonarRequestException)
-	})
-
-	it('return classic when response 200', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: true,
-				json: async () => AudioMode.Classic
-			}) as Response) as unknown as typeof fetch
-
-		const method = request(AudioMode.Classic)
-
-		expect(method).resolves.toBe(AudioMode.Classic)
-	})
-
-	it('return streamer when response 200', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: true,
-				json: async () => AudioMode.Streamer
-			}) as Response) as unknown as typeof fetch
-
-		const method = request(AudioMode.Streamer)
-
-		expect(method).resolves.toBe(AudioMode.Streamer)
-	})
-})

package/tests/unit/audio/set-channel-mute-classic.test.ts

@@ -1,58 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
-import { AudioChannel } from '@/enums'
-import { SonarRequestException } from '@/exceptions'
-import { setChannelMuteClassic } from '@/functions/audio/set-channel-mute-classic'
-
-let originalFetch: typeof fetch
-
-const request = () => setChannelMuteClassic('https://localhost', true, AudioChannel.Master)
-
-describe('setChannelMuteClassic', () => {
-	beforeEach(() => {
-		originalFetch = globalThis.fetch
-	})
-
-	afterEach(() => {
-		globalThis.fetch = originalFetch
-	})
-
-	it('throws SonarException when response not 200', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: false,
-				json: async () => 'Some error occurred'
-			}) as Response) as unknown as typeof fetch
-
-		expect(request()).rejects.toThrow(SonarRequestException)
-	})
-
-	it('throws SonarException when response 200 but not data', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: true,
-				json: async () => ({})
-			}) as Response) as unknown as typeof fetch
-
-		expect(request()).rejects.toThrow(SonarRequestException)
-	})
-
-	it('return data when response 200', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: true,
-				json: async () => ({
-					masters: {
-						classic: {
-							volume: 0.49,
-							muted: false
-						}
-					},
-					devices: {}
-				})
-			}) as Response) as unknown as typeof fetch
-
-		const response = await request()
-		expect(response.volume).toBe(49)
-		expect(response.isMuted).toBe(false)
-	})
-})

package/tests/unit/audio/set-channel-mute-streamer.test.ts

@@ -1,64 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
-import { AudioChannel, StreamerPath } from '@/enums'
-import { SonarRequestException } from '@/exceptions'
-import { setChannelMuteStreamer } from '@/functions/audio/set-channel-mute-streamer'
-
-let originalFetch: typeof fetch
-
-const request = () => setChannelMuteStreamer('https://localhost', false, AudioChannel.Master, StreamerPath.Streaming)
-
-describe('setChannelMuteStreamer', () => {
-	beforeEach(() => {
-		originalFetch = globalThis.fetch
-	})
-
-	afterEach(() => {
-		globalThis.fetch = originalFetch
-	})
-
-	it('throws SonarException when response not 200', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: false,
-				json: async () => 'Some error occurred'
-			}) as Response) as unknown as typeof fetch
-
-		expect(request()).rejects.toThrow(SonarRequestException)
-	})
-
-	it('throws SonarException when response 200 but not data', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: true,
-				json: async () => ({})
-			}) as Response) as unknown as typeof fetch
-
-		expect(request()).rejects.toThrow(SonarRequestException)
-	})
-
-	it('return data when response 200', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: true,
-				json: async () => ({
-					masters: {
-						stream: {
-							streaming: {
-								volume: 0.49,
-								muted: true
-							},
-							monitoring: {
-								volume: 0.48,
-								muted: false
-							}
-						}
-					},
-					devices: {}
-				})
-			}) as Response) as unknown as typeof fetch
-
-		const response = await request()
-		expect(response.volume).toBe(49)
-		expect(response.isMuted).toBe(true)
-	})
-})

package/tests/unit/audio/set-channel-volume-classic.test.ts

@@ -1,58 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
-import { AudioChannel } from '@/enums'
-import { SonarRequestException } from '@/exceptions'
-import { setChannelVolumeClassic } from '@/functions/audio/set-channel-volume-classic'
-
-let originalFetch: typeof fetch
-
-const request = () => setChannelVolumeClassic('https://localhost', 75, AudioChannel.Master)
-
-describe('setChannelVolumeClassic', () => {
-	beforeEach(() => {
-		originalFetch = globalThis.fetch
-	})
-
-	afterEach(() => {
-		globalThis.fetch = originalFetch
-	})
-
-	it('throws SonarException when response not 200', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: false,
-				json: async () => 'Some error occurred'
-			}) as Response) as unknown as typeof fetch
-
-		expect(request()).rejects.toThrow(SonarRequestException)
-	})
-
-	it('throws SonarException when response 200 but not data', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: true,
-				json: async () => ({})
-			}) as Response) as unknown as typeof fetch
-
-		expect(request()).rejects.toThrow(SonarRequestException)
-	})
-
-	it('return data when response 200', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: true,
-				json: async () => ({
-					masters: {
-						classic: {
-							volume: 0.49,
-							muted: false
-						}
-					},
-					devices: {}
-				})
-			}) as Response) as unknown as typeof fetch
-
-		const response = await request()
-		expect(response.volume).toBe(49)
-		expect(response.isMuted).toBe(false)
-	})
-})