diff --git a/db/db_test.go b/db/db_test.go
index 9b353e59..cacc2fda 100644
--- a/db/db_test.go
+++ b/db/db_test.go
@@ -26,8 +26,6 @@ func TestGetSetting(t *testing.T) {
 	key := SettingKey(randKey())
 	value := "howdy"
 
-	require := require.New(t)
-
 	testDB, err := NewMock()
 	if err != nil {
 		t.Fatalf("error creating db: %v", err)
@@ -36,16 +34,16 @@ func TestGetSetting(t *testing.T) {
 		t.Fatalf("error migrating db: %v", err)
 	}
 
-	require.NoError(testDB.SetSetting(key, value))
+	require.NoError(t, testDB.SetSetting(key, value))
 
 	actual, err := testDB.GetSetting(key)
-	require.NoError(err)
-	require.Equal(value, actual)
+	require.NoError(t, err)
+	require.Equal(t, value, actual)
 
-	require.NoError(testDB.SetSetting(key, value))
+	require.NoError(t, testDB.SetSetting(key, value))
 	actual, err = testDB.GetSetting(key)
-	require.NoError(err)
-	require.Equal(value, actual)
+	require.NoError(t, err)
+	require.Equal(t, value, actual)
 }
 
 func TestMain(m *testing.M) {
diff --git a/jukebox/jukebox_test.go b/jukebox/jukebox_test.go
index f1c0f01b..77c26a66 100644
--- a/jukebox/jukebox_test.go
+++ b/jukebox/jukebox_test.go
@@ -38,9 +38,8 @@ func TestPlaySkipReset(t *testing.T) {
 
 	t.Parallel()
 	j := newJukebox(t)
-	require := require.New(t)
 
-	require.NoError(j.SetPlaylist([]string{
+	require.NoError(t, j.SetPlaylist([]string{
 		testPath("tr_0.mp3"),
 		testPath("tr_1.mp3"),
 		testPath("tr_2.mp3"),
@@ -49,56 +48,56 @@ func TestPlaySkipReset(t *testing.T) {
 	}))
 
 	status, err := j.GetStatus()
-	require.NoError(err)
-	require.Equal(0, status.CurrentIndex)
-	require.Equal(testPath("tr_0.mp3"), status.CurrentFilename)
-	require.Equal(5, status.Length)
-	require.Equal(true, status.Playing)
+	require.NoError(t, err)
+	require.Equal(t, 0, status.CurrentIndex)
+	require.Equal(t, testPath("tr_0.mp3"), status.CurrentFilename)
+	require.Equal(t, 5, status.Length)
+	require.Equal(t, true, status.Playing)
 
 	items, err := j.GetPlaylist()
-	require.NoError(err)
+	require.NoError(t, err)
 
 	itemsSorted := append([]string(nil), items...)
 	sort.Strings(itemsSorted)
-	require.Equal(itemsSorted, items)
+	require.Equal(t, itemsSorted, items)
 
-	require.NoError(j.Play())
+	require.NoError(t, j.Play())
 
 	status, err = j.GetStatus()
-	require.NoError(err)
-	require.Equal(true, status.Playing)
+	require.NoError(t, err)
+	require.Equal(t, true, status.Playing)
 
-	require.NoError(j.Pause())
+	require.NoError(t, j.Pause())
 
 	status, err = j.GetStatus()
-	require.NoError(err)
-	require.Equal(false, status.Playing)
+	require.NoError(t, err)
+	require.Equal(t, false, status.Playing)
 
-	require.NoError(j.Play())
+	require.NoError(t, j.Play())
 
 	// skip to 2
-	require.NoError(j.SkipToPlaylistIndex(2, 0))
+	require.NoError(t, j.SkipToPlaylistIndex(2, 0))
 
 	status, err = j.GetStatus()
-	require.NoError(err)
-	require.Equal(2, status.CurrentIndex)
-	require.Equal(testPath("tr_2.mp3"), status.CurrentFilename)
-	require.Equal(5, status.Length)
-	require.Equal(true, status.Playing)
+	require.NoError(t, err)
+	require.Equal(t, 2, status.CurrentIndex)
+	require.Equal(t, testPath("tr_2.mp3"), status.CurrentFilename)
+	require.Equal(t, 5, status.Length)
+	require.Equal(t, true, status.Playing)
 
 	// skip to 3
-	require.NoError(j.SkipToPlaylistIndex(3, 0))
+	require.NoError(t, j.SkipToPlaylistIndex(3, 0))
 
 	status, err = j.GetStatus()
-	require.NoError(err)
-	require.Equal(3, status.CurrentIndex)
-	require.Equal(testPath("tr_3.mp3"), status.CurrentFilename)
-	require.Equal(5, status.Length)
-	require.Equal(true, status.Playing)
+	require.NoError(t, err)
+	require.Equal(t, 3, status.CurrentIndex)
+	require.Equal(t, testPath("tr_3.mp3"), status.CurrentFilename)
+	require.Equal(t, 5, status.Length)
+	require.Equal(t, true, status.Playing)
 
 	// just add one more by overwriting the playlist like some clients do
 	// we should keep the current track unchaned if we find it
-	require.NoError(j.SetPlaylist([]string{
+	require.NoError(t, j.SetPlaylist([]string{
 		"testdata/tr_0.mp3",
 		"testdata/tr_1.mp3",
 		"testdata/tr_2.mp3",
@@ -108,24 +107,24 @@ func TestPlaySkipReset(t *testing.T) {
 	}))
 
 	status, err = j.GetStatus()
-	require.NoError(err)
-	require.Equal(3, status.CurrentIndex) // index unchanged
-	require.Equal(testPath("tr_3.mp3"), status.CurrentFilename)
-	require.Equal(6, status.Length) // we added one more track
-	require.Equal(true, status.Playing)
+	require.NoError(t, err)
+	require.Equal(t, 3, status.CurrentIndex) // index unchanged
+	require.Equal(t, testPath("tr_3.mp3"), status.CurrentFilename)
+	require.Equal(t, 6, status.Length) // we added one more track
+	require.Equal(t, true, status.Playing)
 
 	// skip to 3 again
-	require.NoError(j.SkipToPlaylistIndex(3, 0))
+	require.NoError(t, j.SkipToPlaylistIndex(3, 0))
 
 	status, err = j.GetStatus()
-	require.NoError(err)
-	require.Equal(3, status.CurrentIndex)
-	require.Equal(testPath("tr_3.mp3"), status.CurrentFilename)
-	require.Equal(6, status.Length)
-	require.Equal(true, status.Playing)
+	require.NoError(t, err)
+	require.Equal(t, 3, status.CurrentIndex)
+	require.Equal(t, testPath("tr_3.mp3"), status.CurrentFilename)
+	require.Equal(t, 6, status.Length)
+	require.Equal(t, true, status.Playing)
 
 	// remove all but 3
-	require.NoError(j.SetPlaylist([]string{
+	require.NoError(t, j.SetPlaylist([]string{
 		"testdata/tr_0.mp3",
 		"testdata/tr_1.mp3",
 		"testdata/tr_2.mp3",
@@ -133,25 +132,25 @@ func TestPlaySkipReset(t *testing.T) {
 	}))
 
 	status, err = j.GetStatus()
-	require.NoError(err)
-	require.Equal(3, status.CurrentIndex) // index unchanged
-	require.Equal(testPath("tr_3.mp3"), status.CurrentFilename)
-	require.Equal(4, status.Length)
-	require.Equal(true, status.Playing)
+	require.NoError(t, err)
+	require.Equal(t, 3, status.CurrentIndex) // index unchanged
+	require.Equal(t, testPath("tr_3.mp3"), status.CurrentFilename)
+	require.Equal(t, 4, status.Length)
+	require.Equal(t, true, status.Playing)
 
 	// skip to 2 (5s long) in the middle of the track
-	require.NoError(j.SkipToPlaylistIndex(2, 2))
+	require.NoError(t, j.SkipToPlaylistIndex(2, 2))
 
 	status, err = j.GetStatus()
-	require.NoError(err)
-	require.Equal(2, status.CurrentIndex) // index unchanged
-	require.Equal(testPath("tr_2.mp3"), status.CurrentFilename)
-	require.Equal(4, status.Length)
-	require.Equal(true, status.Playing)
-	require.Equal(2, status.Position) // at new position
+	require.NoError(t, err)
+	require.Equal(t, 2, status.CurrentIndex) // index unchanged
+	require.Equal(t, testPath("tr_2.mp3"), status.CurrentFilename)
+	require.Equal(t, 4, status.Length)
+	require.Equal(t, true, status.Playing)
+	require.Equal(t, 2, status.Position) // at new position
 
 	// overwrite completely
-	require.NoError(j.SetPlaylist([]string{
+	require.NoError(t, j.SetPlaylist([]string{
 		"testdata/tr_5.mp3",
 		"testdata/tr_6.mp3",
 		"testdata/tr_7.mp3",
@@ -160,33 +159,32 @@ func TestPlaySkipReset(t *testing.T) {
 	}))
 
 	status, err = j.GetStatus()
-	require.NoError(err)
-	require.Equal(0, status.CurrentIndex) // index unchanged
-	require.Equal(testPath("tr_5.mp3"), status.CurrentFilename)
-	require.Equal(5, status.Length)
-	require.Equal(true, status.Playing)
+	require.NoError(t, err)
+	require.Equal(t, 0, status.CurrentIndex) // index unchanged
+	require.Equal(t, testPath("tr_5.mp3"), status.CurrentFilename)
+	require.Equal(t, 5, status.Length)
+	require.Equal(t, true, status.Playing)
 }
 
 func TestVolume(t *testing.T) {
 	t.Parallel()
 	j := newJukebox(t)
-	require := require.New(t)
 
 	vol, err := j.GetVolumePct()
-	require.NoError(err)
-	require.Equal(100.0, vol)
+	require.NoError(t, err)
+	require.Equal(t, 100.0, vol)
 
-	require.NoError(j.SetVolumePct(69.0))
+	require.NoError(t, j.SetVolumePct(69.0))
 
 	vol, err = j.GetVolumePct()
-	require.NoError(err)
-	require.Equal(69.0, vol)
+	require.NoError(t, err)
+	require.Equal(t, 69.0, vol)
 
-	require.NoError(j.SetVolumePct(0.0))
+	require.NoError(t, j.SetVolumePct(0.0))
 
 	vol, err = j.GetVolumePct()
-	require.NoError(err)
-	require.Equal(0.0, vol)
+	require.NoError(t, err)
+	require.Equal(t, 0.0, vol)
 }
 
 func testPath(path string) string {
diff --git a/playlist/playlist_test.go b/playlist/playlist_test.go
index 1d48dc55..10b62344 100644
--- a/playlist/playlist_test.go
+++ b/playlist/playlist_test.go
@@ -10,20 +10,18 @@ import (
 func TestPlaylist(t *testing.T) {
 	t.Parallel()
 
-	require := require.New(t)
-
 	tmp := t.TempDir()
 	store, err := playlist.NewStore(tmp)
-	require.NoError(err)
+	require.NoError(t, err)
 
 	playlistIDs, err := store.List()
-	require.NoError(err)
-	require.Empty(playlistIDs)
+	require.NoError(t, err)
+	require.Empty(t, playlistIDs)
 
 	for _, playlistID := range playlistIDs {
 		playlist, err := store.Read(playlistID)
-		require.NoError(err)
-		require.NotZero(playlist.UpdatedAt)
+		require.NoError(t, err)
+		require.NotZero(t, playlist.UpdatedAt)
 	}
 
 	before := playlist.Playlist{
@@ -42,18 +40,18 @@ It has multiple lines 👍
 	}
 
 	newPath := playlist.NewPath(before.UserID, before.Name)
-	require.NoError(store.Write(newPath, &before))
+	require.NoError(t, store.Write(newPath, &before))
 
 	after, err := store.Read(newPath)
-	require.NoError(err)
+	require.NoError(t, err)
 
-	require.Equal(after.UserID, before.UserID)
-	require.Equal(after.Name, before.Name)
-	require.Equal(after.Comment, before.Comment)
-	require.Equal(after.Items, before.Items)
-	require.Equal(after.IsPublic, before.IsPublic)
+	require.Equal(t, after.UserID, before.UserID)
+	require.Equal(t, after.Name, before.Name)
+	require.Equal(t, after.Comment, before.Comment)
+	require.Equal(t, after.Items, before.Items)
+	require.Equal(t, after.IsPublic, before.IsPublic)
 
 	playlistIDs, err = store.List()
-	require.NoError(err)
-	require.True(len(playlistIDs) == 1)
+	require.NoError(t, err)
+	require.True(t, len(playlistIDs) == 1)
 }
diff --git a/podcasts/podcasts_test.go b/podcasts/podcasts_test.go
index 40428504..0108b8a4 100644
--- a/podcasts/podcasts_test.go
+++ b/podcasts/podcasts_test.go
@@ -22,7 +22,6 @@ func TestPodcastsAndEpisodesWithSameName(t *testing.T) {
 	t.Skip("requires network access")
 
 	m := mockfs.New(t)
-	require := require.New(t)
 
 	base := t.TempDir()
 	podcasts := New(m.DB(), base, m.TagReader())
@@ -34,33 +33,33 @@ func TestPodcastsAndEpisodesWithSameName(t *testing.T) {
 	}
 
 	podcast, err := podcasts.AddNewPodcast("file://testdata/rss.new", newFeed)
-	require.NoError(err)
+	require.NoError(t, err)
 
-	require.Equal(podcast.RootDir, filepath.Join(base, "InternetBox"))
+	require.Equal(t, podcast.RootDir, filepath.Join(base, "InternetBox"))
 
 	podcast, err = podcasts.AddNewPodcast("file://testdata/rss.new", newFeed)
-	require.NoError(err)
+	require.NoError(t, err)
 
 	// check we made a unique podcast name
-	require.Equal(podcast.RootDir, filepath.Join(base, "InternetBox (1)"))
+	require.Equal(t, podcast.RootDir, filepath.Join(base, "InternetBox (1)"))
 
 	podcastEpisodes, err := podcasts.GetNewestPodcastEpisodes(10)
-	require.NoError(err)
-	require.Greater(len(podcastEpisodes), 0)
+	require.NoError(t, err)
+	require.Greater(t, len(podcastEpisodes), 0)
 
 	var pe []*db.PodcastEpisode
-	require.NoError(m.DB().Order("id").Find(&pe, "podcast_id=? AND title=?", podcast.ID, "Episode 126").Error)
-	require.Len(pe, 2)
+	require.NoError(t, m.DB().Order("id").Find(&pe, "podcast_id=? AND title=?", podcast.ID, "Episode 126").Error)
+	require.Len(t, pe, 2)
 
-	require.NoError(podcasts.DownloadEpisode(pe[0].ID))
-	require.NoError(podcasts.DownloadEpisode(pe[1].ID))
+	require.NoError(t, podcasts.DownloadEpisode(pe[0].ID))
+	require.NoError(t, podcasts.DownloadEpisode(pe[1].ID))
 
-	require.NoError(m.DB().Order("id").Preload("Podcast").Find(&pe, "podcast_id=? AND title=?", podcast.ID, "Episode 126").Error)
-	require.Len(pe, 2)
+	require.NoError(t, m.DB().Order("id").Preload("Podcast").Find(&pe, "podcast_id=? AND title=?", podcast.ID, "Episode 126").Error)
+	require.Len(t, pe, 2)
 
 	// check we made a unique podcast episode names
-	require.Equal("InternetBoxEpisode126.mp3", pe[0].Filename)
-	require.Equal("InternetBoxEpisode126 (1).mp3", pe[1].Filename)
+	require.Equal(t, "InternetBoxEpisode126.mp3", pe[0].Filename)
+	require.Equal(t, "InternetBoxEpisode126 (1).mp3", pe[1].Filename)
 }
 
 func TestGetMoreRecentEpisodes(t *testing.T) {
diff --git a/scanner/scanner_test.go b/scanner/scanner_test.go
index 032dbae3..0f0b1b6b 100644
--- a/scanner/scanner_test.go
+++ b/scanner/scanner_test.go
@@ -12,7 +12,6 @@ import (
 	"github.com/jinzhu/gorm"
 	_ "github.com/jinzhu/gorm/dialects/sqlite"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 
 	"go.senan.xyz/gonic/db"
 	"go.senan.xyz/gonic/mockfs"
@@ -26,72 +25,68 @@ func TestMain(m *testing.M) {
 
 func TestTableCounts(t *testing.T) {
 	t.Parallel()
-	assert := assert.New(t)
 	m := mockfs.New(t)
 
 	m.AddItems()
 	m.ScanAndClean()
 
 	var tracks int
-	assert.NoError(m.DB().Model(&db.Track{}).Count(&tracks).Error) // not all tracks
-	assert.Equal(tracks, m.NumTracks())
+	assert.NoError(t, m.DB().Model(&db.Track{}).Count(&tracks).Error) // not all tracks
+	assert.Equal(t, tracks, m.NumTracks())
 
 	var albums int
-	assert.NoError(m.DB().Model(&db.Album{}).Count(&albums).Error) // not all albums
-	assert.Equal(albums, 13)                                       // not all albums
+	assert.NoError(t, m.DB().Model(&db.Album{}).Count(&albums).Error) // not all albums
+	assert.Equal(t, albums, 13)                                       // not all albums
 
 	var artists int
-	assert.NoError(m.DB().Model(&db.Artist{}).Count(&artists).Error) // not all artists
-	assert.Equal(artists, 3)                                         // not all artists
+	assert.NoError(t, m.DB().Model(&db.Artist{}).Count(&artists).Error) // not all artists
+	assert.Equal(t, artists, 3)                                         // not all artists
 }
 
 func TestWithExcludePattern(t *testing.T) {
 	t.Parallel()
-	assert := assert.New(t)
 	m := mockfs.NewWithExcludePattern(t, "\\/artist-1\\/|track-0.flac$")
 
 	m.AddItems()
 	m.ScanAndClean()
 
 	var tracks int
-	assert.NoError(m.DB().Model(&db.Track{}).Count(&tracks).Error) // not all tracks
-	assert.Equal(tracks, 12)
+	assert.NoError(t, m.DB().Model(&db.Track{}).Count(&tracks).Error) // not all tracks
+	assert.Equal(t, tracks, 12)
 
 	var albums int
-	assert.NoError(m.DB().Model(&db.Album{}).Count(&albums).Error) // not all albums
-	assert.Equal(albums, 10)                                       // not all albums
+	assert.NoError(t, m.DB().Model(&db.Album{}).Count(&albums).Error) // not all albums
+	assert.Equal(t, albums, 10)                                       // not all albums
 
 	var artists int
-	assert.NoError(m.DB().Model(&db.Artist{}).Count(&artists).Error) // not all artists
-	assert.Equal(artists, 2)                                         // not all artists
+	assert.NoError(t, m.DB().Model(&db.Artist{}).Count(&artists).Error) // not all artists
+	assert.Equal(t, artists, 2)                                         // not all artists
 }
 
 func TestParentID(t *testing.T) {
 	t.Parallel()
-	require := require.New(t)
 	m := mockfs.New(t)
 
 	m.AddItems()
 	m.ScanAndClean()
 
 	var nullParentAlbums []*db.Album
-	require.NoError(m.DB().Where("parent_id IS NULL").Find(&nullParentAlbums).Error) // one parent_id=NULL which is root folder
-	require.Equal(1, len(nullParentAlbums))                                          // one parent_id=NULL which is root folder
-	require.Equal("", nullParentAlbums[0].LeftPath)
-	require.Equal(".", nullParentAlbums[0].RightPath)
+	assert.NoError(t, m.DB().Where("parent_id IS NULL").Find(&nullParentAlbums).Error) // one parent_id=NULL which is root folder
+	assert.Equal(t, 1, len(nullParentAlbums))                                          // one parent_id=NULL which is root folder
+	assert.Equal(t, "", nullParentAlbums[0].LeftPath)
+	assert.Equal(t, ".", nullParentAlbums[0].RightPath)
 
-	require.Equal(gorm.ErrRecordNotFound, m.DB().Where("id=parent_id").Find(&db.Album{}).Error) // no self-referencing albums
+	assert.Equal(t, gorm.ErrRecordNotFound, m.DB().Where("id=parent_id").Find(&db.Album{}).Error) // no self-referencing albums
 
 	var album db.Album
 	var parent db.Album
-	require.NoError(m.DB().Find(&album, "left_path=? AND right_path=?", "artist-0/", "album-0").Error) // album has parent ID
-	require.NoError(m.DB().Find(&parent, "right_path=?", "artist-0").Error)                            // album has parent ID
-	require.Equal(parent.ID, album.ParentID)                                                           // album has parent ID
+	assert.NoError(t, m.DB().Find(&album, "left_path=? AND right_path=?", "artist-0/", "album-0").Error) // album has parent ID
+	assert.NoError(t, m.DB().Find(&parent, "right_path=?", "artist-0").Error)                            // album has parent ID
+	assert.Equal(t, parent.ID, album.ParentID)                                                           // album has parent ID
 }
 
 func TestUpdatedCover(t *testing.T) {
 	t.Parallel()
-	assert := assert.New(t)
 	m := mockfs.New(t)
 
 	m.AddItems()
@@ -100,13 +95,12 @@ func TestUpdatedCover(t *testing.T) {
 	m.ScanAndClean()
 
 	var album db.Album
-	assert.NoError(m.DB().Where("left_path=? AND right_path=?", "artist-0/", "album-0").Find(&album).Error) // album has cover
-	assert.Equal(album.Cover, "cover.jpg")                                                                  // album has cover
+	assert.NoError(t, m.DB().Where("left_path=? AND right_path=?", "artist-0/", "album-0").Find(&album).Error) // album has cover
+	assert.Equal(t, album.Cover, "cover.jpg")                                                                  // album has cover
 }
 
 func TestCoverBeforeTracks(t *testing.T) {
 	t.Parallel()
-	require := require.New(t)
 	m := mockfs.New(t)
 
 	m.AddCover("artist-2/album-2/cover.jpg")
@@ -115,21 +109,20 @@ func TestCoverBeforeTracks(t *testing.T) {
 	m.ScanAndClean()
 
 	var album db.Album
-	require.NoError(m.DB().Where("left_path=? AND right_path=?", "artist-2/", "album-2").Find(&album).Error) // album has cover
-	require.Equal("cover.jpg", album.Cover)                                                                  // album has cover
+	assert.NoError(t, m.DB().Where("left_path=? AND right_path=?", "artist-2/", "album-2").Find(&album).Error) // album has cover
+	assert.Equal(t, "cover.jpg", album.Cover)                                                                  // album has cover
 
 	var albumArtist db.Artist
-	require.NoError(m.DB().Joins("JOIN album_artists ON album_artists.artist_id=artists.id").Where("album_artists.album_id=?", album.ID).Find(&albumArtist).Error) // album has cover
-	require.Equal("artist-2", albumArtist.Name)                                                                                                                    // album artist
+	assert.NoError(t, m.DB().Joins("JOIN album_artists ON album_artists.artist_id=artists.id").Where("album_artists.album_id=?", album.ID).Find(&albumArtist).Error) // album has cover
+	assert.Equal(t, "artist-2", albumArtist.Name)                                                                                                                    // album artist
 
 	var tracks []*db.Track
-	require.NoError(m.DB().Where("album_id=?", album.ID).Find(&tracks).Error) // album has tracks
-	require.Equal(3, len(tracks))                                             // album has tracks
+	assert.NoError(t, m.DB().Where("album_id=?", album.ID).Find(&tracks).Error) // album has tracks
+	assert.Equal(t, 3, len(tracks))                                             // album has tracks
 }
 
 func TestUpdatedTags(t *testing.T) {
 	t.Parallel()
-	require := require.New(t)
 	m := mockfs.New(t)
 
 	m.AddTrack("artist-10/album-10/track-10.flac")
@@ -144,14 +137,14 @@ func TestUpdatedTags(t *testing.T) {
 	m.ScanAndClean()
 
 	var track db.Track
-	require.NoError(m.DB().Preload("Album").Where("filename=?", "track-10.flac").Find(&track).Error) // track has tags
-	require.Equal("artist", track.TagTrackArtist)                                                    // track has tags
-	require.Equal("album", track.Album.TagTitle)                                                     // track has tags
-	require.Equal("title", track.TagTitle)                                                           // track has tags
+	assert.NoError(t, m.DB().Preload("Album").Where("filename=?", "track-10.flac").Find(&track).Error) // track has tags
+	assert.Equal(t, "artist", track.TagTrackArtist)                                                    // track has tags
+	assert.Equal(t, "album", track.Album.TagTitle)                                                     // track has tags
+	assert.Equal(t, "title", track.TagTitle)                                                           // track has tags
 
 	var trackArtistA db.Artist
-	require.NoError(m.DB().Joins("JOIN album_artists ON album_artists.artist_id=artists.id").Where("album_artists.album_id=?", track.AlbumID).Limit(1).Find(&trackArtistA).Error) // updated has tags
-	require.Equal("album-artist", trackArtistA.Name)                                                                                                                              // track has tags
+	assert.NoError(t, m.DB().Joins("JOIN album_artists ON album_artists.artist_id=artists.id").Where("album_artists.album_id=?", track.AlbumID).Limit(1).Find(&trackArtistA).Error) // updated has tags
+	assert.Equal(t, "album-artist", trackArtistA.Name)                                                                                                                              // track has tags
 
 	m.SetTags("artist-10/album-10/track-10.flac", func(tags *mockfs.Tags) error {
 		tags.RawArtist = "artist-upd"
@@ -164,21 +157,20 @@ func TestUpdatedTags(t *testing.T) {
 	m.ScanAndClean()
 
 	var updated db.Track
-	require.NoError(m.DB().Preload("Album").Where("filename=?", "track-10.flac").Find(&updated).Error) // updated has tags
-	require.Equal(track.ID, updated.ID)                                                                // updated has tags
-	require.Equal("artist-upd", updated.TagTrackArtist)                                                // updated has tags
-	require.Equal("album-upd", updated.Album.TagTitle)                                                 // updated has tags
-	require.Equal("title-upd", updated.TagTitle)                                                       // updated has tags
+	assert.NoError(t, m.DB().Preload("Album").Where("filename=?", "track-10.flac").Find(&updated).Error) // updated has tags
+	assert.Equal(t, track.ID, updated.ID)                                                                // updated has tags
+	assert.Equal(t, "artist-upd", updated.TagTrackArtist)                                                // updated has tags
+	assert.Equal(t, "album-upd", updated.Album.TagTitle)                                                 // updated has tags
+	assert.Equal(t, "title-upd", updated.TagTitle)                                                       // updated has tags
 
 	var trackArtistB db.Artist
-	require.NoError(m.DB().Joins("JOIN album_artists ON album_artists.artist_id=artists.id").Where("album_artists.album_id=?", track.AlbumID).Limit(1).Find(&trackArtistB).Error) // updated has tags
-	require.Equal("album-artist-upd", trackArtistB.Name)                                                                                                                          // updated has tags
+	assert.NoError(t, m.DB().Joins("JOIN album_artists ON album_artists.artist_id=artists.id").Where("album_artists.album_id=?", track.AlbumID).Limit(1).Find(&trackArtistB).Error) // updated has tags
+	assert.Equal(t, "album-artist-upd", trackArtistB.Name)                                                                                                                          // updated has tags
 }
 
 // https://github.com/sentriz/gonic/issues/225
 func TestUpdatedAlbumGenre(t *testing.T) {
 	t.Parallel()
-	require := require.New(t)
 	m := mockfs.New(t)
 
 	m.AddItems()
@@ -190,8 +182,8 @@ func TestUpdatedAlbumGenre(t *testing.T) {
 	m.ScanAndClean()
 
 	var album db.Album
-	require.NoError(m.DB().Preload("Genres").Where("left_path=? AND right_path=?", "artist-0/", "album-0").Find(&album).Error)
-	require.Equal([]string{"gen-a", "gen-b"}, album.GenreStrings())
+	assert.NoError(t, m.DB().Preload("Genres").Where("left_path=? AND right_path=?", "artist-0/", "album-0").Find(&album).Error)
+	assert.Equal(t, []string{"gen-a", "gen-b"}, album.GenreStrings())
 
 	m.SetTags("artist-0/album-0/track-0.flac", func(tags *mockfs.Tags) error {
 		tags.RawGenre = "gen-a-upd;gen-b-upd"
@@ -201,46 +193,43 @@ func TestUpdatedAlbumGenre(t *testing.T) {
 	m.ScanAndClean()
 
 	var updated db.Album
-	require.NoError(m.DB().Preload("Genres").Where("left_path=? AND right_path=?", "artist-0/", "album-0").Find(&updated).Error)
-	require.Equal([]string{"gen-a-upd", "gen-b-upd"}, updated.GenreStrings())
+	assert.NoError(t, m.DB().Preload("Genres").Where("left_path=? AND right_path=?", "artist-0/", "album-0").Find(&updated).Error)
+	assert.Equal(t, []string{"gen-a-upd", "gen-b-upd"}, updated.GenreStrings())
 }
 
 func TestDeleteAlbum(t *testing.T) {
 	t.Parallel()
-	assert := assert.New(t)
 	m := mockfs.New(t)
 
 	m.AddItems()
 	m.ScanAndClean()
 
-	assert.NoError(m.DB().Where("left_path=? AND right_path=?", "artist-2/", "album-2").Find(&db.Album{}).Error) // album exists
+	assert.NoError(t, m.DB().Where("left_path=? AND right_path=?", "artist-2/", "album-2").Find(&db.Album{}).Error) // album exists
 
 	m.RemoveAll("artist-2/album-2")
 	m.ScanAndClean()
 
-	assert.Equal(m.DB().Where("left_path=? AND right_path=?", "artist-2/", "album-2").Find(&db.Album{}).Error, gorm.ErrRecordNotFound) // album doesn't exist
+	assert.Equal(t, m.DB().Where("left_path=? AND right_path=?", "artist-2/", "album-2").Find(&db.Album{}).Error, gorm.ErrRecordNotFound) // album doesn't exist
 }
 
 func TestDeleteArtist(t *testing.T) {
 	t.Parallel()
-	assert := assert.New(t)
 	m := mockfs.New(t)
 
 	m.AddItems()
 	m.ScanAndClean()
 
-	assert.NoError(m.DB().Where("left_path=? AND right_path=?", "artist-2/", "album-2").Find(&db.Album{}).Error) // album exists
+	assert.NoError(t, m.DB().Where("left_path=? AND right_path=?", "artist-2/", "album-2").Find(&db.Album{}).Error) // album exists
 
 	m.RemoveAll("artist-2")
 	m.ScanAndClean()
 
-	assert.Equal(m.DB().Where("left_path=? AND right_path=?", "artist-2/", "album-2").Find(&db.Album{}).Error, gorm.ErrRecordNotFound) // album doesn't exist
-	assert.Equal(m.DB().Where("name=?", "artist-2").Find(&db.Artist{}).Error, gorm.ErrRecordNotFound)                                  // artist doesn't exist
+	assert.Equal(t, m.DB().Where("left_path=? AND right_path=?", "artist-2/", "album-2").Find(&db.Album{}).Error, gorm.ErrRecordNotFound) // album doesn't exist
+	assert.Equal(t, m.DB().Where("name=?", "artist-2").Find(&db.Artist{}).Error, gorm.ErrRecordNotFound)                                  // artist doesn't exist
 }
 
 func TestGenres(t *testing.T) {
 	t.Parallel()
-	assert := assert.New(t)
 	m := mockfs.New(t)
 
 	albumGenre := func(artist, album, genre string) error {
@@ -252,10 +241,10 @@ func TestGenres(t *testing.T) {
 			Error
 	}
 	isAlbumGenre := func(artist, album, genreName string) {
-		assert.NoError(albumGenre(artist, album, genreName))
+		assert.NoError(t, albumGenre(artist, album, genreName))
 	}
 	isAlbumGenreMissing := func(artist, album, genreName string) {
-		assert.Equal(albumGenre(artist, album, genreName), gorm.ErrRecordNotFound)
+		assert.Equal(t, albumGenre(artist, album, genreName), gorm.ErrRecordNotFound)
 	}
 
 	trackGenre := func(artist, album, filename, genreName string) error {
@@ -268,20 +257,20 @@ func TestGenres(t *testing.T) {
 			Error
 	}
 	isTrackGenre := func(artist, album, filename, genreName string) {
-		assert.NoError(trackGenre(artist, album, filename, genreName))
+		assert.NoError(t, trackGenre(artist, album, filename, genreName))
 	}
 	isTrackGenreMissing := func(artist, album, filename, genreName string) {
-		assert.Equal(trackGenre(artist, album, filename, genreName), gorm.ErrRecordNotFound)
+		assert.Equal(t, trackGenre(artist, album, filename, genreName), gorm.ErrRecordNotFound)
 	}
 
 	genre := func(genre string) error {
 		return m.DB().Where("name=?", genre).Find(&db.Genre{}).Error
 	}
 	isGenre := func(genreName string) {
-		assert.NoError(genre(genreName))
+		assert.NoError(t, genre(genreName))
 	}
 	isGenreMissing := func(genreName string) {
-		assert.Equal(genre(genreName), gorm.ErrRecordNotFound)
+		assert.Equal(t, genre(genreName), gorm.ErrRecordNotFound)
 	}
 
 	m.AddItems()
@@ -325,7 +314,6 @@ func TestGenres(t *testing.T) {
 
 func TestMultiFolders(t *testing.T) {
 	t.Parallel()
-	require := require.New(t)
 	m := mockfs.NewWithDirs(t, []string{"m-1", "m-2", "m-3"})
 
 	m.AddItemsPrefix("m-1")
@@ -334,13 +322,13 @@ func TestMultiFolders(t *testing.T) {
 	m.ScanAndClean()
 
 	var rootDirs []*db.Album
-	require.NoError(m.DB().Where("parent_id IS NULL").Find(&rootDirs).Error)
-	require.Equal(3, len(rootDirs))
+	assert.NoError(t, m.DB().Where("parent_id IS NULL").Find(&rootDirs).Error)
+	assert.Equal(t, 3, len(rootDirs))
 	for i, r := range rootDirs {
-		require.Equal(filepath.Join(m.TmpDir(), fmt.Sprintf("m-%d", i+1)), r.RootDir)
-		require.Equal(0, r.ParentID)
-		require.Equal("", r.LeftPath)
-		require.Equal(".", r.RightPath)
+		assert.Equal(t, filepath.Join(m.TmpDir(), fmt.Sprintf("m-%d", i+1)), r.RootDir)
+		assert.Equal(t, 0, r.ParentID)
+		assert.Equal(t, "", r.LeftPath)
+		assert.Equal(t, ".", r.RightPath)
 	}
 
 	m.AddCover("m-3/artist-0/album-0/cover.jpg")
@@ -348,7 +336,7 @@ func TestMultiFolders(t *testing.T) {
 	m.LogItems()
 
 	checkCover := func(root string, q string) {
-		require.NoError(m.DB().Where(q, filepath.Join(m.TmpDir(), root)).Find(&db.Album{}).Error)
+		assert.NoError(t, m.DB().Where(q, filepath.Join(m.TmpDir(), root)).Find(&db.Album{}).Error)
 	}
 
 	checkCover("m-1", "root_dir=? AND cover IS NULL")     // mf 1 no cover
@@ -358,7 +346,6 @@ func TestMultiFolders(t *testing.T) {
 
 func TestNewAlbumForExistingArtist(t *testing.T) {
 	t.Parallel()
-	require := require.New(t)
 	m := mockfs.New(t)
 
 	m.AddItems()
@@ -368,8 +355,8 @@ func TestNewAlbumForExistingArtist(t *testing.T) {
 	m.LogArtists()
 
 	var artist db.Artist
-	require.NoError(m.DB().Where("name=?", "artist-2").Find(&artist).Error) // find orig artist
-	require.Greater(artist.ID, 0)
+	assert.NoError(t, m.DB().Where("name=?", "artist-2").Find(&artist).Error) // find orig artist
+	assert.Greater(t, artist.ID, 0)
 
 	for tr := 0; tr < 3; tr++ {
 		m.AddTrack(fmt.Sprintf("artist-2/new-album/track-%d.mp3", tr))
@@ -383,17 +370,16 @@ func TestNewAlbumForExistingArtist(t *testing.T) {
 	}
 
 	var updated db.Artist
-	require.NoError(m.DB().Where("name=?", "artist-2").Find(&updated).Error) // find updated artist
-	require.Equal(updated.ID, artist.ID)                                     // find updated artist
+	assert.NoError(t, m.DB().Where("name=?", "artist-2").Find(&updated).Error) // find updated artist
+	assert.Equal(t, updated.ID, artist.ID)                                     // find updated artist
 
 	var all []*db.Artist
-	require.NoError(m.DB().Find(&all).Error) // still only 3?
-	require.Equal(3, len(all))               // still only 3?
+	assert.NoError(t, m.DB().Find(&all).Error) // still only 3?
+	assert.Equal(t, 3, len(all))               // still only 3?
 }
 
 func TestMultiFolderWithSharedArtist(t *testing.T) {
 	t.Parallel()
-	require := require.New(t)
 	m := mockfs.NewWithDirs(t, []string{"m-0", "m-1"})
 
 	const artistName = "artist-a"
@@ -419,29 +405,29 @@ func TestMultiFolderWithSharedArtist(t *testing.T) {
 	m.ScanAndClean()
 
 	var artist db.Artist
-	require.NoError(m.DB().Where("name=?", artistName).First(&artist).Error)
-	require.Equal(artistName, artist.Name)
+	assert.NoError(t, m.DB().Where("name=?", artistName).First(&artist).Error)
+	assert.Equal(t, artistName, artist.Name)
 
 	var artistAlbums []*db.Album
-	require.NoError(m.DB().
+	assert.NoError(t, m.DB().
 		Select("*, count(sub.id) child_count, sum(sub.length) duration").
 		Joins("JOIN album_artists ON album_artists.album_id=albums.id").
 		Joins("LEFT JOIN tracks sub ON albums.id=sub.album_id").
 		Where("album_artists.artist_id=?", artist.ID).
 		Group("albums.id").
 		Find(&artistAlbums).Error)
-	require.Equal(2, len(artistAlbums))
+
+	assert.Equal(t, 2, len(artistAlbums))
 
 	for _, album := range artistAlbums {
-		require.Greater(album.TagYear, 0)
-		require.Greater(album.ChildCount, 0)
-		require.Greater(album.Duration, 0)
+		assert.Greater(t, album.TagYear, 0)
+		assert.Greater(t, album.ChildCount, 0)
+		assert.Greater(t, album.Duration, 0)
 	}
 }
 
 func TestSymlinkedAlbum(t *testing.T) {
 	t.Parallel()
-	require := require.New(t)
 	m := mockfs.NewWithDirs(t, []string{"scan"})
 
 	m.AddItemsPrefixWithCovers("temp")
@@ -455,20 +441,19 @@ func TestSymlinkedAlbum(t *testing.T) {
 	m.LogAlbums()
 
 	var track db.Track
-	require.NoError(m.DB().Preload("Album.Parent").Find(&track).Error) // track exists
-	require.NotNil(track.Album)                                        // track has album
-	require.NotZero(track.Album.Cover)                                 // album has cover
-	require.Equal("artist-sym", track.Album.Parent.RightPath)          // artist is sym
+	assert.NoError(t, m.DB().Preload("Album.Parent").Find(&track).Error) // track exists
+	assert.NotNil(t, track.Album)                                        // track has album
+	assert.NotZero(t, track.Album.Cover)                                 // album has cover
+	assert.Equal(t, "artist-sym", track.Album.Parent.RightPath)          // artist is sym
 
 	info, err := os.Stat(track.AbsPath())
-	require.NoError(err)            // track resolves
-	require.False(info.IsDir())     // track resolves
-	require.NotZero(info.ModTime()) // track resolves
+	assert.NoError(t, err)            // track resolves
+	assert.False(t, info.IsDir())     // track resolves
+	assert.NotZero(t, info.ModTime()) // track resolves
 }
 
 func TestSymlinkedSubdiscs(t *testing.T) {
 	t.Parallel()
-	require := require.New(t)
 	m := mockfs.NewWithDirs(t, []string{"scan"})
 
 	addItem := func(prefix, artist, album, disc, track string) {
@@ -499,19 +484,18 @@ func TestSymlinkedSubdiscs(t *testing.T) {
 	m.LogAlbums()
 
 	var track db.Track
-	require.NoError(m.DB().Preload("Album.Parent").Find(&track).Error) // track exists
-	require.NotNil(track.Album)                                        // track has album
-	require.Equal("album-sym", track.Album.Parent.RightPath)           // artist is sym
+	assert.NoError(t, m.DB().Preload("Album.Parent").Find(&track).Error) // track exists
+	assert.NotNil(t, track.Album)                                        // track has album
+	assert.Equal(t, "album-sym", track.Album.Parent.RightPath)           // artist is sym
 
 	info, err := os.Stat(track.AbsPath())
-	require.NoError(err)            // track resolves
-	require.False(info.IsDir())     // track resolves
-	require.NotZero(info.ModTime()) // track resolves
+	assert.NoError(t, err)            // track resolves
+	assert.False(t, info.IsDir())     // track resolves
+	assert.NotZero(t, info.ModTime()) // track resolves
 }
 
 func TestTagErrors(t *testing.T) {
 	t.Parallel()
-	require := require.New(t)
 	m := mockfs.New(t)
 
 	m.AddItemsWithCovers()
@@ -524,26 +508,25 @@ func TestTagErrors(t *testing.T) {
 
 	ctx, err := m.ScanAndCleanErr()
 	errs, ok := err.(interface{ Unwrap() []error })
-	require.True(ok)
+	assert.True(t, ok)
 
-	require.ErrorAs(err, &errs)
-	require.Equal(2, len(errs.Unwrap()))                    // we have 2 dir errors
-	require.Equal(m.NumTracks()-(3*2), ctx.SeenTracks())    // we saw all tracks bar 2 album contents
-	require.Equal(m.NumTracks()-(3*2), ctx.SeenTracksNew()) // we have all tracks bar 2 album contents
+	assert.ErrorAs(t, err, &errs)
+	assert.Equal(t, 2, len(errs.Unwrap()))                    // we have 2 dir errors
+	assert.Equal(t, m.NumTracks()-(3*2), ctx.SeenTracks())    // we saw all tracks bar 2 album contents
+	assert.Equal(t, m.NumTracks()-(3*2), ctx.SeenTracksNew()) // we have all tracks bar 2 album contents
 
 	ctx, err = m.ScanAndCleanErr()
 	errs, ok = err.(interface{ Unwrap() []error })
-	require.True(ok)
+	assert.True(t, ok)
 
-	require.Equal(2, len(errs.Unwrap()))                 // we have 2 dir errors
-	require.Equal(m.NumTracks()-(3*2), ctx.SeenTracks()) // we saw all tracks bar 2 album contents
-	require.Equal(0, ctx.SeenTracksNew())                // we have no new tracks
+	assert.Equal(t, 2, len(errs.Unwrap()))                 // we have 2 dir errors
+	assert.Equal(t, m.NumTracks()-(3*2), ctx.SeenTracks()) // we saw all tracks bar 2 album contents
+	assert.Equal(t, 0, ctx.SeenTracksNew())                // we have no new tracks
 }
 
 // https://github.com/sentriz/gonic/issues/185#issuecomment-1050092128
 func TestCompilationAlbumWithoutAlbumArtist(t *testing.T) {
 	t.Parallel()
-	require := require.New(t)
 	m := mockfs.New(t)
 
 	const pathArtist = "various-artists"
@@ -566,43 +549,41 @@ func TestCompilationAlbumWithoutAlbumArtist(t *testing.T) {
 	m.ScanAndClean()
 
 	var trackCount int
-	require.NoError(m.DB().Model(&db.Track{}).Count(&trackCount).Error)
-	require.Equal(5, trackCount)
+	assert.NoError(t, m.DB().Model(&db.Track{}).Count(&trackCount).Error)
+	assert.Equal(t, 5, trackCount)
 
 	var artists []*db.Artist
-	require.NoError(m.DB().Find(&artists).Error)
-	require.Equal(1, len(artists))             // we only have one album artist
-	require.Equal("artist 0", artists[0].Name) // it came from the first track's fallback to artist tag
+	assert.NoError(t, m.DB().Find(&artists).Error)
+	assert.Equal(t, 1, len(artists))             // we only have one album artist
+	assert.Equal(t, "artist 0", artists[0].Name) // it came from the first track's fallback to artist tag
 
 	var artistAlbums []*db.Album
-	require.NoError(m.DB().Joins("JOIN album_artists ON album_artists.album_id=albums.id").Where("album_artists.artist_id=?", artists[0].ID).Find(&artistAlbums).Error)
-	require.Equal(1, len(artistAlbums)) // the artist has one album
-	require.Equal(pathAlbum, artistAlbums[0].RightPath)
-	require.Equal(pathArtist+"/", artistAlbums[0].LeftPath)
+	assert.NoError(t, m.DB().Joins("JOIN album_artists ON album_artists.album_id=albums.id").Where("album_artists.artist_id=?", artists[0].ID).Find(&artistAlbums).Error)
+	assert.Equal(t, 1, len(artistAlbums)) // the artist has one album
+	assert.Equal(t, pathAlbum, artistAlbums[0].RightPath)
+	assert.Equal(t, pathArtist+"/", artistAlbums[0].LeftPath)
 }
 
 func TestIncrementalScanNoChangeNoUpdatedAt(t *testing.T) {
 	t.Parallel()
-	require := require.New(t)
 	m := mockfs.New(t)
 
 	m.AddItems()
 
 	m.ScanAndClean()
 	var albumA db.Album
-	require.NoError(m.DB().Joins("JOIN album_artists ON album_artists.album_id=albums.id").Order("updated_at DESC").Find(&albumA).Error)
+	assert.NoError(t, m.DB().Joins("JOIN album_artists ON album_artists.album_id=albums.id").Order("updated_at DESC").Find(&albumA).Error)
 
 	m.ScanAndClean()
 	var albumB db.Album
-	require.NoError(m.DB().Joins("JOIN album_artists ON album_artists.album_id=albums.id").Order("updated_at DESC").Find(&albumB).Error)
+	assert.NoError(t, m.DB().Joins("JOIN album_artists ON album_artists.album_id=albums.id").Order("updated_at DESC").Find(&albumB).Error)
 
-	require.Equal(albumB.UpdatedAt, albumA.UpdatedAt)
+	assert.Equal(t, albumB.UpdatedAt, albumA.UpdatedAt)
 }
 
 // https://github.com/sentriz/gonic/issues/230
 func TestAlbumAndArtistSameNameWeirdness(t *testing.T) {
 	t.Parallel()
-	assert := assert.New(t)
 	m := mockfs.New(t)
 
 	const name = "same"
@@ -620,13 +601,12 @@ func TestAlbumAndArtistSameNameWeirdness(t *testing.T) {
 	m.ScanAndClean()
 
 	var albums []*db.Album
-	assert.NoError(m.DB().Find(&albums).Error)
-	assert.Equal(len(albums), 5) // root, 2 artists, 2 albums
+	assert.NoError(t, m.DB().Find(&albums).Error)
+	assert.Equal(t, len(albums), 5) // root, 2 artists, 2 albums
 }
 
 func TestNoOrphanedGenres(t *testing.T) {
 	t.Parallel()
-	require := assert.New(t)
 	m := mockfs.New(t)
 
 	m.AddItems()
@@ -642,13 +622,12 @@ func TestNoOrphanedGenres(t *testing.T) {
 	m.ScanAndClean()
 
 	var genreCount int
-	require.NoError(m.DB().Model(&db.Genre{}).Count(&genreCount).Error)
-	require.Equal(0, genreCount)
+	assert.NoError(t, m.DB().Model(&db.Genre{}).Count(&genreCount).Error)
+	assert.Equal(t, 0, genreCount)
 }
 
 func TestMultiArtistSupport(t *testing.T) {
 	t.Parallel()
-	require := assert.New(t)
 	m := mockfs.New(t)
 
 	m.AddItemsGlob("artist-0/album-[012]/track-0.*")
@@ -671,17 +650,17 @@ func TestMultiArtistSupport(t *testing.T) {
 	m.ScanAndClean()
 
 	var artists []*db.Artist
-	require.NoError(m.DB().Find(&artists).Error)
-	require.Len(artists, 3) // alan, liz, mercury
+	assert.NoError(t, m.DB().Find(&artists).Error)
+	assert.Len(t, artists, 3) // alan, liz, mercury
 
 	var albumArtists []*db.AlbumArtist
-	require.NoError(m.DB().Find(&albumArtists).Error)
-	require.Len(albumArtists, 5)
+	assert.NoError(t, m.DB().Find(&albumArtists).Error)
+	assert.Len(t, albumArtists, 5)
 
 	type row struct{ Artist, Albums string }
 	state := func() []row {
 		var table []row
-		require.NoError(m.DB().
+		assert.NoError(t, m.DB().
 			Select("artists.name artist, group_concat(albums.tag_title, ';') albums").
 			Model(db.Artist{}).
 			Joins("JOIN album_artists ON album_artists.artist_id=artists.id").
@@ -690,17 +669,17 @@ func TestMultiArtistSupport(t *testing.T) {
 			Group("artists.id").
 			Scan(&table).
 			Error)
+
 		return table
 	}
 
-	require.Equal(
+	assert.Equal(t,
 		[]row{
 			{"Alan Vega", "Mutator;Dead Man"},
 			{"Liz Lamere", "Mutator"},
 			{"Mercury Rev", "Dead Man;Yerself Is Steam"},
 		},
-		state(),
-	)
+		state())
 
 	m.RemoveAll("artist-0/album-2")
 	m.SetTags("artist-0/album-1/track-0.flac", func(tags *mockfs.Tags) error {
@@ -711,24 +690,22 @@ func TestMultiArtistSupport(t *testing.T) {
 
 	m.ScanAndClean()
 
-	require.NoError(m.DB().Find(&artists).Error)
-	require.Len(artists, 2) // alan, liz
+	assert.NoError(t, m.DB().Find(&artists).Error)
+	assert.Len(t, artists, 2) // alan, liz
 
-	require.NoError(m.DB().Find(&albumArtists).Error)
-	require.Len(albumArtists, 3)
+	assert.NoError(t, m.DB().Find(&albumArtists).Error)
+	assert.Len(t, albumArtists, 3)
 
-	require.Equal(
+	assert.Equal(t,
 		[]row{
 			{"Alan Vega", "Mutator;Dead Man"},
 			{"Liz Lamere", "Mutator"},
 		},
-		state(),
-	)
+		state())
 }
 
 func TestMultiArtistPreload(t *testing.T) {
 	t.Parallel()
-	require := assert.New(t)
 	m := mockfs.New(t)
 
 	m.AddItemsGlob("artist-0/album-[012]/track-0.*")
@@ -751,32 +728,32 @@ func TestMultiArtistPreload(t *testing.T) {
 	m.ScanAndClean()
 
 	var albums []*db.Album
-	require.NoError(m.DB().Preload("Artists").Find(&albums).Error)
-	require.GreaterOrEqual(len(albums), 3)
+	assert.NoError(t, m.DB().Preload("Artists").Find(&albums).Error)
+	assert.GreaterOrEqual(t, len(albums), 3)
 
 	for _, album := range albums {
 		switch album.TagTitle {
 		case "Mutator":
-			require.Len(album.Artists, 2)
+			assert.Len(t, album.Artists, 2)
 		case "Dead Man":
-			require.Len(album.Artists, 2)
+			assert.Len(t, album.Artists, 2)
 		case "Yerself Is Steam":
-			require.Len(album.Artists, 1)
+			assert.Len(t, album.Artists, 1)
 		}
 	}
 
 	var artists []*db.Artist
-	require.NoError(m.DB().Preload("Albums").Find(&artists).Error)
-	require.Equal(3, len(artists))
+	assert.NoError(t, m.DB().Preload("Albums").Find(&artists).Error)
+	assert.Equal(t, 3, len(artists))
 
 	for _, artist := range artists {
 		switch artist.Name {
 		case "Alan Vega":
-			require.Len(artist.Albums, 2)
+			assert.Len(t, artist.Albums, 2)
 		case "Mercury Rev":
-			require.Len(artist.Albums, 2)
+			assert.Len(t, artist.Albums, 2)
 		case "Liz Lamere":
-			require.Len(artist.Albums, 1)
+			assert.Len(t, artist.Albums, 1)
 		}
 	}
 }
diff --git a/scrobble/lastfm/client_test.go b/scrobble/lastfm/client_test.go
index 8a51a8f2..37e2787e 100644
--- a/scrobble/lastfm/client_test.go
+++ b/scrobble/lastfm/client_test.go
@@ -16,16 +16,16 @@ func TestArtistGetInfo(t *testing.T) {
 	t.Parallel()
 
 	// arrange
-	require := require.New(t)
 	client := Client{mockclient.New(t, func(w http.ResponseWriter, r *http.Request) {
-		require.Equal(http.MethodGet, r.Method)
-		require.Equal(url.Values{
+		require.Equal(t, http.MethodGet, r.Method)
+		require.Equal(t, url.Values{
 			"method":  []string{"artist.getInfo"},
 			"api_key": []string{"apiKey1"},
 			"artist":  []string{"Artist 1"},
 		}, r.URL.Query())
-		require.Equal("/2.0/", r.URL.Path)
-		require.Equal(baseURL, "https://"+r.Host+r.URL.Path)
+
+		require.Equal(t, "/2.0/", r.URL.Path)
+		require.Equal(t, baseURL, "https://"+r.Host+r.URL.Path)
 
 		w.WriteHeader(http.StatusOK)
 		w.Write(mockclient.ArtistGetInfoResponse)
@@ -35,8 +35,8 @@ func TestArtistGetInfo(t *testing.T) {
 	actual, err := client.ArtistGetInfo("apiKey1", "Artist 1")
 
 	// assert
-	require.NoError(err)
-	require.Equal(Artist{
+	require.NoError(t, err)
+	require.Equal(t, Artist{
 		XMLName: xml.Name{
 			Local: "artist",
 		},
@@ -98,16 +98,16 @@ func TestArtistGetInfoClientRequestFails(t *testing.T) {
 	t.Parallel()
 
 	// arrange
-	require := require.New(t)
 	client := Client{mockclient.New(t, func(w http.ResponseWriter, r *http.Request) {
-		require.Equal(http.MethodGet, r.Method)
-		require.Equal(url.Values{
+		require.Equal(t, http.MethodGet, r.Method)
+		require.Equal(t, url.Values{
 			"method":  []string{"artist.getInfo"},
 			"api_key": []string{"apiKey1"},
 			"artist":  []string{"Artist 1"},
 		}, r.URL.Query())
-		require.Equal("/2.0/", r.URL.Path)
-		require.Equal(baseURL, "https://"+r.Host+r.URL.Path)
+
+		require.Equal(t, "/2.0/", r.URL.Path)
+		require.Equal(t, baseURL, "https://"+r.Host+r.URL.Path)
 
 		w.WriteHeader(http.StatusInternalServerError)
 	})}
@@ -116,24 +116,24 @@ func TestArtistGetInfoClientRequestFails(t *testing.T) {
 	actual, err := client.ArtistGetInfo("apiKey1", "Artist 1")
 
 	// assert
-	require.Error(err)
-	require.Zero(actual)
+	require.Error(t, err)
+	require.Zero(t, actual)
 }
 
 func TestArtistGetTopTracks(t *testing.T) {
 	t.Parallel()
 
 	// arrange
-	require := require.New(t)
 	client := Client{mockclient.New(t, func(w http.ResponseWriter, r *http.Request) {
-		require.Equal(http.MethodGet, r.Method)
-		require.Equal(url.Values{
+		require.Equal(t, http.MethodGet, r.Method)
+		require.Equal(t, url.Values{
 			"method":  []string{"artist.getTopTracks"},
 			"api_key": []string{"apiKey1"},
 			"artist":  []string{"artist1"},
 		}, r.URL.Query())
-		require.Equal("/2.0/", r.URL.Path)
-		require.Equal(baseURL, "https://"+r.Host+r.URL.Path)
+
+		require.Equal(t, "/2.0/", r.URL.Path)
+		require.Equal(t, baseURL, "https://"+r.Host+r.URL.Path)
 
 		w.WriteHeader(http.StatusOK)
 		w.Write(mockclient.ArtistGetTopTracksResponse)
@@ -143,8 +143,8 @@ func TestArtistGetTopTracks(t *testing.T) {
 	actual, err := client.ArtistGetTopTracks("apiKey1", "artist1")
 
 	// assert
-	require.NoError(err)
-	require.Equal(TopTracks{
+	require.NoError(t, err)
+	require.Equal(t, TopTracks{
 		Artist: "Artist 1",
 		XMLName: xml.Name{
 			Local: "toptracks",
@@ -194,16 +194,16 @@ func TestArtistGetTopTracks_clientRequestFails(t *testing.T) {
 	t.Parallel()
 
 	// arrange
-	require := require.New(t)
 	client := Client{mockclient.New(t, func(w http.ResponseWriter, r *http.Request) {
-		require.Equal(http.MethodGet, r.Method)
-		require.Equal(url.Values{
+		require.Equal(t, http.MethodGet, r.Method)
+		require.Equal(t, url.Values{
 			"method":  []string{"artist.getTopTracks"},
 			"api_key": []string{"apiKey1"},
 			"artist":  []string{"artist1"},
 		}, r.URL.Query())
-		require.Equal("/2.0/", r.URL.Path)
-		require.Equal(baseURL, "https://"+r.Host+r.URL.Path)
+
+		require.Equal(t, "/2.0/", r.URL.Path)
+		require.Equal(t, baseURL, "https://"+r.Host+r.URL.Path)
 
 		w.WriteHeader(http.StatusInternalServerError)
 	})}
@@ -212,24 +212,24 @@ func TestArtistGetTopTracks_clientRequestFails(t *testing.T) {
 	actual, err := client.ArtistGetTopTracks("apiKey1", "artist1")
 
 	// assert
-	require.Error(err)
-	require.Zero(actual)
+	require.Error(t, err)
+	require.Zero(t, actual)
 }
 
 func TestArtistGetSimilar(t *testing.T) {
 	t.Parallel()
 
 	// arrange
-	require := require.New(t)
 	client := Client{mockclient.New(t, func(w http.ResponseWriter, r *http.Request) {
-		require.Equal(http.MethodGet, r.Method)
-		require.Equal(url.Values{
+		require.Equal(t, http.MethodGet, r.Method)
+		require.Equal(t, url.Values{
 			"method":  []string{"artist.getSimilar"},
 			"api_key": []string{"apiKey1"},
 			"artist":  []string{"artist1"},
 		}, r.URL.Query())
-		require.Equal("/2.0/", r.URL.Path)
-		require.Equal(baseURL, "https://"+r.Host+r.URL.Path)
+
+		require.Equal(t, "/2.0/", r.URL.Path)
+		require.Equal(t, baseURL, "https://"+r.Host+r.URL.Path)
 
 		w.WriteHeader(http.StatusOK)
 		w.Write(mockclient.ArtistGetSimilarResponse)
@@ -239,8 +239,8 @@ func TestArtistGetSimilar(t *testing.T) {
 	actual, err := client.ArtistGetSimilar("apiKey1", "artist1")
 
 	// assert
-	require.NoError(err)
-	require.Equal(SimilarArtists{
+	require.NoError(t, err)
+	require.Equal(t, SimilarArtists{
 		XMLName: xml.Name{
 			Local: "similarartists",
 		},
@@ -298,16 +298,16 @@ func TestArtistGetSimilar_clientRequestFails(t *testing.T) {
 	t.Parallel()
 
 	// arrange
-	require := require.New(t)
 	client := Client{mockclient.New(t, func(w http.ResponseWriter, r *http.Request) {
-		require.Equal(http.MethodGet, r.Method)
-		require.Equal(url.Values{
+		require.Equal(t, http.MethodGet, r.Method)
+		require.Equal(t, url.Values{
 			"method":  []string{"artist.getSimilar"},
 			"api_key": []string{"apiKey1"},
 			"artist":  []string{"artist1"},
 		}, r.URL.Query())
-		require.Equal("/2.0/", r.URL.Path)
-		require.Equal(baseURL, "https://"+r.Host+r.URL.Path)
+
+		require.Equal(t, "/2.0/", r.URL.Path)
+		require.Equal(t, baseURL, "https://"+r.Host+r.URL.Path)
 
 		w.WriteHeader(http.StatusInternalServerError)
 	})}
@@ -316,25 +316,25 @@ func TestArtistGetSimilar_clientRequestFails(t *testing.T) {
 	actual, err := client.ArtistGetSimilar("apiKey1", "artist1")
 
 	// assert
-	require.Error(err)
-	require.Zero(actual)
+	require.Error(t, err)
+	require.Zero(t, actual)
 }
 
 func TestTrackGetSimilarTracks(t *testing.T) {
 	t.Parallel()
 
 	// arrange
-	require := require.New(t)
 	client := Client{mockclient.New(t, func(w http.ResponseWriter, r *http.Request) {
-		require.Equal(http.MethodGet, r.Method)
-		require.Equal(url.Values{
+		require.Equal(t, http.MethodGet, r.Method)
+		require.Equal(t, url.Values{
 			"method":  []string{"track.getSimilar"},
 			"api_key": []string{"apiKey1"},
 			"artist":  []string{"artist1"},
 			"track":   []string{"track1"},
 		}, r.URL.Query())
-		require.Equal("/2.0/", r.URL.Path)
-		require.Equal(baseURL, "https://"+r.Host+r.URL.Path)
+
+		require.Equal(t, "/2.0/", r.URL.Path)
+		require.Equal(t, baseURL, "https://"+r.Host+r.URL.Path)
 
 		w.WriteHeader(http.StatusOK)
 		w.Write(mockclient.TrackGetSimilarResponse)
@@ -344,8 +344,8 @@ func TestTrackGetSimilarTracks(t *testing.T) {
 	actual, err := client.TrackGetSimilarTracks("apiKey1", "artist1", "track1")
 
 	// assert
-	require.NoError(err)
-	require.Equal(SimilarTracks{
+	require.NoError(t, err)
+	require.Equal(t, SimilarTracks{
 		Artist: "Artist 1",
 		Track:  "Track 1",
 		XMLName: xml.Name{
@@ -392,17 +392,17 @@ func TestTrackGetSimilarTracks_clientRequestFails(t *testing.T) {
 	t.Parallel()
 
 	// arrange
-	require := require.New(t)
 	client := Client{mockclient.New(t, func(w http.ResponseWriter, r *http.Request) {
-		require.Equal(http.MethodGet, r.Method)
-		require.Equal(url.Values{
+		require.Equal(t, http.MethodGet, r.Method)
+		require.Equal(t, url.Values{
 			"method":  []string{"track.getSimilar"},
 			"api_key": []string{"apiKey1"},
 			"artist":  []string{"artist1"},
 			"track":   []string{"track1"},
 		}, r.URL.Query())
-		require.Equal("/2.0/", r.URL.Path)
-		require.Equal(baseURL, "https://"+r.Host+r.URL.Path)
+
+		require.Equal(t, "/2.0/", r.URL.Path)
+		require.Equal(t, baseURL, "https://"+r.Host+r.URL.Path)
 
 		w.WriteHeader(http.StatusInternalServerError)
 	})}
@@ -411,25 +411,25 @@ func TestTrackGetSimilarTracks_clientRequestFails(t *testing.T) {
 	actual, err := client.TrackGetSimilarTracks("apiKey1", "artist1", "track1")
 
 	// assert
-	require.Error(err)
-	require.Zero(actual)
+	require.Error(t, err)
+	require.Zero(t, actual)
 }
 
 func TestGetSession(t *testing.T) {
 	t.Parallel()
 
 	// arrange
-	require := require.New(t)
 	client := Client{mockclient.New(t, func(w http.ResponseWriter, r *http.Request) {
-		require.Equal(http.MethodGet, r.Method)
-		require.Equal(url.Values{
+		require.Equal(t, http.MethodGet, r.Method)
+		require.Equal(t, url.Values{
 			"method":  []string{"auth.getSession"},
 			"api_key": []string{"apiKey1"},
 			"api_sig": []string{"b872a708a0b8b1d9fc1230b1cb6493f8"},
 			"token":   []string{"token1"},
 		}, r.URL.Query())
-		require.Equal("/2.0/", r.URL.Path)
-		require.Equal(baseURL, "https://"+r.Host+r.URL.Path)
+
+		require.Equal(t, "/2.0/", r.URL.Path)
+		require.Equal(t, baseURL, "https://"+r.Host+r.URL.Path)
 
 		w.WriteHeader(http.StatusOK)
 		w.Write(mockclient.GetSessionResponse)
@@ -439,25 +439,25 @@ func TestGetSession(t *testing.T) {
 	actual, err := client.GetSession("apiKey1", "secret1", "token1")
 
 	// assert
-	require.NoError(err)
-	require.Equal("sessionKey1", actual)
+	require.NoError(t, err)
+	require.Equal(t, "sessionKey1", actual)
 }
 
 func TestGetSessioeClientRequestFails(t *testing.T) {
 	t.Parallel()
 
 	// arrange
-	require := require.New(t)
 	client := Client{mockclient.New(t, func(w http.ResponseWriter, r *http.Request) {
-		require.Equal(http.MethodGet, r.Method)
-		require.Equal(url.Values{
+		require.Equal(t, http.MethodGet, r.Method)
+		require.Equal(t, url.Values{
 			"method":  []string{"auth.getSession"},
 			"api_key": []string{"apiKey1"},
 			"api_sig": []string{"b872a708a0b8b1d9fc1230b1cb6493f8"},
 			"token":   []string{"token1"},
 		}, r.URL.Query())
-		require.Equal("/2.0/", r.URL.Path)
-		require.Equal(baseURL, "https://"+r.Host+r.URL.Path)
+
+		require.Equal(t, "/2.0/", r.URL.Path)
+		require.Equal(t, baseURL, "https://"+r.Host+r.URL.Path)
 
 		w.WriteHeader(http.StatusInternalServerError)
 	})}
@@ -466,8 +466,8 @@ func TestGetSessioeClientRequestFails(t *testing.T) {
 	actual, err := client.GetSession("apiKey1", "secret1", "token1")
 
 	// assert
-	require.Error(err)
-	require.Zero(actual)
+	require.Error(t, err)
+	require.Zero(t, actual)
 }
 
 func TestGetParamSignature(t *testing.T) {
diff --git a/scrobble/lastfm/scrobbler_test.go b/scrobble/lastfm/scrobbler_test.go
index 0b288e6e..395a5f9b 100644
--- a/scrobble/lastfm/scrobbler_test.go
+++ b/scrobble/lastfm/scrobbler_test.go
@@ -15,12 +15,11 @@ import (
 func TestScrobble(t *testing.T) {
 	// arrange
 	t.Parallel()
-	require := require.New(t)
 
 	testDB, err := db.NewMock()
-	require.NoError(err)
+	require.NoError(t, err)
 	err = testDB.Migrate(db.MigrationContext{})
-	require.NoError(err)
+	require.NoError(t, err)
 
 	testDB.SetSetting(db.LastFMAPIKey, "apiKey1")
 	testDB.SetSetting(db.LastFMSecret, "secret1")
@@ -46,8 +45,8 @@ func TestScrobble(t *testing.T) {
 	stamp := time.Date(2023, 8, 12, 12, 34, 1, 200, time.UTC)
 
 	client := Client{mockclient.New(t, func(w http.ResponseWriter, r *http.Request) {
-		require.Equal(http.MethodPost, r.Method)
-		require.Equal(url.Values{
+		require.Equal(t, http.MethodPost, r.Method)
+		require.Equal(t, url.Values{
 			"album":       []string{"album1"},
 			"albumArtist": []string{"artist1"},
 			"api_key":     []string{"apiKey1"},
@@ -61,8 +60,9 @@ func TestScrobble(t *testing.T) {
 			"track":       []string{"title1"},
 			"trackNumber": []string{"1"},
 		}, r.URL.Query())
-		require.Equal("/2.0/", r.URL.Path)
-		require.Equal(baseURL, "https://"+r.Host+r.URL.Path)
+
+		require.Equal(t, "/2.0/", r.URL.Path)
+		require.Equal(t, baseURL, "https://"+r.Host+r.URL.Path)
 
 		w.WriteHeader(http.StatusOK)
 		w.Write(mockclient.ArtistGetTopTracksResponse)
@@ -74,13 +74,12 @@ func TestScrobble(t *testing.T) {
 	err = scrobbler.Scrobble(user, track, stamp, true)
 
 	// assert
-	require.NoError(err)
+	require.NoError(t, err)
 }
 
 func TestScrobbleReturnsWithoutLastFMSession(t *testing.T) {
 	// arrange
 	t.Parallel()
-	require := require.New(t)
 
 	scrobbler := Scrobbler{}
 
@@ -88,16 +87,15 @@ func TestScrobbleReturnsWithoutLastFMSession(t *testing.T) {
 	err := scrobbler.Scrobble(&db.User{}, &db.Track{}, time.Now(), false)
 
 	// assert
-	require.NoError(err)
+	require.NoError(t, err)
 }
 
 func TestScrobbleFailsWithoutLastFMAPIKey(t *testing.T) {
 	// arrange
 	t.Parallel()
-	require := require.New(t)
 
 	testDB, err := db.NewMock()
-	require.NoError(err)
+	require.NoError(t, err)
 
 	user := &db.User{
 		LastFMSession: "lastFMSession1",
@@ -109,5 +107,5 @@ func TestScrobbleFailsWithoutLastFMAPIKey(t *testing.T) {
 	err = scrobbler.Scrobble(user, &db.Track{}, time.Now(), false)
 
 	// assert
-	require.Error(err)
+	require.Error(t, err)
 }
diff --git a/scrobble/listenbrainz/listenbrainz_test.go b/scrobble/listenbrainz/listenbrainz_test.go
index c6e5c46b..9eac8027 100644
--- a/scrobble/listenbrainz/listenbrainz_test.go
+++ b/scrobble/listenbrainz/listenbrainz_test.go
@@ -36,17 +36,16 @@ var submitListensRequest string
 
 func TestScrobble(t *testing.T) {
 	t.Parallel()
-	require := require.New(t)
 
 	// arrange
 	client, shutdown := httpClientMock(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		require.Equal(http.MethodPost, r.Method)
-		require.Equal("/1/submit-listens", r.URL.Path)
-		require.Equal("application/json", r.Header.Get("Content-Type"))
-		require.Equal("Token token1", r.Header.Get("Authorization"))
+		require.Equal(t, http.MethodPost, r.Method)
+		require.Equal(t, "/1/submit-listens", r.URL.Path)
+		require.Equal(t, "application/json", r.Header.Get("Content-Type"))
+		require.Equal(t, "Token token1", r.Header.Get("Authorization"))
 		bodyBytes, err := io.ReadAll(r.Body)
-		require.NoError(err)
-		require.JSONEq(submitListensRequest, string(bodyBytes))
+		require.NoError(t, err)
+		require.JSONEq(t, submitListensRequest, string(bodyBytes))
 
 		w.WriteHeader(http.StatusOK)
 		w.Write([]byte(`{"accepted": 1}`))
@@ -71,19 +70,18 @@ func TestScrobble(t *testing.T) {
 	}, time.Unix(1683804525, 0), true)
 
 	// assert
-	require.NoError(err)
+	require.NoError(t, err)
 }
 
 func TestScrobbleUnauthorized(t *testing.T) {
 	t.Parallel()
-	require := require.New(t)
 
 	// arrange
 	client, shutdown := httpClientMock(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		require.Equal(http.MethodPost, r.Method)
-		require.Equal("/1/submit-listens", r.URL.Path)
-		require.Equal("application/json", r.Header.Get("Content-Type"))
-		require.Equal("Token token1", r.Header.Get("Authorization"))
+		require.Equal(t, http.MethodPost, r.Method)
+		require.Equal(t, "/1/submit-listens", r.URL.Path)
+		require.Equal(t, "application/json", r.Header.Get("Content-Type"))
+		require.Equal(t, "Token token1", r.Header.Get("Authorization"))
 
 		w.WriteHeader(http.StatusUnauthorized)
 		w.Write([]byte(`{"code": 401, "error": "Invalid authorization token."}`))
@@ -108,19 +106,18 @@ func TestScrobbleUnauthorized(t *testing.T) {
 	}, time.Now(), true)
 
 	// assert
-	require.ErrorIs(err, ErrListenBrainz)
+	require.ErrorIs(t, err, ErrListenBrainz)
 }
 
 func TestScrobbleServerError(t *testing.T) {
 	t.Parallel()
-	require := require.New(t)
 
 	// arrange
 	client, shutdown := httpClientMock(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		require.Equal(http.MethodPost, r.Method)
-		require.Equal("/1/submit-listens", r.URL.Path)
-		require.Equal("application/json", r.Header.Get("Content-Type"))
-		require.Equal("Token token1", r.Header.Get("Authorization"))
+		require.Equal(t, http.MethodPost, r.Method)
+		require.Equal(t, "/1/submit-listens", r.URL.Path)
+		require.Equal(t, "application/json", r.Header.Get("Content-Type"))
+		require.Equal(t, "Token token1", r.Header.Get("Authorization"))
 
 		w.WriteHeader(http.StatusInternalServerError)
 	}))
@@ -144,5 +141,5 @@ func TestScrobbleServerError(t *testing.T) {
 	}, time.Now(), true)
 
 	// assert
-	require.ErrorIs(err, ErrListenBrainz)
+	require.ErrorIs(t, err, ErrListenBrainz)
 }