use testify for all tests (#319)

* Use Testify for all tests

* Terminate failing non-relaxed tests using `require`

db/db_test.go

@@ -8,7 +8,7 @@ import (
 	"testing"
 
 	_ "github.com/jinzhu/gorm/dialects/sqlite"
-	"github.com/matryer/is"
+	"github.com/stretchr/testify/require"
 )
 
 func randKey() string {
@@ -24,7 +24,7 @@ func TestGetSetting(t *testing.T) {
 	key := randKey()
 	value := "howdy"
 
-	is := is.New(t)
+	require := require.New(t)
 
 	testDB, err := NewMock()
 	if err != nil {
@@ -34,16 +34,16 @@ func TestGetSetting(t *testing.T) {
 		t.Fatalf("error migrating db: %v", err)
 	}
 
-	is.NoErr(testDB.SetSetting(key, value))
+	require.NoError(testDB.SetSetting(key, value))
 
 	actual, err := testDB.GetSetting(key)
-	is.NoErr(err)
-	is.Equal(actual, value)
+	require.NoError(err)
+	require.Equal(actual, value)
 
-	is.NoErr(testDB.SetSetting(key, value))
+	require.NoError(testDB.SetSetting(key, value))
 	actual, err = testDB.GetSetting(key)
-	is.NoErr(err)
-	is.Equal(actual, value)
+	require.NoError(err)
+	require.Equal(actual, value)
 }
 
 func TestMain(m *testing.M) {

go.mod

@@ -18,7 +18,6 @@ require (
 	github.com/gorilla/sessions v1.2.1
 	github.com/jinzhu/gorm v1.9.17-0.20211120011537-5c235b72a414
 	github.com/josephburnett/jd v1.5.2
-	github.com/matryer/is v1.4.0
 	github.com/mattn/go-sqlite3 v1.14.16
 	github.com/mitchellh/mapstructure v1.5.0
 	github.com/mmcdole/gofeed v1.2.0

go.sum

@@ -98,8 +98,6 @@ github.com/mailru/easyjson v0.0.0-20190626092158-b2ccc519800e/go.mod h1:C1wdFJiN
 github.com/mailru/easyjson v0.7.6/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
 github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
 github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
-github.com/matryer/is v1.4.0 h1:sosSmIWwkYITGrxZ25ULNDeKiMNzFSr4V/eqBQP0PeE=
-github.com/matryer/is v1.4.0/go.mod h1:8I/i5uYgLzgsgEloJE1U6xx5HkBQpAZvepWuujKwMRU=
 github.com/mattn/go-sqlite3 v1.10.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
 github.com/mattn/go-sqlite3 v1.14.0/go.mod h1:JIl7NbARA7phWnGvh0LKTyg7S9BA+6gx71ShQilpsus=
 github.com/mattn/go-sqlite3 v1.14.16 h1:yOQRA0RpS5PFz/oikGwBEqvAWhWg5ufRz4ETLjwpU1Y=

jukebox/jukebox_test.go

@@ -7,7 +7,7 @@ import (
 	"sort"
 	"testing"
 
-	"github.com/matryer/is"
+	"github.com/stretchr/testify/require"
 	"go.senan.xyz/gonic/jukebox"
 )
 
@@ -36,9 +36,9 @@ func TestPlaySkipReset(t *testing.T) {
 
 	t.Parallel()
 	j := newJukebox(t)
-	is := is.New(t)
+	require := require.New(t)
 
-	is.NoErr(j.SetPlaylist([]string{
+	require.NoError(j.SetPlaylist([]string{
 		testPath("tr_0.mp3"),
 		testPath("tr_1.mp3"),
 		testPath("tr_2.mp3"),
@@ -47,56 +47,56 @@ func TestPlaySkipReset(t *testing.T) {
 	}))
 
 	status, err := j.GetStatus()
-	is.NoErr(err)
-	is.Equal(status.CurrentIndex, 0)
-	is.Equal(status.CurrentFilename, testPath("tr_0.mp3"))
-	is.Equal(status.Length, 5)
-	is.Equal(status.Playing, true)
+	require.NoError(err)
+	require.Equal(status.CurrentIndex, 0)
+	require.Equal(status.CurrentFilename, testPath("tr_0.mp3"))
+	require.Equal(status.Length, 5)
+	require.Equal(status.Playing, true)
 
 	items, err := j.GetPlaylist()
-	is.NoErr(err)
+	require.NoError(err)
 
 	itemsSorted := append([]string(nil), items...)
 	sort.Strings(itemsSorted)
-	is.Equal(items, itemsSorted)
+	require.Equal(items, itemsSorted)
 
-	is.NoErr(j.Play())
+	require.NoError(j.Play())
 
 	status, err = j.GetStatus()
-	is.NoErr(err)
-	is.Equal(status.Playing, true)
+	require.NoError(err)
+	require.Equal(status.Playing, true)
 
-	is.NoErr(j.Pause())
+	require.NoError(j.Pause())
 
 	status, err = j.GetStatus()
-	is.NoErr(err)
-	is.Equal(status.Playing, false)
+	require.NoError(err)
+	require.Equal(status.Playing, false)
 
-	is.NoErr(j.Play())
+	require.NoError(j.Play())
 
 	// skip to 2
-	is.NoErr(j.SkipToPlaylistIndex(2, 0))
+	require.NoError(j.SkipToPlaylistIndex(2, 0))
 
 	status, err = j.GetStatus()
-	is.NoErr(err)
-	is.Equal(status.CurrentIndex, 2)
-	is.Equal(status.CurrentFilename, testPath("tr_2.mp3"))
-	is.Equal(status.Length, 5)
-	is.Equal(status.Playing, true)
+	require.NoError(err)
+	require.Equal(status.CurrentIndex, 2)
+	require.Equal(status.CurrentFilename, testPath("tr_2.mp3"))
+	require.Equal(status.Length, 5)
+	require.Equal(status.Playing, true)
 
 	// skip to 3
-	is.NoErr(j.SkipToPlaylistIndex(3, 0))
+	require.NoError(j.SkipToPlaylistIndex(3, 0))
 
 	status, err = j.GetStatus()
-	is.NoErr(err)
-	is.Equal(status.CurrentIndex, 3)
-	is.Equal(status.CurrentFilename, testPath("tr_3.mp3"))
-	is.Equal(status.Length, 5)
-	is.Equal(status.Playing, true)
+	require.NoError(err)
+	require.Equal(status.CurrentIndex, 3)
+	require.Equal(status.CurrentFilename, testPath("tr_3.mp3"))
+	require.Equal(status.Length, 5)
+	require.Equal(status.Playing, true)
 
 	// just add one more by overwriting the playlist like some clients do
 	// we should keep the current track unchaned if we find it
-	is.NoErr(j.SetPlaylist([]string{
+	require.NoError(j.SetPlaylist([]string{
 		"testdata/tr_0.mp3",
 		"testdata/tr_1.mp3",
 		"testdata/tr_2.mp3",
@@ -106,50 +106,50 @@ func TestPlaySkipReset(t *testing.T) {
 	}))
 
 	status, err = j.GetStatus()
-	is.NoErr(err)
-	is.Equal(status.CurrentIndex, 3) // index unchanged
-	is.Equal(status.CurrentFilename, testPath("tr_3.mp3"))
-	is.Equal(status.Length, 6) // we added one more track
-	is.Equal(status.Playing, true)
+	require.NoError(err)
+	require.Equal(status.CurrentIndex, 3) // index unchanged
+	require.Equal(status.CurrentFilename, testPath("tr_3.mp3"))
+	require.Equal(status.Length, 6) // we added one more track
+	require.Equal(status.Playing, true)
 
 	// skip to 3 again
-	is.NoErr(j.SkipToPlaylistIndex(3, 0))
+	require.NoError(j.SkipToPlaylistIndex(3, 0))
 
 	status, err = j.GetStatus()
-	is.NoErr(err)
-	is.Equal(status.CurrentIndex, 3)
-	is.Equal(status.CurrentFilename, testPath("tr_3.mp3"))
-	is.Equal(status.Length, 6)
-	is.Equal(status.Playing, true)
+	require.NoError(err)
+	require.Equal(status.CurrentIndex, 3)
+	require.Equal(status.CurrentFilename, testPath("tr_3.mp3"))
+	require.Equal(status.Length, 6)
+	require.Equal(status.Playing, true)
 
 	// remove all but 3
-	is.NoErr(j.SetPlaylist([]string{
+	require.NoError(j.SetPlaylist([]string{
 		"testdata/tr_0.mp3",
 		"testdata/tr_1.mp3",
 		"testdata/tr_2.mp3",
 		"testdata/tr_3.mp3",
 	}))
 
 	status, err = j.GetStatus()
-	is.NoErr(err)
-	is.Equal(status.CurrentIndex, 3) // index unchanged
-	is.Equal(status.CurrentFilename, testPath("tr_3.mp3"))
-	is.Equal(status.Length, 4)
-	is.Equal(status.Playing, true)
+	require.NoError(err)
+	require.Equal(status.CurrentIndex, 3) // index unchanged
+	require.Equal(status.CurrentFilename, testPath("tr_3.mp3"))
+	require.Equal(status.Length, 4)
+	require.Equal(status.Playing, true)
 
 	// skip to 2 (5s long) in the middle of the track
-	is.NoErr(j.SkipToPlaylistIndex(2, 2))
+	require.NoError(j.SkipToPlaylistIndex(2, 2))
 
 	status, err = j.GetStatus()
-	is.NoErr(err)
-	is.Equal(status.CurrentIndex, 2) // index unchanged
-	is.Equal(status.CurrentFilename, testPath("tr_2.mp3"))
-	is.Equal(status.Length, 4)
-	is.Equal(status.Playing, true)
-	is.Equal(status.Position, 2) // at new position
+	require.NoError(err)
+	require.Equal(status.CurrentIndex, 2) // index unchanged
+	require.Equal(status.CurrentFilename, testPath("tr_2.mp3"))
+	require.Equal(status.Length, 4)
+	require.Equal(status.Playing, true)
+	require.Equal(status.Position, 2) // at new position
 
 	// overwrite completely
-	is.NoErr(j.SetPlaylist([]string{
+	require.NoError(j.SetPlaylist([]string{
 		"testdata/tr_5.mp3",
 		"testdata/tr_6.mp3",
 		"testdata/tr_7.mp3",
@@ -158,33 +158,33 @@ func TestPlaySkipReset(t *testing.T) {
 	}))
 
 	status, err = j.GetStatus()
-	is.NoErr(err)
-	is.Equal(status.CurrentIndex, 0) // index unchanged
-	is.Equal(status.CurrentFilename, testPath("tr_5.mp3"))
-	is.Equal(status.Length, 5)
-	is.Equal(status.Playing, true)
+	require.NoError(err)
+	require.Equal(status.CurrentIndex, 0) // index unchanged
+	require.Equal(status.CurrentFilename, testPath("tr_5.mp3"))
+	require.Equal(status.Length, 5)
+	require.Equal(status.Playing, true)
 }
 
 func TestVolume(t *testing.T) {
 	t.Parallel()
 	j := newJukebox(t)
-	is := is.New(t)
+	require := require.New(t)
 
 	vol, err := j.GetVolumePct()
-	is.NoErr(err)
-	is.Equal(vol, 100.0)
+	require.NoError(err)
+	require.Equal(vol, 100.0)
 
-	is.NoErr(j.SetVolumePct(69.0))
+	require.NoError(j.SetVolumePct(69.0))
 
 	vol, err = j.GetVolumePct()
-	is.NoErr(err)
-	is.Equal(vol, 69.0)
+	require.NoError(err)
+	require.Equal(vol, 69.0)
 
-	is.NoErr(j.SetVolumePct(0.0))
+	require.NoError(j.SetVolumePct(0.0))
 
 	vol, err = j.GetVolumePct()
-	is.NoErr(err)
-	is.Equal(vol, 0.0)
+	require.NoError(err)
+	require.Equal(vol, 0.0)
 }
 
 func testPath(path string) string {

playlist/playlist_test.go

@@ -3,25 +3,25 @@ package playlist_test
 import (
 	"testing"
 
-	"github.com/matryer/is"
+	"github.com/stretchr/testify/require"
 	"go.senan.xyz/gonic/playlist"
 )
 
 func TestPlaylist(t *testing.T) {
-	is := is.New(t)
+	require := require.New(t)
 
 	tmp := t.TempDir()
 	store, err := playlist.NewStore(tmp)
-	is.NoErr(err)
+	require.NoError(err)
 
 	playlistIDs, err := store.List()
-	is.NoErr(err)
-	is.True(len(playlistIDs) == 0)
+	require.NoError(err)
+	require.Empty(playlistIDs)
 
 	for _, playlistID := range playlistIDs {
 		playlist, err := store.Read(playlistID)
-		is.NoErr(err)
-		is.True(!playlist.UpdatedAt.IsZero())
+		require.NoError(err)
+		require.NotZero(playlist.UpdatedAt)
 	}
 
 	before := playlist.Playlist{
@@ -40,18 +40,18 @@ It has multiple lines 👍
 	}
 
 	newPath := playlist.NewPath(before.UserID, before.Name)
-	is.NoErr(store.Write(newPath, &before))
+	require.NoError(store.Write(newPath, &before))
 
 	after, err := store.Read(newPath)
-	is.NoErr(err)
+	require.NoError(err)
 
-	is.Equal(before.UserID, after.UserID)
-	is.Equal(before.Name, after.Name)
-	is.Equal(before.Comment, after.Comment)
-	is.Equal(before.Items, after.Items)
-	is.Equal(before.IsPublic, after.IsPublic)
+	require.Equal(before.UserID, after.UserID)
+	require.Equal(before.Name, after.Name)
+	require.Equal(before.Comment, after.Comment)
+	require.Equal(before.Items, after.Items)
+	require.Equal(before.IsPublic, after.IsPublic)
 
 	playlistIDs, err = store.List()
-	is.NoErr(err)
-	is.True(len(playlistIDs) == 1)
+	require.NoError(err)
+	require.True(len(playlistIDs) == 1)
 }

scanner/scanner_fuzz_test.go

@@ -10,25 +10,23 @@ import (
 	"testing"
 
 	_ "github.com/jinzhu/gorm/dialects/sqlite"
-	"github.com/matryer/is"
+	"github.com/stretchr/testify/assert"
 	"go.senan.xyz/gonic/mockfs"
 )
 
 func FuzzScanner(f *testing.F) {
-	checkDelta := func(is *is.I, m *mockfs.MockFS, expSeen, expNew int) {
-		is.Helper()
-
+	checkDelta := func(assert *assert.Assertions, m *mockfs.MockFS, expSeen, expNew int) {
 		ctx := m.ScanAndClean()
-		is.Equal(ctx.SeenTracks(), expSeen)
-		is.Equal(ctx.SeenTracksNew(), expNew)
-		is.Equal(ctx.TracksMissing(), 0)
-		is.Equal(ctx.AlbumsMissing(), 0)
-		is.Equal(ctx.ArtistsMissing(), 0)
-		is.Equal(ctx.GenresMissing(), 0)
+		assert.Equal(ctx.SeenTracks(), expSeen)
+		assert.Equal(ctx.SeenTracksNew(), expNew)
+		assert.Equal(ctx.TracksMissing(), 0)
+		assert.Equal(ctx.AlbumsMissing(), 0)
+		assert.Equal(ctx.ArtistsMissing(), 0)
+		assert.Equal(ctx.GenresMissing(), 0)
 	}
 
 	f.Fuzz(func(t *testing.T, data []byte, seed int64) {
-		is := is.NewRelaxed(t)
+		assert := assert.New(t)
 		m := mockfs.New(t)
 
 		const toAdd = 1000
@@ -41,8 +39,8 @@ func FuzzScanner(f *testing.F) {
 			})
 		}
 
-		checkDelta(is, m, toAdd, toAdd) // we added all tracks, 0 delta
-		checkDelta(is, m, toAdd, 0)     // we added 0 tracks, 0 delta
+		checkDelta(assert, m, toAdd, toAdd) // we added all tracks, 0 delta
+		checkDelta(assert, m, toAdd, 0)     // we added 0 tracks, 0 delta
 	})
 }