heimoshuiyu/gonic
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

use testify for all tests (#319)

Browse Source 
* Use Testify for all tests

* Terminate failing non-relaxed tests using `require`
This commit is contained in:
Gregor Zurowski
2023-05-13 17:17:37 +02:00
committed by GitHub
parent bb8507a72f
commit b7a50ee9cb
8 changed files with 251 additions and 263 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
db/db_test.go
View File

@@ -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) {

1
go.mod
View File

@@ -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

2
go.sum
View File

@@ -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=

138
jukebox/jukebox_test.go
View File

@@ -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,24 +106,24 @@ 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",
@@ -131,25 +131,25 @@ 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, 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 {

32
playlist/playlist_test.go
View File

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

24
scanner/scanner_fuzz_test.go
View File

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

273
scanner/scanner_test.go
View File

@@ -1,7 +1,6 @@
package scanner_test
import (
"errors"
"fmt"
"io"
"log"
@@ -11,7 +10,8 @@ import (
"github.com/jinzhu/gorm"
_ "github.com/jinzhu/gorm/dialects/sqlite"
"github.com/matryer/is"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"go.senan.xyz/gonic/db"
"go.senan.xyz/gonic/mockfs"
@@ -26,72 +26,72 @@ func TestMain(m *testing.M) {
func TestTableCounts(t *testing.T) {
t.Parallel()
is := is.NewRelaxed(t)
assert := assert.New(t)
m := mockfs.New(t)
m.AddItems()
m.ScanAndClean()
var tracks int
is.NoErr(m.DB().Model(&db.Track{}).Count(&tracks).Error) // not all tracks
is.Equal(tracks, m.NumTracks())
assert.NoError(m.DB().Model(&db.Track{}).Count(&tracks).Error) // not all tracks
assert.Equal(tracks, m.NumTracks())
var albums int
is.NoErr(m.DB().Model(&db.Album{}).Count(&albums).Error) // not all albums
is.Equal(albums, 13) // not all albums
assert.NoError(m.DB().Model(&db.Album{}).Count(&albums).Error) // not all albums
assert.Equal(albums, 13) // not all albums
var artists int
is.NoErr(m.DB().Model(&db.Artist{}).Count(&artists).Error) // not all artists
is.Equal(artists, 3) // not all artists
assert.NoError(m.DB().Model(&db.Artist{}).Count(&artists).Error) // not all artists
assert.Equal(artists, 3) // not all artists
}
func TestWithExcludePattern(t *testing.T) {
t.Parallel()
is := is.NewRelaxed(t)
assert := assert.New(t)
m := mockfs.NewWithExcludePattern(t, "\\/artist-1\\/|track-0.flac$")
m.AddItems()
m.ScanAndClean()
var tracks int
is.NoErr(m.DB().Model(&db.Track{}).Count(&tracks).Error) // not all tracks
is.Equal(tracks, 12)
assert.NoError(m.DB().Model(&db.Track{}).Count(&tracks).Error) // not all tracks
assert.Equal(tracks, 12)
var albums int
is.NoErr(m.DB().Model(&db.Album{}).Count(&albums).Error) // not all albums
is.Equal(albums, 10) // not all albums
assert.NoError(m.DB().Model(&db.Album{}).Count(&albums).Error) // not all albums
assert.Equal(albums, 10) // not all albums
var artists int
is.NoErr(m.DB().Model(&db.Artist{}).Count(&artists).Error) // not all artists
is.Equal(artists, 2) // not all artists
assert.NoError(m.DB().Model(&db.Artist{}).Count(&artists).Error) // not all artists
assert.Equal(artists, 2) // not all artists
}
func TestParentID(t *testing.T) {
t.Parallel()
is := is.New(t)
require := require.New(t)
m := mockfs.New(t)
m.AddItems()
m.ScanAndClean()
var nullParentAlbums []*db.Album
is.NoErr(m.DB().Where("parent_id IS NULL").Find(&nullParentAlbums).Error) // one parent_id=NULL which is root folder
is.Equal(len(nullParentAlbums), 1) // one parent_id=NULL which is root folder
is.Equal(nullParentAlbums[0].LeftPath, "")
is.Equal(nullParentAlbums[0].RightPath, ".")
require.NoError(m.DB().Where("parent_id IS NULL").Find(&nullParentAlbums).Error) // one parent_id=NULL which is root folder
require.Equal(len(nullParentAlbums), 1) // one parent_id=NULL which is root folder
require.Equal(nullParentAlbums[0].LeftPath, "")
require.Equal(nullParentAlbums[0].RightPath, ".")
is.Equal(m.DB().Where("id=parent_id").Find(&db.Album{}).Error, gorm.ErrRecordNotFound) // no self-referencing albums
require.Equal(m.DB().Where("id=parent_id").Find(&db.Album{}).Error, gorm.ErrRecordNotFound) // no self-referencing albums
var album db.Album
var parent db.Album
is.NoErr(m.DB().Find(&album, "left_path=? AND right_path=?", "artist-0/", "album-0").Error) // album has parent ID
is.NoErr(m.DB().Find(&parent, "right_path=?", "artist-0").Error) // album has parent ID
is.Equal(album.ParentID, parent.ID) // album has parent ID
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(album.ParentID, parent.ID) // album has parent ID
}
func TestUpdatedCover(t *testing.T) {
t.Parallel()
is := is.NewRelaxed(t)
assert := assert.New(t)
m := mockfs.New(t)
m.AddItems()
@@ -100,13 +100,13 @@ func TestUpdatedCover(t *testing.T) {
m.ScanAndClean()
var album db.Album
is.NoErr(m.DB().Where("left_path=? AND right_path=?", "artist-0/", "album-0").Find(&album).Error) // album has cover
is.Equal(album.Cover, "cover.jpg") // album has cover
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
}
func TestCoverBeforeTracks(t *testing.T) {
t.Parallel()
is := is.New(t)
require := require.New(t)
m := mockfs.New(t)
m.AddCover("artist-2/album-2/cover.jpg")
@@ -115,18 +115,18 @@ func TestCoverBeforeTracks(t *testing.T) {
m.ScanAndClean()
var album db.Album
is.NoErr(m.DB().Preload("TagArtist").Where("left_path=? AND right_path=?", "artist-2/", "album-2").Find(&album).Error) // album has cover
is.Equal(album.Cover, "cover.jpg") // album has cover
is.Equal(album.TagArtist.Name, "artist-2") // album artist
require.NoError(m.DB().Preload("TagArtist").Where("left_path=? AND right_path=?", "artist-2/", "album-2").Find(&album).Error) // album has cover
require.Equal(album.Cover, "cover.jpg") // album has cover
require.Equal(album.TagArtist.Name, "artist-2") // album artist
var tracks []*db.Track
is.NoErr(m.DB().Where("album_id=?", album.ID).Find(&tracks).Error) // album has tracks
is.Equal(len(tracks), 3) // album has tracks
require.NoError(m.DB().Where("album_id=?", album.ID).Find(&tracks).Error) // album has tracks
require.Equal(len(tracks), 3) // album has tracks
}
func TestUpdatedTags(t *testing.T) {
t.Parallel()
is := is.New(t)
require := require.New(t)
m := mockfs.New(t)
m.AddTrack("artist-10/album-10/track-10.flac")
@@ -141,11 +141,11 @@ func TestUpdatedTags(t *testing.T) {
m.ScanAndClean()
var track db.Track
is.NoErr(m.DB().Preload("Album").Preload("Artist").Where("filename=?", "track-10.flac").Find(&track).Error) // track has tags
is.Equal(track.TagTrackArtist, "artist") // track has tags
is.Equal(track.Artist.Name, "album-artist") // track has tags
is.Equal(track.Album.TagTitle, "album") // track has tags
is.Equal(track.TagTitle, "title") // track has tags
require.NoError(m.DB().Preload("Album").Preload("Artist").Where("filename=?", "track-10.flac").Find(&track).Error) // track has tags
require.Equal(track.TagTrackArtist, "artist") // track has tags
require.Equal(track.Artist.Name, "album-artist") // track has tags
require.Equal(track.Album.TagTitle, "album") // track has tags
require.Equal(track.TagTitle, "title") // track has tags
m.SetTags("artist-10/album-10/track-10.flac", func(tags *mockfs.Tags) error {
tags.RawArtist = "artist-upd"
@@ -158,18 +158,18 @@ func TestUpdatedTags(t *testing.T) {
m.ScanAndClean()
var updated db.Track
is.NoErr(m.DB().Preload("Album").Preload("Artist").Where("filename=?", "track-10.flac").Find(&updated).Error) // updated has tags
is.Equal(updated.ID, track.ID) // updated has tags
is.Equal(updated.TagTrackArtist, "artist-upd") // updated has tags
is.Equal(updated.Artist.Name, "album-artist-upd") // updated has tags
is.Equal(updated.Album.TagTitle, "album-upd") // updated has tags
is.Equal(updated.TagTitle, "title-upd") // updated has tags
require.NoError(m.DB().Preload("Album").Preload("Artist").Where("filename=?", "track-10.flac").Find(&updated).Error) // updated has tags
require.Equal(updated.ID, track.ID) // updated has tags
require.Equal(updated.TagTrackArtist, "artist-upd") // updated has tags
require.Equal(updated.Artist.Name, "album-artist-upd") // updated has tags
require.Equal(updated.Album.TagTitle, "album-upd") // updated has tags
require.Equal(updated.TagTitle, "title-upd") // updated has tags
}
// https://github.com/sentriz/gonic/issues/225
func TestUpdatedAlbumGenre(t *testing.T) {
t.Parallel()
is := is.New(t)
require := require.New(t)
m := mockfs.New(t)
m.AddItems()
@@ -181,8 +181,8 @@ func TestUpdatedAlbumGenre(t *testing.T) {
m.ScanAndClean()
var album db.Album
is.NoErr(m.DB().Preload("Genres").Where("left_path=? AND right_path=?", "artist-0/", "album-0").Find(&album).Error)
is.Equal(album.GenreStrings(), []string{"gen-a", "gen-b"})
require.NoError(m.DB().Preload("Genres").Where("left_path=? AND right_path=?", "artist-0/", "album-0").Find(&album).Error)
require.Equal(album.GenreStrings(), []string{"gen-a", "gen-b"})
m.SetTags("artist-0/album-0/track-0.flac", func(tags *mockfs.Tags) error {
tags.RawGenre = "gen-a-upd;gen-b-upd"
@@ -192,46 +192,46 @@ func TestUpdatedAlbumGenre(t *testing.T) {
m.ScanAndClean()
var updated db.Album
is.NoErr(m.DB().Preload("Genres").Where("left_path=? AND right_path=?", "artist-0/", "album-0").Find(&updated).Error)
is.Equal(updated.GenreStrings(), []string{"gen-a-upd", "gen-b-upd"})
require.NoError(m.DB().Preload("Genres").Where("left_path=? AND right_path=?", "artist-0/", "album-0").Find(&updated).Error)
require.Equal(updated.GenreStrings(), []string{"gen-a-upd", "gen-b-upd"})
}
func TestDeleteAlbum(t *testing.T) {
t.Parallel()
is := is.NewRelaxed(t)
assert := assert.New(t)
m := mockfs.New(t)
m.AddItems()
m.ScanAndClean()
is.NoErr(m.DB().Where("left_path=? AND right_path=?", "artist-2/", "album-2").Find(&db.Album{}).Error) // album exists
assert.NoError(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()
is.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("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()
is := is.NewRelaxed(t)
assert := assert.New(t)
m := mockfs.New(t)
m.AddItems()
m.ScanAndClean()
is.NoErr(m.DB().Where("left_path=? AND right_path=?", "artist-2/", "album-2").Find(&db.Album{}).Error) // album exists
assert.NoError(m.DB().Where("left_path=? AND right_path=?", "artist-2/", "album-2").Find(&db.Album{}).Error) // album exists
m.RemoveAll("artist-2")
m.ScanAndClean()
is.Equal(m.DB().Where("left_path=? AND right_path=?", "artist-2/", "album-2").Find(&db.Album{}).Error, gorm.ErrRecordNotFound) // album doesn't exist
is.Equal(m.DB().Where("name=?", "artist-2").Find(&db.Artist{}).Error, gorm.ErrRecordNotFound) // artist doesn't exist
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
}
func TestGenres(t *testing.T) {
t.Parallel()
is := is.New(t)
assert := assert.New(t)
m := mockfs.New(t)
albumGenre := func(artist, album, genre string) error {
@@ -243,12 +243,10 @@ func TestGenres(t *testing.T) {
Error
}
isAlbumGenre := func(artist, album, genreName string) {
is.Helper()
is.NoErr(albumGenre(artist, album, genreName))
assert.NoError(albumGenre(artist, album, genreName))
}
isAlbumGenreMissing := func(artist, album, genreName string) {
is.Helper()
is.Equal(albumGenre(artist, album, genreName), gorm.ErrRecordNotFound)
assert.Equal(albumGenre(artist, album, genreName), gorm.ErrRecordNotFound)
}
trackGenre := func(artist, album, filename, genreName string) error {
@@ -261,24 +259,20 @@ func TestGenres(t *testing.T) {
Error
}
isTrackGenre := func(artist, album, filename, genreName string) {
is.Helper()
is.NoErr(trackGenre(artist, album, filename, genreName))
assert.NoError(trackGenre(artist, album, filename, genreName))
}
isTrackGenreMissing := func(artist, album, filename, genreName string) {
is.Helper()
is.Equal(trackGenre(artist, album, filename, genreName), gorm.ErrRecordNotFound)
assert.Equal(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) {
is.Helper()
is.NoErr(genre(genreName))
assert.NoError(genre(genreName))
}
isGenreMissing := func(genreName string) {
is.Helper()
is.Equal(genre(genreName), gorm.ErrRecordNotFound)
assert.Equal(genre(genreName), gorm.ErrRecordNotFound)
}
m.AddItems()
@@ -322,7 +316,7 @@ func TestGenres(t *testing.T) {
func TestMultiFolders(t *testing.T) {
t.Parallel()
is := is.New(t)
require := require.New(t)
m := mockfs.NewWithDirs(t, []string{"m-1", "m-2", "m-3"})
m.AddItemsPrefix("m-1")
@@ -331,13 +325,13 @@ func TestMultiFolders(t *testing.T) {
m.ScanAndClean()
var rootDirs []*db.Album
is.NoErr(m.DB().Where("parent_id IS NULL").Find(&rootDirs).Error)
is.Equal(len(rootDirs), 3)
require.NoError(m.DB().Where("parent_id IS NULL").Find(&rootDirs).Error)
require.Equal(len(rootDirs), 3)
for i, r := range rootDirs {
is.Equal(r.RootDir, filepath.Join(m.TmpDir(), fmt.Sprintf("m-%d", i+1)))
is.Equal(r.ParentID, 0)
is.Equal(r.LeftPath, "")
is.Equal(r.RightPath, ".")
require.Equal(r.RootDir, filepath.Join(m.TmpDir(), fmt.Sprintf("m-%d", i+1)))
require.Equal(r.ParentID, 0)
require.Equal(r.LeftPath, "")
require.Equal(r.RightPath, ".")
}
m.AddCover("m-3/artist-0/album-0/cover.jpg")
@@ -345,8 +339,7 @@ func TestMultiFolders(t *testing.T) {
m.LogItems()
checkCover := func(root string, q string) {
is.Helper()
is.NoErr(m.DB().Where(q, filepath.Join(m.TmpDir(), root)).Find(&db.Album{}).Error)
require.NoError(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
@@ -356,7 +349,7 @@ func TestMultiFolders(t *testing.T) {
func TestNewAlbumForExistingArtist(t *testing.T) {
t.Parallel()
is := is.New(t)
require := require.New(t)
m := mockfs.New(t)
m.AddItems()
@@ -366,8 +359,8 @@ func TestNewAlbumForExistingArtist(t *testing.T) {
m.LogArtists()
var artist db.Artist
is.NoErr(m.DB().Where("name=?", "artist-2").Find(&artist).Error) // find orig artist
is.True(artist.ID > 0)
require.NoError(m.DB().Where("name=?", "artist-2").Find(&artist).Error) // find orig artist
require.Greater(artist.ID, 0)
for tr := 0; tr < 3; tr++ {
m.AddTrack(fmt.Sprintf("artist-2/new-album/track-%d.mp3", tr))
@@ -381,17 +374,17 @@ func TestNewAlbumForExistingArtist(t *testing.T) {
}
var updated db.Artist
is.NoErr(m.DB().Where("name=?", "artist-2").Find(&updated).Error) // find updated artist
is.Equal(artist.ID, updated.ID) // find updated artist
require.NoError(m.DB().Where("name=?", "artist-2").Find(&updated).Error) // find updated artist
require.Equal(artist.ID, updated.ID) // find updated artist
var all []*db.Artist
is.NoErr(m.DB().Find(&all).Error) // still only 3?
is.Equal(len(all), 3) // still only 3?
require.NoError(m.DB().Find(&all).Error) // still only 3?
require.Equal(len(all), 3) // still only 3?
}
func TestMultiFolderWithSharedArtist(t *testing.T) {
t.Parallel()
is := is.New(t)
require := require.New(t)
m := mockfs.NewWithDirs(t, []string{"m-0", "m-1"})
const artistName = "artist-a"
@@ -424,21 +417,21 @@ func TestMultiFolderWithSharedArtist(t *testing.T) {
}
var artist db.Artist
is.NoErr(m.DB().Where("name=?", artistName).Preload("Albums", sq).First(&artist).Error)
is.Equal(artist.Name, artistName)
is.Equal(len(artist.Albums), 2)
require.NoError(m.DB().Where("name=?", artistName).Preload("Albums", sq).First(&artist).Error)
require.Equal(artist.Name, artistName)
require.Equal(len(artist.Albums), 2)
for _, album := range artist.Albums {
is.True(album.TagYear > 0)
is.Equal(album.TagArtistID, artist.ID)
is.True(album.ChildCount > 0)
is.True(album.Duration > 0)
require.Greater(album.TagYear, 0)
require.Equal(album.TagArtistID, artist.ID)
require.Greater(album.ChildCount, 0)
require.Greater(album.Duration, 0)
}
}
func TestSymlinkedAlbum(t *testing.T) {
t.Parallel()
is := is.New(t)
require := require.New(t)
m := mockfs.NewWithDirs(t, []string{"scan"})
m.AddItemsPrefixWithCovers("temp")
@@ -452,20 +445,20 @@ func TestSymlinkedAlbum(t *testing.T) {
m.LogAlbums()
var track db.Track
is.NoErr(m.DB().Preload("Album.Parent").Find(&track).Error) // track exists
is.True(track.Album != nil) // track has album
is.True(track.Album.Cover != "") // album has cover
is.Equal(track.Album.Parent.RightPath, "artist-sym") // artist is sym
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(track.Album.Parent.RightPath, "artist-sym") // artist is sym
info, err := os.Stat(track.AbsPath())
is.NoErr(err) // track resolves
is.True(!info.IsDir()) // track resolves
is.True(!info.ModTime().IsZero()) // track resolves
require.NoError(err) // track resolves
require.False(info.IsDir()) // track resolves
require.NotZero(info.ModTime()) // track resolves
}
func TestSymlinkedSubdiscs(t *testing.T) {
t.Parallel()
is := is.New(t)
require := require.New(t)
m := mockfs.NewWithDirs(t, []string{"scan"})
addItem := func(prefix, artist, album, disc, track string) {
@@ -496,19 +489,19 @@ func TestSymlinkedSubdiscs(t *testing.T) {
m.LogAlbums()
var track db.Track
is.NoErr(m.DB().Preload("Album.Parent").Find(&track).Error) // track exists
is.True(track.Album != nil) // track has album
is.Equal(track.Album.Parent.RightPath, "album-sym") // artist is sym
require.NoError(m.DB().Preload("Album.Parent").Find(&track).Error) // track exists
require.NotNil(track.Album) // track has album
require.Equal(track.Album.Parent.RightPath, "album-sym") // artist is sym
info, err := os.Stat(track.AbsPath())
is.NoErr(err) // track resolves
is.True(!info.IsDir()) // track resolves
is.True(!info.ModTime().IsZero()) // track resolves
require.NoError(err) // track resolves
require.False(info.IsDir()) // track resolves
require.NotZero(info.ModTime()) // track resolves
}
func TestArtistHasCover(t *testing.T) {
t.Parallel()
is := is.New(t)
require := require.New(t)
m := mockfs.New(t)
m.AddItemsWithCovers()
@@ -516,17 +509,17 @@ func TestArtistHasCover(t *testing.T) {
m.ScanAndClean()
var artistWith db.Artist
is.NoErr(m.DB().Where("name=?", "artist-2").First(&artistWith).Error)
is.Equal(artistWith.Cover, "artist.png")
require.NoError(m.DB().Where("name=?", "artist-2").First(&artistWith).Error)
require.Equal(artistWith.Cover, "artist.png")
var artistWithout db.Artist
is.NoErr(m.DB().Where("name=?", "artist-0").First(&artistWithout).Error)
is.Equal(artistWithout.Cover, "")
require.NoError(m.DB().Where("name=?", "artist-0").First(&artistWithout).Error)
require.Equal(artistWithout.Cover, "")
}
func TestTagErrors(t *testing.T) {
t.Parallel()
is := is.New(t)
require := require.New(t)
m := mockfs.New(t)
m.AddItemsWithCovers()
@@ -539,22 +532,22 @@ func TestTagErrors(t *testing.T) {
var errs *multierr.Err
ctx, err := m.ScanAndCleanErr()
is.True(errors.As(err, &errs))
is.Equal(errs.Len(), 2) // we have 2 dir errors
is.Equal(ctx.SeenTracks(), m.NumTracks()-(3*2)) // we saw all tracks bar 2 album contents
is.Equal(ctx.SeenTracksNew(), m.NumTracks()-(3*2)) // we have all tracks bar 2 album contents
require.ErrorAs(err, &errs)
require.Equal(errs.Len(), 2) // we have 2 dir errors
require.Equal(ctx.SeenTracks(), m.NumTracks()-(3*2)) // we saw all tracks bar 2 album contents
require.Equal(ctx.SeenTracksNew(), m.NumTracks()-(3*2)) // we have all tracks bar 2 album contents
ctx, err = m.ScanAndCleanErr()
is.True(errors.As(err, &errs))
is.Equal(errs.Len(), 2) // we have 2 dir errors
is.Equal(ctx.SeenTracks(), m.NumTracks()-(3*2)) // we saw all tracks bar 2 album contents
is.Equal(ctx.SeenTracksNew(), 0) // we have no new tracks
require.ErrorAs(err, &errs)
require.Equal(errs.Len(), 2) // we have 2 dir errors
require.Equal(ctx.SeenTracks(), m.NumTracks()-(3*2)) // we saw all tracks bar 2 album contents
require.Equal(ctx.SeenTracksNew(), 0) // we have no new tracks
}
// https://github.com/sentriz/gonic/issues/185#issuecomment-1050092128
func TestCompilationAlbumWithoutAlbumArtist(t *testing.T) {
t.Parallel()
is := is.New(t)
require := require.New(t)
m := mockfs.New(t)
const pathArtist = "various-artists"
@@ -577,40 +570,40 @@ func TestCompilationAlbumWithoutAlbumArtist(t *testing.T) {
m.ScanAndClean()
var trackCount int
is.NoErr(m.DB().Model(&db.Track{}).Count(&trackCount).Error)
is.Equal(trackCount, 5)
require.NoError(m.DB().Model(&db.Track{}).Count(&trackCount).Error)
require.Equal(trackCount, 5)
var artists []*db.Artist
is.NoErr(m.DB().Preload("Albums").Find(&artists).Error)
is.Equal(len(artists), 1) // we only have one album artist
is.Equal(artists[0].Name, "artist 0") // it came from the first track's fallback to artist tag
is.Equal(len(artists[0].Albums), 1) // the artist has one album
is.Equal(artists[0].Albums[0].RightPath, pathAlbum)
is.Equal(artists[0].Albums[0].LeftPath, pathArtist+"/")
require.NoError(m.DB().Preload("Albums").Find(&artists).Error)
require.Equal(len(artists), 1) // we only have one album artist
require.Equal(artists[0].Name, "artist 0") // it came from the first track's fallback to artist tag
require.Equal(len(artists[0].Albums), 1) // the artist has one album
require.Equal(artists[0].Albums[0].RightPath, pathAlbum)
require.Equal(artists[0].Albums[0].LeftPath, pathArtist+"/")
}
func TestIncrementalScanNoChangeNoUpdatedAt(t *testing.T) {
t.Parallel()
is := is.New(t)
require := require.New(t)
m := mockfs.New(t)
m.AddItems()
m.ScanAndClean()
var albumA db.Album
is.NoErr(m.DB().Where("tag_artist_id NOT NULL").Order("updated_at DESC").Find(&albumA).Error)
require.NoError(m.DB().Where("tag_artist_id NOT NULL").Order("updated_at DESC").Find(&albumA).Error)
m.ScanAndClean()
var albumB db.Album
is.NoErr(m.DB().Where("tag_artist_id NOT NULL").Order("updated_at DESC").Find(&albumB).Error)
require.NoError(m.DB().Where("tag_artist_id NOT NULL").Order("updated_at DESC").Find(&albumB).Error)
is.Equal(albumA.UpdatedAt, albumB.UpdatedAt)
require.Equal(albumA.UpdatedAt, albumB.UpdatedAt)
}
// https://github.com/sentriz/gonic/issues/230
func TestAlbumAndArtistSameNameWeirdness(t *testing.T) {
t.Parallel()
is := is.NewRelaxed(t)
assert := assert.New(t)
m := mockfs.New(t)
const name = "same"
@@ -628,6 +621,6 @@ func TestAlbumAndArtistSameNameWeirdness(t *testing.T) {
m.ScanAndClean()
var albums []*db.Album
is.NoErr(m.DB().Find(&albums).Error)
is.Equal(len(albums), 5) // root, 2 artists, 2 albums
assert.NoError(m.DB().Find(&albums).Error)
assert.Equal(len(albums), 5) // root, 2 artists, 2 albums
}

28
scrobble/listenbrainz/listenbrainz_test.go
View File

@@ -11,7 +11,7 @@ import (
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"go.senan.xyz/gonic/db"
)
@@ -36,7 +36,7 @@ var submitListensResponse string
func TestScrobble(t *testing.T) {
t.Parallel()
assert := assert.New(t)
assert := require.New(t)
// arrange
client, close := httpClientMock(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -76,14 +76,14 @@ func TestScrobble(t *testing.T) {
func TestScrobbleUnauthorized(t *testing.T) {
t.Parallel()
assert := assert.New(t)
require := require.New(t)
// arrange
client, close := httpClientMock(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
assert.Equal(http.MethodPost, r.Method)
assert.Equal("/1/submit-listens", r.URL.Path)
assert.Equal("application/json", r.Header.Get("Content-Type"))
assert.Equal("Token token1", r.Header.Get("Authorization"))
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"))
w.WriteHeader(http.StatusUnauthorized)
w.Write([]byte(`{"code": 401, "error": "Invalid authorization token."}`))
@@ -108,19 +108,19 @@ func TestScrobbleUnauthorized(t *testing.T) {
}, time.Now(), true)
// assert
assert.ErrorIs(err, ErrListenBrainz)
require.ErrorIs(err, ErrListenBrainz)
}
func TestScrobbleServerError(t *testing.T) {
t.Parallel()
assert := assert.New(t)
require := require.New(t)
// arrange
client, close := httpClientMock(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
assert.Equal(http.MethodPost, r.Method)
assert.Equal("/1/submit-listens", r.URL.Path)
assert.Equal("application/json", r.Header.Get("Content-Type"))
assert.Equal("Token token1", r.Header.Get("Authorization"))
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"))
w.WriteHeader(http.StatusInternalServerError)
}))
@@ -144,5 +144,5 @@ func TestScrobbleServerError(t *testing.T) {
}, time.Now(), true)
// assert
assert.ErrorIs(err, ErrListenBrainz)
require.ErrorIs(err, ErrListenBrainz)
}