Nomchy/discord.js
1
0
Fork 0
mirror of https://github.com/discordjs/discord.js.git synced 2026-03-17 03:53:29 +01:00
Code Issues Packages Projects Releases Wiki Activity

style: cleanup tests and tsup configs

Browse Source
This commit is contained in:
iCrawl
2022-06-04 15:21:57 +02:00
parent a45bef4cad
commit 6b8ef20cb3
26 changed files with 310 additions and 306 deletions
Download Patch File Download Diff File Expand all files Collapse all files

110
packages/voice/__tests__/AudioPlayer.test.ts
View File

@@ -66,7 +66,7 @@ afterEach(() => {
describe('State transitions', () => {
test('Starts in Idle state', () => {
player = createAudioPlayer();
expect(player.state.status).toBe(AudioPlayerStatus.Idle);
expect(player.state.status).toEqual(AudioPlayerStatus.Idle);
expect(addAudioPlayerMock).toBeCalledTimes(0);
expect(deleteAudioPlayerMock).toBeCalledTimes(0);
});
@@ -75,34 +75,34 @@ describe('State transitions', () => {
// Call AudioResource constructor directly to avoid analysing pipeline for stream
const resource = await started(new AudioResource([], [Readable.from(silence())], null, 5));
player = createAudioPlayer();
expect(player.state.status).toBe(AudioPlayerStatus.Idle);
expect(player.state.status).toEqual(AudioPlayerStatus.Idle);
// Pause and unpause should not affect the status of an Idle player
expect(player.pause()).toBe(false);
expect(player.state.status).toBe(AudioPlayerStatus.Idle);
expect(player.unpause()).toBe(false);
expect(player.state.status).toBe(AudioPlayerStatus.Idle);
expect(player.pause()).toEqual(false);
expect(player.state.status).toEqual(AudioPlayerStatus.Idle);
expect(player.unpause()).toEqual(false);
expect(player.state.status).toEqual(AudioPlayerStatus.Idle);
expect(addAudioPlayerMock).toBeCalledTimes(0);
player.play(resource);
expect(player.state.status).toBe(AudioPlayerStatus.Playing);
expect(player.state.status).toEqual(AudioPlayerStatus.Playing);
expect(addAudioPlayerMock).toBeCalledTimes(1);
// Expect pause() to return true and transition to paused state
expect(player.pause()).toBe(true);
expect(player.state.status).toBe(AudioPlayerStatus.Paused);
expect(player.pause()).toEqual(true);
expect(player.state.status).toEqual(AudioPlayerStatus.Paused);
// further calls to pause() should be unsuccessful
expect(player.pause()).toBe(false);
expect(player.state.status).toBe(AudioPlayerStatus.Paused);
expect(player.pause()).toEqual(false);
expect(player.state.status).toEqual(AudioPlayerStatus.Paused);
// unpause() should transition back to Playing
expect(player.unpause()).toBe(true);
expect(player.state.status).toBe(AudioPlayerStatus.Playing);
expect(player.unpause()).toEqual(true);
expect(player.state.status).toEqual(AudioPlayerStatus.Playing);
// further calls to unpause() should be unsuccessful
expect(player.unpause()).toBe(false);
expect(player.state.status).toBe(AudioPlayerStatus.Playing);
expect(player.unpause()).toEqual(false);
expect(player.state.status).toEqual(AudioPlayerStatus.Playing);
// The audio player should not have been deleted throughout these changes
expect(deleteAudioPlayerMock).toBeCalledTimes(0);
@@ -113,19 +113,19 @@ describe('State transitions', () => {
player = createAudioPlayer();
// stop() shouldn't do anything in Idle state
expect(player.stop(true)).toBe(false);
expect(player.state.status).toBe(AudioPlayerStatus.Idle);
expect(player.stop(true)).toEqual(false);
expect(player.state.status).toEqual(AudioPlayerStatus.Idle);
player.play(resource);
expect(player.state.status).toBe(AudioPlayerStatus.Playing);
expect(player.state.status).toEqual(AudioPlayerStatus.Playing);
expect(addAudioPlayerMock).toBeCalledTimes(1);
expect(deleteAudioPlayerMock).toBeCalledTimes(0);
expect(player.stop()).toBe(true);
expect(player.state.status).toBe(AudioPlayerStatus.Playing);
expect(player.stop()).toEqual(true);
expect(player.state.status).toEqual(AudioPlayerStatus.Playing);
expect(addAudioPlayerMock).toBeCalledTimes(1);
expect(deleteAudioPlayerMock).toBeCalledTimes(0);
expect(resource.silenceRemaining).toBe(5);
expect(resource.silenceRemaining).toEqual(5);
});
test('Buffering to Playing', async () => {
@@ -133,11 +133,11 @@ describe('State transitions', () => {
player = createAudioPlayer();
player.play(resource);
expect(player.state.status).toBe(AudioPlayerStatus.Buffering);
expect(player.state.status).toEqual(AudioPlayerStatus.Buffering);
await started(resource);
expect(player.state.status).toBe(AudioPlayerStatus.Playing);
expect(player.state.status).toEqual(AudioPlayerStatus.Playing);
expect(addAudioPlayerMock).toHaveBeenCalled();
expect(deleteAudioPlayerMock).not.toHaveBeenCalled();
});
@@ -154,9 +154,9 @@ describe('State transitions', () => {
connection.subscribe(player);
player.play(resource);
expect(player.checkPlayable()).toBe(true);
expect(player.checkPlayable()).toEqual(true);
player['_stepPrepare']();
expect(player.state.status).toBe(AudioPlayerStatus.AutoPaused);
expect(player.state.status).toEqual(AudioPlayerStatus.AutoPaused);
connection.state = {
...connection.state,
@@ -164,9 +164,9 @@ describe('State transitions', () => {
networking: null as any,
};
expect(player.checkPlayable()).toBe(true);
expect(player.checkPlayable()).toEqual(true);
player['_stepPrepare']();
expect(player.state.status).toBe(AudioPlayerStatus.Playing);
expect(player.state.status).toEqual(AudioPlayerStatus.Playing);
});
test('NoSubscriberBehavior.Play', async () => {
@@ -174,9 +174,9 @@ describe('State transitions', () => {
player = createAudioPlayer({ behaviors: { noSubscriber: NoSubscriberBehavior.Play } });
player.play(resource);
expect(player.checkPlayable()).toBe(true);
expect(player.checkPlayable()).toEqual(true);
player['_stepPrepare']();
expect(player.state.status).toBe(AudioPlayerStatus.Playing);
expect(player.state.status).toEqual(AudioPlayerStatus.Playing);
});
test('NoSubscriberBehavior.Stop', async () => {
@@ -185,9 +185,9 @@ describe('State transitions', () => {
player.play(resource);
expect(addAudioPlayerMock).toBeCalledTimes(1);
expect(player.checkPlayable()).toBe(true);
expect(player.checkPlayable()).toEqual(true);
player['_stepPrepare']();
expect(player.state.status).toBe(AudioPlayerStatus.Idle);
expect(player.state.status).toEqual(AudioPlayerStatus.Idle);
expect(deleteAudioPlayerMock).toBeCalledTimes(1);
});
});
@@ -211,9 +211,9 @@ describe('State transitions', () => {
connection.subscribe(player);
player.play(resource);
expect(player.state.status).toBe(AudioPlayerStatus.Playing);
expect(player.state.status).toEqual(AudioPlayerStatus.Playing);
expect(addAudioPlayerMock).toBeCalledTimes(1);
expect(player.checkPlayable()).toBe(true);
expect(player.checkPlayable()).toEqual(true);
// Run through a few packet cycles
for (let i = 1; i <= 5; i++) {
@@ -225,7 +225,7 @@ describe('State transitions', () => {
player['_stepPrepare']();
expect(connection.prepareAudioPacket).toHaveBeenCalledTimes(i);
expect(connection.prepareAudioPacket).toHaveBeenLastCalledWith(buffer);
expect(player.state.status).toBe(AudioPlayerStatus.Playing);
expect(player.state.status).toEqual(AudioPlayerStatus.Playing);
if (player.state.status === AudioPlayerStatus.Playing) {
expect(player.state.playbackDuration).toStrictEqual(i * 20);
}
@@ -243,7 +243,7 @@ describe('State transitions', () => {
expect(prepareAudioPacket.mock.calls[5][0]).toEqual(silence().next().value);
player.stop(true);
expect(player.state.status).toBe(AudioPlayerStatus.Idle);
expect(player.state.status).toEqual(AudioPlayerStatus.Idle);
expect(connection.setSpeaking).toBeCalledTimes(1);
expect(connection.setSpeaking).toHaveBeenLastCalledWith(false);
expect(deleteAudioPlayerMock).toHaveBeenCalledTimes(1);
@@ -268,9 +268,9 @@ describe('State transitions', () => {
connection.subscribe(player);
player.play(resource);
expect(player.state.status).toBe(AudioPlayerStatus.Playing);
expect(player.state.status).toEqual(AudioPlayerStatus.Playing);
expect(addAudioPlayerMock).toBeCalledTimes(1);
expect(player.checkPlayable()).toBe(true);
expect(player.checkPlayable()).toEqual(true);
player.stop();
@@ -284,19 +284,19 @@ describe('State transitions', () => {
player['_stepPrepare']();
expect(connection.prepareAudioPacket).toHaveBeenCalledTimes(i);
expect(connection.prepareAudioPacket).toHaveBeenLastCalledWith(SILENCE_FRAME);
expect(player.state.status).toBe(AudioPlayerStatus.Playing);
expect(player.state.status).toEqual(AudioPlayerStatus.Playing);
if (player.state.status === AudioPlayerStatus.Playing) {
expect(player.state.playbackDuration).toStrictEqual(i * 20);
}
}
await wait();
expect(player.checkPlayable()).toBe(false);
expect(player.checkPlayable()).toEqual(false);
const prepareAudioPacket = connection.prepareAudioPacket as unknown as jest.Mock<
typeof connection.prepareAudioPacket
>;
expect(prepareAudioPacket).toHaveBeenCalledTimes(5);
expect(player.state.status).toBe(AudioPlayerStatus.Idle);
expect(player.state.status).toEqual(AudioPlayerStatus.Idle);
expect(connection.setSpeaking).toBeCalledTimes(1);
expect(connection.setSpeaking).toHaveBeenLastCalledWith(false);
expect(deleteAudioPlayerMock).toHaveBeenCalledTimes(1);
@@ -319,9 +319,9 @@ describe('State transitions', () => {
connection.subscribe(player);
player.play(resource);
expect(player.state.status).toBe(AudioPlayerStatus.Playing);
expect(player.state.status).toEqual(AudioPlayerStatus.Playing);
expect(addAudioPlayerMock).toBeCalledTimes(1);
expect(player.checkPlayable()).toBe(true);
expect(player.checkPlayable()).toEqual(true);
const prepareAudioPacket = connection.prepareAudioPacket as unknown as jest.Mock<
typeof connection.prepareAudioPacket
@@ -329,10 +329,10 @@ describe('State transitions', () => {
// Run through a few packet cycles
for (let i = 1; i <= 5; i++) {
expect(player.state.status).toBe(AudioPlayerStatus.Playing);
expect(player.state.status).toEqual(AudioPlayerStatus.Playing);
if (player.state.status !== AudioPlayerStatus.Playing) throw new Error('Error');
expect(player.state.playbackDuration).toStrictEqual((i - 1) * 20);
expect(player.state.missedFrames).toBe(i - 1);
expect(player.state.missedFrames).toEqual(i - 1);
player['_stepDispatch']();
expect(connection.dispatchAudio).toHaveBeenCalledTimes(i);
player['_stepPrepare']();
@@ -340,7 +340,7 @@ describe('State transitions', () => {
expect(prepareAudioPacket.mock.calls[i - 1][0]).toEqual(silence().next().value);
}
expect(player.state.status).toBe(AudioPlayerStatus.Idle);
expect(player.state.status).toEqual(AudioPlayerStatus.Idle);
expect(connection.setSpeaking).toBeCalledTimes(1);
expect(connection.setSpeaking).toHaveBeenLastCalledWith(false);
expect(deleteAudioPlayerMock).toHaveBeenCalledTimes(1);
@@ -350,15 +350,15 @@ describe('State transitions', () => {
const resource = await started(new AudioResource([], [Readable.from([1])], null, 0));
player = createAudioPlayer();
player.play(resource);
expect(player.checkPlayable()).toBe(true);
expect(player.state.status).toBe(AudioPlayerStatus.Playing);
expect(player.checkPlayable()).toEqual(true);
expect(player.state.status).toEqual(AudioPlayerStatus.Playing);
for (let i = 0; i < 3; i++) {
resource.playStream.read();
await wait();
}
expect(resource.playStream.readableEnded).toBe(true);
expect(player.checkPlayable()).toBe(false);
expect(player.state.status).toBe(AudioPlayerStatus.Idle);
expect(resource.playStream.readableEnded).toEqual(true);
expect(player.checkPlayable()).toEqual(false);
expect(player.state.status).toEqual(AudioPlayerStatus.Idle);
});
});
@@ -366,14 +366,14 @@ test('play() throws when playing a resource that has already ended', async () =>
const resource = await started(new AudioResource([], [Readable.from([1])], null, 5));
player = createAudioPlayer();
player.play(resource);
expect(player.state.status).toBe(AudioPlayerStatus.Playing);
expect(player.state.status).toEqual(AudioPlayerStatus.Playing);
for (let i = 0; i < 3; i++) {
resource.playStream.read();
await wait();
}
expect(resource.playStream.readableEnded).toBe(true);
expect(resource.playStream.readableEnded).toEqual(true);
player.stop(true);
expect(player.state.status).toBe(AudioPlayerStatus.Idle);
expect(player.state.status).toEqual(AudioPlayerStatus.Idle);
expect(() => player?.play(resource)).toThrow();
});
@@ -381,12 +381,12 @@ test('Propagates errors from streams', async () => {
const resource = await started(new AudioResource([], [Readable.from(silence())], null, 5));
player = createAudioPlayer();
player.play(resource);
expect(player.state.status).toBe(AudioPlayerStatus.Playing);
expect(player.state.status).toEqual(AudioPlayerStatus.Playing);
const error = new Error('AudioPlayer test error');
process.nextTick(() => resource.playStream.emit('error', error));
const res = await once(player, 'error');
const playerError = res[0] as AudioPlayerError;
expect(playerError).toBeInstanceOf(AudioPlayerError);
expect(AudioPlayerErrorMock).toHaveBeenCalledWith(error, resource);
expect(player.state.status).toBe(AudioPlayerStatus.Idle);
expect(player.state.status).toEqual(AudioPlayerStatus.Idle);
});

12
packages/voice/__tests__/AudioReceiveStream.test.ts
View File

@@ -10,17 +10,17 @@ function wait(ms: number) {
async function stepSilence(stream: AudioReceiveStream, increment: number) {
stream.push(SILENCE_FRAME);
await wait(increment);
expect(stream.readable).toBe(true);
expect(stream.readable).toEqual(true);
}
describe('AudioReceiveStream', () => {
test('Manual end behavior', async () => {
const stream = new AudioReceiveStream({ end: { behavior: EndBehaviorType.Manual } });
stream.push(DUMMY_BUFFER);
expect(stream.readable).toBe(true);
expect(stream.readable).toEqual(true);
await wait(200);
stream.push(DUMMY_BUFFER);
expect(stream.readable).toBe(true);
expect(stream.readable).toEqual(true);
});
// TODO: Fix this test
@@ -42,7 +42,7 @@ describe('AudioReceiveStream', () => {
// }
// await wait(increment);
// expect(stream.readableEnded).toBe(true);
// expect(stream.readableEnded).toEqual(true);
// });
test('AfterInactivity end behavior', async () => {
@@ -63,10 +63,10 @@ describe('AudioReceiveStream', () => {
}
await wait(increment);
expect(stream.readableEnded).toBe(false);
expect(stream.readableEnded).toEqual(false);
await wait(duration - increment);
expect(stream.readableEnded).toBe(true);
expect(stream.readableEnded).toEqual(true);
});
});

12
packages/voice/__tests__/AudioResource.test.ts
View File

@@ -96,7 +96,7 @@ describe('createAudioResource', () => {
const stream = new VolumeTransformer({} as any);
const resource = createAudioResource(stream, { inlineVolume: true });
expect(findPipeline).toHaveBeenCalledWith(StreamType.Raw, NO_CONSTRAINT);
expect(resource.volume).toBe(stream);
expect(resource.volume).toEqual(stream);
});
test('Falls back to Arbitrary for unknown stream type', () => {
@@ -111,15 +111,15 @@ describe('createAudioResource', () => {
const resource = new AudioResource([], [stream], null, 5);
await started(resource);
expect(resource.readable).toBe(true);
expect(resource.readable).toEqual(true);
expect(resource.read()).toEqual(Buffer.from([1]));
for (let i = 0; i < 5; i++) {
await wait();
expect(resource.readable).toBe(true);
expect(resource.read()).toBe(SILENCE_FRAME);
expect(resource.readable).toEqual(true);
expect(resource.read()).toEqual(SILENCE_FRAME);
}
await wait();
expect(resource.readable).toBe(false);
expect(resource.read()).toBe(null);
expect(resource.readable).toEqual(false);
expect(resource.read()).toEqual(null);
});
});

16
packages/voice/__tests__/DataStore.test.ts
View File

@@ -52,9 +52,9 @@ describe('DataStore', () => {
test('VoiceConnection management respects group', () => {
DataStore.trackVoiceConnection(voiceConnectionDefault);
DataStore.trackVoiceConnection(voiceConnectionAbc);
expect(DataStore.getVoiceConnection('123')).toBe(voiceConnectionDefault);
expect(DataStore.getVoiceConnection('123', 'default')).toBe(voiceConnectionDefault);
expect(DataStore.getVoiceConnection('123', 'abc')).toBe(voiceConnectionAbc);
expect(DataStore.getVoiceConnection('123')).toEqual(voiceConnectionDefault);
expect(DataStore.getVoiceConnection('123', 'default')).toEqual(voiceConnectionDefault);
expect(DataStore.getVoiceConnection('123', 'abc')).toEqual(voiceConnectionAbc);
expect([...DataStore.getGroups().keys()]).toEqual(['default', 'abc']);
@@ -64,17 +64,17 @@ describe('DataStore', () => {
DataStore.untrackVoiceConnection(voiceConnectionDefault);
expect(DataStore.getVoiceConnection('123')).toBeUndefined();
expect(DataStore.getVoiceConnection('123', 'abc')).toBe(voiceConnectionAbc);
expect(DataStore.getVoiceConnection('123', 'abc')).toEqual(voiceConnectionAbc);
});
test('Managing Audio Players', async () => {
const player = DataStore.addAudioPlayer(new AudioPlayer.AudioPlayer());
const dispatchSpy = jest.spyOn(player as any, '_stepDispatch');
const prepareSpy = jest.spyOn(player as any, '_stepPrepare');
expect(DataStore.hasAudioPlayer(player)).toBe(true);
expect(DataStore.addAudioPlayer(player)).toBe(player);
expect(DataStore.hasAudioPlayer(player)).toEqual(true);
expect(DataStore.addAudioPlayer(player)).toEqual(player);
DataStore.deleteAudioPlayer(player);
expect(DataStore.deleteAudioPlayer(player)).toBe(undefined);
expect(DataStore.hasAudioPlayer(player)).toBe(false);
expect(DataStore.deleteAudioPlayer(player)).toBeUndefined();
expect(DataStore.hasAudioPlayer(player)).toEqual(false);
// Tests audio cycle with nextTime === -1
await waitForEventLoop();
expect(dispatchSpy).toHaveBeenCalledTimes(0);

12
packages/voice/__tests__/TransformerGraph.test.ts
View File

@@ -26,9 +26,9 @@ describe('findPipeline (no constraints)', () => {
const pipeline = findPipeline(type, noConstraint);
const path = reducePath(pipeline);
expect(path.length).toBeGreaterThanOrEqual(2);
expect(path[0]).toBe(type);
expect(path.pop()).toBe(StreamType.Opus);
expect(pipeline.some(isVolume)).toBe(false);
expect(path[0]).toEqual(type);
expect(path.pop()).toEqual(StreamType.Opus);
expect(pipeline.some(isVolume)).toEqual(false);
},
);
@@ -42,8 +42,8 @@ describe('findPipeline (volume constraint)', () => {
const pipeline = findPipeline(type, containsVolume);
const path = reducePath(pipeline);
expect(path.length).toBeGreaterThanOrEqual(2);
expect(path[0]).toBe(type);
expect(path.pop()).toBe(StreamType.Opus);
expect(pipeline.some(isVolume)).toBe(true);
expect(path[0]).toEqual(type);
expect(path.pop()).toEqual(StreamType.Opus);
expect(pipeline.some(isVolume)).toEqual(true);
});
});

102
packages/voice/__tests__/VoiceConnection.test.ts
View File

@@ -91,7 +91,7 @@ describe('createVoiceConnection', () => {
debug: false,
adapterCreator: adapter.creator,
});
expect(voiceConnection.state.status).toBe(VoiceConnectionStatus.Signalling);
expect(voiceConnection.state.status).toEqual(VoiceConnectionStatus.Signalling);
expect(DataStore.getVoiceConnection).toHaveBeenCalledTimes(1);
expect(DataStore.trackVoiceConnection).toHaveBeenCalledWith(voiceConnection);
expect(DataStore.untrackVoiceConnection).not.toHaveBeenCalled();
@@ -108,7 +108,7 @@ describe('createVoiceConnection', () => {
debug: false,
adapterCreator: adapter.creator,
});
expect(voiceConnection.state.status).toBe(VoiceConnectionStatus.Disconnected);
expect(voiceConnection.state.status).toEqual(VoiceConnectionStatus.Disconnected);
expect(DataStore.getVoiceConnection).toHaveBeenCalledTimes(1);
expect(DataStore.trackVoiceConnection).toHaveBeenCalledWith(voiceConnection);
expect(DataStore.untrackVoiceConnection).not.toHaveBeenCalled();
@@ -144,7 +144,7 @@ describe('createVoiceConnection', () => {
expect(DataStore.untrackVoiceConnection).not.toHaveBeenCalled();
expect(newAdapter.creator).not.toHaveBeenCalled();
expect(existingAdapter.sendPayload).toHaveBeenCalledWith(mockPayload);
expect(newVoiceConnection).toBe(existingVoiceConnection);
expect(newVoiceConnection).toEqual(existingVoiceConnection);
expect(stateSetter).not.toHaveBeenCalled();
});
@@ -183,7 +183,7 @@ describe('createVoiceConnection', () => {
expect(DataStore.untrackVoiceConnection).not.toHaveBeenCalled();
expect(newAdapter.creator).not.toHaveBeenCalled();
expect(rejoinSpy).toHaveBeenCalledWith(rejoinConfig);
expect(newVoiceConnection).toBe(existingVoiceConnection);
expect(newVoiceConnection).toEqual(existingVoiceConnection);
});
test('Reconfiguring existing connection with adapter failure', () => {
@@ -214,8 +214,8 @@ describe('createVoiceConnection', () => {
expect(DataStore.untrackVoiceConnection).not.toHaveBeenCalled();
expect(newAdapter.creator).not.toHaveBeenCalled();
expect(existingAdapter.sendPayload).toHaveBeenCalledWith(mockPayload);
expect(newVoiceConnection).toBe(existingVoiceConnection);
expect(newVoiceConnection.state.status).toBe(VoiceConnectionStatus.Disconnected);
expect(newVoiceConnection).toEqual(existingVoiceConnection);
expect(newVoiceConnection.state.status).toEqual(VoiceConnectionStatus.Disconnected);
});
});
@@ -229,7 +229,7 @@ describe('VoiceConnection#addServerPacket', () => {
token: 'abc',
} as any;
voiceConnection['addServerPacket'](dummy);
expect(voiceConnection['packets'].server).toBe(dummy);
expect(voiceConnection['packets'].server).toEqual(dummy);
expect(voiceConnection.configureNetworking).toHaveBeenCalled();
});
@@ -243,7 +243,7 @@ describe('VoiceConnection#addServerPacket', () => {
token: 'abc',
} as any;
voiceConnection['addServerPacket'](dummy);
expect(voiceConnection['packets'].server).toBe(dummy);
expect(voiceConnection['packets'].server).toEqual(dummy);
expect(voiceConnection.configureNetworking).toHaveBeenCalled();
});
@@ -257,9 +257,9 @@ describe('VoiceConnection#addServerPacket', () => {
token: 'abc',
} as any;
voiceConnection['addServerPacket'](dummy);
expect(voiceConnection['packets'].server).toBe(dummy);
expect(voiceConnection['packets'].server).toEqual(dummy);
expect(voiceConnection.configureNetworking).not.toHaveBeenCalled();
expect(voiceConnection.state.status).toBe(VoiceConnectionStatus.Disconnected);
expect(voiceConnection.state.status).toEqual(VoiceConnectionStatus.Disconnected);
});
});
@@ -293,10 +293,10 @@ describe('VoiceConnection#addStatePacket', () => {
describe('VoiceConnection#configureNetworking', () => {
test('Only creates Networking instance when both packets are present and not destroyed', () => {
const { voiceConnection } = createFakeVoiceConnection();
expect(voiceConnection.state.status).toBe(VoiceConnectionStatus.Signalling);
expect(voiceConnection.state.status).toEqual(VoiceConnectionStatus.Signalling);
voiceConnection.configureNetworking();
expect(voiceConnection.state.status).toBe(VoiceConnectionStatus.Signalling);
expect(voiceConnection.state.status).toEqual(VoiceConnectionStatus.Signalling);
const adapter = (voiceConnection.state as VoiceConnectionSignallingState).adapter;
const state = {
@@ -312,18 +312,18 @@ describe('VoiceConnection#configureNetworking', () => {
Object.assign(voiceConnection['packets'], { state, server: undefined });
voiceConnection.configureNetworking();
expect(voiceConnection.state.status).toBe(VoiceConnectionStatus.Signalling);
expect(voiceConnection.state.status).toEqual(VoiceConnectionStatus.Signalling);
expect(Networking.Networking).toHaveBeenCalledTimes(0);
Object.assign(voiceConnection['packets'], { state: undefined, server });
voiceConnection.configureNetworking();
expect(voiceConnection.state.status).toBe(VoiceConnectionStatus.Signalling);
expect(voiceConnection.state.status).toEqual(VoiceConnectionStatus.Signalling);
expect(Networking.Networking).toHaveBeenCalledTimes(0);
Object.assign(voiceConnection['packets'], { state, server });
voiceConnection.state = { status: VoiceConnectionStatus.Destroyed };
voiceConnection.configureNetworking();
expect(voiceConnection.state.status).toBe(VoiceConnectionStatus.Destroyed);
expect(voiceConnection.state.status).toEqual(VoiceConnectionStatus.Destroyed);
expect(Networking.Networking).toHaveBeenCalledTimes(0);
voiceConnection.state = { status: VoiceConnectionStatus.Signalling, adapter };
@@ -356,7 +356,7 @@ describe('VoiceConnection#onNetworkingClose', () => {
status: VoiceConnectionStatus.Destroyed,
};
voiceConnection['onNetworkingClose'](1000);
expect(voiceConnection.state.status).toBe(VoiceConnectionStatus.Destroyed);
expect(voiceConnection.state.status).toEqual(VoiceConnectionStatus.Destroyed);
expect(adapter.sendPayload).not.toHaveBeenCalled();
});
@@ -377,9 +377,9 @@ describe('VoiceConnection#onNetworkingClose', () => {
config === joinConfig ? dummyPayload : undefined,
);
voiceConnection['onNetworkingClose'](1234);
expect(voiceConnection.state.status).toBe(VoiceConnectionStatus.Signalling);
expect(voiceConnection.state.status).toEqual(VoiceConnectionStatus.Signalling);
expect(adapter.sendPayload).toHaveBeenCalledWith(dummyPayload);
expect(voiceConnection.rejoinAttempts).toBe(1);
expect(voiceConnection.rejoinAttempts).toEqual(1);
});
test('Attempts rejoin for codes != 4014 (with adapter failure)', () => {
@@ -390,9 +390,9 @@ describe('VoiceConnection#onNetworkingClose', () => {
);
adapter.sendPayload.mockReturnValue(false);
voiceConnection['onNetworkingClose'](1234);
expect(voiceConnection.state.status).toBe(VoiceConnectionStatus.Disconnected);
expect(voiceConnection.state.status).toEqual(VoiceConnectionStatus.Disconnected);
expect(adapter.sendPayload).toHaveBeenCalledWith(dummyPayload);
expect(voiceConnection.rejoinAttempts).toBe(1);
expect(voiceConnection.rejoinAttempts).toEqual(1);
});
});
@@ -442,7 +442,7 @@ describe('VoiceConnection#onNetworkingStateChange', () => {
);
expect(stateSetter).toHaveBeenCalledTimes(1);
expect(voiceConnection.state.status).toBe(VoiceConnectionStatus.Ready);
expect(voiceConnection.state.status).toEqual(VoiceConnectionStatus.Ready);
});
test('Transitions to Connecting', () => {
@@ -460,7 +460,7 @@ describe('VoiceConnection#onNetworkingStateChange', () => {
);
expect(stateSetter).toHaveBeenCalledTimes(1);
expect(voiceConnection.state.status).toBe(VoiceConnectionStatus.Connecting);
expect(voiceConnection.state.status).toEqual(VoiceConnectionStatus.Connecting);
});
});
@@ -486,7 +486,7 @@ describe('VoiceConnection#destroy', () => {
guildId: joinConfig.guildId,
});
expect(adapter.sendPayload).toHaveBeenCalledWith(dummy);
expect(voiceConnection.state.status).toBe(VoiceConnectionStatus.Destroyed);
expect(voiceConnection.state.status).toEqual(VoiceConnectionStatus.Destroyed);
});
});
@@ -494,12 +494,12 @@ describe('VoiceConnection#disconnect', () => {
test('Fails in Destroyed and Signalling states', () => {
const { voiceConnection, adapter } = createFakeVoiceConnection();
voiceConnection.state = { status: VoiceConnectionStatus.Destroyed };
expect(voiceConnection.disconnect()).toBe(false);
expect(voiceConnection.state.status).toBe(VoiceConnectionStatus.Destroyed);
expect(voiceConnection.disconnect()).toEqual(false);
expect(voiceConnection.state.status).toEqual(VoiceConnectionStatus.Destroyed);
voiceConnection.state = { status: VoiceConnectionStatus.Signalling, adapter };
expect(voiceConnection.disconnect()).toBe(false);
expect(voiceConnection.state.status).toBe(VoiceConnectionStatus.Signalling);
expect(voiceConnection.disconnect()).toEqual(false);
expect(voiceConnection.state.status).toEqual(VoiceConnectionStatus.Signalling);
});
test('Disconnects - available adapter', () => {
@@ -511,7 +511,7 @@ describe('VoiceConnection#disconnect', () => {
};
const leavePayload = Symbol('dummy');
DataStore.createJoinVoiceChannelPayload.mockImplementation(() => leavePayload as any);
expect(voiceConnection.disconnect()).toBe(true);
expect(voiceConnection.disconnect()).toEqual(true);
expect(voiceConnection.joinConfig).toMatchObject({
channelId: null,
guildId: '2',
@@ -534,7 +534,7 @@ describe('VoiceConnection#disconnect', () => {
networking: new Networking.Networking({} as any, false),
};
adapter.sendPayload.mockImplementation(() => false);
expect(voiceConnection.disconnect()).toBe(false);
expect(voiceConnection.disconnect()).toEqual(false);
expect(voiceConnection.state).toMatchObject({
status: VoiceConnectionStatus.Disconnected,
reason: VoiceConnectionDisconnectReason.AdapterUnavailable,
@@ -554,10 +554,10 @@ describe('VoiceConnection#rejoin', () => {
reason: VoiceConnectionDisconnectReason.WebSocketClose,
closeCode: 1000,
};
expect(voiceConnection.rejoin()).toBe(true);
expect(voiceConnection.rejoinAttempts).toBe(1);
expect(voiceConnection.rejoin()).toEqual(true);
expect(voiceConnection.rejoinAttempts).toEqual(1);
expect(adapter.sendPayload).toHaveBeenCalledWith(dummy);
expect(voiceConnection.state.status).toBe(VoiceConnectionStatus.Signalling);
expect(voiceConnection.state.status).toEqual(VoiceConnectionStatus.Signalling);
});
test('Rejoins in a ready state', () => {
@@ -569,10 +569,10 @@ describe('VoiceConnection#rejoin', () => {
...(voiceConnection.state as VoiceConnectionReadyState),
status: VoiceConnectionStatus.Ready,
};
expect(voiceConnection.rejoin()).toBe(true);
expect(voiceConnection.rejoinAttempts).toBe(0);
expect(voiceConnection.rejoin()).toEqual(true);
expect(voiceConnection.rejoinAttempts).toEqual(0);
expect(adapter.sendPayload).toHaveBeenCalledWith(dummy);
expect(voiceConnection.state.status).toBe(VoiceConnectionStatus.Ready);
expect(voiceConnection.state.status).toEqual(VoiceConnectionStatus.Ready);
});
test('Stays in the disconnected state when the adapter fails', () => {
@@ -587,10 +587,10 @@ describe('VoiceConnection#rejoin', () => {
closeCode: 1000,
};
adapter.sendPayload.mockReturnValue(false);
expect(voiceConnection.rejoin()).toBe(false);
expect(voiceConnection.rejoinAttempts).toBe(1);
expect(voiceConnection.rejoin()).toEqual(false);
expect(voiceConnection.rejoinAttempts).toEqual(1);
expect(adapter.sendPayload).toHaveBeenCalledWith(dummy);
expect(voiceConnection.state.status).toBe(VoiceConnectionStatus.Disconnected);
expect(voiceConnection.state.status).toEqual(VoiceConnectionStatus.Disconnected);
});
});
@@ -602,7 +602,7 @@ describe('VoiceConnection#subscribe', () => {
voiceConnection.state = { status: VoiceConnectionStatus.Destroyed };
expect(voiceConnection.subscribe(player)).toBeUndefined();
expect(player['subscribe']).not.toHaveBeenCalled();
expect(voiceConnection.state.status).toBe(VoiceConnectionStatus.Destroyed);
expect(voiceConnection.state.status).toEqual(VoiceConnectionStatus.Destroyed);
});
test('Subscribes in a live state', () => {
@@ -611,7 +611,7 @@ describe('VoiceConnection#subscribe', () => {
const player = new AudioPlayer.AudioPlayer();
const dummy = Symbol('dummy');
player['subscribe'] = jest.fn().mockImplementation(() => dummy);
expect(voiceConnection.subscribe(player)).toBe(dummy);
expect(voiceConnection.subscribe(player)).toEqual(dummy);
expect(player['subscribe']).toHaveBeenCalledWith(voiceConnection);
expect(voiceConnection.state).toMatchObject({
status: VoiceConnectionStatus.Signalling,
@@ -628,7 +628,7 @@ describe('VoiceConnection#onSubscriptionRemoved', () => {
voiceConnection.state = { status: VoiceConnectionStatus.Destroyed };
voiceConnection['onSubscriptionRemoved'](subscription);
expect(voiceConnection.state.status).toBe(VoiceConnectionStatus.Destroyed);
expect(voiceConnection.state.status).toEqual(VoiceConnectionStatus.Destroyed);
expect(subscription.unsubscribe).not.toHaveBeenCalled();
});
@@ -686,9 +686,9 @@ describe('VoiceConnection#onSubscriptionRemoved', () => {
voiceConnection['updateReceiveBindings'](newNetworking.state, oldNetworking.state);
// Assert
expect(oldNetworking.state.udp.listenerCount('message')).toBe(0);
expect(newNetworking.state.udp.listenerCount('message')).toBe(1);
expect(voiceConnection.receiver.connectionData).toBe(newNetworking.state.connectionData);
expect(oldNetworking.state.udp.listenerCount('message')).toEqual(0);
expect(newNetworking.state.udp.listenerCount('message')).toEqual(1);
expect(voiceConnection.receiver.connectionData).toEqual(newNetworking.state.connectionData);
});
test('Applies and removes ws listeners', () => {
@@ -716,9 +716,9 @@ describe('VoiceConnection#onSubscriptionRemoved', () => {
voiceConnection['updateReceiveBindings'](newNetworking.state, oldNetworking.state);
// Assert
expect(oldNetworking.state.ws.listenerCount('packet')).toBe(0);
expect(newNetworking.state.ws.listenerCount('packet')).toBe(1);
expect(voiceConnection.receiver.connectionData).toBe(newNetworking.state.connectionData);
expect(oldNetworking.state.ws.listenerCount('packet')).toEqual(0);
expect(newNetworking.state.ws.listenerCount('packet')).toEqual(1);
expect(voiceConnection.receiver.connectionData).toEqual(newNetworking.state.connectionData);
});
test('Applies initial listeners', () => {
@@ -739,9 +739,9 @@ describe('VoiceConnection#onSubscriptionRemoved', () => {
voiceConnection['updateReceiveBindings'](newNetworking.state, undefined);
// Assert
expect(newNetworking.state.ws.listenerCount('packet')).toBe(1);
expect(newNetworking.state.udp.listenerCount('message')).toBe(1);
expect(voiceConnection.receiver.connectionData).toBe(newNetworking.state.connectionData);
expect(newNetworking.state.ws.listenerCount('packet')).toEqual(1);
expect(newNetworking.state.udp.listenerCount('message')).toEqual(1);
expect(voiceConnection.receiver.connectionData).toEqual(newNetworking.state.connectionData);
});
});
});
@@ -766,7 +766,7 @@ describe('Adapter', () => {
test('destroy', () => {
const { adapter, voiceConnection } = createFakeVoiceConnection();
adapter.libMethods.destroy();
expect(voiceConnection.state.status).toBe(VoiceConnectionStatus.Destroyed);
expect(voiceConnection.state.status).toEqual(VoiceConnectionStatus.Destroyed);
expect(adapter.sendPayload).not.toHaveBeenCalled();
});
});

16
packages/voice/__tests__/VoiceReceiver.test.ts
View File

@@ -88,7 +88,7 @@ describe('VoiceReceiver', () => {
receiver['onUdpMessage'](RTP_PACKET_DESKTOP.packet);
await nextTick();
await expect(errorEvent).resolves.toMatchObject([expect.any(Error)]);
expect(receiver.subscriptions.size).toBe(0);
expect(receiver.subscriptions.size).toEqual(0);
});
test('subscribe: only allows one subscribe stream per SSRC', () => {
@@ -99,7 +99,7 @@ describe('VoiceReceiver', () => {
}));
const stream = receiver.subscribe('123');
expect(receiver.subscribe('123')).toBe(stream);
expect(receiver.subscribe('123')).toEqual(stream);
});
describe('onWsPacket', () => {
@@ -177,8 +177,8 @@ describe('VoiceReceiver', () => {
const decrypted = receiver['decrypt'](buffer, 'xsalsa20_poly1305_lite', nonce, secretKey);
// Assert
expect(nonce.equals(range(29, 32))).toBe(true);
expect(decrypted.equals(range(13, 28))).toBe(true);
expect(nonce.equals(range(29, 32))).toEqual(true);
expect(decrypted.equals(range(13, 28))).toEqual(true);
});
test('decrypt: xsalsa20_poly1305_suffix', () => {
@@ -190,8 +190,8 @@ describe('VoiceReceiver', () => {
const decrypted = receiver['decrypt'](buffer, 'xsalsa20_poly1305_suffix', nonce, secretKey);
// Assert
expect(nonce.equals(range(41, 64))).toBe(true);
expect(decrypted.equals(range(13, 40))).toBe(true);
expect(nonce.equals(range(41, 64))).toEqual(true);
expect(decrypted.equals(range(13, 40))).toEqual(true);
});
test('decrypt: xsalsa20_poly1305', () => {
@@ -203,8 +203,8 @@ describe('VoiceReceiver', () => {
const decrypted = receiver['decrypt'](buffer, 'xsalsa20_poly1305', nonce, secretKey);
// Assert
expect(nonce.equals(range(1, 12))).toBe(true);
expect(decrypted.equals(range(13, 64))).toBe(true);
expect(nonce.equals(range(1, 12))).toEqual(true);
expect(decrypted.equals(range(13, 64))).toEqual(true);
});
});
});

16
packages/voice/__tests__/VoiceUDPSocket.test.ts
View File

@@ -55,13 +55,13 @@ describe('VoiceUDPSocket#performIPDiscovery', () => {
socket = new VoiceUDPSocket({ ip: '1.2.3.4', port: 25565 });
expect(createSocket).toHaveBeenCalledWith('udp4');
expect(fake.listenerCount('message')).toBe(1);
expect(fake.listenerCount('message')).toEqual(1);
await expect(socket.performIPDiscovery(1234)).resolves.toEqual({
ip: '91.90.123.93',
port: 54148,
});
// Ensure clean up occurs
expect(fake.listenerCount('message')).toBe(1);
expect(fake.listenerCount('message')).toEqual(1);
});
/*
@@ -80,13 +80,13 @@ describe('VoiceUDPSocket#performIPDiscovery', () => {
socket = new VoiceUDPSocket({ ip: '1.2.3.4', port: 25565 });
expect(createSocket).toHaveBeenCalledWith('udp4');
expect(fake.listenerCount('message')).toBe(1);
expect(fake.listenerCount('message')).toEqual(1);
await expect(socket.performIPDiscovery(1234)).resolves.toEqual({
ip: '91.90.123.93',
port: 54148,
});
// Ensure clean up occurs
expect(fake.listenerCount('message')).toBe(1);
expect(fake.listenerCount('message')).toEqual(1);
});
test('Rejects if socket closes before IP discovery can be completed', async () => {
@@ -120,7 +120,7 @@ describe('VoiceUDPSocket#performIPDiscovery', () => {
await wait();
}
expect(closed).toBe(false);
expect(closed).toEqual(false);
});
test('Emits an error when no response received to keep alive messages', async () => {
@@ -138,7 +138,7 @@ describe('VoiceUDPSocket#performIPDiscovery', () => {
await wait();
}
expect(closed).toBe(true);
expect(closed).toEqual(true);
});
test('Recovers from intermittent responses', async () => {
@@ -160,11 +160,11 @@ describe('VoiceUDPSocket#performIPDiscovery', () => {
await wait();
fake.emit('message', buffer);
});
expect(closed).toBe(false);
expect(closed).toEqual(false);
for (let i = 0; i < 30; i++) {
jest.advanceTimersToNextTimer();
await wait();
}
expect(closed).toBe(false);
expect(closed).toEqual(false);
});
});

4
packages/voice/__tests__/VoiceWebSocket.test.ts
View File

@@ -119,7 +119,7 @@ describe.skip('VoiceWebSocket: heartbeating', () => {
const rcv = onceIgnoreError(ws, 'close');
ws.setHeartbeatInterval(50);
await expect(rcv).resolves.toBeTruthy();
expect(ws.ping).toBe(undefined);
expect(server.messages.length).toBe(3);
expect(ws.ping).toBeUndefined();
expect(server.messages.length).toEqual(3);
});
});

10
packages/voice/__tests__/abortAfter.test.ts
View File

@@ -7,16 +7,16 @@ const clearTimeoutSpy = jest.spyOn(global, 'clearTimeout');
describe('abortAfter', () => {
test('Aborts after the given delay', () => {
const [ac, signal] = abortAfter(100);
expect(ac.signal).toBe(signal);
expect(signal.aborted).toBe(false);
expect(ac.signal).toEqual(signal);
expect(signal.aborted).toEqual(false);
jest.runAllTimers();
expect(signal.aborted).toBe(true);
expect(signal.aborted).toEqual(true);
});
test('Cleans up when manually aborted', () => {
const [ac, signal] = abortAfter(100);
expect(ac.signal).toBe(signal);
expect(signal.aborted).toBe(false);
expect(ac.signal).toEqual(signal);
expect(signal.aborted).toEqual(false);
clearTimeoutSpy.mockClear();
ac.abort();
expect(clearTimeoutSpy).toHaveBeenCalledTimes(1);

12
packages/voice/__tests__/demuxProbe.test.ts
View File

@@ -69,7 +69,7 @@ describe('demuxProbe', () => {
test('Defaults to arbitrary', async () => {
const stream = Readable.from(gen(10), { objectMode: false });
const probe = await demuxProbe(stream);
expect(probe.type).toBe(StreamType.Arbitrary);
expect(probe.type).toEqual(StreamType.Arbitrary);
await expect(collectStream(probe.stream)).resolves.toEqual(range(10));
});
@@ -80,7 +80,7 @@ describe('demuxProbe', () => {
if (data[0] === 5) this.emit('head', validHead);
} as any);
const probe = await demuxProbe(stream);
expect(probe.type).toBe(StreamType.WebmOpus);
expect(probe.type).toEqual(StreamType.WebmOpus);
await expect(collectStream(probe.stream)).resolves.toEqual(range(10));
});
@@ -91,7 +91,7 @@ describe('demuxProbe', () => {
if (data[0] === 5) this.emit('head', validHead);
} as any);
const probe = await demuxProbe(stream);
expect(probe.type).toBe(StreamType.OggOpus);
expect(probe.type).toEqual(StreamType.OggOpus);
await expect(collectStream(probe.stream)).resolves.toEqual(range(10));
});
@@ -102,14 +102,14 @@ describe('demuxProbe', () => {
if (data[0] === 5) this.emit('head', invalidHead);
} as any);
const probe = await demuxProbe(stream);
expect(probe.type).toBe(StreamType.Arbitrary);
expect(probe.type).toEqual(StreamType.Arbitrary);
await expect(collectStream(probe.stream)).resolves.toEqual(range(10));
});
test('Gives up on larger streams', async () => {
const stream = Readable.from(gen(8192), { objectMode: false });
const probe = await demuxProbe(stream);
expect(probe.type).toBe(StreamType.Arbitrary);
expect(probe.type).toEqual(StreamType.Arbitrary);
await expect(collectStream(probe.stream)).resolves.toEqual(range(8192));
});
@@ -120,6 +120,6 @@ describe('demuxProbe', () => {
this.destroy(testError);
},
});
await expect(demuxProbe(stream)).rejects.toBe(testError);
await expect(demuxProbe(stream)).rejects.toEqual(testError);
});
});

6
packages/voice/__tests__/entersState.test.ts
View File

@@ -21,7 +21,7 @@ describe('entersState', () => {
// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
process.nextTick(() => vc.emit(VoiceConnectionStatus.Ready, null as any, null as any));
const result = await entersState(vc, VoiceConnectionStatus.Ready, 1000);
expect(result).toBe(vc);
expect(result).toEqual(vc);
});
test('Rejects once the timeout is exceeded', async () => {
@@ -38,7 +38,7 @@ describe('entersState', () => {
// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
process.nextTick(() => vc.emit(VoiceConnectionStatus.Ready, null as any, null as any));
const result = await entersState(vc, VoiceConnectionStatus.Ready, ac.signal);
expect(result).toBe(vc);
expect(result).toEqual(vc);
});
test('Rejects once the signal is aborted', async () => {
@@ -51,6 +51,6 @@ describe('entersState', () => {
test('Resolves immediately when target already in desired state', async () => {
const vc = createFakeVoiceConnection();
await expect(entersState(vc, VoiceConnectionStatus.Signalling, 1000)).resolves.toBe(vc);
await expect(entersState(vc, VoiceConnectionStatus.Signalling, 1000)).resolves.toEqual(vc);
});
});