steelseries-sonar-sdk 0.2.0 → 0.2.2

package/tests/unit/audio/set-channel-volume-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 { 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

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

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

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

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

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

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

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

@@ -1,140 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
-import { InitializeErrorReason, SonarInitializationException } from '../../../src/exceptions'
-import { getSonarEndpoint } from '../../../src/functions/endpoint/get-sonar-endpoint'
-
-let originalFetch: typeof fetch
-
-const request = () => getSonarEndpoint('')
-
-describe('getSonarEndpoint', () => {
-	beforeEach(() => {
-		originalFetch = globalThis.fetch
-	})
-
-	afterEach(() => {
-		globalThis.fetch = originalFetch
-	})
-
-	it('throws NotEnabled Exception if sonar is not enabled', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: true,
-				json: async () => ({
-					subApps: {
-						sonar: {
-							isEnabled: false,
-							isReady: true,
-							isRunning: true,
-							metadata: { webServerAddress: '127.0.0.1:1234' }
-						}
-					}
-				})
-			}) as Response) as unknown as typeof fetch
-
-		const rejects = expect(request()).rejects
-		rejects.toThrow(SonarInitializationException)
-		rejects.toMatchObject({ reason: InitializeErrorReason.NotEnabled })
-	})
-
-	it('throws NotReady Exception if sonar is not ready', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: true,
-				json: async () => ({
-					subApps: {
-						sonar: {
-							isEnabled: true,
-							isReady: false,
-							isRunning: true,
-							metadata: { webServerAddress: '127.0.0.1:1234' }
-						}
-					}
-				})
-			}) as Response) as unknown as typeof fetch
-
-		const rejects = expect(request()).rejects
-		rejects.toThrow(SonarInitializationException)
-		rejects.toMatchObject({ reason: InitializeErrorReason.NotReady })
-	})
-
-	it('throws NotRunning Exception if sonar is not running', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: true,
-				json: async () => ({
-					subApps: {
-						sonar: {
-							isEnabled: true,
-							isReady: true,
-							isRunning: false,
-							metadata: { webServerAddress: '127.0.0.1:1234' }
-						}
-					}
-				})
-			}) as Response) as unknown as typeof fetch
-
-		const rejects = expect(request()).rejects
-		rejects.toThrow(SonarInitializationException)
-		rejects.toMatchObject({ reason: InitializeErrorReason.NotRunning })
-	})
-
-	it('throws NotResponding Exception if sonar server is not found', async () => {
-		globalThis.fetch = (async () => {
-			throw new Error('Failed to fetch')
-		}) as unknown as typeof fetch
-		const rejects = expect(request()).rejects
-		rejects.toThrow(SonarInitializationException)
-		rejects.toMatchObject({ reason: InitializeErrorReason.NotResponding })
-	})
-
-	it('throws NotResponding Exception if sonar server returns bad status code', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: false
-			}) as Response) as unknown as typeof fetch
-		const rejects = expect(request()).rejects
-		rejects.toThrow(SonarInitializationException)
-		rejects.toMatchObject({ reason: InitializeErrorReason.NotResponding })
-	})
-
-	it('throws NotAvailable Exception if sonar webServerAddress is not provided', async () => {
-		globalThis.fetch = (async () =>
-			({
-				ok: true,
-				json: async () => ({
-					subApps: {
-						sonar: {
-							isEnabled: true,
-							isReady: true,
-							isRunning: true
-						}
-					}
-				})
-			}) as Response) as unknown as typeof fetch
-
-		const rejects = expect(request()).rejects
-		rejects.toThrow(SonarInitializationException)
-		rejects.toMatchObject({ reason: InitializeErrorReason.NotAvailable })
-	})
-
-	it('return Sonar webServerAddress when response is valid', 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
-
-		expect(getSonarEndpoint('')).resolves.toBe(expectedWebServerAddress)
-	})
-})