steelseries-sonar-sdk 0.1.1 → 0.2.2

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)
-	})
-})

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)
-	})
-})