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

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
}