Tests: Add tests for internal/entity

2021-02-24 11:38:28 +01:00 · 2021-02-24 11:38:28 +01:00 · 7714ab893b
parent 2d3c4233c2
commit 7714ab893b
4 changed files with 304 additions and 0 deletions
--- a/internal/entity/album_fixtures.go
+++ b/internal/entity/album_fixtures.go
@ -83,6 +83,7 @@ var AlbumFixtures = AlbumMap{
 		AlbumNotes:       "Thunderstorms cause most of the severe spring weather.",
 		AlbumOrder:       "oldest",
 		AlbumTemplate:    "",
+		AlbumPath:        "1990/04",
 		AlbumFilter:      "path:\"1990/04\"",
 		AlbumFavorite:    false,
 		CreatedAt:        time.Date(2019, 7, 1, 0, 0, 0, 0, time.UTC),
@ -125,6 +126,23 @@ var AlbumFixtures = AlbumMap{
 		UpdatedAt:        time.Date(2020, 2, 1, 0, 0, 0, 0, time.UTC),
 		DeletedAt:        nil,
 	},
+	"2016-04": {
+		ID:               1000006,
+		CoverUID:         "",
+		AlbumUID:         "at1lxuqipogaabj8",
+		AlbumSlug:        "2016-04",
+		AlbumType:        AlbumFolder,
+		AlbumTitle:       "April 2016",
+		AlbumDescription: "",
+		AlbumNotes:       "",
+		AlbumTemplate:    "",
+		AlbumPath:        "2016/04",
+		AlbumFilter:      "path:\"2016/04\"",
+		AlbumFavorite:    false,
+		CreatedAt:        time.Date(2019, 7, 1, 0, 0, 0, 0, time.UTC),
+		UpdatedAt:        time.Date(2020, 2, 1, 0, 0, 0, 0, time.UTC),
+		DeletedAt:        nil,
+	},
 }

 // CreateAlbumFixtures inserts known entities into the database for testing.
--- a/internal/entity/album_test.go
+++ b/internal/entity/album_test.go
@ -435,3 +435,74 @@ func TestAlbum_RemovePhotos(t *testing.T) {
 		assert.Equal(t, 2, len(removed))
 	})
 }
+
+func TestAlbum_Find(t *testing.T) {
+	t.Run("existing album", func(t *testing.T) {
+		a := Album{AlbumUID: "at6axuzitogaaiax"}
+
+		if err := a.Find(); err != nil {
+			t.Fatal(err)
+		}
+	})
+	t.Run("invalid id", func(t *testing.T) {
+		a := Album{AlbumUID: "xx"}
+
+		assert.Error(t, a.Find())
+	})
+	t.Run("album not existing", func(t *testing.T) {
+		a := Album{AlbumUID: "at6axuzitogaaxxx"}
+
+		assert.Error(t, a.Find())
+	})
+}
+
+func TestAlbum_UpdateFolder(t *testing.T) {
+	t.Run("success", func(t *testing.T) {
+		a := Album{AlbumUID: "at6axuzitogaaxxx"}
+		assert.Empty(t, a.AlbumPath)
+		assert.Empty(t, a.AlbumFilter)
+		if err := a.UpdateFolder("2222/07", "month:07"); err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, "2222/07", a.AlbumPath)
+		assert.Equal(t, "month:07", a.AlbumFilter)
+	})
+
+	t.Run("empty path", func(t *testing.T) {
+		a := Album{AlbumUID: "at6axuzitogaaxxy"}
+		assert.Empty(t, a.AlbumPath)
+		assert.Empty(t, a.AlbumFilter)
+		if err := a.UpdateFolder("", "month:07"); err != nil {
+			t.Fatal(err)
+		}
+		assert.Empty(t, a.AlbumPath)
+		assert.Empty(t, a.AlbumFilter)
+	})
+}
+
+/*func TestFindFolderAlbum(t *testing.T) {
+	t.Run("1 result", func(t *testing.T) {
+		album := FindFolderAlbum("2016/04")
+
+		if album == nil {
+			t.Fatal("expected to find an album")
+		}
+
+		assert.Equal(t, "April 2016", album.AlbumTitle)
+		assert.Equal(t, "2016-04", album.AlbumSlug)
+	})
+	t.Run("no result because slug empty", func(t *testing.T) {
+		album := FindFolderAlbum("")
+
+		if album != nil {
+			t.Fatal("album should be nil")
+		}
+	})
+	t.Run("no result because not found slug", func(t *testing.T) {
+		album := FindFolderAlbum("2000/04")
+
+		if album != nil {
+			t.Fatal("album should be nil")
+		}
+	})
+}*/
--- a/internal/entity/details_test.go
+++ b/internal/entity/details_test.go
@ -35,11 +35,13 @@ func TestDetails_NoKeywords(t *testing.T) {
 		description := &Details{PhotoID: 123, Keywords: ""}

 		assert.Equal(t, true, description.NoKeywords())
+		assert.False(t, description.HasKeywords())
 	})
 	t.Run("keywords", func(t *testing.T) {
 		description := &Details{PhotoID: 123, Keywords: "test cat dog", Subject: "animals", Artist: "Bender", Notes: "notes", Copyright: "copy"}

 		assert.Equal(t, false, description.NoKeywords())
+		assert.True(t, description.HasKeywords())
 	})
 }

@ -48,11 +50,13 @@ func TestDetails_NoSubject(t *testing.T) {
 		description := &Details{PhotoID: 123, Subject: ""}

 		assert.Equal(t, true, description.NoSubject())
+		assert.False(t, description.HasSubject())
 	})
 	t.Run("subject", func(t *testing.T) {
 		description := &Details{PhotoID: 123, Keywords: "test cat dog", Subject: "animals", Artist: "Bender", Notes: "notes", Copyright: "copy"}

 		assert.Equal(t, false, description.NoSubject())
+		assert.True(t, description.HasSubject())
 	})
 }

@ -61,11 +65,13 @@ func TestDetails_NoNotes(t *testing.T) {
 		description := &Details{PhotoID: 123, Notes: ""}

 		assert.Equal(t, true, description.NoNotes())
+		assert.False(t, description.HasNotes())
 	})
 	t.Run("notes", func(t *testing.T) {
 		description := &Details{PhotoID: 123, Keywords: "test cat dog", Subject: "animals", Artist: "Bender", Notes: "notes", Copyright: "copy"}

 		assert.Equal(t, false, description.NoNotes())
+		assert.True(t, description.HasNotes())
 	})
 }

@ -74,11 +80,14 @@ func TestDetails_NoArtist(t *testing.T) {
 		description := &Details{PhotoID: 123, Artist: ""}

 		assert.Equal(t, true, description.NoArtist())
+		assert.False(t, description.HasArtist())
+
 	})
 	t.Run("artist", func(t *testing.T) {
 		description := &Details{PhotoID: 123, Keywords: "test cat dog", Subject: "animals", Artist: "Bender", Notes: "notes", Copyright: "copy"}

 		assert.Equal(t, false, description.NoArtist())
+		assert.True(t, description.HasArtist())
 	})
 }

@ -87,11 +96,28 @@ func TestDetails_NoCopyright(t *testing.T) {
 		description := &Details{PhotoID: 123, Copyright: ""}

 		assert.Equal(t, true, description.NoCopyright())
+		assert.False(t, description.HasCopyright())
 	})
 	t.Run("copyright", func(t *testing.T) {
 		description := &Details{PhotoID: 123, Keywords: "test cat dog", Subject: "animals", Artist: "Bender", Notes: "notes", Copyright: "copy"}

 		assert.Equal(t, false, description.NoCopyright())
+		assert.True(t, description.HasCopyright())
+	})
+}
+
+func TestDetails_NoLicense(t *testing.T) {
+	t.Run("no license", func(t *testing.T) {
+		description := &Details{PhotoID: 123, License: ""}
+
+		assert.Equal(t, true, description.NoLicense())
+		assert.False(t, description.HasLicense())
+	})
+	t.Run("license", func(t *testing.T) {
+		description := &Details{PhotoID: 123, Keywords: "test cat dog", Subject: "animals", Artist: "Bender", Notes: "notes", License: "copy"}
+
+		assert.Equal(t, false, description.NoLicense())
+		assert.True(t, description.HasLicense())
 	})
 }

@ -155,3 +181,147 @@ func TestDetails_Save(t *testing.T) {
 		assert.Error(t, details.Save())
 	})
 }
+
+func TestDetails_SetKeywords(t *testing.T) {
+	t.Run("no keywords", func(t *testing.T) {
+		description := &Details{PhotoID: 123, Keywords: ""}
+		assert.False(t, description.HasKeywords())
+
+		description.SetKeywords("", "manual")
+		assert.False(t, description.HasKeywords())
+	})
+	t.Run("new keywords have no priority", func(t *testing.T) {
+		description := &Details{PhotoID: 123, Keywords: "cat, brown", KeywordsSrc: SrcManual}
+		assert.Equal(t, "cat, brown", description.Keywords)
+
+		description.SetKeywords("dog", SrcMeta)
+		assert.Equal(t, "cat, brown", description.Keywords)
+	})
+	t.Run("new keywords set", func(t *testing.T) {
+		description := &Details{PhotoID: 123, Keywords: "cat, brown", KeywordsSrc: SrcMeta}
+		assert.Equal(t, "cat, brown", description.Keywords)
+
+		description.SetKeywords("dog", SrcMeta)
+		assert.Equal(t, "dog", description.Keywords)
+	})
+}
+
+func TestDetails_SetSubject(t *testing.T) {
+	t.Run("no subject", func(t *testing.T) {
+		description := &Details{PhotoID: 123, Subject: ""}
+		assert.False(t, description.HasSubject())
+
+		description.SetSubject("", "manual")
+		assert.False(t, description.HasSubject())
+	})
+	t.Run("new subject has no priority", func(t *testing.T) {
+		description := &Details{PhotoID: 123, Subject: "My cat", SubjectSrc: SrcManual}
+		assert.Equal(t, "My cat", description.Subject)
+
+		description.SetSubject("My dog", SrcMeta)
+		assert.Equal(t, "My cat", description.Subject)
+	})
+	t.Run("new subject set", func(t *testing.T) {
+		description := &Details{PhotoID: 123, Subject: "My cat", SubjectSrc: SrcMeta}
+		assert.Equal(t, "My cat", description.Subject)
+
+		description.SetSubject("My dog", SrcMeta)
+		assert.Equal(t, "My dog", description.Subject)
+	})
+}
+
+func TestDetails_SetNotes(t *testing.T) {
+	t.Run("no notes", func(t *testing.T) {
+		description := &Details{PhotoID: 123, Notes: ""}
+		assert.False(t, description.HasNotes())
+
+		description.SetNotes("", "manual")
+		assert.False(t, description.HasNotes())
+	})
+	t.Run("new notes has no priority", func(t *testing.T) {
+		description := &Details{PhotoID: 123, Notes: "My old notes", NotesSrc: SrcManual}
+		assert.Equal(t, "My old notes", description.Notes)
+
+		description.SetNotes("My new notes", SrcAuto)
+		assert.Equal(t, "My old notes", description.Notes)
+	})
+	t.Run("new notes set", func(t *testing.T) {
+		description := &Details{PhotoID: 123, Notes: "My old notes", NotesSrc: SrcMeta}
+		assert.Equal(t, "My old notes", description.Notes)
+
+		description.SetNotes("My new notes", SrcManual)
+		assert.Equal(t, "My new notes", description.Notes)
+	})
+}
+
+func TestDetails_SetArtist(t *testing.T) {
+	t.Run("no artist", func(t *testing.T) {
+		description := &Details{PhotoID: 123, Artist: ""}
+		assert.False(t, description.HasArtist())
+
+		description.SetArtist("", "manual")
+		assert.False(t, description.HasArtist())
+	})
+	t.Run("new artist has no priority", func(t *testing.T) {
+		description := &Details{PhotoID: 123, Artist: "Hans", ArtistSrc: SrcManual}
+		assert.Equal(t, "Hans", description.Artist)
+
+		description.SetArtist("Maria", SrcAuto)
+		assert.Equal(t, "Hans", description.Artist)
+	})
+	t.Run("new artist set", func(t *testing.T) {
+		description := &Details{PhotoID: 123, Artist: "Hans", ArtistSrc: SrcMeta}
+		assert.Equal(t, "Hans", description.Artist)
+
+		description.SetArtist("Maria", SrcManual)
+		assert.Equal(t, "Maria", description.Artist)
+	})
+}
+
+func TestDetails_SetCopyright(t *testing.T) {
+	t.Run("no copyright", func(t *testing.T) {
+		description := &Details{PhotoID: 123, Copyright: ""}
+		assert.False(t, description.HasCopyright())
+
+		description.SetCopyright("", "manual")
+		assert.False(t, description.HasCopyright())
+	})
+	t.Run("new copyright has no priority", func(t *testing.T) {
+		description := &Details{PhotoID: 123, Copyright: "2018", CopyrightSrc: SrcManual}
+		assert.Equal(t, "2018", description.Copyright)
+
+		description.SetCopyright("3000", SrcAuto)
+		assert.Equal(t, "2018", description.Copyright)
+	})
+	t.Run("new copyright set", func(t *testing.T) {
+		description := &Details{PhotoID: 123, Copyright: "2018", CopyrightSrc: SrcMeta}
+		assert.Equal(t, "2018", description.Copyright)
+
+		description.SetCopyright("3000", SrcManual)
+		assert.Equal(t, "3000", description.Copyright)
+	})
+}
+
+func TestDetails_SetLicense(t *testing.T) {
+	t.Run("no license", func(t *testing.T) {
+		description := &Details{PhotoID: 123, License: ""}
+		assert.False(t, description.HasLicense())
+
+		description.SetLicense("", "manual")
+		assert.False(t, description.HasLicense())
+	})
+	t.Run("new license has no priority", func(t *testing.T) {
+		description := &Details{PhotoID: 123, License: "old", LicenseSrc: SrcManual}
+		assert.Equal(t, "old", description.License)
+
+		description.SetLicense("new", SrcAuto)
+		assert.Equal(t, "old", description.License)
+	})
+	t.Run("new license set", func(t *testing.T) {
+		description := &Details{PhotoID: 123, License: "old", LicenseSrc: SrcMeta}
+		assert.Equal(t, "old", description.License)
+
+		description.SetLicense("new", SrcManual)
+		assert.Equal(t, "new", description.License)
+	})
+}
--- a/internal/entity/duplicate_test.go
+++ b/internal/entity/duplicate_test.go
@ -1,6 +1,7 @@
 package entity

 import (
+	"github.com/stretchr/testify/assert"
 	"testing"
 	"time"
 )
@ -152,3 +153,47 @@ func TestSaveDuplicate(t *testing.T) {
 		}
 	})
 }
+
+func TestDuplicate_Purge(t *testing.T) {
+	t.Run("success", func(t *testing.T) {
+		if err := AddDuplicate(
+			"forpurge.jpg",
+			RootOriginals,
+			"3cad9168fa6acc5c5c2965ddf6ec465ca42fd844",
+			661851,
+			time.Date(2019, 1, 6, 2, 6, 51, 0, time.UTC).Unix(),
+		); err != nil {
+			t.Fatal(err)
+		}
+
+		if err := AddDuplicate(
+			"forpurge.jpg",
+			RootOriginals,
+			"3cad9168fa6acc5c5c2965ddf6ec465ca42fd855",
+			661858,
+			time.Date(2019, 3, 6, 2, 6, 51, 0, time.UTC).Unix(),
+		); err != nil {
+			t.Fatal(err)
+		}
+
+		duplicate := &Duplicate{FileName: "forpurge.jpg", FileRoot: RootOriginals}
+		if err := duplicate.Find(); err != nil {
+			t.Fatal(err)
+		}
+		if err := duplicate.Purge(); err != nil {
+			t.Fatal(err)
+		}
+		if err := duplicate.Find(); err == nil {
+			t.Log("Dulicate deleted")
+		}
+	})
+}
+
+func TestPurgeDuplicate(t *testing.T) {
+	t.Run("empty filename", func(t *testing.T) {
+		assert.Error(t, PurgeDuplicate("", RootOriginals))
+	})
+	t.Run("empty fileroot", func(t *testing.T) {
+		assert.Error(t, PurgeDuplicate("test.jpg", ""))
+	})
+}