style: cleanup tests and tsup configs

packages/builders/__tests__/messages/embed.test.ts

@@ -13,13 +13,13 @@ describe('Embed', () => {
 				footer: { text: alpha },
 			});
 
-			expect(embedLength(embed.data)).toBe(alpha.length * 6);
+			expect(embedLength(embed.data)).toEqual(alpha.length * 6);
 		});
 
 		test('GIVEN an embed with zero characters THEN returns amount of characters', () => {
 			const embed = new EmbedBuilder();
 
-			expect(embedLength(embed.data)).toBe(0);
+			expect(embedLength(embed.data)).toEqual(0);
 		});
 	});
 

packages/builders/__tests__/messages/formatters.test.ts

@@ -22,75 +22,75 @@ import {
 describe('Message formatters', () => {
 	describe('codeBlock', () => {
 		test('GIVEN "discord.js" with no language THEN returns "```\\ndiscord.js```"', () => {
-			expect<'```\ndiscord.js```'>(codeBlock('discord.js')).toBe('```\ndiscord.js```');
+			expect<'```\ndiscord.js```'>(codeBlock('discord.js')).toEqual('```\ndiscord.js```');
 		});
 
 		test('GIVEN "discord.js" with "js" as language THEN returns "```js\\ndiscord.js```"', () => {
-			expect<'```js\ndiscord.js```'>(codeBlock('js', 'discord.js')).toBe('```js\ndiscord.js```');
+			expect<'```js\ndiscord.js```'>(codeBlock('js', 'discord.js')).toEqual('```js\ndiscord.js```');
 		});
 	});
 
 	describe('inlineCode', () => {
 		test('GIVEN "discord.js" THEN returns "`discord.js`"', () => {
-			expect<'`discord.js`'>(inlineCode('discord.js')).toBe('`discord.js`');
+			expect<'`discord.js`'>(inlineCode('discord.js')).toEqual('`discord.js`');
 		});
 	});
 
 	describe('italic', () => {
 		test('GIVEN "discord.js" THEN returns "_discord.js_"', () => {
-			expect<'_discord.js_'>(italic('discord.js')).toBe('_discord.js_');
+			expect<'_discord.js_'>(italic('discord.js')).toEqual('_discord.js_');
 		});
 	});
 
 	describe('bold', () => {
 		test('GIVEN "discord.js" THEN returns "**discord.js**"', () => {
-			expect<'**discord.js**'>(bold('discord.js')).toBe('**discord.js**');
+			expect<'**discord.js**'>(bold('discord.js')).toEqual('**discord.js**');
 		});
 	});
 
 	describe('underscore', () => {
 		test('GIVEN "discord.js" THEN returns "__discord.js__"', () => {
-			expect<'__discord.js__'>(underscore('discord.js')).toBe('__discord.js__');
+			expect<'__discord.js__'>(underscore('discord.js')).toEqual('__discord.js__');
 		});
 	});
 
 	describe('strikethrough', () => {
 		test('GIVEN "discord.js" THEN returns "~~discord.js~~"', () => {
-			expect<'~~discord.js~~'>(strikethrough('discord.js')).toBe('~~discord.js~~');
+			expect<'~~discord.js~~'>(strikethrough('discord.js')).toEqual('~~discord.js~~');
 		});
 	});
 
 	describe('quote', () => {
 		test('GIVEN "discord.js" THEN returns "> discord.js"', () => {
-			expect<'> discord.js'>(quote('discord.js')).toBe('> discord.js');
+			expect<'> discord.js'>(quote('discord.js')).toEqual('> discord.js');
 		});
 	});
 
 	describe('blockQuote', () => {
 		test('GIVEN "discord.js" THEN returns ">>> discord.js"', () => {
-			expect<'>>> discord.js'>(blockQuote('discord.js')).toBe('>>> discord.js');
+			expect<'>>> discord.js'>(blockQuote('discord.js')).toEqual('>>> discord.js');
 		});
 	});
 
 	describe('hideLinkEmbed', () => {
 		test('GIVEN "https://discord.js.org" THEN returns "<https://discord.js.org>"', () => {
-			expect<'<https://discord.js.org>'>(hideLinkEmbed('https://discord.js.org')).toBe('<https://discord.js.org>');
+			expect<'<https://discord.js.org>'>(hideLinkEmbed('https://discord.js.org')).toEqual('<https://discord.js.org>');
 		});
 
 		test('GIVEN new URL("https://discord.js.org") THEN returns "<https://discord.js.org>"', () => {
-			expect<`<${string}>`>(hideLinkEmbed(new URL('https://discord.js.org/'))).toBe('<https://discord.js.org/>');
+			expect<`<${string}>`>(hideLinkEmbed(new URL('https://discord.js.org/'))).toEqual('<https://discord.js.org/>');
 		});
 	});
 
 	describe('hyperlink', () => {
 		test('GIVEN content and string URL THEN returns "[content](url)"', () => {
-			expect<'[discord.js](https://discord.js.org)'>(hyperlink('discord.js', 'https://discord.js.org')).toBe(
+			expect<'[discord.js](https://discord.js.org)'>(hyperlink('discord.js', 'https://discord.js.org')).toEqual(
 				'[discord.js](https://discord.js.org)',
 			);
 		});
 
 		test('GIVEN content and URL THEN returns "[content](url)"', () => {
-			expect<`[discord.js](${string})`>(hyperlink('discord.js', new URL('https://discord.js.org'))).toBe(
+			expect<`[discord.js](${string})`>(hyperlink('discord.js', new URL('https://discord.js.org'))).toEqual(
 				'[discord.js](https://discord.js.org/)',
 			);
 		});
@@ -98,53 +98,53 @@ describe('Message formatters', () => {
 		test('GIVEN content, string URL, and title THEN returns "[content](url "title")"', () => {
 			expect<'[discord.js](https://discord.js.org "Official Documentation")'>(
 				hyperlink('discord.js', 'https://discord.js.org', 'Official Documentation'),
-			).toBe('[discord.js](https://discord.js.org "Official Documentation")');
+			).toEqual('[discord.js](https://discord.js.org "Official Documentation")');
 		});
 
 		test('GIVEN content, URL, and title THEN returns "[content](url "title")"', () => {
 			expect<`[discord.js](${string} "Official Documentation")`>(
 				hyperlink('discord.js', new URL('https://discord.js.org'), 'Official Documentation'),
-			).toBe('[discord.js](https://discord.js.org/ "Official Documentation")');
+			).toEqual('[discord.js](https://discord.js.org/ "Official Documentation")');
 		});
 	});
 
 	describe('spoiler', () => {
 		test('GIVEN "discord.js" THEN returns "||discord.js||"', () => {
-			expect<'||discord.js||'>(spoiler('discord.js')).toBe('||discord.js||');
+			expect<'||discord.js||'>(spoiler('discord.js')).toEqual('||discord.js||');
 		});
 	});
 
 	describe('Mentions', () => {
 		describe('userMention', () => {
 			test('GIVEN userId THEN returns "<@[userId]>"', () => {
-				expect(userMention('139836912335716352')).toBe('<@139836912335716352>');
+				expect(userMention('139836912335716352')).toEqual('<@139836912335716352>');
 			});
 		});
 
 		describe('channelMention', () => {
 			test('GIVEN channelId THEN returns "<#[channelId]>"', () => {
-				expect(channelMention('829924760309334087')).toBe('<#829924760309334087>');
+				expect(channelMention('829924760309334087')).toEqual('<#829924760309334087>');
 			});
 		});
 
 		describe('roleMention', () => {
 			test('GIVEN roleId THEN returns "<&[roleId]>"', () => {
-				expect(roleMention('815434166602170409')).toBe('<@&815434166602170409>');
+				expect(roleMention('815434166602170409')).toEqual('<@&815434166602170409>');
 			});
 		});
 	});
 
 	describe('formatEmoji', () => {
 		test('GIVEN static emojiId THEN returns "<:_:${emojiId}>"', () => {
-			expect<`<:_:851461487498493952>`>(formatEmoji('851461487498493952')).toBe('<:_:851461487498493952>');
+			expect<`<:_:851461487498493952>`>(formatEmoji('851461487498493952')).toEqual('<:_:851461487498493952>');
 		});
 
 		test('GIVEN static emojiId WITH animated explicitly false THEN returns "<:_:[emojiId]>"', () => {
-			expect<`<:_:851461487498493952>`>(formatEmoji('851461487498493952', false)).toBe('<:_:851461487498493952>');
+			expect<`<:_:851461487498493952>`>(formatEmoji('851461487498493952', false)).toEqual('<:_:851461487498493952>');
 		});
 
 		test('GIVEN animated emojiId THEN returns "<a:_:${emojiId}>"', () => {
-			expect<`<a:_:827220205352255549>`>(formatEmoji('827220205352255549', true)).toBe('<a:_:827220205352255549>');
+			expect<`<a:_:827220205352255549>`>(formatEmoji('827220205352255549', true)).toEqual('<a:_:827220205352255549>');
 		});
 	});
 
@@ -153,47 +153,49 @@ describe('Message formatters', () => {
 			jest.useFakeTimers('modern');
 			jest.setSystemTime(1566424897579);
 
-			expect<`<t:${bigint}>`>(time()).toBe('<t:1566424897>');
+			expect<`<t:${bigint}>`>(time()).toEqual('<t:1566424897>');
 
 			jest.useRealTimers();
 		});
 
 		test('GIVEN a date THEN returns "<t:${bigint}>"', () => {
-			expect<`<t:${bigint}>`>(time(new Date(1867424897579))).toBe('<t:1867424897>');
+			expect<`<t:${bigint}>`>(time(new Date(1867424897579))).toEqual('<t:1867424897>');
 		});
 
 		test('GIVEN a date and a style from string THEN returns "<t:${bigint}:${style}>"', () => {
-			expect<`<t:${bigint}:d>`>(time(new Date(1867424897579), 'd')).toBe('<t:1867424897:d>');
+			expect<`<t:${bigint}:d>`>(time(new Date(1867424897579), 'd')).toEqual('<t:1867424897:d>');
 		});
 
 		test('GIVEN a date and a format from enum THEN returns "<t:${bigint}:${style}>"', () => {
-			expect<`<t:${bigint}:R>`>(time(new Date(1867424897579), TimestampStyles.RelativeTime)).toBe('<t:1867424897:R>');
+			expect<`<t:${bigint}:R>`>(time(new Date(1867424897579), TimestampStyles.RelativeTime)).toEqual(
+				'<t:1867424897:R>',
+			);
 		});
 
 		test('GIVEN a date THEN returns "<t:${time}>"', () => {
-			expect<'<t:1867424897>'>(time(1867424897)).toBe('<t:1867424897>');
+			expect<'<t:1867424897>'>(time(1867424897)).toEqual('<t:1867424897>');
 		});
 
 		test('GIVEN a date and a style from string THEN returns "<t:${time}:${style}>"', () => {
-			expect<'<t:1867424897:d>'>(time(1867424897, 'd')).toBe('<t:1867424897:d>');
+			expect<'<t:1867424897:d>'>(time(1867424897, 'd')).toEqual('<t:1867424897:d>');
 		});
 
 		test('GIVEN a date and a format from enum THEN returns "<t:${time}:${style}>"', () => {
-			expect<'<t:1867424897:R>'>(time(1867424897, TimestampStyles.RelativeTime)).toBe('<t:1867424897:R>');
+			expect<'<t:1867424897:R>'>(time(1867424897, TimestampStyles.RelativeTime)).toEqual('<t:1867424897:R>');
 		});
 	});
 
 	describe('Faces', () => {
 		test('GIVEN Faces.Shrug THEN returns "¯\\_(ツ)\\_/¯"', () => {
-			expect<'¯\\_(ツ)\\_/¯'>(Faces.Shrug).toBe('¯\\_(ツ)\\_/¯');
+			expect<'¯\\_(ツ)\\_/¯'>(Faces.Shrug).toEqual('¯\\_(ツ)\\_/¯');
 		});
 
 		test('GIVEN Faces.Tableflip THEN returns "(╯°□°）╯︵ ┻━┻"', () => {
-			expect<'(╯°□°）╯︵ ┻━┻'>(Faces.Tableflip).toBe('(╯°□°）╯︵ ┻━┻');
+			expect<'(╯°□°）╯︵ ┻━┻'>(Faces.Tableflip).toEqual('(╯°□°）╯︵ ┻━┻');
 		});
 
 		test('GIVEN Faces.Unflip THEN returns "┬─┬ ノ( ゜-゜ノ)"', () => {
-			expect<'┬─┬ ノ( ゜-゜ノ)'>(Faces.Unflip).toBe('┬─┬ ノ( ゜-゜ノ)');
+			expect<'┬─┬ ノ( ゜-゜ノ)'>(Faces.Unflip).toEqual('┬─┬ ノ( ゜-゜ノ)');
 		});
 	});
 });

packages/builders/tsup.config.ts

@@ -1,6 +1,6 @@
-import type { Options } from 'tsup';
+import { defineConfig } from 'tsup';
 
-export const tsup: Options = {
+export default defineConfig({
 	clean: true,
 	dts: true,
 	entryPoints: ['src/index.ts'],
@@ -17,4 +17,4 @@ export const tsup: Options = {
 			};
 		}
 	},
-};
+});

packages/collection/tsup.config.ts

@@ -1,6 +1,6 @@
-import type { Options } from 'tsup';
+import { defineConfig } from 'tsup';
 
-export const tsup: Options = {
+export default defineConfig({
 	clean: true,
 	dts: true,
 	entryPoints: ['src/index.ts'],
@@ -18,4 +18,4 @@ export const tsup: Options = {
 			};
 		}
 	},
-};
+});

packages/discord.js/test/escapeMarkdown.test.js

@@ -8,150 +8,150 @@ const testString = "`_Behold!_`\n||___~~***```js\n`use strict`;\nrequire('discor
 
 describe('escapeCodeblock', () => {
   test('shared', () => {
-    expect(Util.escapeCodeBlock(testString)).toBe(
+    expect(Util.escapeCodeBlock(testString)).toEqual(
       "`_Behold!_`\n||___~~***\\`\\`\\`js\n`use strict`;\nrequire('discord.js');\\`\\`\\`***~~___||",
     );
   });
 
   test('basic', () => {
-    expect(Util.escapeCodeBlock('```test```')).toBe('\\`\\`\\`test\\`\\`\\`');
+    expect(Util.escapeCodeBlock('```test```')).toEqual('\\`\\`\\`test\\`\\`\\`');
   });
 });
 
 describe('escapeInlineCode', () => {
   test('shared', () => {
-    expect(Util.escapeInlineCode(testString)).toBe(
+    expect(Util.escapeInlineCode(testString)).toEqual(
       "\\`_Behold!_\\`\n||___~~***```js\n\\`use strict\\`;\nrequire('discord.js');```***~~___||",
     );
   });
 
   test('basic', () => {
-    expect(Util.escapeInlineCode('`test`')).toBe('\\`test\\`');
+    expect(Util.escapeInlineCode('`test`')).toEqual('\\`test\\`');
   });
 });
 
 describe('escapeBold', () => {
   test('shared', () => {
-    expect(Util.escapeBold(testString)).toBe(
+    expect(Util.escapeBold(testString)).toEqual(
       "`_Behold!_`\n||___~~*\\*\\*```js\n`use strict`;\nrequire('discord.js');```\\*\\**~~___||",
     );
   });
 
   test('basic', () => {
-    expect(Util.escapeBold('**test**')).toBe('\\*\\*test\\*\\*');
+    expect(Util.escapeBold('**test**')).toEqual('\\*\\*test\\*\\*');
   });
 });
 
 describe('escapeItalic', () => {
   test('shared', () => {
-    expect(Util.escapeItalic(testString)).toBe(
+    expect(Util.escapeItalic(testString)).toEqual(
       "`\\_Behold!\\_`\n||\\___~~\\***```js\n`use strict`;\nrequire('discord.js');```**\\*~~__\\_||",
     );
   });
 
   test('basic (_)', () => {
-    expect(Util.escapeItalic('_test_')).toBe('\\_test\\_');
+    expect(Util.escapeItalic('_test_')).toEqual('\\_test\\_');
   });
 
   test('basic (*)', () => {
-    expect(Util.escapeItalic('*test*')).toBe('\\*test\\*');
+    expect(Util.escapeItalic('*test*')).toEqual('\\*test\\*');
   });
 });
 
 describe('escapeUnderline', () => {
   test('shared', () => {
-    expect(Util.escapeUnderline(testString)).toBe(
+    expect(Util.escapeUnderline(testString)).toEqual(
       "`_Behold!_`\n||_\\_\\_~~***```js\n`use strict`;\nrequire('discord.js');```***~~\\_\\__||",
     );
   });
 
   test('basic', () => {
-    expect(Util.escapeUnderline('__test__')).toBe('\\_\\_test\\_\\_');
+    expect(Util.escapeUnderline('__test__')).toEqual('\\_\\_test\\_\\_');
   });
 });
 
 describe('escapeStrikethrough', () => {
   test('shared', () => {
-    expect(Util.escapeStrikethrough(testString)).toBe(
+    expect(Util.escapeStrikethrough(testString)).toEqual(
       "`_Behold!_`\n||___\\~\\~***```js\n`use strict`;\nrequire('discord.js');```***\\~\\~___||",
     );
   });
 
   test('basic', () => {
-    expect(Util.escapeStrikethrough('~~test~~')).toBe('\\~\\~test\\~\\~');
+    expect(Util.escapeStrikethrough('~~test~~')).toEqual('\\~\\~test\\~\\~');
   });
 });
 
 describe('escapeSpoiler', () => {
   test('shared', () => {
-    expect(Util.escapeSpoiler(testString)).toBe(
+    expect(Util.escapeSpoiler(testString)).toEqual(
       "`_Behold!_`\n\\|\\|___~~***```js\n`use strict`;\nrequire('discord.js');```***~~___\\|\\|",
     );
   });
 
   test('basic', () => {
-    expect(Util.escapeSpoiler('||test||')).toBe('\\|\\|test\\|\\|');
+    expect(Util.escapeSpoiler('||test||')).toEqual('\\|\\|test\\|\\|');
   });
 });
 
 describe('escapeMarkdown', () => {
   test('shared', () => {
-    expect(Util.escapeMarkdown(testString)).toBe(
+    expect(Util.escapeMarkdown(testString)).toEqual(
       "\\`\\_Behold!\\_\\`\n\\|\\|\\_\\_\\_\\~\\~\\*\\*\\*\\`\\`\\`js\n\\`use strict\\`;\nrequire('discord.js');\\`\\`\\`\\*\\*\\*\\~\\~\\_\\_\\_\\|\\|",
     );
   });
 
   test('no codeBlock', () => {
-    expect(Util.escapeMarkdown(testString, { codeBlock: false })).toBe(
+    expect(Util.escapeMarkdown(testString, { codeBlock: false })).toEqual(
       "\\`\\_Behold!\\_\\`\n\\|\\|\\_\\_\\_\\~\\~\\*\\*\\*```js\n\\`use strict\\`;\nrequire('discord.js');```\\*\\*\\*\\~\\~\\_\\_\\_\\|\\|",
     );
   });
 
   test('no inlineCode', () => {
-    expect(Util.escapeMarkdown(testString, { inlineCode: false })).toBe(
+    expect(Util.escapeMarkdown(testString, { inlineCode: false })).toEqual(
       "`\\_Behold!\\_`\n\\|\\|\\_\\_\\_\\~\\~\\*\\*\\*\\`\\`\\`js\n`use strict`;\nrequire('discord.js');\\`\\`\\`\\*\\*\\*\\~\\~\\_\\_\\_\\|\\|",
     );
   });
 
   test('no bold', () => {
-    expect(Util.escapeMarkdown(testString, { bold: false })).toBe(
+    expect(Util.escapeMarkdown(testString, { bold: false })).toEqual(
       "\\`\\_Behold!\\_\\`\n\\|\\|\\_\\_\\_\\~\\~\\***\\`\\`\\`js\n\\`use strict\\`;\nrequire('discord.js');\\`\\`\\`**\\*\\~\\~\\_\\_\\_\\|\\|",
     );
   });
 
   test('no italic', () => {
-    expect(Util.escapeMarkdown(testString, { italic: false })).toBe(
+    expect(Util.escapeMarkdown(testString, { italic: false })).toEqual(
       "\\`_Behold!_\\`\n\\|\\|_\\_\\_\\~\\~*\\*\\*\\`\\`\\`js\n\\`use strict\\`;\nrequire('discord.js');\\`\\`\\`\\*\\**\\~\\~\\_\\__\\|\\|",
     );
   });
 
   test('no underline', () => {
-    expect(Util.escapeMarkdown(testString, { underline: false })).toBe(
+    expect(Util.escapeMarkdown(testString, { underline: false })).toEqual(
       "\\`\\_Behold!\\_\\`\n\\|\\|\\___\\~\\~\\*\\*\\*\\`\\`\\`js\n\\`use strict\\`;\nrequire('discord.js');\\`\\`\\`\\*\\*\\*\\~\\~__\\_\\|\\|",
     );
   });
 
   test('no strikethrough', () => {
-    expect(Util.escapeMarkdown(testString, { strikethrough: false })).toBe(
+    expect(Util.escapeMarkdown(testString, { strikethrough: false })).toEqual(
       "\\`\\_Behold!\\_\\`\n\\|\\|\\_\\_\\_~~\\*\\*\\*\\`\\`\\`js\n\\`use strict\\`;\nrequire('discord.js');\\`\\`\\`\\*\\*\\*~~\\_\\_\\_\\|\\|",
     );
   });
 
   test('no spoiler', () => {
-    expect(Util.escapeMarkdown(testString, { spoiler: false })).toBe(
+    expect(Util.escapeMarkdown(testString, { spoiler: false })).toEqual(
       "\\`\\_Behold!\\_\\`\n||\\_\\_\\_\\~\\~\\*\\*\\*\\`\\`\\`js\n\\`use strict\\`;\nrequire('discord.js');\\`\\`\\`\\*\\*\\*\\~\\~\\_\\_\\_||",
     );
   });
 
   describe('code content', () => {
     test('no code block content', () => {
-      expect(Util.escapeMarkdown(testString, { codeBlockContent: false })).toBe(
+      expect(Util.escapeMarkdown(testString, { codeBlockContent: false })).toEqual(
         "\\`\\_Behold!\\_\\`\n\\|\\|\\_\\_\\_\\~\\~\\*\\*\\*\\`\\`\\`js\n`use strict`;\nrequire('discord.js');\\`\\`\\`\\*\\*\\*\\~\\~\\_\\_\\_\\|\\|",
       );
     });
 
     test('no inline code content', () => {
-      expect(Util.escapeMarkdown(testString, { inlineCodeContent: false })).toBe(
+      expect(Util.escapeMarkdown(testString, { inlineCodeContent: false })).toEqual(
         "\\`_Behold!_\\`\n\\|\\|\\_\\_\\_\\~\\~\\*\\*\\*\\`\\`\\`js\n\\`use strict\\`;\nrequire('discord.js');\\`\\`\\`\\*\\*\\*\\~\\~\\_\\_\\_\\|\\|",
       );
     });
@@ -159,19 +159,19 @@ describe('escapeMarkdown', () => {
     test('neither inline code or code block content', () => {
       expect(Util.escapeMarkdown(testString, { inlineCodeContent: false, codeBlockContent: false }))
         // eslint-disable-next-line max-len
-        .toBe(
+        .toEqual(
           "\\`_Behold!_\\`\n\\|\\|\\_\\_\\_\\~\\~\\*\\*\\*\\`\\`\\`js\n`use strict`;\nrequire('discord.js');\\`\\`\\`\\*\\*\\*\\~\\~\\_\\_\\_\\|\\|",
         );
     });
 
     test('neither code blocks or code block content', () => {
-      expect(Util.escapeMarkdown(testString, { codeBlock: false, codeBlockContent: false })).toBe(
+      expect(Util.escapeMarkdown(testString, { codeBlock: false, codeBlockContent: false })).toEqual(
         "\\`\\_Behold!\\_\\`\n\\|\\|\\_\\_\\_\\~\\~\\*\\*\\*```js\n`use strict`;\nrequire('discord.js');```\\*\\*\\*\\~\\~\\_\\_\\_\\|\\|",
       );
     });
 
     test('neither inline code or inline code content', () => {
-      expect(Util.escapeMarkdown(testString, { inlineCode: false, inlineCodeContent: false })).toBe(
+      expect(Util.escapeMarkdown(testString, { inlineCode: false, inlineCodeContent: false })).toEqual(
         "`_Behold!_`\n\\|\\|\\_\\_\\_\\~\\~\\*\\*\\*\\`\\`\\`js\n`use strict`;\nrequire('discord.js');\\`\\`\\`\\*\\*\\*\\~\\~\\_\\_\\_\\|\\|",
       );
     });
@@ -182,13 +182,13 @@ describe('escapeMarkdown', () => {
           codeBlock: false,
           codeBlockContent: false,
         }),
-      ).toBe('\\*\\*foo\\*\\* ```**bar**``` \\*\\*fizz\\*\\* ``` \\*\\*buzz\\*\\*');
+      ).toEqual('\\*\\*foo\\*\\* ```**bar**``` \\*\\*fizz\\*\\* ``` \\*\\*buzz\\*\\*');
     });
 
     test('edge-case odd number of backticks with no inline code content', () => {
       expect(
         Util.escapeMarkdown('**foo** `**bar**` **fizz** ` **buzz**', { inlineCode: false, inlineCodeContent: false }),
-      ).toBe('\\*\\*foo\\*\\* `**bar**` \\*\\*fizz\\*\\* ` \\*\\*buzz\\*\\*');
+      ).toEqual('\\*\\*foo\\*\\* `**bar**` \\*\\*fizz\\*\\* ` \\*\\*buzz\\*\\*');
     });
   });
 });

packages/discord.js/test/resolveGuildTemplateCode.test.js

@@ -6,6 +6,6 @@ const { DataResolver } = require('../src');
 
 describe('resolveGuildTemplateCode', () => {
   test('basic', () => {
-    expect(DataResolver.resolveGuildTemplateCode('https://discord.new/abc')).toBe('abc');
+    expect(DataResolver.resolveGuildTemplateCode('https://discord.new/abc')).toEqual('abc');
   });
 });

packages/proxy/.eslintrc.json

@@ -2,7 +2,8 @@
 	"root": true,
 	"extends": "marine/prettier/node",
 	"parserOptions": {
-		"project": "./tsconfig.eslint.json"
+		"project": "./tsconfig.eslint.json",
+		"extraFileExtensions": [".mjs"]
 	},
 	"ignorePatterns": ["**/dist/*"],
 	"env": {

packages/proxy/__tests__/proxyRequests.test.ts

@@ -58,7 +58,7 @@ test('simple GET', async () => {
 	expect(headers['content-type']).toEqual(expect.stringMatching(/^application\/json/));
 	// Ratelimit headers should be dropped
 	expect(headers).not.toHaveProperty('x-ratelimit-limit');
-	expect(res.statusCode).toBe(200);
+	expect(res.statusCode).toEqual(200);
 	expect(res.body).toStrictEqual({ test: true });
 });
 
@@ -78,6 +78,6 @@ test('failed request', async () => {
 	const headers = res.headers as Record<string, string>;
 
 	expect(headers['content-type']).toEqual(expect.stringMatching(/^application\/json/));
-	expect(res.statusCode).toBe(404);
+	expect(res.statusCode).toEqual(404);
 	expect(res.body).toStrictEqual({ code: 404, message: 'Not Found' });
 });

packages/rest/.eslintrc.json

@@ -2,7 +2,8 @@
 	"root": true,
 	"extends": "marine/prettier/node",
 	"parserOptions": {
-		"project": "./tsconfig.eslint.json"
+		"project": "./tsconfig.eslint.json",
+		"extraFileExtensions": [".mjs"]
 	},
 	"ignorePatterns": ["**/dist/*"],
 	"env": {

packages/rest/__tests__/CDN.test.ts

@@ -9,97 +9,97 @@ const defaultAvatar = 1234 % 5;
 const cdn = new CDN(base);
 
 test('appAsset default', () => {
-	expect(cdn.appAsset(id, hash)).toBe(`${base}/app-assets/${id}/${hash}.webp`);
+	expect(cdn.appAsset(id, hash)).toEqual(`${base}/app-assets/${id}/${hash}.webp`);
 });
 
 test('appIcon default', () => {
-	expect(cdn.appIcon(id, hash)).toBe(`${base}/app-icons/${id}/${hash}.webp`);
+	expect(cdn.appIcon(id, hash)).toEqual(`${base}/app-icons/${id}/${hash}.webp`);
 });
 
 test('avatar default', () => {
-	expect(cdn.avatar(id, hash)).toBe(`${base}/avatars/${id}/${hash}.webp`);
+	expect(cdn.avatar(id, hash)).toEqual(`${base}/avatars/${id}/${hash}.webp`);
 });
 
 test('avatar dynamic-animated', () => {
-	expect(cdn.avatar(id, animatedHash)).toBe(`${base}/avatars/${id}/${animatedHash}.gif`);
+	expect(cdn.avatar(id, animatedHash)).toEqual(`${base}/avatars/${id}/${animatedHash}.gif`);
 });
 
 test('avatar dynamic-not-animated', () => {
-	expect(cdn.avatar(id, hash)).toBe(`${base}/avatars/${id}/${hash}.webp`);
+	expect(cdn.avatar(id, hash)).toEqual(`${base}/avatars/${id}/${hash}.webp`);
 });
 
 test('banner default', () => {
-	expect(cdn.banner(id, hash)).toBe(`${base}/banners/${id}/${hash}.webp`);
+	expect(cdn.banner(id, hash)).toEqual(`${base}/banners/${id}/${hash}.webp`);
 });
 
 test('channelIcon default', () => {
-	expect(cdn.channelIcon(id, hash)).toBe(`${base}/channel-icons/${id}/${hash}.webp`);
+	expect(cdn.channelIcon(id, hash)).toEqual(`${base}/channel-icons/${id}/${hash}.webp`);
 });
 
 test('defaultAvatar default', () => {
-	expect(cdn.defaultAvatar(defaultAvatar)).toBe(`${base}/embed/avatars/${defaultAvatar}.png`);
+	expect(cdn.defaultAvatar(defaultAvatar)).toEqual(`${base}/embed/avatars/${defaultAvatar}.png`);
 });
 
 test('discoverySplash default', () => {
-	expect(cdn.discoverySplash(id, hash)).toBe(`${base}/discovery-splashes/${id}/${hash}.webp`);
+	expect(cdn.discoverySplash(id, hash)).toEqual(`${base}/discovery-splashes/${id}/${hash}.webp`);
 });
 
 test('emoji default', () => {
-	expect(cdn.emoji(id)).toBe(`${base}/emojis/${id}.webp`);
+	expect(cdn.emoji(id)).toEqual(`${base}/emojis/${id}.webp`);
 });
 
 test('emoji gif', () => {
-	expect(cdn.emoji(id, 'gif')).toBe(`${base}/emojis/${id}.gif`);
+	expect(cdn.emoji(id, 'gif')).toEqual(`${base}/emojis/${id}.gif`);
 });
 
 test('guildMemberAvatar default', () => {
-	expect(cdn.guildMemberAvatar(id, id, hash)).toBe(`${base}/guilds/${id}/users/${id}/avatars/${hash}.webp`);
+	expect(cdn.guildMemberAvatar(id, id, hash)).toEqual(`${base}/guilds/${id}/users/${id}/avatars/${hash}.webp`);
 });
 
 test('guildMemberAvatar dynamic-animated', () => {
-	expect(cdn.guildMemberAvatar(id, id, animatedHash)).toBe(
+	expect(cdn.guildMemberAvatar(id, id, animatedHash)).toEqual(
 		`${base}/guilds/${id}/users/${id}/avatars/${animatedHash}.gif`,
 	);
 });
 
 test('guildMemberAvatar dynamic-not-animated', () => {
-	expect(cdn.guildMemberAvatar(id, id, hash)).toBe(`${base}/guilds/${id}/users/${id}/avatars/${hash}.webp`);
+	expect(cdn.guildMemberAvatar(id, id, hash)).toEqual(`${base}/guilds/${id}/users/${id}/avatars/${hash}.webp`);
 });
 
 test('guildScheduledEventCover default', () => {
-	expect(cdn.guildScheduledEventCover(id, hash)).toBe(`${base}/guild-events/${id}/${hash}.webp`);
+	expect(cdn.guildScheduledEventCover(id, hash)).toEqual(`${base}/guild-events/${id}/${hash}.webp`);
 });
 
 test('icon default', () => {
-	expect(cdn.icon(id, hash)).toBe(`${base}/icons/${id}/${hash}.webp`);
+	expect(cdn.icon(id, hash)).toEqual(`${base}/icons/${id}/${hash}.webp`);
 });
 
 test('icon dynamic-animated', () => {
-	expect(cdn.icon(id, animatedHash)).toBe(`${base}/icons/${id}/${animatedHash}.gif`);
+	expect(cdn.icon(id, animatedHash)).toEqual(`${base}/icons/${id}/${animatedHash}.gif`);
 });
 
 test('icon dynamic-not-animated', () => {
-	expect(cdn.icon(id, hash)).toBe(`${base}/icons/${id}/${hash}.webp`);
+	expect(cdn.icon(id, hash)).toEqual(`${base}/icons/${id}/${hash}.webp`);
 });
 
 test('role icon default', () => {
-	expect(cdn.roleIcon(id, hash)).toBe(`${base}/role-icons/${id}/${hash}.webp`);
+	expect(cdn.roleIcon(id, hash)).toEqual(`${base}/role-icons/${id}/${hash}.webp`);
 });
 
 test('splash default', () => {
-	expect(cdn.splash(id, hash)).toBe(`${base}/splashes/${id}/${hash}.webp`);
+	expect(cdn.splash(id, hash)).toEqual(`${base}/splashes/${id}/${hash}.webp`);
 });
 
 test('sticker default', () => {
-	expect(cdn.sticker(id)).toBe(`${base}/stickers/${id}.png`);
+	expect(cdn.sticker(id)).toEqual(`${base}/stickers/${id}.png`);
 });
 
 test('stickerPackBanner default', () => {
-	expect(cdn.stickerPackBanner(id)).toBe(`${base}/app-assets/710982414301790216/store/${id}.webp`);
+	expect(cdn.stickerPackBanner(id)).toEqual(`${base}/app-assets/710982414301790216/store/${id}.webp`);
 });
 
 test('teamIcon default', () => {
-	expect(cdn.teamIcon(id, hash)).toBe(`${base}/team-icons/${id}/${hash}.webp`);
+	expect(cdn.teamIcon(id, hash)).toEqual(`${base}/team-icons/${id}/${hash}.webp`);
 });
 
 test('makeURL throws on invalid size', () => {
@@ -113,5 +113,5 @@ test('makeURL throws on invalid extension', () => {
 });
 
 test('makeURL valid size', () => {
-	expect(cdn.avatar(id, animatedHash, { size: 512 })).toBe(`${base}/avatars/${id}/${animatedHash}.gif?size=512`);
+	expect(cdn.avatar(id, animatedHash, { size: 512 })).toEqual(`${base}/avatars/${id}/${animatedHash}.gif?size=512`);
 });

packages/rest/__tests__/DiscordAPIError.test.ts

@@ -13,14 +13,14 @@ test('Unauthorized', () => {
 		},
 	);
 
-	expect(error.code).toBe(0);
+	expect(error.code).toEqual(0);
-	expect(error.message).toBe('401: Unauthorized');
+	expect(error.message).toEqual('401: Unauthorized');
-	expect(error.method).toBe('PATCH');
+	expect(error.method).toEqual('PATCH');
-	expect(error.name).toBe('DiscordAPIError[0]');
+	expect(error.name).toEqual('DiscordAPIError[0]');
-	expect(error.status).toBe(401);
+	expect(error.status).toEqual(401);
-	expect(error.url).toBe('https://discord.com/api/v10/guilds/:id');
+	expect(error.url).toEqual('https://discord.com/api/v10/guilds/:id');
-	expect(error.requestBody.files).toBe(undefined);
+	expect(error.requestBody.files).toBeUndefined();
-	expect(error.requestBody.json).toBe(undefined);
+	expect(error.requestBody.json).toBeUndefined();
 });
 
 test('Invalid Form Body Error (error.{property}._errors.{index})', () => {
@@ -44,15 +44,15 @@ test('Invalid Form Body Error (error.{property}._errors.{index})', () => {
 		},
 	);
 
-	expect(error.code).toBe(50035);
+	expect(error.code).toEqual(50035);
-	expect(error.message).toBe(
+	expect(error.message).toEqual(
 		['Invalid Form Body', 'username[BASE_TYPE_BAD_LENGTH]: Must be between 2 and 32 in length.'].join('\n'),
 	);
-	expect(error.method).toBe('PATCH');
+	expect(error.method).toEqual('PATCH');
-	expect(error.name).toBe('DiscordAPIError[50035]');
+	expect(error.name).toEqual('DiscordAPIError[50035]');
-	expect(error.status).toBe(400);
+	expect(error.status).toEqual(400);
-	expect(error.url).toBe('https://discord.com/api/v10/users/@me');
+	expect(error.url).toEqual('https://discord.com/api/v10/users/@me');
-	expect(error.requestBody.files).toBe(undefined);
+	expect(error.requestBody.files).toBeUndefined();
 	expect(error.requestBody.json).toStrictEqual({ username: 'a' });
 });
 
@@ -74,14 +74,14 @@ test('Invalid FormFields Error (error.errors.{property}.{property}.{index}.{prop
 		{},
 	);
 
-	expect(error.code).toBe(50035);
+	expect(error.code).toEqual(50035);
-	expect(error.message).toBe(
+	expect(error.message).toEqual(
 		['Invalid Form Body', 'embed.fields[0].value[BASE_TYPE_REQUIRED]: This field is required'].join('\n'),
 	);
-	expect(error.method).toBe('POST');
+	expect(error.method).toEqual('POST');
-	expect(error.name).toBe('DiscordAPIError[50035]');
+	expect(error.name).toEqual('DiscordAPIError[50035]');
-	expect(error.status).toBe(400);
+	expect(error.status).toEqual(400);
-	expect(error.url).toBe('https://discord.com/api/v10/channels/:id');
+	expect(error.url).toEqual('https://discord.com/api/v10/channels/:id');
 });
 
 test('Invalid FormFields Error (error.errors.{property}.{property}._errors.{index}._errors)', () => {
@@ -102,14 +102,14 @@ test('Invalid FormFields Error (error.errors.{property}.{property}._errors.{inde
 		{},
 	);
 
-	expect(error.code).toBe(50035);
+	expect(error.code).toEqual(50035);
-	expect(error.message).toBe(
+	expect(error.message).toEqual(
 		['Invalid Form Body', 'form_fields.label[0][BASE_TYPE_REQUIRED]: This field is required'].join('\n'),
 	);
-	expect(error.method).toBe('PATCH');
+	expect(error.method).toEqual('PATCH');
-	expect(error.name).toBe('DiscordAPIError[50035]');
+	expect(error.name).toEqual('DiscordAPIError[50035]');
-	expect(error.status).toBe(400);
+	expect(error.status).toEqual(400);
-	expect(error.url).toBe('https://discord.com/api/v10/guilds/:id');
+	expect(error.url).toEqual('https://discord.com/api/v10/guilds/:id');
 });
 
 test('Invalid Oauth Code Error (error.error)', () => {
@@ -133,10 +133,10 @@ test('Invalid Oauth Code Error (error.error)', () => {
 		},
 	);
 
-	expect(error.code).toBe('invalid_request');
+	expect(error.code).toEqual('invalid_request');
-	expect(error.message).toBe('Invalid "code" in request.');
+	expect(error.message).toEqual('Invalid "code" in request.');
-	expect(error.method).toBe('POST');
+	expect(error.method).toEqual('POST');
-	expect(error.name).toBe('DiscordAPIError[invalid_request]');
+	expect(error.name).toEqual('DiscordAPIError[invalid_request]');
-	expect(error.status).toBe(400);
+	expect(error.status).toEqual(400);
-	expect(error.url).toBe('https://discord.com/api/v10/oauth2/token');
+	expect(error.url).toEqual('https://discord.com/api/v10/oauth2/token');
 });

packages/rest/__tests__/RequestManager.test.ts

@@ -36,5 +36,5 @@ test('no token', async () => {
 test('negative offset', () => {
 	const badREST = new REST({ offset: -5000 });
 
-	expect(badREST.requestManager.options.offset).toBe(0);
+	expect(badREST.requestManager.options.offset).toEqual(0);
 });

packages/rest/__tests__/Util.test.ts

@@ -4,13 +4,13 @@ import { resolveBody, parseHeader } from '../src/lib/utils/utils';
 test('GIVEN string parseHeader returns string', () => {
 	const header = 'application/json';
 
-	expect(parseHeader(header)).toBe(header);
+	expect(parseHeader(header)).toEqual(header);
 });
 
 test('GIVEN string[] parseHeader returns string', () => {
 	const header = ['application/json', 'wait sorry I meant text/html'];
 
-	expect(parseHeader(header)).toBe(header.join(';'));
+	expect(parseHeader(header)).toEqual(header.join(';'));
 });
 
 test('GIVEN undefined parseHeader return undefined', () => {
@@ -18,15 +18,15 @@ test('GIVEN undefined parseHeader return undefined', () => {
 });
 
 test('resolveBody', async () => {
-	await expect(resolveBody(null)).resolves.toBe(null);
+	await expect(resolveBody(null)).resolves.toEqual(null);
-	await expect(resolveBody(undefined)).resolves.toBe(null);
+	await expect(resolveBody(undefined)).resolves.toEqual(null);
-	await expect(resolveBody('Hello')).resolves.toBe('Hello');
+	await expect(resolveBody('Hello')).resolves.toEqual('Hello');
 	await expect(resolveBody(new Uint8Array([1, 2, 3]))).resolves.toStrictEqual(new Uint8Array([1, 2, 3]));
 	// ArrayBuffers gets resolved to Uint8Array
 	await expect(resolveBody(new ArrayBuffer(8))).resolves.toStrictEqual(new Uint8Array(new ArrayBuffer(8)));
 
 	const urlSearchParams = new URLSearchParams([['a', 'b']]);
-	await expect(resolveBody(urlSearchParams)).resolves.toBe(urlSearchParams.toString());
+	await expect(resolveBody(urlSearchParams)).resolves.toEqual(urlSearchParams.toString());
 
 	const dataView = new DataView(new ArrayBuffer(8));
 	await expect(resolveBody(dataView)).resolves.toStrictEqual(new Uint8Array(new ArrayBuffer(8)));

packages/rest/tsup.config.ts

@@ -1,6 +1,6 @@
-import type { Options } from 'tsup';
+import { defineConfig } from 'tsup';
 
-export const tsup: Options = {
+export default defineConfig({
 	clean: true,
 	dts: false,
 	entryPoints: ['src/index.ts'],
@@ -17,4 +17,4 @@ export const tsup: Options = {
 			};
 		}
 	},
-};
+});

packages/voice/__tests__/AudioPlayer.test.ts

@@ -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.pause()).toEqual(false);
-		expect(player.state.status).toBe(AudioPlayerStatus.Idle);
+		expect(player.state.status).toEqual(AudioPlayerStatus.Idle);
-		expect(player.unpause()).toBe(false);
+		expect(player.unpause()).toEqual(false);
-		expect(player.state.status).toBe(AudioPlayerStatus.Idle);
+		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.pause()).toEqual(true);
-		expect(player.state.status).toBe(AudioPlayerStatus.Paused);
+		expect(player.state.status).toEqual(AudioPlayerStatus.Paused);
 
 		// further calls to pause() should be unsuccessful
-		expect(player.pause()).toBe(false);
+		expect(player.pause()).toEqual(false);
-		expect(player.state.status).toBe(AudioPlayerStatus.Paused);
+		expect(player.state.status).toEqual(AudioPlayerStatus.Paused);
 
 		// unpause() should transition back to Playing
-		expect(player.unpause()).toBe(true);
+		expect(player.unpause()).toEqual(true);
-		expect(player.state.status).toBe(AudioPlayerStatus.Playing);
+		expect(player.state.status).toEqual(AudioPlayerStatus.Playing);
 
 		// further calls to unpause() should be unsuccessful
-		expect(player.unpause()).toBe(false);
+		expect(player.unpause()).toEqual(false);
-		expect(player.state.status).toBe(AudioPlayerStatus.Playing);
+		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.stop(true)).toEqual(false);
-		expect(player.state.status).toBe(AudioPlayerStatus.Idle);
+		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.stop()).toEqual(true);
-		expect(player.state.status).toBe(AudioPlayerStatus.Playing);
+		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.checkPlayable()).toEqual(true);
-		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);
-		expect(player.checkPlayable()).toBe(false);
+		expect(player.checkPlayable()).toEqual(false);
-		expect(player.state.status).toBe(AudioPlayerStatus.Idle);
+		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);
 });

packages/voice/__tests__/AudioReceiveStream.test.ts

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

packages/voice/__tests__/AudioResource.test.ts

@@ -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.readable).toEqual(true);
-			expect(resource.read()).toBe(SILENCE_FRAME);
+			expect(resource.read()).toEqual(SILENCE_FRAME);
 		}
 		await wait();
-		expect(resource.readable).toBe(false);
+		expect(resource.readable).toEqual(false);
-		expect(resource.read()).toBe(null);
+		expect(resource.read()).toEqual(null);
 	});
 });

packages/voice/__tests__/DataStore.test.ts

@@ -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')).toEqual(voiceConnectionDefault);
-		expect(DataStore.getVoiceConnection('123', 'default')).toBe(voiceConnectionDefault);
+		expect(DataStore.getVoiceConnection('123', 'default')).toEqual(voiceConnectionDefault);
-		expect(DataStore.getVoiceConnection('123', 'abc')).toBe(voiceConnectionAbc);
+		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.hasAudioPlayer(player)).toEqual(true);
-		expect(DataStore.addAudioPlayer(player)).toBe(player);
+		expect(DataStore.addAudioPlayer(player)).toEqual(player);
 		DataStore.deleteAudioPlayer(player);
-		expect(DataStore.deleteAudioPlayer(player)).toBe(undefined);
+		expect(DataStore.deleteAudioPlayer(player)).toBeUndefined();
-		expect(DataStore.hasAudioPlayer(player)).toBe(false);
+		expect(DataStore.hasAudioPlayer(player)).toEqual(false);
 		// Tests audio cycle with nextTime === -1
 		await waitForEventLoop();
 		expect(dispatchSpy).toHaveBeenCalledTimes(0);

packages/voice/__tests__/TransformerGraph.test.ts

@@ -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[0]).toEqual(type);
-			expect(path.pop()).toBe(StreamType.Opus);
+			expect(path.pop()).toEqual(StreamType.Opus);
-			expect(pipeline.some(isVolume)).toBe(false);
+			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[0]).toEqual(type);
-		expect(path.pop()).toBe(StreamType.Opus);
+		expect(path.pop()).toEqual(StreamType.Opus);
-		expect(pipeline.some(isVolume)).toBe(true);
+		expect(pipeline.some(isVolume)).toEqual(true);
 	});
 });

packages/voice/__tests__/VoiceConnection.test.ts

@@ -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).toEqual(existingVoiceConnection);
-		expect(newVoiceConnection.state.status).toBe(VoiceConnectionStatus.Disconnected);
+		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.disconnect()).toEqual(false);
-		expect(voiceConnection.state.status).toBe(VoiceConnectionStatus.Destroyed);
+		expect(voiceConnection.state.status).toEqual(VoiceConnectionStatus.Destroyed);
 
 		voiceConnection.state = { status: VoiceConnectionStatus.Signalling, adapter };
-		expect(voiceConnection.disconnect()).toBe(false);
+		expect(voiceConnection.disconnect()).toEqual(false);
-		expect(voiceConnection.state.status).toBe(VoiceConnectionStatus.Signalling);
+		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.rejoin()).toEqual(true);
-		expect(voiceConnection.rejoinAttempts).toBe(1);
+		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.rejoin()).toEqual(true);
-		expect(voiceConnection.rejoinAttempts).toBe(0);
+		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.rejoin()).toEqual(false);
-		expect(voiceConnection.rejoinAttempts).toBe(1);
+		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(oldNetworking.state.udp.listenerCount('message')).toEqual(0);
-			expect(newNetworking.state.udp.listenerCount('message')).toBe(1);
+			expect(newNetworking.state.udp.listenerCount('message')).toEqual(1);
-			expect(voiceConnection.receiver.connectionData).toBe(newNetworking.state.connectionData);
+			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(oldNetworking.state.ws.listenerCount('packet')).toEqual(0);
-			expect(newNetworking.state.ws.listenerCount('packet')).toBe(1);
+			expect(newNetworking.state.ws.listenerCount('packet')).toEqual(1);
-			expect(voiceConnection.receiver.connectionData).toBe(newNetworking.state.connectionData);
+			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.ws.listenerCount('packet')).toEqual(1);
-			expect(newNetworking.state.udp.listenerCount('message')).toBe(1);
+			expect(newNetworking.state.udp.listenerCount('message')).toEqual(1);
-			expect(voiceConnection.receiver.connectionData).toBe(newNetworking.state.connectionData);
+			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();
 	});
 });

packages/voice/__tests__/VoiceReceiver.test.ts

@@ -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(nonce.equals(range(29, 32))).toEqual(true);
-			expect(decrypted.equals(range(13, 28))).toBe(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(nonce.equals(range(41, 64))).toEqual(true);
-			expect(decrypted.equals(range(13, 40))).toBe(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(nonce.equals(range(1, 12))).toEqual(true);
-			expect(decrypted.equals(range(13, 64))).toBe(true);
+			expect(decrypted.equals(range(13, 64))).toEqual(true);
 		});
 	});
 });

packages/voice/__tests__/VoiceUDPSocket.test.ts

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

packages/voice/__tests__/VoiceWebSocket.test.ts

@@ -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(ws.ping).toBeUndefined();
-		expect(server.messages.length).toBe(3);
+		expect(server.messages.length).toEqual(3);
 	});
 });

packages/voice/__tests__/abortAfter.test.ts

@@ -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(ac.signal).toEqual(signal);
-		expect(signal.aborted).toBe(false);
+		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(ac.signal).toEqual(signal);
-		expect(signal.aborted).toBe(false);
+		expect(signal.aborted).toEqual(false);
 		clearTimeoutSpy.mockClear();
 		ac.abort();
 		expect(clearTimeoutSpy).toHaveBeenCalledTimes(1);

packages/voice/__tests__/demuxProbe.test.ts

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

packages/voice/__tests__/entersState.test.ts

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