steelseries-sonar-sdk 0.1.1

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

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,58 @@
+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)
+	})
+})

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

@@ -0,0 +1,64 @@
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
+import { AudioChannel, StreamerPath } from '@/enums'
+import { SonarRequestException } from '@/exceptions'
+import { setChannelVolumeStreamer } from '@/functions/audio/set-channel-volume-streamer'
+
+let originalFetch: typeof fetch
+
+const request = () => setChannelVolumeStreamer('https://localhost', 75, AudioChannel.Master, StreamerPath.Streaming)
+
+describe('setChannelVolumeStreamer', () => {
+	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/chatmix/get-chat-mix-state.test.ts

@@ -0,0 +1,70 @@
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
+import { ChatMixState } from '@/enums'
+import { SonarRequestException } from '@/exceptions'
+import { getChatMixState } from '@/functions/chatmix/get-chat-mix-state'
+
+let originalFetch: typeof fetch
+
+const request = () => getChatMixState('http://localhost')
+
+describe('getChatMixState', () => {
+	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 data when classic and response 200', async () => {
+		globalThis.fetch = (async () =>
+			({
+				ok: true,
+				json: async () => ({
+					balance: 0.5,
+					state: ChatMixState.Enabled
+				})
+			}) as Response) as unknown as typeof fetch
+
+		const response = await request()
+		expect(response.chatBalance).toBe(75)
+		expect(response.state).toBe(ChatMixState.Enabled)
+		expect(response.isEnabled).toBeTrue()
+	})
+
+	it('return data when streamer and response 200', async () => {
+		globalThis.fetch = (async () =>
+			({
+				ok: true,
+				json: async () => ({
+					balance: 0.5,
+					state: ChatMixState.FiniteWheel
+				})
+			}) as Response) as unknown as typeof fetch
+
+		const response = await request()
+		expect(response.chatBalance).toBe(75)
+		expect(response.state).toBe(ChatMixState.FiniteWheel)
+		expect(response.isEnabled).toBeFalse()
+	})
+})

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

@@ -0,0 +1,58 @@
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
+import { ChatMixState } from '@/enums'
+import { SonarRequestException } from '@/exceptions'
+import { setChatMixBalance } from '@/functions/chatmix/set-chat-mix-balance'
+
+let originalFetch: typeof fetch
+
+const request = (chatBalance: number) => setChatMixBalance('http://localhost', chatBalance)
+
+describe('setChatBalance', () => {
+	beforeEach(() => {
+		originalFetch = globalThis.fetch
+	})
+
+	afterEach(() => {
+		globalThis.fetch = originalFetch
+	})
+
+	it('throws SonarException when response not 200', async () => {
+		globalThis.fetch = (async () =>
+			({
+				ok: false,
+				json: async () => ({
+					message: 'Some error occurred'
+				})
+			}) as Response) as unknown as typeof fetch
+
+		expect(request(0)).rejects.toThrow(SonarRequestException)
+	})
+
+	it('throws SonarException when response 200 but not data', async () => {
+		globalThis.fetch = (async () =>
+			({
+				ok: true,
+				json: async () => ({
+					message: 'Some error occurred'
+				})
+			}) as Response) as unknown as typeof fetch
+
+		expect(request(0)).rejects.toThrow(SonarRequestException)
+	})
+
+	it('return data when response 200', async () => {
+		globalThis.fetch = (async () =>
+			({
+				ok: true,
+				json: async () => ({
+					balance: 0.5,
+					state: ChatMixState.Enabled
+				})
+			}) as Response) as unknown as typeof fetch
+
+		const response = await request(0.5)
+		expect(response.chatBalance).toBe(75)
+		expect(response.state).toBe(ChatMixState.Enabled)
+		expect(response.isEnabled).toBeTrue()
+	})
+})

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

@@ -0,0 +1,59 @@
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
+import { SonarRequestException } from '@/exceptions'
+import { getAudioDevices } from '@/functions/devices/get-audio-devices'
+
+let originalFetch: typeof fetch
+
+const request = () => getAudioDevices('http://localhost')
+
+describe('getAudioDevices', () => {
+	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 data when response 200', async () => {
+		globalThis.fetch = (async () =>
+			({
+				ok: true,
+				json: async () => [
+					{
+						friendlyName: 'Speakers',
+						id: 'speaker',
+						dataFlow: 'render'
+					},
+					{
+						friendlyName: 'Microphone',
+						id: 'mic',
+						dataFlow: 'capture'
+					}
+				]
+			}) as Response) as unknown as typeof fetch
+
+		const response = await request()
+		expect(response.length).toBe(2)
+	})
+})

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

@@ -0,0 +1,62 @@
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
+import { DeviceChannel } from '@/enums'
+import { SonarRequestException } from '@/exceptions'
+import { setAudioDevice } from '@/functions/devices/set-audio-device'
+
+let originalFetch: typeof fetch
+
+const request = () => setAudioDevice('http://localhost', DeviceChannel.Output, 'game_ID')
+
+describe('setAudioDevices', () => {
+	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 data when response 200', async () => {
+		globalThis.fetch = (async () =>
+			({
+				ok: true,
+				json: async () => [
+					{
+						id: 'game',
+						deviceId: 'game_ID',
+						isRunning: true
+					},
+					{
+						id: 'aux',
+						deviceId: 'game_ID',
+						isRunning: false
+					}
+				]
+			}) as Response) as unknown as typeof fetch
+
+		const response = await request()
+		expect(response.length).toBe(2)
+		expect(response[0]?.deviceChannel).toBe(DeviceChannel.Game)
+		expect(response[1]?.deviceChannel).toBe(DeviceChannel.Aux)
+	})
+})

package/tests/unit/endpoint/get-app-endpoint.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it, mock } from 'bun:test'
+import { InitializeErrorReason, SonarInitializationException } from '../../../src/exceptions'
+import { getAppEndpoint } from '../../../src/functions/endpoint/get-app-endpoint'
+
+describe('getAppEndpoint', () => {
+	it('throws Unsupported Exception on unsupported OS', async () => {
+		mock.module('node:os', () => ({
+			platform: () => 'linux'
+		}))
+		const rejects = expect(getAppEndpoint()).rejects
+		rejects.toThrow(SonarInitializationException)
+		rejects.toMatchObject({ reason: InitializeErrorReason.OSUnsupported })
+	})
+
+	it('throws BadConfig Exception when appData file does not exist', async () => {
+		mock.module('node:os', () => ({
+			platform: () => 'win32'
+		}))
+		mock.module('node:fs', () => ({
+			promises: {
+				readFile: async () => {
+					throw new Error('File not found')
+				}
+			}
+		}))
+		const rejects = expect(getAppEndpoint()).rejects
+		rejects.toThrow(SonarInitializationException)
+		rejects.toMatchObject({ reason: InitializeErrorReason.BadConfig })
+	})
+
+	it('throws BadConfig Exception when appData file is invalid JSON', async () => {
+		mock.module('node:os', () => ({
+			platform: () => 'win32'
+		}))
+		mock.module('node:fs', () => ({
+			promises: {
+				readFile: async () => 'invalid json'
+			}
+		}))
+		const rejects = expect(getAppEndpoint()).rejects
+		rejects.toThrow(SonarInitializationException)
+		rejects.toMatchObject({ reason: InitializeErrorReason.BadConfig })
+	})
+
+	it('throws BadConfig Exception when ggEncryptedAddress is missing', async () => {
+		mock.module('node:os', () => ({
+			platform: () => 'win32'
+		}))
+		mock.module('node:fs', () => ({
+			promises: {
+				readFile: async () => JSON.stringify({})
+			}
+		}))
+		const rejects = expect(getAppEndpoint()).rejects
+		rejects.toThrow(SonarInitializationException)
+		rejects.toMatchObject({ reason: InitializeErrorReason.BadConfig })
+	})
+
+	it('returns ggEncryptedAddress when file is valid', async () => {
+		const mockAddress = 'encrypted-address-123'
+		const expectedUrl = `https://${mockAddress}`
+		mock.module('node:os', () => ({
+			platform: () => 'win32'
+		}))
+		mock.module('node:fs', () => ({
+			promises: {
+				readFile: async () => JSON.stringify({ ggEncryptedAddress: mockAddress })
+			}
+		}))
+		expect(getAppEndpoint()).resolves.toBe(expectedUrl)
+	})
+})

package/tests/unit/endpoint/get-sonar-endpoint-cached.test.ts

@@ -0,0 +1,93 @@
+import { afterEach, beforeEach, describe, expect, it, setSystemTime } from 'bun:test'
+import { getSonarEndpointCached } from '../../../src/functions/endpoint/get-sonar-endpoint-cached'
+
+let originalFetch: typeof fetch
+
+describe('getSonarEndpointCached', () => {
+	beforeEach(() => {
+		originalFetch = globalThis.fetch
+	})
+
+	afterEach(() => {
+		globalThis.fetch = originalFetch
+	})
+
+	it('return cached value when within time', async () => {
+		const expectedWebServerAddress = 'https://127.0.0.1:1234'
+
+		globalThis.fetch = (async () =>
+			({
+				ok: true,
+				json: async () => ({
+					subApps: {
+						sonar: {
+							isEnabled: true,
+							isReady: true,
+							isRunning: true,
+							metadata: { webServerAddress: expectedWebServerAddress }
+						}
+					}
+				})
+			}) as Response) as unknown as typeof fetch
+
+		setSystemTime(1000)
+		expect(getSonarEndpointCached('', 1)).resolves.toBe(expectedWebServerAddress)
+
+		globalThis.fetch = (async () =>
+			({
+				ok: true,
+				json: async () => ({
+					subApps: {
+						sonar: {
+							isEnabled: true,
+							isReady: true,
+							isRunning: true,
+							metadata: { webServerAddress: 'other' }
+						}
+					}
+				})
+			}) as Response) as unknown as typeof fetch
+		setSystemTime(500)
+		expect(getSonarEndpointCached('', 1)).resolves.toBe(expectedWebServerAddress)
+	})
+
+	it('return new value when cache time expired', async () => {
+		const expectedFirstAddress = 'https://127.0.0.1:1234'
+		const expectedSecondAddress = 'https://127.0.0.1:4321'
+
+		globalThis.fetch = (async () =>
+			({
+				ok: true,
+				json: async () => ({
+					subApps: {
+						sonar: {
+							isEnabled: true,
+							isReady: true,
+							isRunning: true,
+							metadata: { webServerAddress: expectedFirstAddress }
+						}
+					}
+				})
+			}) as Response) as unknown as typeof fetch
+
+		setSystemTime(1000)
+		expect(getSonarEndpointCached('', 1)).resolves.toBe(expectedFirstAddress)
+
+		globalThis.fetch = (async () =>
+			({
+				ok: true,
+				json: async () => ({
+					subApps: {
+						sonar: {
+							isEnabled: true,
+							isReady: true,
+							isRunning: true,
+							metadata: { webServerAddress: expectedSecondAddress }
+						}
+					}
+				})
+			}) as Response) as unknown as typeof fetch
+		setSystemTime(2500)
+		expect(getSonarEndpointCached('', 1)).resolves.toBe(expectedSecondAddress)
+	})
+})