diff --git a/packages/crates-io-msw/handlers/api-tokens/create.test.js b/packages/crates-io-msw/handlers/api-tokens/create.test.js
index 6a1351c8644..261746e8750 100644
--- a/packages/crates-io-msw/handlers/api-tokens/create.test.js
+++ b/packages/crates-io-msw/handlers/api-tokens/create.test.js
@@ -1,4 +1,4 @@
-import { afterEach, assert, beforeEach, test, vi } from 'vitest';
+import { afterEach, beforeEach, expect, test, vi } from 'vitest';
 
 import { db } from '../../index.js';
 
@@ -17,12 +17,12 @@ test('creates a new API token', async function () {
 
   let body = JSON.stringify({ api_token: { name: 'foooo' } });
   let response = await fetch('/api/v1/me/tokens', { method: 'PUT', body });
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
 
   let token = db.apiToken.findMany(null)[0];
-  assert.ok(token);
+  expect(token).toBeTruthy();
 
-  assert.deepEqual(await response.json(), {
+  expect(await response.json()).toEqual({
     api_token: {
       id: 1,
       crate_scopes: null,
@@ -49,12 +49,12 @@ test('creates a new API token with scopes', async function () {
     },
   });
   let response = await fetch('/api/v1/me/tokens', { method: 'PUT', body });
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
 
   let token = db.apiToken.findMany(null)[0];
-  assert.ok(token);
+  expect(token).toBeTruthy();
 
-  assert.deepEqual(await response.json(), {
+  expect(await response.json()).toEqual({
     api_token: {
       id: 1,
       crate_scopes: ['serde', 'serde-*'],
@@ -80,12 +80,12 @@ test('creates a new API token with expiry date', async function () {
     },
   });
   let response = await fetch('/api/v1/me/tokens', { method: 'PUT', body });
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
 
   let token = db.apiToken.findMany(null)[0];
-  assert.ok(token);
+  expect(token).toBeTruthy();
 
-  assert.deepEqual(await response.json(), {
+  expect(await response.json()).toEqual({
     api_token: {
       id: 1,
       crate_scopes: null,
@@ -103,8 +103,8 @@ test('creates a new API token with expiry date', async function () {
 test('returns an error if unauthenticated', async function () {
   let body = JSON.stringify({ api_token: {} });
   let response = await fetch('/api/v1/me/tokens', { method: 'PUT', body });
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
diff --git a/packages/crates-io-msw/handlers/api-tokens/delete.test.js b/packages/crates-io-msw/handlers/api-tokens/delete.test.js
index 0145ac7f537..13137f05a37 100644
--- a/packages/crates-io-msw/handlers/api-tokens/delete.test.js
+++ b/packages/crates-io-msw/handlers/api-tokens/delete.test.js
@@ -1,4 +1,4 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
@@ -9,11 +9,11 @@ test('revokes an API token', async function () {
   let token = await db.apiToken.create({ user });
 
   let response = await fetch(`/api/v1/me/tokens/${token.id}`, { method: 'DELETE' });
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {});
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({});
 
   let tokens = db.apiToken.findMany(null);
-  assert.strictEqual(tokens.length, 0);
+  expect(tokens.length).toBe(0);
 });
 
 test('returns an error if unauthenticated', async function () {
@@ -21,8 +21,8 @@ test('returns an error if unauthenticated', async function () {
   let token = await db.apiToken.create({ user });
 
   let response = await fetch(`/api/v1/me/tokens/${token.id}`, { method: 'DELETE' });
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
diff --git a/packages/crates-io-msw/handlers/api-tokens/get.test.js b/packages/crates-io-msw/handlers/api-tokens/get.test.js
index e280d65de32..69b5ad8e19f 100644
--- a/packages/crates-io-msw/handlers/api-tokens/get.test.js
+++ b/packages/crates-io-msw/handlers/api-tokens/get.test.js
@@ -1,4 +1,4 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
@@ -13,8 +13,8 @@ test('returns the requested token', async function () {
   });
 
   let response = await fetch(`/api/v1/me/tokens/${token.id}`);
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     api_token: {
       id: 1,
       crate_scopes: ['serde', 'serde-*'],
@@ -32,14 +32,14 @@ test('returns 404 if token not found', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/me/tokens/42');
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('returns an error if unauthenticated', async function () {
   let response = await fetch('/api/v1/me/tokens/42');
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
diff --git a/packages/crates-io-msw/handlers/api-tokens/list.test.js b/packages/crates-io-msw/handlers/api-tokens/list.test.js
index c9349a5426e..0ba58199057 100644
--- a/packages/crates-io-msw/handlers/api-tokens/list.test.js
+++ b/packages/crates-io-msw/handlers/api-tokens/list.test.js
@@ -1,4 +1,4 @@
-import { afterEach, assert, beforeEach, test, vi } from 'vitest';
+import { afterEach, beforeEach, expect, test, vi } from 'vitest';
 
 import { db } from '../../index.js';
 
@@ -26,8 +26,8 @@ test('returns the list of API token for the authenticated `user`', async functio
   await db.apiToken.create({ user, createdAt: '2017-11-19T15:59:22Z', expiredAt: '2017-11-20T10:59:22Z' });
 
   let response = await fetch('/api/v1/me/tokens');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     api_tokens: [
       {
         id: 3,
@@ -65,14 +65,14 @@ test('empty list case', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/me/tokens');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), { api_tokens: [] });
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({ api_tokens: [] });
 });
 
 test('returns an error if unauthenticated', async function () {
   let response = await fetch('/api/v1/me/tokens');
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
diff --git a/packages/crates-io-msw/handlers/categories/get.test.js b/packages/crates-io-msw/handlers/categories/get.test.js
index 63dfec046e6..d74b2e575ae 100644
--- a/packages/crates-io-msw/handlers/categories/get.test.js
+++ b/packages/crates-io-msw/handlers/categories/get.test.js
@@ -1,11 +1,11 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('returns 404 for unknown categories', async function () {
   let response = await fetch('/api/v1/categories/foo');
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('returns a category object for known categories', async function () {
@@ -15,8 +15,8 @@ test('returns a category object for known categories', async function () {
   });
 
   let response = await fetch('/api/v1/categories/no-std');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     category: {
       id: 'no-std',
       category: 'no-std',
@@ -35,8 +35,8 @@ test('calculates `crates_cnt` correctly', async function () {
   await Promise.all(Array.from({ length: 3 }, () => db.crate.create({ categories: [notTestCli] })));
 
   let response = await fetch('/api/v1/categories/test-cli-category');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     category: {
       category: 'test-cli-category',
       crates_cnt: 7,
diff --git a/packages/crates-io-msw/handlers/categories/list-slugs.test.js b/packages/crates-io-msw/handlers/categories/list-slugs.test.js
index 36699c62b4b..f122e45b695 100644
--- a/packages/crates-io-msw/handlers/categories/list-slugs.test.js
+++ b/packages/crates-io-msw/handlers/categories/list-slugs.test.js
@@ -1,11 +1,11 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('empty case', async function () {
   let response = await fetch('/api/v1/category_slugs');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     category_slugs: [],
   });
 });
@@ -18,8 +18,8 @@ test('returns a category slugs list', async function () {
   await Promise.all(Array.from({ length: 2 }, () => db.category.create()));
 
   let response = await fetch('/api/v1/category_slugs');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     category_slugs: [
       {
         description: 'This is the description for the category called "Category 2"',
@@ -44,6 +44,6 @@ test('has no pagination', async function () {
   await Promise.all(Array.from({ length: 25 }, () => db.category.create()));
 
   let response = await fetch('/api/v1/category_slugs');
-  assert.strictEqual(response.status, 200);
-  assert.strictEqual((await response.json()).category_slugs.length, 25);
+  expect(response.status).toBe(200);
+  expect((await response.json()).category_slugs.length).toBe(25);
 });
diff --git a/packages/crates-io-msw/handlers/categories/list.test.js b/packages/crates-io-msw/handlers/categories/list.test.js
index 56a6ec9e1e3..e06ff0bd410 100644
--- a/packages/crates-io-msw/handlers/categories/list.test.js
+++ b/packages/crates-io-msw/handlers/categories/list.test.js
@@ -1,11 +1,11 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('empty case', async function () {
   let response = await fetch('/api/v1/categories');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     categories: [],
     meta: {
       total: 0,
@@ -21,8 +21,8 @@ test('returns a paginated categories list', async function () {
   await Promise.all(Array.from({ length: 2 }, () => db.category.create()));
 
   let response = await fetch('/api/v1/categories');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     categories: [
       {
         id: 'category-2',
@@ -59,11 +59,11 @@ test('never returns more than 10 results', async function () {
   await Promise.all(Array.from({ length: 25 }, () => db.category.create()));
 
   let response = await fetch('/api/v1/categories');
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
 
   let responsePayload = await response.json();
-  assert.strictEqual(responsePayload.categories.length, 10);
-  assert.strictEqual(responsePayload.meta.total, 25);
+  expect(responsePayload.categories.length).toBe(10);
+  expect(responsePayload.meta.total).toBe(25);
 });
 
 test('supports `page` and `per_page` parameters', async function () {
@@ -76,13 +76,10 @@ test('supports `page` and `per_page` parameters', async function () {
   );
 
   let response = await fetch('/api/v1/categories?page=2&per_page=5');
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
 
   let responsePayload = await response.json();
-  assert.strictEqual(responsePayload.categories.length, 5);
-  assert.deepEqual(
-    responsePayload.categories.map(it => it.id),
-    ['cat-06', 'cat-07', 'cat-08', 'cat-09', 'cat-10'],
-  );
-  assert.strictEqual(responsePayload.meta.total, 25);
+  expect(responsePayload.categories.length).toBe(5);
+  expect(responsePayload.categories.map(it => it.id)).toEqual(['cat-06', 'cat-07', 'cat-08', 'cat-09', 'cat-10']);
+  expect(responsePayload.meta.total).toBe(25);
 });
diff --git a/packages/crates-io-msw/handlers/crates/add-owners.test.js b/packages/crates-io-msw/handlers/crates/add-owners.test.js
index 8671942dfa5..af2e208e209 100644
--- a/packages/crates-io-msw/handlers/crates/add-owners.test.js
+++ b/packages/crates-io-msw/handlers/crates/add-owners.test.js
@@ -1,4 +1,4 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
@@ -6,8 +6,8 @@ const ADD_USER_BODY = JSON.stringify({ owners: ['john-doe'] });
 
 test('returns 403 if unauthenticated', async function () {
   let response = await fetch('/api/v1/crates/foo/owners', { method: 'PUT', body: ADD_USER_BODY });
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
@@ -17,8 +17,8 @@ test('returns 404 for unknown crates', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/crates/foo/owners', { method: 'PUT', body: ADD_USER_BODY });
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('can add new owner', async function () {
@@ -32,20 +32,20 @@ test('can add new owner', async function () {
 
   let body = JSON.stringify({ owners: [user2.login] });
   let response = await fetch('/api/v1/crates/foo/owners', { method: 'PUT', body });
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     ok: true,
     msg: 'user user-2 has been invited to be an owner of crate foo',
   });
 
   let owners = db.crateOwnership.findMany(q => q.where({ crate: { id: crate.id } }));
-  assert.strictEqual(owners.length, 1);
-  assert.strictEqual(owners[0].user.id, user.id);
+  expect(owners.length).toBe(1);
+  expect(owners[0].user.id).toBe(user.id);
 
   let invites = db.crateOwnerInvitation.findMany(q => q.where({ crate: { id: crate.id } }));
-  assert.strictEqual(invites.length, 1);
-  assert.strictEqual(invites[0].inviter.id, user.id);
-  assert.strictEqual(invites[0].invitee.id, user2.id);
+  expect(invites.length).toBe(1);
+  expect(invites[0].inviter.id).toBe(user.id);
+  expect(invites[0].invitee.id).toBe(user2.id);
 });
 
 test('can add team owner', async function () {
@@ -59,21 +59,21 @@ test('can add team owner', async function () {
 
   let body = JSON.stringify({ owners: [team.login] });
   let response = await fetch('/api/v1/crates/foo/owners', { method: 'PUT', body });
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     ok: true,
     msg: 'team github:rust-lang:team-1 has been added as an owner of crate foo',
   });
 
   let owners = db.crateOwnership.findMany(q => q.where({ crate: { id: crate.id } }));
-  assert.strictEqual(owners.length, 2);
-  assert.strictEqual(owners[0].user.id, user.id);
-  assert.strictEqual(owners[0].team, null);
-  assert.strictEqual(owners[1].user, null);
-  assert.strictEqual(owners[1].team.id, user.id);
+  expect(owners.length).toBe(2);
+  expect(owners[0].user.id).toBe(user.id);
+  expect(owners[0].team).toBe(null);
+  expect(owners[1].user).toBe(null);
+  expect(owners[1].team.id).toBe(user.id);
 
   let invites = db.crateOwnerInvitation.findMany(q => q.where({ crate: { id: crate.id } }));
-  assert.strictEqual(invites.length, 0);
+  expect(invites.length).toBe(0);
 });
 
 test('can add multiple owners', async function () {
@@ -89,23 +89,23 @@ test('can add multiple owners', async function () {
 
   let body = JSON.stringify({ owners: [user2.login, team.login, user3.login] });
   let response = await fetch('/api/v1/crates/foo/owners', { method: 'PUT', body });
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     ok: true,
     msg: 'user user-2 has been invited to be an owner of crate foo,team github:rust-lang:team-1 has been added as an owner of crate foo,user user-3 has been invited to be an owner of crate foo',
   });
 
   let owners = db.crateOwnership.findMany(q => q.where({ crate: { id: crate.id } }));
-  assert.strictEqual(owners.length, 2);
-  assert.strictEqual(owners[0].user.id, user.id);
-  assert.strictEqual(owners[0].team, null);
-  assert.strictEqual(owners[1].user, null);
-  assert.strictEqual(owners[1].team.id, user.id);
+  expect(owners.length).toBe(2);
+  expect(owners[0].user.id).toBe(user.id);
+  expect(owners[0].team).toBe(null);
+  expect(owners[1].user).toBe(null);
+  expect(owners[1].team.id).toBe(user.id);
 
   let invites = db.crateOwnerInvitation.findMany(q => q.where({ crate: { id: crate.id } }));
-  assert.strictEqual(invites.length, 2);
-  assert.strictEqual(invites[0].inviter.id, user.id);
-  assert.strictEqual(invites[0].invitee.id, user2.id);
-  assert.strictEqual(invites[1].inviter.id, user.id);
-  assert.strictEqual(invites[1].invitee.id, user3.id);
+  expect(invites.length).toBe(2);
+  expect(invites[0].inviter.id).toBe(user.id);
+  expect(invites[0].invitee.id).toBe(user2.id);
+  expect(invites[1].inviter.id).toBe(user.id);
+  expect(invites[1].invitee.id).toBe(user3.id);
 });
diff --git a/packages/crates-io-msw/handlers/crates/delete.test.js b/packages/crates-io-msw/handlers/crates/delete.test.js
index 367da9cff73..40f198872fd 100644
--- a/packages/crates-io-msw/handlers/crates/delete.test.js
+++ b/packages/crates-io-msw/handlers/crates/delete.test.js
@@ -1,11 +1,11 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('returns 403 if unauthenticated', async function () {
   let response = await fetch('/api/v1/crates/foo', { method: 'DELETE' });
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
@@ -15,8 +15,8 @@ test('returns 404 for unknown crates', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/crates/foo', { method: 'DELETE' });
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'crate `foo` does not exist' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'crate `foo` does not exist' }] });
 });
 
 test('deletes crates', async function () {
@@ -27,11 +27,8 @@ test('deletes crates', async function () {
   await db.crateOwnership.create({ crate, user });
 
   let response = await fetch('/api/v1/crates/foo', { method: 'DELETE' });
-  assert.strictEqual(response.status, 204);
-  assert.deepEqual(await response.text(), '');
+  expect(response.status).toBe(204);
+  expect(await response.text()).toEqual('');
 
-  assert.strictEqual(
-    db.crate.findFirst(q => q.where({ name: 'foo' })),
-    undefined,
-  );
+  expect(db.crate.findFirst(q => q.where({ name: 'foo' }))).toBe(undefined);
 });
diff --git a/packages/crates-io-msw/handlers/crates/downloads.test.js b/packages/crates-io-msw/handlers/crates/downloads.test.js
index d0730b38406..0e6c8b117ae 100644
--- a/packages/crates-io-msw/handlers/crates/downloads.test.js
+++ b/packages/crates-io-msw/handlers/crates/downloads.test.js
@@ -1,19 +1,19 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('returns 404 for unknown crates', async function () {
   let response = await fetch('/api/v1/crates/foo/downloads');
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('empty case', async function () {
   await db.crate.create({ name: 'rand' });
 
   let response = await fetch('/api/v1/crates/rand/downloads');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     version_downloads: [],
     meta: {
       extra_downloads: [],
@@ -29,8 +29,8 @@ test('returns a list of version downloads belonging to the specified crate versi
   await db.versionDownload.create({ version: versions[1], date: '2020-01-15' });
 
   let response = await fetch('/api/v1/crates/rand/downloads');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     version_downloads: [
       {
         date: '2020-01-13',
@@ -62,8 +62,8 @@ test('includes related versions', async function () {
   await db.versionDownload.create({ version: versions[1], date: '2020-01-15' });
 
   let response = await fetch('/api/v1/crates/rand/downloads?include=versions');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     version_downloads: [
       {
         date: '2020-01-13',
diff --git a/packages/crates-io-msw/handlers/crates/follow.test.js b/packages/crates-io-msw/handlers/crates/follow.test.js
index 9166b7e335c..ea46524e0b2 100644
--- a/packages/crates-io-msw/handlers/crates/follow.test.js
+++ b/packages/crates-io-msw/handlers/crates/follow.test.js
@@ -1,11 +1,11 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('returns 403 if unauthenticated', async function () {
   let response = await fetch('/api/v1/crates/foo/follow', { method: 'PUT' });
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
@@ -15,8 +15,8 @@ test('returns 404 for unknown crates', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/crates/foo/follow', { method: 'PUT' });
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('makes the authenticated user follow the crate', async function () {
@@ -25,13 +25,13 @@ test('makes the authenticated user follow the crate', async function () {
   let user = await db.user.create();
   await db.mswSession.create({ user });
 
-  assert.deepEqual(user.followedCrates, []);
+  expect(user.followedCrates).toEqual([]);
 
   let response = await fetch('/api/v1/crates/rand/follow', { method: 'PUT' });
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), { ok: true });
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({ ok: true });
 
   user = db.user.findFirst(q => q.where({ id: user.id }));
-  assert.equal(user.followedCrates.length, 1);
-  assert.equal(user.followedCrates[0].name, crate.name);
+  expect(user.followedCrates.length).toBe(1);
+  expect(user.followedCrates[0].name).toBe(crate.name);
 });
diff --git a/packages/crates-io-msw/handlers/crates/following.test.js b/packages/crates-io-msw/handlers/crates/following.test.js
index 64bae13a426..a6d2daa78aa 100644
--- a/packages/crates-io-msw/handlers/crates/following.test.js
+++ b/packages/crates-io-msw/handlers/crates/following.test.js
@@ -1,11 +1,11 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('returns 403 if unauthenticated', async function () {
   let response = await fetch('/api/v1/crates/foo/following');
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
@@ -15,8 +15,8 @@ test('returns 404 for unknown crates', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/crates/foo/following');
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('returns true if the authenticated user follows the crate', async function () {
@@ -26,8 +26,8 @@ test('returns true if the authenticated user follows the crate', async function
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/crates/rand/following');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), { following: true });
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({ following: true });
 });
 
 test('returns false if the authenticated user is not following the crate', async function () {
@@ -37,6 +37,6 @@ test('returns false if the authenticated user is not following the crate', async
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/crates/rand/following');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), { following: false });
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({ following: false });
 });
diff --git a/packages/crates-io-msw/handlers/crates/get.test.js b/packages/crates-io-msw/handlers/crates/get.test.js
index 1ef7f82a765..62c8c8bcd01 100644
--- a/packages/crates-io-msw/handlers/crates/get.test.js
+++ b/packages/crates-io-msw/handlers/crates/get.test.js
@@ -1,11 +1,11 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('returns 404 for unknown crates', async function () {
   let response = await fetch('/api/v1/crates/foo');
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('returns a crate object for known crates', async function () {
@@ -13,8 +13,8 @@ test('returns a crate object for known crates', async function () {
   await db.version.create({ crate, num: '1.0.0-beta.1' });
 
   let response = await fetch('/api/v1/crates/rand');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     categories: [],
     crate: {
       badges: [],
@@ -95,8 +95,8 @@ test('works for non-canonical names', async function () {
   await db.version.create({ crate, num: '1.0.0-beta.1' });
 
   let response = await fetch('/api/v1/crates/foo_bar');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     categories: [],
     crate: {
       badges: [],
@@ -179,11 +179,11 @@ test('includes related versions', async function () {
   await db.version.create({ crate, num: '1.2.0' });
 
   let response = await fetch('/api/v1/crates/rand');
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
 
   let responsePayload = await response.json();
-  assert.deepEqual(responsePayload.crate.versions, [1, 2, 3]);
-  assert.deepEqual(responsePayload.versions, [
+  expect(responsePayload.crate.versions).toEqual([1, 2, 3]);
+  expect(responsePayload.versions).toEqual([
     {
       id: 3,
       crate: 'rand',
@@ -308,11 +308,11 @@ test('includes related categories', async function () {
   await db.version.create({ crate });
 
   let response = await fetch('/api/v1/crates/rand');
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
 
   let responsePayload = await response.json();
-  assert.deepEqual(responsePayload.crate.categories, ['no-std']);
-  assert.deepEqual(responsePayload.categories, [
+  expect(responsePayload.crate.categories).toEqual(['no-std']);
+  expect(responsePayload.categories).toEqual([
     {
       id: 'no-std',
       category: 'no-std',
@@ -331,11 +331,11 @@ test('includes related keywords', async function () {
   await db.version.create({ crate });
 
   let response = await fetch('/api/v1/crates/rand');
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
 
   let responsePayload = await response.json();
-  assert.deepEqual(responsePayload.crate.keywords, ['no-std']);
-  assert.deepEqual(responsePayload.keywords, [
+  expect(responsePayload.crate.keywords).toEqual(['no-std']);
+  expect(responsePayload.keywords).toEqual([
     {
       crates_cnt: 1,
       id: 'no-std',
@@ -358,10 +358,10 @@ test('without versions included', async function () {
   let expected = await req.json();
 
   let response = await fetch('/api/v1/crates/rand?include=keywords,categories');
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
 
   let responsePayload = await response.json();
-  assert.deepEqual(responsePayload, {
+  expect(responsePayload).toEqual({
     ...expected,
     crate: {
       ...expected.crate,
@@ -384,11 +384,11 @@ test('includes default_version', async function () {
   let expected = await req.json();
 
   let response = await fetch('/api/v1/crates/rand?include=default_version');
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
 
   let responsePayload = await response.json();
   let default_version = expected.versions.find(it => it.num === responsePayload.crate.default_version);
-  assert.deepEqual(responsePayload, {
+  expect(responsePayload).toEqual({
     ...expected,
     crate: {
       ...expected.crate,
@@ -405,8 +405,8 @@ test('includes default_version', async function () {
   });
 
   let resp_both = await fetch('/api/v1/crates/rand?include=versions,default_version');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await resp_both.json(), {
+  expect(response.status).toBe(200);
+  expect(await resp_both.json()).toEqual({
     ...expected,
     crate: {
       ...expected.crate,
diff --git a/packages/crates-io-msw/handlers/crates/list.test.js b/packages/crates-io-msw/handlers/crates/list.test.js
index 734cbc314c4..f0255add0be 100644
--- a/packages/crates-io-msw/handlers/crates/list.test.js
+++ b/packages/crates-io-msw/handlers/crates/list.test.js
@@ -1,11 +1,11 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('empty case', async function () {
   let response = await fetch('/api/v1/crates');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     crates: [],
     meta: {
       total: 0,
@@ -29,8 +29,8 @@ test('returns a paginated crates list', async function () {
   });
 
   let response = await fetch('/api/v1/crates');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     crates: [
       {
         id: 'rand',
@@ -75,11 +75,11 @@ test('never returns more than 10 results', async function () {
   await Promise.all(crates.map(crate => db.version.create({ crate })));
 
   let response = await fetch('/api/v1/crates');
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
 
   let responsePayload = await response.json();
-  assert.strictEqual(responsePayload.crates.length, 10);
-  assert.strictEqual(responsePayload.meta.total, 25);
+  expect(responsePayload.crates.length).toBe(10);
+  expect(responsePayload.meta.total).toBe(25);
 });
 
 test('supports `page` and `per_page` parameters', async function () {
@@ -89,15 +89,12 @@ test('supports `page` and `per_page` parameters', async function () {
   await Promise.all(crates.map(crate => db.version.create({ crate })));
 
   let response = await fetch('/api/v1/crates?page=2&per_page=5');
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
 
   let responsePayload = await response.json();
-  assert.strictEqual(responsePayload.crates.length, 5);
-  assert.deepEqual(
-    responsePayload.crates.map(it => it.id),
-    ['crate-06', 'crate-07', 'crate-08', 'crate-09', 'crate-10'],
-  );
-  assert.strictEqual(responsePayload.meta.total, 25);
+  expect(responsePayload.crates.length).toBe(5);
+  expect(responsePayload.crates.map(it => it.id)).toEqual(['crate-06', 'crate-07', 'crate-08', 'crate-09', 'crate-10']);
+  expect(responsePayload.meta.total).toBe(25);
 });
 
 test('supports a `letter` parameter', async function () {
@@ -109,15 +106,12 @@ test('supports a `letter` parameter', async function () {
   await db.version.create({ crate: baz });
 
   let response = await fetch('/api/v1/crates?letter=b');
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
 
   let responsePayload = await response.json();
-  assert.strictEqual(responsePayload.crates.length, 2);
-  assert.deepEqual(
-    responsePayload.crates.map(it => it.id),
-    ['bar', 'BAZ'],
-  );
-  assert.strictEqual(responsePayload.meta.total, 2);
+  expect(responsePayload.crates.length).toBe(2);
+  expect(responsePayload.crates.map(it => it.id)).toEqual(['bar', 'BAZ']);
+  expect(responsePayload.meta.total).toBe(2);
 });
 
 test('supports a `q` parameter', async function () {
@@ -129,19 +123,13 @@ test('supports a `q` parameter', async function () {
   await db.version.create({ crate: crate3 });
 
   let response = await fetch('/api/v1/crates?q=123');
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
 
   let responsePayload = await response.json();
-  assert.strictEqual(responsePayload.crates.length, 2);
-  assert.deepEqual(
-    responsePayload.crates.map(it => it.id),
-    ['123456', '123'],
-  );
-  assert.deepEqual(
-    responsePayload.crates.map(it => it.exact_match),
-    [false, true],
-  );
-  assert.strictEqual(responsePayload.meta.total, 2);
+  expect(responsePayload.crates.length).toBe(2);
+  expect(responsePayload.crates.map(it => it.id)).toEqual(['123456', '123']);
+  expect(responsePayload.crates.map(it => it.exact_match)).toEqual([false, true]);
+  expect(responsePayload.meta.total).toBe(2);
 });
 
 test('supports a `user_id` parameter', async function () {
@@ -158,12 +146,12 @@ test('supports a `user_id` parameter', async function () {
   await db.version.create({ crate: baz });
 
   let response = await fetch(`/api/v1/crates?user_id=${user1.id}`);
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
 
   let responsePayload = await response.json();
-  assert.strictEqual(responsePayload.crates.length, 1);
-  assert.strictEqual(responsePayload.crates[0].id, 'bar');
-  assert.strictEqual(responsePayload.meta.total, 1);
+  expect(responsePayload.crates.length).toBe(1);
+  expect(responsePayload.crates[0].id).toBe('bar');
+  expect(responsePayload.meta.total).toBe(1);
 });
 
 test('supports a `team_id` parameter', async function () {
@@ -180,12 +168,12 @@ test('supports a `team_id` parameter', async function () {
   await db.version.create({ crate: baz });
 
   let response = await fetch(`/api/v1/crates?team_id=${team1.id}`);
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
 
   let responsePayload = await response.json();
-  assert.strictEqual(responsePayload.crates.length, 1);
-  assert.strictEqual(responsePayload.crates[0].id, 'bar');
-  assert.strictEqual(responsePayload.meta.total, 1);
+  expect(responsePayload.crates.length).toBe(1);
+  expect(responsePayload.crates[0].id).toBe('bar');
+  expect(responsePayload.meta.total).toBe(1);
 });
 
 test('supports a `following` parameter', async function () {
@@ -198,12 +186,12 @@ test('supports a `following` parameter', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch(`/api/v1/crates?following=1`);
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
 
   let responsePayload = await response.json();
-  assert.strictEqual(responsePayload.crates.length, 1);
-  assert.strictEqual(responsePayload.crates[0].id, 'bar');
-  assert.strictEqual(responsePayload.meta.total, 1);
+  expect(responsePayload.crates.length).toBe(1);
+  expect(responsePayload.crates[0].id).toBe('bar');
+  expect(responsePayload.meta.total).toBe(1);
 });
 
 test('supports multiple `ids[]` parameters', async function () {
@@ -217,12 +205,12 @@ test('supports multiple `ids[]` parameters', async function () {
   await db.version.create({ crate: other });
 
   let response = await fetch(`/api/v1/crates?ids[]=foo&ids[]=bar&ids[]=baz&ids[]=baz&ids[]=unknown`);
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
 
   let responsePayload = await response.json();
-  assert.strictEqual(responsePayload.crates.length, 3);
-  assert.strictEqual(responsePayload.crates[0].id, 'foo');
-  assert.strictEqual(responsePayload.crates[1].id, 'bar');
-  assert.strictEqual(responsePayload.crates[2].id, 'baz');
-  assert.strictEqual(responsePayload.meta.total, 3);
+  expect(responsePayload.crates.length).toBe(3);
+  expect(responsePayload.crates[0].id).toBe('foo');
+  expect(responsePayload.crates[1].id).toBe('bar');
+  expect(responsePayload.crates[2].id).toBe('baz');
+  expect(responsePayload.meta.total).toBe(3);
 });
diff --git a/packages/crates-io-msw/handlers/crates/patch.test.js b/packages/crates-io-msw/handlers/crates/patch.test.js
index 621c18a8ddd..c7678843e2f 100644
--- a/packages/crates-io-msw/handlers/crates/patch.test.js
+++ b/packages/crates-io-msw/handlers/crates/patch.test.js
@@ -1,4 +1,4 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
@@ -8,8 +8,8 @@ test('returns 403 if unauthenticated', async function () {
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify({ crate: { trustpub_only: true } }),
   });
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
@@ -23,8 +23,8 @@ test('returns 404 for unknown crates', async function () {
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify({ crate: { trustpub_only: true } }),
   });
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'crate `foo` does not exist' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'crate `foo` does not exist' }] });
 });
 
 test('updates trustpub_only flag', async function () {
@@ -32,7 +32,7 @@ test('updates trustpub_only flag', async function () {
   await db.mswSession.create({ user });
 
   let crate = await db.crate.create({ name: 'foo', trustpubOnly: false });
-  assert.strictEqual(crate.trustpubOnly, false);
+  expect(crate.trustpubOnly).toBe(false);
 
   await db.version.create({ crate, num: '1.0.0' });
   await db.crateOwnership.create({ crate, user });
@@ -42,11 +42,11 @@ test('updates trustpub_only flag', async function () {
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify({ crate: { trustpub_only: true } }),
   });
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
 
   let json = await response.json();
-  assert.strictEqual(json.crate.trustpub_only, true);
+  expect(json.crate.trustpub_only).toBe(true);
 
   let updatedCrate = db.crate.findFirst(q => q.where({ name: 'foo' }));
-  assert.strictEqual(updatedCrate.trustpubOnly, true);
+  expect(updatedCrate.trustpubOnly).toBe(true);
 });
diff --git a/packages/crates-io-msw/handlers/crates/remove-owners.test.js b/packages/crates-io-msw/handlers/crates/remove-owners.test.js
index b3ab41e161c..78bece37b9d 100644
--- a/packages/crates-io-msw/handlers/crates/remove-owners.test.js
+++ b/packages/crates-io-msw/handlers/crates/remove-owners.test.js
@@ -1,4 +1,4 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
@@ -6,8 +6,8 @@ const REMOVE_USER_BODY = JSON.stringify({ owners: ['john-doe'] });
 
 test('returns 403 if unauthenticated', async function () {
   let response = await fetch('/api/v1/crates/foo/owners', { method: 'DELETE', body: REMOVE_USER_BODY });
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
@@ -17,8 +17,8 @@ test('returns 404 for unknown crates', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/crates/foo/owners', { method: 'DELETE', body: REMOVE_USER_BODY });
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('can remove a user owner', async function () {
@@ -33,15 +33,15 @@ test('can remove a user owner', async function () {
 
   let body = JSON.stringify({ owners: [user2.login] });
   let response = await fetch('/api/v1/crates/foo/owners', { method: 'DELETE', body });
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), { ok: true, msg: 'owners successfully removed' });
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({ ok: true, msg: 'owners successfully removed' });
 
   let owners = db.crateOwnership.findMany(q => q.where({ crate: { id: crate.id } }));
-  assert.strictEqual(owners.length, 1);
-  assert.strictEqual(owners[0].user.id, user.id);
+  expect(owners.length).toBe(1);
+  expect(owners[0].user.id).toBe(user.id);
 
   let invites = db.crateOwnerInvitation.findMany(q => q.where({ crate: { id: crate.id } }));
-  assert.strictEqual(invites.length, 0);
+  expect(invites.length).toBe(0);
 });
 
 test('can remove a team owner', async function () {
@@ -56,16 +56,16 @@ test('can remove a team owner', async function () {
 
   let body = JSON.stringify({ owners: [team.login] });
   let response = await fetch('/api/v1/crates/foo/owners', { method: 'DELETE', body });
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), { ok: true, msg: 'owners successfully removed' });
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({ ok: true, msg: 'owners successfully removed' });
 
   let owners = db.crateOwnership.findMany(q => q.where({ crate: { id: crate.id } }));
-  assert.strictEqual(owners.length, 1);
-  assert.strictEqual(owners[0].user.id, user.id);
-  assert.strictEqual(owners[0].team, null);
+  expect(owners.length).toBe(1);
+  expect(owners[0].user.id).toBe(user.id);
+  expect(owners[0].team).toBe(null);
 
   let invites = db.crateOwnerInvitation.findMany(q => q.where({ crate: { id: crate.id } }));
-  assert.strictEqual(invites.length, 0);
+  expect(invites.length).toBe(0);
 });
 
 test('can remove multiple owners', async function () {
@@ -83,14 +83,14 @@ test('can remove multiple owners', async function () {
 
   let body = JSON.stringify({ owners: [user2.login, team.login] });
   let response = await fetch('/api/v1/crates/foo/owners', { method: 'DELETE', body });
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), { ok: true, msg: 'owners successfully removed' });
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({ ok: true, msg: 'owners successfully removed' });
 
   let owners = db.crateOwnership.findMany(q => q.where({ crate: { id: crate.id } }));
-  assert.strictEqual(owners.length, 1);
-  assert.strictEqual(owners[0].user.id, user.id);
-  assert.strictEqual(owners[0].team, null);
+  expect(owners.length).toBe(1);
+  expect(owners[0].user.id).toBe(user.id);
+  expect(owners[0].team).toBe(null);
 
   let invites = db.crateOwnerInvitation.findMany(q => q.where({ crate: { id: crate.id } }));
-  assert.strictEqual(invites.length, 0);
+  expect(invites.length).toBe(0);
 });
diff --git a/packages/crates-io-msw/handlers/crates/reverse-dependencies.test.js b/packages/crates-io-msw/handlers/crates/reverse-dependencies.test.js
index 896637e797c..2a6bd2c268b 100644
--- a/packages/crates-io-msw/handlers/crates/reverse-dependencies.test.js
+++ b/packages/crates-io-msw/handlers/crates/reverse-dependencies.test.js
@@ -1,19 +1,19 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('returns 404 for unknown crates', async function () {
   let response = await fetch('/api/v1/crates/foo/reverse_dependencies');
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('empty case', async function () {
   await db.crate.create({ name: 'rand' });
 
   let response = await fetch('/api/v1/crates/rand/reverse_dependencies');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     dependencies: [],
     versions: [],
     meta: {
@@ -40,8 +40,8 @@ test('returns a paginated list of crate versions depending to the specified crat
   });
 
   let response = await fetch('/api/v1/crates/foo/reverse_dependencies');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     dependencies: [
       {
         id: 2,
@@ -167,12 +167,12 @@ test('never returns more than 10 results', async function () {
   );
 
   let response = await fetch('/api/v1/crates/foo/reverse_dependencies');
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
 
   let responsePayload = await response.json();
-  assert.strictEqual(responsePayload.dependencies.length, 10);
-  assert.strictEqual(responsePayload.versions.length, 10);
-  assert.strictEqual(responsePayload.meta.total, 25);
+  expect(responsePayload.dependencies.length).toBe(10);
+  expect(responsePayload.versions.length).toBe(10);
+  expect(responsePayload.meta.total).toBe(25);
 });
 
 test('supports `page` and `per_page` parameters', async function () {
@@ -185,13 +185,16 @@ test('supports `page` and `per_page` parameters', async function () {
   await Promise.all(versions.map(version => db.dependency.create({ crate, version })));
 
   let response = await fetch('/api/v1/crates/foo/reverse_dependencies?page=2&per_page=5');
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
 
   let responsePayload = await response.json();
-  assert.strictEqual(responsePayload.dependencies.length, 5);
-  assert.deepEqual(
-    responsePayload.versions.map(it => it.crate),
-    ['crate-24', 'crate-02', 'crate-15', 'crate-06', 'crate-19'],
-  );
-  assert.strictEqual(responsePayload.meta.total, 25);
+  expect(responsePayload.dependencies.length).toBe(5);
+  expect(responsePayload.versions.map(it => it.crate)).toEqual([
+    'crate-24',
+    'crate-02',
+    'crate-15',
+    'crate-06',
+    'crate-19',
+  ]);
+  expect(responsePayload.meta.total).toBe(25);
 });
diff --git a/packages/crates-io-msw/handlers/crates/team-owners.test.js b/packages/crates-io-msw/handlers/crates/team-owners.test.js
index 8d15130c647..83aa658e3cb 100644
--- a/packages/crates-io-msw/handlers/crates/team-owners.test.js
+++ b/packages/crates-io-msw/handlers/crates/team-owners.test.js
@@ -1,19 +1,19 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('returns 404 for unknown crates', async function () {
   let response = await fetch('/api/v1/crates/foo/owner_team');
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('empty case', async function () {
   await db.crate.create({ name: 'rand' });
 
   let response = await fetch('/api/v1/crates/rand/owner_team');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     teams: [],
   });
 });
@@ -24,8 +24,8 @@ test('returns the list of teams that own the specified crate', async function ()
   await db.crateOwnership.create({ crate, team });
 
   let response = await fetch('/api/v1/crates/rand/owner_team');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     teams: [
       {
         id: 1,
diff --git a/packages/crates-io-msw/handlers/crates/unfollow.test.js b/packages/crates-io-msw/handlers/crates/unfollow.test.js
index e018cc0f647..7dcf3255564 100644
--- a/packages/crates-io-msw/handlers/crates/unfollow.test.js
+++ b/packages/crates-io-msw/handlers/crates/unfollow.test.js
@@ -1,11 +1,11 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('returns 403 if unauthenticated', async function () {
   let response = await fetch('/api/v1/crates/foo/follow', { method: 'DELETE' });
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
@@ -15,8 +15,8 @@ test('returns 404 for unknown crates', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/crates/foo/follow', { method: 'DELETE' });
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('makes the authenticated user unfollow the crate', async function () {
@@ -25,13 +25,13 @@ test('makes the authenticated user unfollow the crate', async function () {
   let user = await db.user.create({ followedCrates: [crate] });
   await db.mswSession.create({ user });
 
-  assert.equal(user.followedCrates.length, 1);
-  assert.equal(user.followedCrates[0].name, crate.name);
+  expect(user.followedCrates.length).toBe(1);
+  expect(user.followedCrates[0].name).toBe(crate.name);
 
   let response = await fetch('/api/v1/crates/rand/follow', { method: 'DELETE' });
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), { ok: true });
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({ ok: true });
 
   user = db.user.findFirst(q => q.where({ id: user.id }));
-  assert.deepEqual(user.followedCrates, []);
+  expect(user.followedCrates).toEqual([]);
 });
diff --git a/packages/crates-io-msw/handlers/crates/user-owners.test.js b/packages/crates-io-msw/handlers/crates/user-owners.test.js
index c763ddd3de8..52d95b8a52d 100644
--- a/packages/crates-io-msw/handlers/crates/user-owners.test.js
+++ b/packages/crates-io-msw/handlers/crates/user-owners.test.js
@@ -1,19 +1,19 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('returns 404 for unknown crates', async function () {
   let response = await fetch('/api/v1/crates/foo/owner_user');
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('empty case', async function () {
   await db.crate.create({ name: 'rand' });
 
   let response = await fetch('/api/v1/crates/rand/owner_user');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     users: [],
   });
 });
@@ -24,8 +24,8 @@ test('returns the list of users that own the specified crate', async function ()
   await db.crateOwnership.create({ crate, user });
 
   let response = await fetch('/api/v1/crates/rand/owner_user');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     users: [
       {
         id: 1,
diff --git a/packages/crates-io-msw/handlers/docs-rs.test.js b/packages/crates-io-msw/handlers/docs-rs.test.js
index 8f4b6fc12b0..b27700803ac 100644
--- a/packages/crates-io-msw/handlers/docs-rs.test.js
+++ b/packages/crates-io-msw/handlers/docs-rs.test.js
@@ -1,7 +1,7 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 test('returns 200 OK and an empty object', async function () {
   let response = await fetch('https://docs.rs/crate/foo/0.0.0/status.json');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {});
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({});
 });
diff --git a/packages/crates-io-msw/handlers/invites/legacy-list.test.js b/packages/crates-io-msw/handlers/invites/legacy-list.test.js
index 75d79c31ac8..fe82e4f3ccc 100644
--- a/packages/crates-io-msw/handlers/invites/legacy-list.test.js
+++ b/packages/crates-io-msw/handlers/invites/legacy-list.test.js
@@ -1,4 +1,4 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
@@ -7,8 +7,8 @@ test('empty case', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/me/crate_owner_invitations');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), { crate_owner_invitations: [], users: [] });
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({ crate_owner_invitations: [], users: [] });
 });
 
 test('returns the list of invitations for the authenticated user', async function () {
@@ -38,8 +38,8 @@ test('returns the list of invitations for the authenticated user', async functio
   });
 
   let response = await fetch('/api/v1/me/crate_owner_invitations');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     crate_owner_invitations: [
       {
         crate_id: Number(nanomsg.id),
@@ -86,8 +86,8 @@ test('returns the list of invitations for the authenticated user', async functio
 
 test('returns an error if unauthenticated', async function () {
   let response = await fetch('/api/v1/me/crate_owner_invitations');
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
diff --git a/packages/crates-io-msw/handlers/invites/list.test.js b/packages/crates-io-msw/handlers/invites/list.test.js
index 15d3b983639..7fcf4f7a93d 100644
--- a/packages/crates-io-msw/handlers/invites/list.test.js
+++ b/packages/crates-io-msw/handlers/invites/list.test.js
@@ -1,4 +1,4 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
@@ -29,8 +29,8 @@ test('happy path (invitee_id)', async function () {
   });
 
   let response = await fetch(`/api/private/crate_owner_invitations?invitee_id=${user.id}`);
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     crate_owner_invitations: [
       {
         crate_id: Number(nanomsg.id),
@@ -83,8 +83,8 @@ test('happy path with empty response (invitee_id)', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch(`/api/private/crate_owner_invitations?invitee_id=${user.id}`);
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     crate_owner_invitations: [],
     users: [],
     meta: {
@@ -106,16 +106,16 @@ test('happy path with pagination (invitee_id)', async function () {
   }
 
   let response = await fetch(`/api/private/crate_owner_invitations?invitee_id=${user.id}`);
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
   let responseJSON = await response.json();
-  assert.strictEqual(responseJSON['crate_owner_invitations'].length, 10);
-  assert.ok(responseJSON.meta['next_page']);
+  expect(responseJSON['crate_owner_invitations'].length).toBe(10);
+  expect(responseJSON.meta['next_page']).toBeTruthy();
 
   response = await fetch(`/api/private/crate_owner_invitations${responseJSON.meta['next_page']}`);
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
   responseJSON = await response.json();
-  assert.strictEqual(responseJSON['crate_owner_invitations'].length, 5);
-  assert.strictEqual(responseJSON.meta['next_page'], null);
+  expect(responseJSON['crate_owner_invitations'].length).toBe(5);
+  expect(responseJSON.meta['next_page']).toBe(null);
 });
 
 test('happy path (crate_name)', async function () {
@@ -145,8 +145,8 @@ test('happy path (crate_name)', async function () {
   });
 
   let response = await fetch(`/api/private/crate_owner_invitations?crate_name=ember-rs`);
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     crate_owner_invitations: [
       {
         crate_id: Number(ember.id),
@@ -181,8 +181,8 @@ test('happy path (crate_name)', async function () {
 
 test('returns 403 if unauthenticated', async function () {
   let response = await fetch(`/api/private/crate_owner_invitations?invitee_id=42`);
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
@@ -192,8 +192,8 @@ test('returns 400 if query params are missing', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch(`/api/private/crate_owner_invitations`);
-  assert.strictEqual(response.status, 400);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(400);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'missing or invalid filter' }],
   });
 });
@@ -203,8 +203,8 @@ test("returns 404 if crate can't be found", async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch(`/api/private/crate_owner_invitations?crate_name=foo`);
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'Not Found' }],
   });
 });
@@ -214,8 +214,8 @@ test('returns 403 if requesting for other user', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch(`/api/private/crate_owner_invitations?invitee_id=${user.id + 1}`);
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
diff --git a/packages/crates-io-msw/handlers/invites/redeem-by-crate-id.test.js b/packages/crates-io-msw/handlers/invites/redeem-by-crate-id.test.js
index 398f011b855..649904092ef 100644
--- a/packages/crates-io-msw/handlers/invites/redeem-by-crate-id.test.js
+++ b/packages/crates-io-msw/handlers/invites/redeem-by-crate-id.test.js
@@ -1,4 +1,4 @@
-import { test as _test, assert } from 'vitest';
+import { test as _test, expect } from 'vitest';
 
 import { db } from '../../index.js';
 
@@ -20,8 +20,8 @@ test('can accept an invitation', async function ({ serde }) {
 
   let body = JSON.stringify({ crate_owner_invite: { crate_id: serde.id, accepted: true } });
   let response = await fetch('/api/v1/me/crate_owner_invitations/serde', { method: 'PUT', body });
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     crate_owner_invitation: {
       accepted: true,
       crate_id: serde.id,
@@ -31,9 +31,9 @@ test('can accept an invitation', async function ({ serde }) {
   let invites = db.crateOwnerInvitation.findMany(q =>
     q.where({ crate: { id: serde.id }, invitee: { id: invitee.id } }),
   );
-  assert.strictEqual(invites.length, 0);
+  expect(invites.length).toBe(0);
   let owners = db.crateOwnership.findMany(q => q.where({ crate: { id: serde.id }, user: { id: invitee.id } }));
-  assert.strictEqual(owners.length, 1);
+  expect(owners.length).toBe(1);
 });
 
 test('can decline an invitation', async function ({ serde }) {
@@ -45,8 +45,8 @@ test('can decline an invitation', async function ({ serde }) {
 
   let body = JSON.stringify({ crate_owner_invite: { crate_id: serde.id, accepted: false } });
   let response = await fetch('/api/v1/me/crate_owner_invitations/serde', { method: 'PUT', body });
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     crate_owner_invitation: {
       accepted: false,
       crate_id: serde.id,
@@ -56,9 +56,9 @@ test('can decline an invitation', async function ({ serde }) {
   let invites = db.crateOwnerInvitation.findMany(q =>
     q.where({ crate: { id: serde.id }, invitee: { id: invitee.id } }),
   );
-  assert.strictEqual(invites.length, 0);
+  expect(invites.length).toBe(0);
   let owners = db.crateOwnership.findMany(q => q.where({ crate: { id: serde.id }, user: { id: invitee.id } }));
-  assert.strictEqual(owners.length, 0);
+  expect(owners.length).toBe(0);
 });
 
 test('returns 404 if invite does not exist', async function ({ serde }) {
@@ -67,7 +67,7 @@ test('returns 404 if invite does not exist', async function ({ serde }) {
 
   let body = JSON.stringify({ crate_owner_invite: { crate_id: serde.id, accepted: true } });
   let response = await fetch('/api/v1/me/crate_owner_invitations/serde', { method: 'PUT', body });
-  assert.strictEqual(response.status, 404);
+  expect(response.status).toBe(404);
 });
 
 test('returns 404 if invite is for another user', async function ({ serde }) {
@@ -79,14 +79,14 @@ test('returns 404 if invite is for another user', async function ({ serde }) {
 
   let body = JSON.stringify({ crate_owner_invite: { crate_id: serde.id, accepted: true } });
   let response = await fetch('/api/v1/me/crate_owner_invitations/serde', { method: 'PUT', body });
-  assert.strictEqual(response.status, 404);
+  expect(response.status).toBe(404);
 });
 
 test('returns an error if unauthenticated', async function ({ serde }) {
   let body = JSON.stringify({ crate_owner_invite: { crate_id: serde.id, accepted: true } });
   let response = await fetch('/api/v1/me/crate_owner_invitations/serde', { method: 'PUT', body });
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
diff --git a/packages/crates-io-msw/handlers/invites/redeem-by-token.test.js b/packages/crates-io-msw/handlers/invites/redeem-by-token.test.js
index c11ff9b2c6c..7ce678ff1af 100644
--- a/packages/crates-io-msw/handlers/invites/redeem-by-token.test.js
+++ b/packages/crates-io-msw/handlers/invites/redeem-by-token.test.js
@@ -1,4 +1,4 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
@@ -13,8 +13,8 @@ test('can accept an invitation', async function () {
   let invite = await db.crateOwnerInvitation.create({ crate: serde, invitee, inviter });
 
   let response = await fetch(`/api/v1/me/crate_owner_invitations/accept/${invite.token}`, { method: 'PUT' });
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     crate_owner_invitation: {
       accepted: true,
       crate_id: serde.id,
@@ -24,9 +24,9 @@ test('can accept an invitation', async function () {
   let invites = db.crateOwnerInvitation.findMany(q =>
     q.where({ crate: { id: serde.id }, invitee: { id: invitee.id } }),
   );
-  assert.strictEqual(invites.length, 0);
+  expect(invites.length).toBe(0);
   let owners = db.crateOwnership.findMany(q => q.where({ crate: { id: serde.id }, user: { id: invitee.id } }));
-  assert.strictEqual(owners.length, 1);
+  expect(owners.length).toBe(1);
 });
 
 test('returns 404 if invite does not exist', async function () {
@@ -34,5 +34,5 @@ test('returns 404 if invite does not exist', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/me/crate_owner_invitations/accept/secret-token', { method: 'PUT' });
-  assert.strictEqual(response.status, 404);
+  expect(response.status).toBe(404);
 });
diff --git a/packages/crates-io-msw/handlers/keywords/get.test.js b/packages/crates-io-msw/handlers/keywords/get.test.js
index 2caaf3390de..90a322d126c 100644
--- a/packages/crates-io-msw/handlers/keywords/get.test.js
+++ b/packages/crates-io-msw/handlers/keywords/get.test.js
@@ -1,19 +1,19 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('returns 404 for unknown keywords', async function () {
   let response = await fetch('/api/v1/keywords/foo');
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('returns a keyword object for known keywords', async function () {
   await db.keyword.create({ keyword: 'cli' });
 
   let response = await fetch('/api/v1/keywords/cli');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     keyword: {
       id: 'cli',
       crates_cnt: 0,
@@ -29,8 +29,8 @@ test('calculates `crates_cnt` correctly', async function () {
   await Promise.all(Array.from({ length: 3 }, () => db.crate.create({ keywords: [notTestKeyword] })));
 
   let response = await fetch('/api/v1/keywords/test-cli-keyword');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     keyword: {
       id: 'test-cli-keyword',
       crates_cnt: 7,
diff --git a/packages/crates-io-msw/handlers/keywords/list.test.js b/packages/crates-io-msw/handlers/keywords/list.test.js
index fec4444fdbd..a3bf3470435 100644
--- a/packages/crates-io-msw/handlers/keywords/list.test.js
+++ b/packages/crates-io-msw/handlers/keywords/list.test.js
@@ -1,11 +1,11 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('empty case', async function () {
   let response = await fetch('/api/v1/keywords');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     keywords: [],
     meta: {
       total: 0,
@@ -18,8 +18,8 @@ test('returns a paginated keywords list', async function () {
   await Promise.all(Array.from({ length: 2 }, () => db.keyword.create()));
 
   let response = await fetch('/api/v1/keywords');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     keywords: [
       {
         id: 'api',
@@ -47,11 +47,11 @@ test('never returns more than 10 results', async function () {
   await Promise.all(Array.from({ length: 25 }, () => db.keyword.create()));
 
   let response = await fetch('/api/v1/keywords');
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
 
   let responsePayload = await response.json();
-  assert.strictEqual(responsePayload.keywords.length, 10);
-  assert.strictEqual(responsePayload.meta.total, 25);
+  expect(responsePayload.keywords.length).toBe(10);
+  expect(responsePayload.meta.total).toBe(25);
 });
 
 test('supports `page` and `per_page` parameters', async function () {
@@ -60,13 +60,10 @@ test('supports `page` and `per_page` parameters', async function () {
   );
 
   let response = await fetch('/api/v1/keywords?page=2&per_page=5');
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
 
   let responsePayload = await response.json();
-  assert.strictEqual(responsePayload.keywords.length, 5);
-  assert.deepEqual(
-    responsePayload.keywords.map(it => it.id),
-    ['k06', 'k07', 'k08', 'k09', 'k10'],
-  );
-  assert.strictEqual(responsePayload.meta.total, 25);
+  expect(responsePayload.keywords.length).toBe(5);
+  expect(responsePayload.keywords.map(it => it.id)).toEqual(['k06', 'k07', 'k08', 'k09', 'k10']);
+  expect(responsePayload.meta.total).toBe(25);
 });
diff --git a/packages/crates-io-msw/handlers/metadata.test.js b/packages/crates-io-msw/handlers/metadata.test.js
index 2b6bbce4261..3caf677a1cb 100644
--- a/packages/crates-io-msw/handlers/metadata.test.js
+++ b/packages/crates-io-msw/handlers/metadata.test.js
@@ -1,8 +1,8 @@
-import { assert, expect, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 test('returns the deployed SHA1 and read-only status', async function () {
   let response = await fetch('/api/v1/site_metadata');
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
   expect(await response.json()).toMatchInlineSnapshot(`
     {
       "commit": "5048d31943118c6d67359bd207d307c854e82f45",
diff --git a/packages/crates-io-msw/handlers/playground.test.js b/packages/crates-io-msw/handlers/playground.test.js
index f5c40b3aa76..ecc9db92549 100644
--- a/packages/crates-io-msw/handlers/playground.test.js
+++ b/packages/crates-io-msw/handlers/playground.test.js
@@ -1,7 +1,7 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 test('returns 200 OK and an empty array', async function () {
   let response = await fetch('https://play.rust-lang.org/meta/crates');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), []);
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual([]);
 });
diff --git a/packages/crates-io-msw/handlers/sessions/delete.test.js b/packages/crates-io-msw/handlers/sessions/delete.test.js
index 2658dae8b2e..395ce5a5c6a 100644
--- a/packages/crates-io-msw/handlers/sessions/delete.test.js
+++ b/packages/crates-io-msw/handlers/sessions/delete.test.js
@@ -1,4 +1,4 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
@@ -7,16 +7,16 @@ test('returns 200 when authenticated', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/private/session', { method: 'DELETE' });
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), { ok: true });
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({ ok: true });
 
-  assert.notOk(db.mswSession.findFirst(null));
+  expect(db.mswSession.findFirst(null)).toBeFalsy();
 });
 
 test('returns 200 when unauthenticated', async function () {
   let response = await fetch('/api/private/session', { method: 'DELETE' });
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), { ok: true });
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({ ok: true });
 
-  assert.notOk(db.mswSession.findFirst(null));
+  expect(db.mswSession.findFirst(null)).toBeFalsy();
 });
diff --git a/packages/crates-io-msw/handlers/summary.test.js b/packages/crates-io-msw/handlers/summary.test.js
index 9feef67affe..33637179f89 100644
--- a/packages/crates-io-msw/handlers/summary.test.js
+++ b/packages/crates-io-msw/handlers/summary.test.js
@@ -1,11 +1,11 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../index.js';
 
 test('empty case', async function () {
   let response = await fetch('/api/v1/summary');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     just_updated: [],
     most_downloaded: [],
     most_recently_downloaded: [],
@@ -24,12 +24,12 @@ test('returns the data for the front page', async function () {
   await Promise.all(crates.map(crate => db.version.create({ crate })));
 
   let response = await fetch('/api/v1/summary');
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
 
   let responsePayload = await response.json();
 
-  assert.strictEqual(responsePayload.just_updated.length, 10);
-  assert.deepEqual(responsePayload.just_updated[0], {
+  expect(responsePayload.just_updated.length).toBe(10);
+  expect(responsePayload.just_updated[0]).toEqual({
     id: 'crate-1',
     badges: [],
     categories: null,
@@ -60,8 +60,8 @@ test('returns the data for the front page', async function () {
     yanked: false,
   });
 
-  assert.strictEqual(responsePayload.most_downloaded.length, 10);
-  assert.deepEqual(responsePayload.most_downloaded[0], {
+  expect(responsePayload.most_downloaded.length).toBe(10);
+  expect(responsePayload.most_downloaded[0]).toEqual({
     id: 'crate-4',
     badges: [],
     categories: null,
@@ -92,8 +92,8 @@ test('returns the data for the front page', async function () {
     yanked: false,
   });
 
-  assert.strictEqual(responsePayload.most_recently_downloaded.length, 10);
-  assert.deepEqual(responsePayload.most_recently_downloaded[0], {
+  expect(responsePayload.most_recently_downloaded.length).toBe(10);
+  expect(responsePayload.most_recently_downloaded[0]).toEqual({
     id: 'crate-11',
     badges: [],
     categories: null,
@@ -124,8 +124,8 @@ test('returns the data for the front page', async function () {
     yanked: false,
   });
 
-  assert.strictEqual(responsePayload.new_crates.length, 10);
-  assert.deepEqual(responsePayload.new_crates[0], {
+  expect(responsePayload.new_crates.length).toBe(10);
+  expect(responsePayload.new_crates[0]).toEqual({
     id: 'crate-20',
     badges: [],
     categories: null,
@@ -156,11 +156,11 @@ test('returns the data for the front page', async function () {
     yanked: false,
   });
 
-  assert.strictEqual(responsePayload.num_crates, 20);
-  assert.strictEqual(responsePayload.num_downloads, 1_518_435);
+  expect(responsePayload.num_crates).toBe(20);
+  expect(responsePayload.num_downloads).toBe(1_518_435);
 
-  assert.strictEqual(responsePayload.popular_categories.length, 10);
-  assert.deepEqual(responsePayload.popular_categories[0], {
+  expect(responsePayload.popular_categories.length).toBe(10);
+  expect(responsePayload.popular_categories[0]).toEqual({
     id: 'category-1',
     category: 'Category 1',
     crates_cnt: 0,
@@ -169,8 +169,8 @@ test('returns the data for the front page', async function () {
     slug: 'category-1',
   });
 
-  assert.strictEqual(responsePayload.popular_keywords.length, 10);
-  assert.deepEqual(responsePayload.popular_keywords[0], {
+  expect(responsePayload.popular_keywords.length).toBe(10);
+  expect(responsePayload.popular_keywords[0]).toEqual({
     id: 'keyword-1',
     crates_cnt: 0,
     keyword: 'keyword-1',
diff --git a/packages/crates-io-msw/handlers/teams/get.test.js b/packages/crates-io-msw/handlers/teams/get.test.js
index 1046ee20433..360316ac3b1 100644
--- a/packages/crates-io-msw/handlers/teams/get.test.js
+++ b/packages/crates-io-msw/handlers/teams/get.test.js
@@ -1,19 +1,19 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('returns 404 for unknown teams', async function () {
   let response = await fetch('/api/v1/teams/foo');
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('returns a team object for known teams', async function () {
   let team = await db.team.create({ name: 'maintainers' });
 
   let response = await fetch(`/api/v1/teams/${team.login}`);
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     team: {
       id: 1,
       avatar: 'https://avatars1.githubusercontent.com/u/14631425?v=4',
diff --git a/packages/crates-io-msw/handlers/trustpub/github-configs/create.test.js b/packages/crates-io-msw/handlers/trustpub/github-configs/create.test.js
index e89f9ade13c..7b26c872fd9 100644
--- a/packages/crates-io-msw/handlers/trustpub/github-configs/create.test.js
+++ b/packages/crates-io-msw/handlers/trustpub/github-configs/create.test.js
@@ -1,4 +1,4 @@
-import { afterEach, assert, beforeEach, test, vi } from 'vitest';
+import { afterEach, beforeEach, expect, test, vi } from 'vitest';
 
 import { db } from '../../../index.js';
 
@@ -37,8 +37,8 @@ test('happy path', async function () {
     }),
   });
 
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     github_config: {
       id: 1,
       crate: crate.name,
@@ -80,8 +80,8 @@ test('happy path with environment', async function () {
     }),
   });
 
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     github_config: {
       id: 1,
       crate: crate.name,
@@ -108,8 +108,8 @@ test('returns 403 if unauthenticated', async function () {
     }),
   });
 
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
@@ -123,8 +123,8 @@ test('returns 400 if request body is invalid', async function () {
     body: JSON.stringify({}),
   });
 
-  assert.strictEqual(response.status, 400);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(400);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'invalid request body' }],
   });
 });
@@ -142,8 +142,8 @@ test('returns 400 if required fields are missing', async function () {
     }),
   });
 
-  assert.strictEqual(response.status, 400);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(400);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'missing required fields' }],
   });
 });
@@ -164,8 +164,8 @@ test("returns 404 if crate can't be found", async function () {
     }),
   });
 
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'Not Found' }],
   });
 });
@@ -189,8 +189,8 @@ test('returns 400 if user is not an owner of the crate', async function () {
     }),
   });
 
-  assert.strictEqual(response.status, 400);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(400);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'You are not an owner of this crate' }],
   });
 });
@@ -220,8 +220,8 @@ test('returns 403 if user email is not verified', async function () {
     }),
   });
 
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'You must verify your email address to create a Trusted Publishing config' }],
   });
 });
diff --git a/packages/crates-io-msw/handlers/trustpub/github-configs/delete.test.js b/packages/crates-io-msw/handlers/trustpub/github-configs/delete.test.js
index 045c0b0ae27..775dca3fe6d 100644
--- a/packages/crates-io-msw/handlers/trustpub/github-configs/delete.test.js
+++ b/packages/crates-io-msw/handlers/trustpub/github-configs/delete.test.js
@@ -1,4 +1,4 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../../index.js';
 
@@ -28,12 +28,12 @@ test('happy path', async function () {
     method: 'DELETE',
   });
 
-  assert.strictEqual(response.status, 204);
-  assert.strictEqual(await response.text(), '');
+  expect(response.status).toBe(204);
+  expect(await response.text()).toBe('');
 
   // Verify the config was deleted
   let deletedConfig = db.trustpubGithubConfig.findFirst(q => q.where({ id: config.id }));
-  assert.strictEqual(deletedConfig, undefined);
+  expect(deletedConfig).toBe(undefined);
 });
 
 test('returns 403 if unauthenticated', async function () {
@@ -41,8 +41,8 @@ test('returns 403 if unauthenticated', async function () {
     method: 'DELETE',
   });
 
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
@@ -55,8 +55,8 @@ test('returns 404 if config ID is invalid', async function () {
     method: 'DELETE',
   });
 
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'Not Found' }],
   });
 });
@@ -69,8 +69,8 @@ test("returns 404 if config can't be found", async function () {
     method: 'DELETE',
   });
 
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'Not Found' }],
   });
 });
@@ -102,8 +102,8 @@ test('returns 400 if user is not an owner of the crate', async function () {
     method: 'DELETE',
   });
 
-  assert.strictEqual(response.status, 400);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(400);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'You are not an owner of this crate' }],
   });
 });
diff --git a/packages/crates-io-msw/handlers/trustpub/github-configs/list.test.js b/packages/crates-io-msw/handlers/trustpub/github-configs/list.test.js
index 469971bd5b4..94eaf3ca110 100644
--- a/packages/crates-io-msw/handlers/trustpub/github-configs/list.test.js
+++ b/packages/crates-io-msw/handlers/trustpub/github-configs/list.test.js
@@ -1,4 +1,4 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../../index.js';
 
@@ -36,8 +36,8 @@ test('happy path', async function () {
   });
 
   let response = await fetch(`/api/v1/trusted_publishing/github_configs?crate=${crate.name}`);
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     github_configs: [
       {
         id: Number(config1.id),
@@ -77,16 +77,16 @@ test('happy path with no configs', async function () {
   });
 
   let response = await fetch(`/api/v1/trusted_publishing/github_configs?crate=${crate.name}`);
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     github_configs: [],
   });
 });
 
 test('returns 403 if unauthenticated', async function () {
   let response = await fetch(`/api/v1/trusted_publishing/github_configs?crate=test-crate`);
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
@@ -96,8 +96,8 @@ test('returns 400 if query params are missing', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch(`/api/v1/trusted_publishing/github_configs`);
-  assert.strictEqual(response.status, 400);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(400);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'missing or invalid filter' }],
   });
 });
@@ -107,8 +107,8 @@ test("returns 404 if crate can't be found", async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch(`/api/v1/trusted_publishing/github_configs?crate=nonexistent`);
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'Not Found' }],
   });
 });
@@ -121,8 +121,8 @@ test('returns 400 if user is not an owner of the crate', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch(`/api/v1/trusted_publishing/github_configs?crate=${crate.name}`);
-  assert.strictEqual(response.status, 400);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(400);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'You are not an owner of this crate' }],
   });
 });
diff --git a/packages/crates-io-msw/handlers/trustpub/gitlab-configs/create.test.js b/packages/crates-io-msw/handlers/trustpub/gitlab-configs/create.test.js
index 4ca709b405c..42d1b730402 100644
--- a/packages/crates-io-msw/handlers/trustpub/gitlab-configs/create.test.js
+++ b/packages/crates-io-msw/handlers/trustpub/gitlab-configs/create.test.js
@@ -1,4 +1,4 @@
-import { afterEach, assert, beforeEach, test, vi } from 'vitest';
+import { afterEach, beforeEach, expect, test, vi } from 'vitest';
 
 import { db } from '../../../index.js';
 
@@ -37,8 +37,8 @@ test('happy path', async function () {
     }),
   });
 
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     gitlab_config: {
       id: 1,
       crate: crate.name,
@@ -80,8 +80,8 @@ test('happy path with environment', async function () {
     }),
   });
 
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     gitlab_config: {
       id: 1,
       crate: crate.name,
@@ -108,8 +108,8 @@ test('returns 403 if unauthenticated', async function () {
     }),
   });
 
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
@@ -123,8 +123,8 @@ test('returns 400 if request body is invalid', async function () {
     body: JSON.stringify({}),
   });
 
-  assert.strictEqual(response.status, 400);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(400);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'invalid request body' }],
   });
 });
@@ -142,8 +142,8 @@ test('returns 400 if required fields are missing', async function () {
     }),
   });
 
-  assert.strictEqual(response.status, 400);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(400);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'missing required fields' }],
   });
 });
@@ -164,8 +164,8 @@ test("returns 404 if crate can't be found", async function () {
     }),
   });
 
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'Not Found' }],
   });
 });
@@ -189,8 +189,8 @@ test('returns 400 if user is not an owner of the crate', async function () {
     }),
   });
 
-  assert.strictEqual(response.status, 400);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(400);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'You are not an owner of this crate' }],
   });
 });
@@ -220,8 +220,8 @@ test('returns 403 if user email is not verified', async function () {
     }),
   });
 
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'You must verify your email address to create a Trusted Publishing config' }],
   });
 });
diff --git a/packages/crates-io-msw/handlers/trustpub/gitlab-configs/delete.test.js b/packages/crates-io-msw/handlers/trustpub/gitlab-configs/delete.test.js
index c69772792f0..f3fa51c5573 100644
--- a/packages/crates-io-msw/handlers/trustpub/gitlab-configs/delete.test.js
+++ b/packages/crates-io-msw/handlers/trustpub/gitlab-configs/delete.test.js
@@ -1,4 +1,4 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../../index.js';
 
@@ -28,12 +28,12 @@ test('happy path', async function () {
     method: 'DELETE',
   });
 
-  assert.strictEqual(response.status, 204);
-  assert.strictEqual(await response.text(), '');
+  expect(response.status).toBe(204);
+  expect(await response.text()).toBe('');
 
   // Verify the config was deleted
   let deletedConfig = db.trustpubGitlabConfig.findFirst(q => q.where({ id: config.id }));
-  assert.strictEqual(deletedConfig, undefined);
+  expect(deletedConfig).toBe(undefined);
 });
 
 test('returns 403 if unauthenticated', async function () {
@@ -41,8 +41,8 @@ test('returns 403 if unauthenticated', async function () {
     method: 'DELETE',
   });
 
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
@@ -55,8 +55,8 @@ test('returns 404 if config ID is invalid', async function () {
     method: 'DELETE',
   });
 
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'Not Found' }],
   });
 });
@@ -69,8 +69,8 @@ test("returns 404 if config can't be found", async function () {
     method: 'DELETE',
   });
 
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'Not Found' }],
   });
 });
@@ -102,8 +102,8 @@ test('returns 400 if user is not an owner of the crate', async function () {
     method: 'DELETE',
   });
 
-  assert.strictEqual(response.status, 400);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(400);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'You are not an owner of this crate' }],
   });
 });
diff --git a/packages/crates-io-msw/handlers/trustpub/gitlab-configs/list.test.js b/packages/crates-io-msw/handlers/trustpub/gitlab-configs/list.test.js
index 15c8d2c59c7..e15a8335508 100644
--- a/packages/crates-io-msw/handlers/trustpub/gitlab-configs/list.test.js
+++ b/packages/crates-io-msw/handlers/trustpub/gitlab-configs/list.test.js
@@ -1,4 +1,4 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../../index.js';
 
@@ -36,8 +36,8 @@ test('happy path', async function () {
   });
 
   let response = await fetch(`/api/v1/trusted_publishing/gitlab_configs?crate=${crate.name}`);
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     gitlab_configs: [
       {
         id: Number(config1.id),
@@ -77,16 +77,16 @@ test('happy path with no configs', async function () {
   });
 
   let response = await fetch(`/api/v1/trusted_publishing/gitlab_configs?crate=${crate.name}`);
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     gitlab_configs: [],
   });
 });
 
 test('returns 403 if unauthenticated', async function () {
   let response = await fetch(`/api/v1/trusted_publishing/gitlab_configs?crate=test-crate`);
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
@@ -96,8 +96,8 @@ test('returns 400 if query params are missing', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch(`/api/v1/trusted_publishing/gitlab_configs`);
-  assert.strictEqual(response.status, 400);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(400);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'missing or invalid filter' }],
   });
 });
@@ -107,8 +107,8 @@ test("returns 404 if crate can't be found", async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch(`/api/v1/trusted_publishing/gitlab_configs?crate=nonexistent`);
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'Not Found' }],
   });
 });
@@ -121,8 +121,8 @@ test('returns 400 if user is not an owner of the crate', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch(`/api/v1/trusted_publishing/gitlab_configs?crate=${crate.name}`);
-  assert.strictEqual(response.status, 400);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(400);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'You are not an owner of this crate' }],
   });
 });
diff --git a/packages/crates-io-msw/handlers/users/confirm-email.test.js b/packages/crates-io-msw/handlers/users/confirm-email.test.js
index 419f542a002..52661f06958 100644
--- a/packages/crates-io-msw/handlers/users/confirm-email.test.js
+++ b/packages/crates-io-msw/handlers/users/confirm-email.test.js
@@ -1,37 +1,37 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('returns `ok: true` for a known token (unauthenticated)', async function () {
   let user = await db.user.create({ emailVerificationToken: 'foo' });
-  assert.strictEqual(user.emailVerified, false);
+  expect(user.emailVerified).toBe(false);
 
   let response = await fetch('/api/v1/confirm/foo', { method: 'PUT' });
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), { ok: true });
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({ ok: true });
 
   user = db.user.findFirst(q => q.where({ id: user.id }));
-  assert.strictEqual(user.emailVerified, true);
+  expect(user.emailVerified).toBe(true);
 });
 
 test('returns `ok: true` for a known token (authenticated)', async function () {
   let user = await db.user.create({ emailVerificationToken: 'foo' });
-  assert.strictEqual(user.emailVerified, false);
+  expect(user.emailVerified).toBe(false);
 
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/confirm/foo', { method: 'PUT' });
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), { ok: true });
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({ ok: true });
 
   user = db.user.findFirst(q => q.where({ id: user.id }));
-  assert.strictEqual(user.emailVerified, true);
+  expect(user.emailVerified).toBe(true);
 });
 
 test('returns an error for unknown tokens', async function () {
   let response = await fetch('/api/v1/confirm/unknown', { method: 'PUT' });
-  assert.strictEqual(response.status, 400);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(400);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'Email belonging to token not found.' }],
   });
 });
diff --git a/packages/crates-io-msw/handlers/users/get.test.js b/packages/crates-io-msw/handlers/users/get.test.js
index 8aa14a51cf1..1c02ae28603 100644
--- a/packages/crates-io-msw/handlers/users/get.test.js
+++ b/packages/crates-io-msw/handlers/users/get.test.js
@@ -1,19 +1,19 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('returns 404 for unknown users', async function () {
   let response = await fetch('/api/v1/users/foo');
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('returns a user object for known users', async function () {
   let user = await db.user.create({ name: 'John Doe' });
 
   let response = await fetch(`/api/v1/users/${user.login}`);
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     user: {
       id: 1,
       avatar: 'https://avatars1.githubusercontent.com/u/14631425?v=4',
diff --git a/packages/crates-io-msw/handlers/users/me.test.js b/packages/crates-io-msw/handlers/users/me.test.js
index 1bf292254e3..3faa10b554c 100644
--- a/packages/crates-io-msw/handlers/users/me.test.js
+++ b/packages/crates-io-msw/handlers/users/me.test.js
@@ -1,4 +1,4 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
@@ -7,8 +7,8 @@ test('returns the `user` resource including the private fields', async function
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/me');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     user: {
       id: 1,
       avatar: 'https://avatars1.githubusercontent.com/u/14631425?v=4',
@@ -35,10 +35,10 @@ test('returns a list of `owned_crates`', async function () {
   await db.crateOwnership.create({ crate: crate3, user });
 
   let response = await fetch('/api/v1/me');
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
 
   let responsePayload = await response.json();
-  assert.deepEqual(responsePayload.owned_crates, [
+  expect(responsePayload.owned_crates).toEqual([
     { id: crate1.id, name: 'crate-1', email_notifications: true },
     { id: crate3.id, name: 'crate-3', email_notifications: true },
   ]);
@@ -48,8 +48,8 @@ test('returns an error if unauthenticated', async function () {
   await db.user.create();
 
   let response = await fetch('/api/v1/me');
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
diff --git a/packages/crates-io-msw/handlers/users/resend.test.js b/packages/crates-io-msw/handlers/users/resend.test.js
index 8acef23dffc..5dff446b2e9 100644
--- a/packages/crates-io-msw/handlers/users/resend.test.js
+++ b/packages/crates-io-msw/handlers/users/resend.test.js
@@ -1,4 +1,4 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
@@ -7,16 +7,16 @@ test('returns `ok`', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch(`/api/v1/users/${user.id}/resend`, { method: 'PUT' });
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), { ok: true });
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({ ok: true });
 });
 
 test('returns 403 when not logged in', async function () {
   let user = await db.user.create();
 
   let response = await fetch(`/api/v1/users/${user.id}/resend`, { method: 'PUT' });
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'must be logged in to perform that action' }] });
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'must be logged in to perform that action' }] });
 });
 
 test('returns 400 when requesting the wrong user id', async function () {
@@ -24,6 +24,6 @@ test('returns 400 when requesting the wrong user id', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch(`/api/v1/users/wrong-id/resend`, { method: 'PUT' });
-  assert.strictEqual(response.status, 400);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'current user does not match requested user' }] });
+  expect(response.status).toBe(400);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'current user does not match requested user' }] });
 });
diff --git a/packages/crates-io-msw/handlers/users/update.test.js b/packages/crates-io-msw/handlers/users/update.test.js
index 04f6ba58dd6..a0b5b45624b 100644
--- a/packages/crates-io-msw/handlers/users/update.test.js
+++ b/packages/crates-io-msw/handlers/users/update.test.js
@@ -1,4 +1,4 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
@@ -8,27 +8,27 @@ test('updates the user with a new email address', async function () {
 
   let body = JSON.stringify({ user: { email: 'new@email.com' } });
   let response = await fetch(`/api/v1/users/${user.id}`, { method: 'PUT', body });
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), { ok: true });
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({ ok: true });
 
   user = db.user.findFirst(q => q.where({ id: user.id }));
-  assert.strictEqual(user.email, 'new@email.com');
-  assert.strictEqual(user.emailVerified, false);
-  assert.strictEqual(user.emailVerificationToken, 'secret123');
+  expect(user.email).toBe('new@email.com');
+  expect(user.emailVerified).toBe(false);
+  expect(user.emailVerificationToken).toBe('secret123');
 });
 
 test('updates the `publish_notifications` settings', async function () {
   let user = await db.user.create();
   await db.mswSession.create({ user });
-  assert.strictEqual(user.publishNotifications, true);
+  expect(user.publishNotifications).toBe(true);
 
   let body = JSON.stringify({ user: { publish_notifications: false } });
   let response = await fetch(`/api/v1/users/${user.id}`, { method: 'PUT', body });
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), { ok: true });
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({ ok: true });
 
   user = db.user.findFirst(q => q.where({ id: user.id }));
-  assert.strictEqual(user.publishNotifications, false);
+  expect(user.publishNotifications).toBe(false);
 });
 
 test('returns 403 when not logged in', async function () {
@@ -36,11 +36,11 @@ test('returns 403 when not logged in', async function () {
 
   let body = JSON.stringify({ user: { email: 'new@email.com' } });
   let response = await fetch(`/api/v1/users/${user.id}`, { method: 'PUT', body });
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'must be logged in to perform that action' }] });
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'must be logged in to perform that action' }] });
 
   user = db.user.findFirst(q => q.where({ id: user.id }));
-  assert.strictEqual(user.email, 'old@email.com');
+  expect(user.email).toBe('old@email.com');
 });
 
 test('returns 400 when requesting the wrong user id', async function () {
@@ -49,11 +49,11 @@ test('returns 400 when requesting the wrong user id', async function () {
 
   let body = JSON.stringify({ user: { email: 'new@email.com' } });
   let response = await fetch(`/api/v1/users/wrong-id`, { method: 'PUT', body });
-  assert.strictEqual(response.status, 400);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'current user does not match requested user' }] });
+  expect(response.status).toBe(400);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'current user does not match requested user' }] });
 
   user = db.user.findFirst(q => q.where({ id: user.id }));
-  assert.strictEqual(user.email, 'old@email.com');
+  expect(user.email).toBe('old@email.com');
 });
 
 test('returns 400 when sending an invalid payload', async function () {
@@ -62,11 +62,11 @@ test('returns 400 when sending an invalid payload', async function () {
 
   let body = JSON.stringify({});
   let response = await fetch(`/api/v1/users/${user.id}`, { method: 'PUT', body });
-  assert.strictEqual(response.status, 400);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'invalid json request' }] });
+  expect(response.status).toBe(400);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'invalid json request' }] });
 
   user = db.user.findFirst(q => q.where({ id: user.id }));
-  assert.strictEqual(user.email, 'old@email.com');
+  expect(user.email).toBe('old@email.com');
 });
 
 test('returns 400 when sending an empty email address', async function () {
@@ -75,9 +75,9 @@ test('returns 400 when sending an empty email address', async function () {
 
   let body = JSON.stringify({ user: { email: '' } });
   let response = await fetch(`/api/v1/users/${user.id}`, { method: 'PUT', body });
-  assert.strictEqual(response.status, 400);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'empty email rejected' }] });
+  expect(response.status).toBe(400);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'empty email rejected' }] });
 
   user = db.user.findFirst(q => q.where({ id: user.id }));
-  assert.strictEqual(user.email, 'old@email.com');
+  expect(user.email).toBe('old@email.com');
 });
diff --git a/packages/crates-io-msw/handlers/versions/dependencies.test.js b/packages/crates-io-msw/handlers/versions/dependencies.test.js
index 4a3f04e835d..2c6a8e21220 100644
--- a/packages/crates-io-msw/handlers/versions/dependencies.test.js
+++ b/packages/crates-io-msw/handlers/versions/dependencies.test.js
@@ -1,19 +1,19 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('returns 404 for unknown crates', async function () {
   let response = await fetch('/api/v1/crates/foo/1.0.0/dependencies');
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('returns 404 for unknown versions', async function () {
   await db.crate.create({ name: 'rand' });
 
   let response = await fetch('/api/v1/crates/rand/1.0.0/dependencies');
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'crate `rand` does not have a version `1.0.0`' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'crate `rand` does not have a version `1.0.0`' }] });
 });
 
 test('empty case', async function () {
@@ -21,8 +21,8 @@ test('empty case', async function () {
   await db.version.create({ crate, num: '1.0.0' });
 
   let response = await fetch('/api/v1/crates/rand/1.0.0/dependencies');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     dependencies: [],
   });
 });
@@ -39,8 +39,8 @@ test('returns a list of dependencies belonging to the specified crate version',
   await db.dependency.create({ crate: baz, version });
 
   let response = await fetch('/api/v1/crates/rand/1.0.0/dependencies');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     dependencies: [
       {
         id: 1,
diff --git a/packages/crates-io-msw/handlers/versions/downloads.test.js b/packages/crates-io-msw/handlers/versions/downloads.test.js
index 6d9e22818f1..d05e7424c43 100644
--- a/packages/crates-io-msw/handlers/versions/downloads.test.js
+++ b/packages/crates-io-msw/handlers/versions/downloads.test.js
@@ -1,19 +1,19 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('returns 404 for unknown crates', async function () {
   let response = await fetch('/api/v1/crates/foo/1.0.0/downloads');
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('returns 404 for unknown versions', async function () {
   await db.crate.create({ name: 'rand' });
 
   let response = await fetch('/api/v1/crates/rand/1.0.0/downloads');
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'crate `rand` does not have a version `1.0.0`' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'crate `rand` does not have a version `1.0.0`' }] });
 });
 
 test('empty case', async function () {
@@ -21,8 +21,8 @@ test('empty case', async function () {
   await db.version.create({ crate, num: '1.0.0' });
 
   let response = await fetch('/api/v1/crates/rand/1.0.0/downloads');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     version_downloads: [],
   });
 });
@@ -35,8 +35,8 @@ test('returns a list of version downloads belonging to the specified crate versi
   await db.versionDownload.create({ version, date: '2020-01-15' });
 
   let response = await fetch('/api/v1/crates/rand/1.0.0/downloads');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     version_downloads: [
       {
         date: '2020-01-13',
diff --git a/packages/crates-io-msw/handlers/versions/follow-updates.test.js b/packages/crates-io-msw/handlers/versions/follow-updates.test.js
index f3c933f386b..8d86577e0b4 100644
--- a/packages/crates-io-msw/handlers/versions/follow-updates.test.js
+++ b/packages/crates-io-msw/handlers/versions/follow-updates.test.js
@@ -1,11 +1,11 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('returns 403 for unauthenticated user', async function () {
   let response = await fetch('/api/v1/me/updates');
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
@@ -21,8 +21,8 @@ test('returns latest versions of followed crates', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/me/updates');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     versions: [
       {
         id: 1,
@@ -74,8 +74,8 @@ test('empty case', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/me/updates');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     versions: [],
     meta: { more: false },
   });
@@ -89,13 +89,10 @@ test('supports pagination', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/me/updates?page=2');
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
 
   let responsePayload = await response.json();
-  assert.strictEqual(responsePayload.versions.length, 10);
-  assert.deepEqual(
-    responsePayload.versions.map(it => it.id),
-    [15, 14, 13, 12, 11, 10, 9, 8, 7, 6],
-  );
-  assert.deepEqual(responsePayload.meta, { more: true });
+  expect(responsePayload.versions.length).toBe(10);
+  expect(responsePayload.versions.map(it => it.id)).toEqual([15, 14, 13, 12, 11, 10, 9, 8, 7, 6]);
+  expect(responsePayload.meta).toEqual({ more: true });
 });
diff --git a/packages/crates-io-msw/handlers/versions/get.test.js b/packages/crates-io-msw/handlers/versions/get.test.js
index a1d328e6663..052f892eb6c 100644
--- a/packages/crates-io-msw/handlers/versions/get.test.js
+++ b/packages/crates-io-msw/handlers/versions/get.test.js
@@ -1,19 +1,19 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('returns 404 for unknown crates', async function () {
   let response = await fetch('/api/v1/crates/foo/1.0.0-beta.1');
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('returns 404 for unknown versions', async function () {
   let crate = await db.crate.create({ name: 'rand' });
   await db.version.create({ crate, num: '1.0.0-alpha.1' });
   let response = await fetch('/api/v1/crates/rand/1.0.0-beta.1');
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'crate `rand` does not have a version `1.0.0-beta.1`' }],
   });
 });
@@ -23,8 +23,8 @@ test('returns a version object for known version', async function () {
   await db.version.create({ crate, num: '1.0.0-beta.1' });
 
   let response = await fetch('/api/v1/crates/rand/1.0.0-beta.1');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     version: {
       crate: 'rand',
       crate_size: 162_963,
diff --git a/packages/crates-io-msw/handlers/versions/list.test.js b/packages/crates-io-msw/handlers/versions/list.test.js
index 919cb5d754b..85aff7edc75 100644
--- a/packages/crates-io-msw/handlers/versions/list.test.js
+++ b/packages/crates-io-msw/handlers/versions/list.test.js
@@ -1,19 +1,19 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('returns 404 for unknown crates', async function () {
   let response = await fetch('/api/v1/crates/foo/versions');
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('empty case', async function () {
   await db.crate.create({ name: 'rand' });
 
   let response = await fetch('/api/v1/crates/rand/versions');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     versions: [],
     meta: { total: 0, next_page: null },
   });
@@ -27,8 +27,8 @@ test('returns all versions belonging to the specified crate', async function ()
   await db.version.create({ crate, num: '1.2.0', rust_version: '1.69' });
 
   let response = await fetch('/api/v1/crates/rand/versions');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     versions: [
       {
         id: 3,
@@ -165,32 +165,23 @@ test('supports `sort` parameters', async function () {
   // sort by `semver` by default
   {
     let response = await fetch('/api/v1/crates/rand/versions');
-    assert.strictEqual(response.status, 200);
+    expect(response.status).toBe(200);
     let json = await response.json();
-    assert.deepEqual(
-      json.versions.map(it => it.num),
-      ['2.0.0-alpha', '1.1.0', '1.0.0'],
-    );
+    expect(json.versions.map(it => it.num)).toEqual(['2.0.0-alpha', '1.1.0', '1.0.0']);
   }
 
   {
     let response = await fetch('/api/v1/crates/rand/versions?sort=semver');
-    assert.strictEqual(response.status, 200);
+    expect(response.status).toBe(200);
     let json = await response.json();
-    assert.deepEqual(
-      json.versions.map(it => it.num),
-      ['2.0.0-alpha', '1.1.0', '1.0.0'],
-    );
+    expect(json.versions.map(it => it.num)).toEqual(['2.0.0-alpha', '1.1.0', '1.0.0']);
   }
 
   {
     let response = await fetch('/api/v1/crates/rand/versions?sort=date');
-    assert.strictEqual(response.status, 200);
+    expect(response.status).toBe(200);
     let json = await response.json();
-    assert.deepEqual(
-      json.versions.map(it => it.num),
-      ['1.1.0', '2.0.0-alpha', '1.0.0'],
-    );
+    expect(json.versions.map(it => it.num)).toEqual(['1.1.0', '2.0.0-alpha', '1.0.0']);
   }
 });
 
@@ -201,12 +192,9 @@ test('supports multiple `ids[]` parameters', async function () {
   await db.version.create({ crate, num: '1.1.0', publishedBy: user });
   await db.version.create({ crate, num: '1.2.0', rust_version: '1.69' });
   let response = await fetch('/api/v1/crates/rand/versions?nums[]=1.0.0&nums[]=1.2.0');
-  assert.strictEqual(response.status, 200);
+  expect(response.status).toBe(200);
   let json = await response.json();
-  assert.deepEqual(
-    json.versions.map(v => v.num),
-    ['1.2.0', '1.0.0'],
-  );
+  expect(json.versions.map(v => v.num)).toEqual(['1.2.0', '1.0.0']);
 });
 
 test('supports seek pagination', async function () {
@@ -229,7 +217,7 @@ test('supports seek pagination', async function () {
       }
       let response = await fetch(url);
       calls += 1;
-      assert.strictEqual(response.status, 200);
+      expect(response.status).toBe(200);
       let json = await response.json();
       responses.push(json);
       next_page = json.meta.next_page;
@@ -243,48 +231,35 @@ test('supports seek pagination', async function () {
   // sort by `semver` by default
   {
     let responses = await seek_forwards({ per_page: 1 });
-    assert.deepEqual(
-      responses.map(it => it.versions.map(v => v.num)),
-      [['2.0.0-alpha'], ['1.1.0'], ['1.0.0'], []],
-    );
-    assert.deepEqual(
-      responses.map(it => it.meta.next_page),
-      ['?per_page=1&seek=2.0.0-alpha', '?per_page=1&seek=1.1.0', '?per_page=1&seek=1.0.0', null],
-    );
+    expect(responses.map(it => it.versions.map(v => v.num))).toEqual([['2.0.0-alpha'], ['1.1.0'], ['1.0.0'], []]);
+    expect(responses.map(it => it.meta.next_page)).toEqual([
+      '?per_page=1&seek=2.0.0-alpha',
+      '?per_page=1&seek=1.1.0',
+      '?per_page=1&seek=1.0.0',
+      null,
+    ]);
   }
 
   {
     let responses = await seek_forwards({ per_page: 1, sort: 'semver' });
-    assert.deepEqual(
-      responses.map(it => it.versions.map(v => v.num)),
-      [['2.0.0-alpha'], ['1.1.0'], ['1.0.0'], []],
-    );
-    assert.deepEqual(
-      responses.map(it => it.meta.next_page),
-      [
-        '?per_page=1&sort=semver&seek=2.0.0-alpha',
-        '?per_page=1&sort=semver&seek=1.1.0',
-        '?per_page=1&sort=semver&seek=1.0.0',
-        null,
-      ],
-    );
+    expect(responses.map(it => it.versions.map(v => v.num))).toEqual([['2.0.0-alpha'], ['1.1.0'], ['1.0.0'], []]);
+    expect(responses.map(it => it.meta.next_page)).toEqual([
+      '?per_page=1&sort=semver&seek=2.0.0-alpha',
+      '?per_page=1&sort=semver&seek=1.1.0',
+      '?per_page=1&sort=semver&seek=1.0.0',
+      null,
+    ]);
   }
 
   {
     let responses = await seek_forwards({ per_page: 1, sort: 'date' });
-    assert.deepEqual(
-      responses.map(it => it.versions.map(v => v.num)),
-      [['1.1.0'], ['2.0.0-alpha'], ['1.0.0'], []],
-    );
-    assert.deepEqual(
-      responses.map(it => it.meta.next_page),
-      [
-        '?per_page=1&sort=date&seek=1.1.0',
-        '?per_page=1&sort=date&seek=2.0.0-alpha',
-        '?per_page=1&sort=date&seek=1.0.0',
-        null,
-      ],
-    );
+    expect(responses.map(it => it.versions.map(v => v.num))).toEqual([['1.1.0'], ['2.0.0-alpha'], ['1.0.0'], []]);
+    expect(responses.map(it => it.meta.next_page)).toEqual([
+      '?per_page=1&sort=date&seek=1.1.0',
+      '?per_page=1&sort=date&seek=2.0.0-alpha',
+      '?per_page=1&sort=date&seek=1.0.0',
+      null,
+    ]);
   }
 });
 
@@ -301,8 +276,8 @@ test('include `release_tracks` meta', async function () {
   let expected = await req.json();
 
   let response = await fetch('/api/v1/crates/rand/versions?include=release_tracks');
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     ...expected,
     meta: {
       ...expected.meta,
diff --git a/packages/crates-io-msw/handlers/versions/patch.test.js b/packages/crates-io-msw/handlers/versions/patch.test.js
index c1154b81903..a6156b1d971 100644
--- a/packages/crates-io-msw/handlers/versions/patch.test.js
+++ b/packages/crates-io-msw/handlers/versions/patch.test.js
@@ -1,4 +1,4 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
@@ -17,8 +17,8 @@ const UNYANK_BODY = JSON.stringify({
 
 test('returns 403 if unauthenticated', async function () {
   let response = await fetch('/api/v1/crates/foo/1.0.0', { method: 'PATCH', body: YANK_BODY });
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
@@ -28,8 +28,8 @@ test('returns 404 for unknown crates', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/crates/foo/1.0.0', { method: 'PATCH', body: YANK_BODY });
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('returns 404 for unknown versions', async function () {
@@ -39,22 +39,22 @@ test('returns 404 for unknown versions', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/crates/foo/1.0.0', { method: 'PATCH', body: YANK_BODY });
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('yanks the version', async function () {
   let crate = await db.crate.create({ name: 'foo' });
   let version = await db.version.create({ crate, num: '1.0.0', yanked: false });
-  assert.strictEqual(version.yanked, false);
-  assert.strictEqual(version.yank_message, null);
+  expect(version.yanked).toBe(false);
+  expect(version.yank_message).toBe(null);
 
   let user = await db.user.create();
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/crates/foo/1.0.0', { method: 'PATCH', body: YANK_BODY });
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     version: {
       crate: 'foo',
       crate_size: 162_963,
@@ -96,12 +96,12 @@ test('yanks the version', async function () {
   });
 
   version = db.version.findFirst(q => q.where({ id: version.id }));
-  assert.strictEqual(version.yanked, true);
-  assert.strictEqual(version.yank_message, 'some reason');
+  expect(version.yanked).toBe(true);
+  expect(version.yank_message).toBe('some reason');
 
   response = await fetch('/api/v1/crates/foo/1.0.0', { method: 'PATCH', body: UNYANK_BODY });
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({
     version: {
       crate: 'foo',
       crate_size: 162_963,
@@ -143,6 +143,6 @@ test('yanks the version', async function () {
   });
 
   version = db.version.findFirst(q => q.where({ id: version.id }));
-  assert.strictEqual(version.yanked, false);
-  assert.strictEqual(version.yank_message, null);
+  expect(version.yanked).toBe(false);
+  expect(version.yank_message).toBe(null);
 });
diff --git a/packages/crates-io-msw/handlers/versions/readme.test.js b/packages/crates-io-msw/handlers/versions/readme.test.js
index a15d957c38f..ff997b416e4 100644
--- a/packages/crates-io-msw/handlers/versions/readme.test.js
+++ b/packages/crates-io-msw/handlers/versions/readme.test.js
@@ -1,19 +1,19 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('returns 404 for unknown crates', async function () {
   let response = await fetch('/api/v1/crates/foo/1.0.0/readme');
-  assert.strictEqual(response.status, 403);
-  assert.strictEqual(await response.text(), '');
+  expect(response.status).toBe(403);
+  expect(await response.text()).toBe('');
 });
 
 test('returns 404 for unknown versions', async function () {
   await db.crate.create({ name: 'rand' });
 
   let response = await fetch('/api/v1/crates/rand/1.0.0/readme');
-  assert.strictEqual(response.status, 403);
-  assert.strictEqual(await response.text(), '');
+  expect(response.status).toBe(403);
+  expect(await response.text()).toBe('');
 });
 
 test('returns 404 for versions without README', async function () {
@@ -21,8 +21,8 @@ test('returns 404 for versions without README', async function () {
   await db.version.create({ crate, num: '1.0.0' });
 
   let response = await fetch('/api/v1/crates/rand/1.0.0/readme');
-  assert.strictEqual(response.status, 403);
-  assert.strictEqual(await response.text(), '');
+  expect(response.status).toBe(403);
+  expect(await response.text()).toBe('');
 });
 
 test('returns the README as raw HTML', async function () {
@@ -32,6 +32,6 @@ test('returns the README as raw HTML', async function () {
   await db.version.create({ crate, num: '1.0.0', readme: readme });
 
   let response = await fetch('/api/v1/crates/rand/1.0.0/readme');
-  assert.strictEqual(response.status, 200);
-  assert.strictEqual(await response.text(), readme);
+  expect(response.status).toBe(200);
+  expect(await response.text()).toBe(readme);
 });
diff --git a/packages/crates-io-msw/handlers/versions/rebuild-docs.test.js b/packages/crates-io-msw/handlers/versions/rebuild-docs.test.js
index c0b1b9095cf..db6fa6fea61 100644
--- a/packages/crates-io-msw/handlers/versions/rebuild-docs.test.js
+++ b/packages/crates-io-msw/handlers/versions/rebuild-docs.test.js
@@ -1,11 +1,11 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('returns 403 if unauthenticated', async function () {
   let response = await fetch('/api/v1/crates/foo/1.0.0/rebuild_docs', { method: 'POST' });
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
@@ -15,8 +15,8 @@ test('returns 404 for unknown crates', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/crates/foo/1.0.0/rebuild_docs', { method: 'POST' });
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('returns 404 for unknown versions', async function () {
@@ -26,8 +26,8 @@ test('returns 404 for unknown versions', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/crates/foo/1.0.0/rebuild_docs', { method: 'POST' });
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('triggers a rebuild for the crate documentation', async function () {
@@ -38,6 +38,6 @@ test('triggers a rebuild for the crate documentation', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/crates/foo/1.0.0/rebuild_docs', { method: 'POST' });
-  assert.strictEqual(response.status, 201);
-  assert.deepEqual(await response.text(), '');
+  expect(response.status).toBe(201);
+  expect(await response.text()).toBe('');
 });
diff --git a/packages/crates-io-msw/handlers/versions/unyank.test.js b/packages/crates-io-msw/handlers/versions/unyank.test.js
index 4bc4dcbfaa7..0db99046b32 100644
--- a/packages/crates-io-msw/handlers/versions/unyank.test.js
+++ b/packages/crates-io-msw/handlers/versions/unyank.test.js
@@ -1,11 +1,11 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('returns 403 if unauthenticated', async function () {
   let response = await fetch('/api/v1/crates/foo/1.0.0/unyank', { method: 'PUT' });
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
@@ -15,8 +15,8 @@ test('returns 404 for unknown crates', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/crates/foo/1.0.0/unyank', { method: 'PUT' });
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('returns 404 for unknown versions', async function () {
@@ -26,24 +26,24 @@ test('returns 404 for unknown versions', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/crates/foo/1.0.0/unyank', { method: 'PUT' });
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('unyanks the version', async function () {
   let crate = await db.crate.create({ name: 'foo' });
   let version = await db.version.create({ crate, num: '1.0.0', yanked: true, yank_message: 'some reason' });
-  assert.strictEqual(version.yanked, true);
-  assert.strictEqual(version.yank_message, 'some reason');
+  expect(version.yanked).toBe(true);
+  expect(version.yank_message).toBe('some reason');
 
   let user = await db.user.create();
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/crates/foo/1.0.0/unyank', { method: 'PUT' });
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), { ok: true });
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({ ok: true });
 
   version = db.version.findFirst(q => q.where({ id: version.id }));
-  assert.strictEqual(version.yanked, false);
-  assert.strictEqual(version.yank_message, null);
+  expect(version.yanked).toBe(false);
+  expect(version.yank_message).toBe(null);
 });
diff --git a/packages/crates-io-msw/handlers/versions/yank.test.js b/packages/crates-io-msw/handlers/versions/yank.test.js
index f4e5bb548b1..9801645b2a6 100644
--- a/packages/crates-io-msw/handlers/versions/yank.test.js
+++ b/packages/crates-io-msw/handlers/versions/yank.test.js
@@ -1,11 +1,11 @@
-import { assert, test } from 'vitest';
+import { expect, test } from 'vitest';
 
 import { db } from '../../index.js';
 
 test('returns 403 if unauthenticated', async function () {
   let response = await fetch('/api/v1/crates/foo/1.0.0/yank', { method: 'DELETE' });
-  assert.strictEqual(response.status, 403);
-  assert.deepEqual(await response.json(), {
+  expect(response.status).toBe(403);
+  expect(await response.json()).toEqual({
     errors: [{ detail: 'must be logged in to perform that action' }],
   });
 });
@@ -15,8 +15,8 @@ test('returns 404 for unknown crates', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/crates/foo/1.0.0/yank', { method: 'DELETE' });
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('returns 404 for unknown versions', async function () {
@@ -26,22 +26,22 @@ test('returns 404 for unknown versions', async function () {
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/crates/foo/1.0.0/yank', { method: 'DELETE' });
-  assert.strictEqual(response.status, 404);
-  assert.deepEqual(await response.json(), { errors: [{ detail: 'Not Found' }] });
+  expect(response.status).toBe(404);
+  expect(await response.json()).toEqual({ errors: [{ detail: 'Not Found' }] });
 });
 
 test('yanks the version', async function () {
   let crate = await db.crate.create({ name: 'foo' });
   let version = await db.version.create({ crate, num: '1.0.0', yanked: false });
-  assert.strictEqual(version.yanked, false);
+  expect(version.yanked).toBe(false);
 
   let user = await db.user.create();
   await db.mswSession.create({ user });
 
   let response = await fetch('/api/v1/crates/foo/1.0.0/yank', { method: 'DELETE' });
-  assert.strictEqual(response.status, 200);
-  assert.deepEqual(await response.json(), { ok: true });
+  expect(response.status).toBe(200);
+  expect(await response.json()).toEqual({ ok: true });
 
   version = db.version.findFirst(q => q.where({ id: version.id }));
-  assert.strictEqual(version.yanked, true);
+  expect(version.yanked).toBe(true);
 });