Mirrors/photoprism
1
0
Fork 0
mirror of https://github.com/photoprism/photoprism.git synced 2026-01-23 02:24:24 +00:00
Code Issues Projects Releases Wiki Activity

Test: Use PascalCase names for all Go subtests in /pkg

Browse source 
Signed-off-by: Michael Mayer <michael@photoprism.app>
This commit is contained in:
Michael Mayer 2025-10-02 15:03:47 +02:00
parent 94b6631b3d
commit b00dd133db
73 changed files with 736 additions and 736 deletions
Download patch file Download diff file Expand all files Collapse all files

1
AGENTS.md
View file

@ -161,6 +161,7 @@ Note: Across our public documentation, official images, and in production, the c
- Go: run `make fmt-go swag-fmt` to reformat the backend code + Swagger annotations (see `Makefile` for additional targets)
- Doc comments for packages and exported identifiers must be complete sentences that begin with the name of the thing being described and end with a period.
- For short examples inside comments, indent code rather than using backticks; godoc treats indented blocks as preformatted.
- Branding: Always spell the product name as `PhotoPrism`; this proper noun is an exception to generic naming rules.
- Every Go package must contain a `<package>.go` file in its root (for example, `internal/auth/jwt/jwt.go`) with the standard license header and a short package description comment explaining its purpose.
- JS/Vue: use the lint/format scripts in `frontend/package.json` (ESLint + Prettier)
- All added code and tests **must** be formatted according to our standards.

3
frontend/src/locales/pl.po
View file

@ -1,8 +1,7 @@
msgid ""
msgstr ""
"Project-Id-Version: Photoprism\n"
"Project-Id-Version: \n"
"Report-Msgid-Bugs-To: ci@photoprism.app\n"
"POT-Creation-Date: \n"
"PO-Revision-Date: 2025-10-02 11:15+0000\n"
"Last-Translator: DeepL <noreply-mt-deepl@weblate.org>\n"
"Language-Team: Polish <https://translate.photoprism.app/projects/photoprism/frontend/pl/>\n"

2
internal/config/config_cluster_test.go
View file

@ -57,7 +57,7 @@ func TestConfig_PortalUrl(t *testing.T) {
c.options.ClusterDomain = "foo.bar.baz"
assert.Equal(t, "https://portal.foo.bar.baz", c.PortalUrl())
})
t.Run("SubstitutePhotoprismClusterDomain", func(t *testing.T) {
t.Run("SubstitutePhotoPrismClusterDomain", func(t *testing.T) {
c := NewConfig(CliTestContext())
c.options.ClusterDomain = "example.dev"
// Use curly braces style as found in repo fixtures; resolver normalizes to ${...}.

2
internal/entity/album_test.go
View file

@ -1053,7 +1053,7 @@ func TestAlbum_ZipName(t *testing.T) {
assert.Equal(t, "christmas-2030.zip", result)
})
t.Run("PhotoprismAlbumNum1234Zip", func(t *testing.T) {
t.Run("PhotoPrismAlbumNum1234Zip", func(t *testing.T) {
album := Album{AlbumSlug: "a", AlbumUID: "1234"}
result := album.ZipName()

2
internal/photoprism/mediafile_thumbs_test.go
View file

@ -194,7 +194,7 @@ func TestMediaFile_GenerateThumbnails(t *testing.T) {
assert.FileExists(t, thumbFilename)
assert.NoError(t, m.GenerateThumbnails(thumbsPath, false))
})
t.Run("PhotoprismPng", func(t *testing.T) {
t.Run("PhotoPrismPng", func(t *testing.T) {
m, err := NewMediaFile("testdata/photoprism.png")
if err != nil {

2
pkg/authn/username_test.go
View file

@ -15,7 +15,7 @@ func TestUsername(t *testing.T) {
assert.Equal(t, name, s)
}
})
t.Run("Too Long", func(t *testing.T) {
t.Run("TooLong", func(t *testing.T) {
name := "teeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeest"
if s, err := Username(name); err != nil {
assert.ErrorIs(t, err, ErrTooLong)

2
pkg/clean/altitude_test.go
View file

@ -7,7 +7,7 @@ import (
)
func TestAltitude(t *testing.T) {
t.Run("0", func(t *testing.T) {
t.Run("Zero", func(t *testing.T) {
assert.Equal(t, 0, Altitude(0.0))
})
t.Run("Negative", func(t *testing.T) {

34
pkg/clean/auth_test.go
View file

@ -40,25 +40,25 @@ func TestAuth(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
assert.Equal(t, "", Auth(""))
})
t.Run("Te<s>t", func(t *testing.T) {
t.Run("TeLessThanSGreaterThanT", func(t *testing.T) {
assert.Equal(t, "Test", Auth("Te<s>t"))
})
}
func TestHandle(t *testing.T) {
t.Run("Admin ", func(t *testing.T) {
t.Run("Admin", func(t *testing.T) {
assert.Equal(t, "admin", Handle("Admin "))
})
t.Run(" Admin ", func(t *testing.T) {
t.Run("Admin", func(t *testing.T) {
assert.Equal(t, "admin", Handle(" Admin@foo "))
})
t.Run(" Admin ", func(t *testing.T) {
t.Run("Admin", func(t *testing.T) {
assert.Equal(t, "admin.foo", Handle(" Admin foo "))
})
t.Run(" admin ", func(t *testing.T) {
t.Run("Admin", func(t *testing.T) {
assert.Equal(t, "admin", Handle(" admin "))
})
t.Run("admin/user", func(t *testing.T) {
t.Run("AdminUser", func(t *testing.T) {
assert.Equal(t, "admin.user", Handle("admin/user"))
})
t.Run("Windows", func(t *testing.T) {
@ -67,25 +67,25 @@ func TestHandle(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
assert.Equal(t, "", Handle(" "))
})
t.Run("control character", func(t *testing.T) {
t.Run("ControlCharacter", func(t *testing.T) {
assert.Equal(t, "admin!", Handle("admin!"+string(rune(1))))
})
}
func TestUsername(t *testing.T) {
t.Run("Admin ", func(t *testing.T) {
t.Run("Admin", func(t *testing.T) {
assert.Equal(t, "admin", Username("Admin "))
})
t.Run(" Admin ", func(t *testing.T) {
t.Run("Admin", func(t *testing.T) {
assert.Equal(t, "admin@foo", Username(" Admin@foo "))
})
t.Run(" Admin ", func(t *testing.T) {
t.Run("Admin", func(t *testing.T) {
assert.Equal(t, "admin foo", Username(" Admin foo "))
})
t.Run(" admin ", func(t *testing.T) {
t.Run("Admin", func(t *testing.T) {
assert.Equal(t, "admin", Username(" admin "))
})
t.Run("admin/user", func(t *testing.T) {
t.Run("AdminUser", func(t *testing.T) {
assert.Equal(t, "adminuser", Username("admin/user"))
})
t.Run("Windows", func(t *testing.T) {
@ -94,7 +94,7 @@ func TestUsername(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
assert.Equal(t, "", Username(" "))
})
t.Run("control character", func(t *testing.T) {
t.Run("ControlCharacter", func(t *testing.T) {
assert.Equal(t, "admin!", Username("admin!"+string(rune(1))))
})
}
@ -146,16 +146,16 @@ func TestDomain(t *testing.T) {
}
func TestRole(t *testing.T) {
t.Run("Admin ", func(t *testing.T) {
t.Run("Admin", func(t *testing.T) {
assert.Equal(t, "admin", Role("Admin "))
})
t.Run(" Admin ", func(t *testing.T) {
t.Run("Admin", func(t *testing.T) {
assert.Equal(t, "admin", Role(" Admin "))
})
t.Run(" admin ", func(t *testing.T) {
t.Run("Admin", func(t *testing.T) {
assert.Equal(t, "admin", Role(" admin "))
})
t.Run("adm}in", func(t *testing.T) {
t.Run("AdmIn", func(t *testing.T) {
assert.Equal(t, "admin", Role("adm}in"))
})
t.Run("Empty", func(t *testing.T) {

4
pkg/clean/codec_test.go
View file

@ -10,13 +10,13 @@ func TestCodec(t *testing.T) {
t.Run("UUID", func(t *testing.T) {
assert.Equal(t, "123e4567e89b12d3A456426614174000", Codec("123e4567-e89b-12d3-A456-426614174000 "))
})
t.Run("left_224", func(t *testing.T) {
t.Run("LeftNum224", func(t *testing.T) {
assert.Equal(t, "left_224", Codec("left_224"))
})
t.Run("VP09", func(t *testing.T) {
assert.Equal(t, "VP09", Codec("VP09"))
})
t.Run("v_vp9", func(t *testing.T) {
t.Run("VVp9", func(t *testing.T) {
assert.Equal(t, "v_vp9", Codec("v_vp9"))
})
t.Run("SHA1", func(t *testing.T) {

2
pkg/clean/content_type_test.go
View file

@ -87,7 +87,7 @@ func TestContentType(t *testing.T) {
result := ContentType("video/ogg; codecs=\"vorbis\"")
assert.Equal(t, "video/ogg", result)
})
t.Run("Ú", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
result := ContentType("Ú")
assert.Equal(t, "application/octet-stream", result)
})

2
pkg/clean/duration_test.go
View file

@ -31,7 +31,7 @@ func TestDuration(t *testing.T) {
result := Duration("1.0 m0.01 s ")
assert.Equal(t, "1.0m0.01s", result)
})
t.Run("01:00", func(t *testing.T) {
t.Run("Num01Num00", func(t *testing.T) {
result := Duration("01:00")
assert.Equal(t, "01:00", result)
})

8
pkg/clean/filename_test.go
View file

@ -13,10 +13,10 @@ func TestFileName(t *testing.T) {
t.Run("File", func(t *testing.T) {
assert.Equal(t, "filename.TXT", FileName("filename.TXT"))
})
t.Run("The quick brown fox.", func(t *testing.T) {
t.Run("TheQuickBrownFox", func(t *testing.T) {
assert.Equal(t, "The quick brown fox.", FileName("The quick brown fox."))
})
t.Run("filename.txt", func(t *testing.T) {
t.Run("FilenameTxt", func(t *testing.T) {
assert.Equal(t, "filename.txt", FileName("filename.txt"))
})
t.Run("Empty", func(t *testing.T) {
@ -34,10 +34,10 @@ func TestFileName(t *testing.T) {
t.Run("Replace", func(t *testing.T) {
assert.Equal(t, "", FileName("${https://<host>:<port>/<path>}"))
})
t.Run("file?name.jpg", func(t *testing.T) {
t.Run("FileNameJpg", func(t *testing.T) {
assert.Equal(t, "filename.jpg", FileName("file?name.jpg"))
})
t.Run("Control Character", func(t *testing.T) {
t.Run("ControlCharacter", func(t *testing.T) {
assert.Equal(t, "filename.", FileName("filename."+string(rune(127))))
})
}

2
pkg/clean/id_test.go
View file

@ -40,7 +40,7 @@ func TestUID(t *testing.T) {
}
func TestIdUint(t *testing.T) {
t.Run("12334545", func(t *testing.T) {
t.Run("Num12334545", func(t *testing.T) {
assert.Equal(t, uint(12334545), IdUint("12334545"))
})
t.Run("ThumbSize", func(t *testing.T) {

14
pkg/clean/log_test.go
View file

@ -9,13 +9,13 @@ import (
)
func TestLog(t *testing.T) {
t.Run("The quick brown fox.", func(t *testing.T) {
t.Run("TheQuickBrownFox", func(t *testing.T) {
assert.Equal(t, "'The quick brown fox.'", Log("The quick brown fox."))
})
t.Run("filename.txt", func(t *testing.T) {
t.Run("FilenameTxt", func(t *testing.T) {
assert.Equal(t, "filename.txt", Log("filename.txt"))
})
t.Run("empty string", func(t *testing.T) {
t.Run("EmptyString", func(t *testing.T) {
assert.Equal(t, "''", Log(""))
})
t.Run("Replace", func(t *testing.T) {
@ -38,7 +38,7 @@ func TestLog(t *testing.T) {
}
func TestLogQuote(t *testing.T) {
t.Run("The quick brown fox.", func(t *testing.T) {
t.Run("TheQuickBrownFox", func(t *testing.T) {
assert.Equal(t, "'The quick brown fox.'", LogQuote("The quick brown fox."))
})
t.Run("SpecialChars", func(t *testing.T) {
@ -47,13 +47,13 @@ func TestLogQuote(t *testing.T) {
}
func TestLogLower(t *testing.T) {
t.Run("The quick brown fox.", func(t *testing.T) {
t.Run("TheQuickBrownFox", func(t *testing.T) {
assert.Equal(t, "'the quick brown fox.'", LogLower("The quick brown fox."))
})
t.Run("filename.txt", func(t *testing.T) {
t.Run("FilenameTxt", func(t *testing.T) {
assert.Equal(t, "filename.txt", LogLower("filename.TXT"))
})
t.Run("empty string", func(t *testing.T) {
t.Run("EmptyString", func(t *testing.T) {
assert.Equal(t, "''", LogLower(""))
})
t.Run("Replace", func(t *testing.T) {

4
pkg/clean/name_test.go
View file

@ -28,7 +28,7 @@ func TestName(t *testing.T) {
t.Run("Chinese", func(t *testing.T) {
assert.Equal(t, "陈 赵", Name(" 陈 赵"))
})
t.Run("Control Character", func(t *testing.T) {
t.Run("ControlCharacter", func(t *testing.T) {
assert.Equal(t, "William Henry Gates III", Name("William Henry Gates III"+string(rune(1))))
})
t.Run("Space", func(t *testing.T) {
@ -82,7 +82,7 @@ func TestDlName(t *testing.T) {
t.Run("Chinese", func(t *testing.T) {
assert.Equal(t, "陈 赵", DlName(" 陈 赵"))
})
t.Run("Control Character", func(t *testing.T) {
t.Run("ControlCharacter", func(t *testing.T) {
assert.Equal(t, "William Henry Gates III", DlName("William Henry Gates III"+string(rune(1))))
})
t.Run("Space", func(t *testing.T) {

4
pkg/clean/numeric_test.go
View file

@ -19,11 +19,11 @@ func TestNumeric(t *testing.T) {
result := Numeric("0")
assert.Equal(t, "0", result)
})
t.Run("0.5", func(t *testing.T) {
t.Run("ZeroFive", func(t *testing.T) {
result := Numeric("0.5")
assert.Equal(t, "0.5", result)
})
t.Run("01:00", func(t *testing.T) {
t.Run("Num01Num00", func(t *testing.T) {
result := Numeric("01:00")
assert.Equal(t, "0100", result)
})

12
pkg/clean/path_test.go
View file

@ -13,10 +13,10 @@ func TestPath(t *testing.T) {
t.Run("ValidFile", func(t *testing.T) {
assert.Equal(t, "filename.TXT", Path("filename.TXT"))
})
t.Run("The quick brown fox.", func(t *testing.T) {
t.Run("TheQuickBrownFox", func(t *testing.T) {
assert.Equal(t, "The quick brown fox.", Path("The quick brown fox."))
})
t.Run("filename.txt", func(t *testing.T) {
t.Run("FilenameTxt", func(t *testing.T) {
assert.Equal(t, "filename.txt", Path("filename.txt"))
})
t.Run("Empty", func(t *testing.T) {
@ -34,10 +34,10 @@ func TestPath(t *testing.T) {
t.Run("Replace", func(t *testing.T) {
assert.Equal(t, "", Path("${https://<host>:<port>/<path>}"))
})
t.Run("Control Character", func(t *testing.T) {
t.Run("ControlCharacter", func(t *testing.T) {
assert.Equal(t, "filename.", Path("filename."+string(rune(127))))
})
t.Run("Special Chars", func(t *testing.T) {
t.Run("SpecialChars", func(t *testing.T) {
assert.Equal(t, "filename.", Path("filename.?**"))
})
t.Run("IncludesHash", func(t *testing.T) {
@ -55,10 +55,10 @@ func TestUserPath(t *testing.T) {
t.Run("ValidFile", func(t *testing.T) {
assert.Equal(t, "filename.TXT", UserPath("filename.TXT"))
})
t.Run("The quick brown fox.", func(t *testing.T) {
t.Run("TheQuickBrownFox", func(t *testing.T) {
assert.Equal(t, "The quick brown fox", UserPath("The quick brown fox."))
})
t.Run("filename.txt", func(t *testing.T) {
t.Run("FilenameTxt", func(t *testing.T) {
assert.Equal(t, "filename.txt", UserPath("filename.txt"))
})
t.Run("Empty", func(t *testing.T) {

6
pkg/clean/state_test.go
View file

@ -35,7 +35,7 @@ func TestState(t *testing.T) {
result := State("Washington", "us")
assert.Equal(t, "Washington", result)
})
t.Run("Never mind Nirvana", func(t *testing.T) {
t.Run("NeverMindNirvana", func(t *testing.T) {
result := State("Never mind Nirvana.", "us")
assert.Equal(t, "Never mind Nirvana.", result)
})
@ -51,11 +51,11 @@ func TestState(t *testing.T) {
result := State(" ", "us")
assert.Equal(t, "", result)
})
t.Run("Control Character", func(t *testing.T) {
t.Run("ControlCharacter", func(t *testing.T) {
result := State("Washington"+string(rune(127)), "us")
assert.Equal(t, "Washington", result)
})
t.Run("Special Chars", func(t *testing.T) {
t.Run("SpecialChars", func(t *testing.T) {
result := State("Wa?shing*ton"+string(rune(127)), "us")
assert.Equal(t, "Washington", result)
})

8
pkg/fs/cache_test.go
View file

@ -9,19 +9,19 @@ import (
)
func TestCachePath(t *testing.T) {
t.Run("hash too short", func(t *testing.T) {
t.Run("HashTooShort", func(t *testing.T) {
result, err := CachePath("/foo/bar", "123", "baz", false)
assert.Equal(t, "", result)
assert.EqualError(t, err, "cache: hash '123' is too short")
})
t.Run("namespace empty", func(t *testing.T) {
t.Run("NamespaceEmpty", func(t *testing.T) {
result, err := CachePath("/foo/bar", "123hjfju567695", "", false)
assert.Equal(t, "", result)
assert.EqualError(t, err, "cache: namespace for hash '123hjfju567695' is empty")
})
t.Run("1234567890abcdef", func(t *testing.T) {
t.Run("Num1234567890Abcdef", func(t *testing.T) {
result, err := CachePath("/foo/bar", "1234567890abcdef", "baz", false)
if err != nil {
@ -30,7 +30,7 @@ func TestCachePath(t *testing.T) {
assert.Equal(t, "/foo/bar/baz/1/2/3", result)
})
t.Run("create", func(t *testing.T) {
t.Run("Create", func(t *testing.T) {
ns := "pkg_fs_test"
result, err := CachePath(os.TempDir(), "1234567890abcdef", ns, true)

8
pkg/fs/canonical_test.go
View file

@ -8,16 +8,16 @@ import (
)
func TestNonCanonical(t *testing.T) {
t.Run("short", func(t *testing.T) {
t.Run("Short", func(t *testing.T) {
assert.Equal(t, true, NonCanonical("short"))
})
t.Run("short_", func(t *testing.T) {
t.Run("Short", func(t *testing.T) {
assert.Equal(t, true, NonCanonical("short/short/short/test1_"))
})
t.Run("short?", func(t *testing.T) {
t.Run("Short", func(t *testing.T) {
assert.Equal(t, true, NonCanonical("short#short_short_test1?"))
})
t.Run("short/test_test_test1234", func(t *testing.T) {
t.Run("ShortTestTestTest1234", func(t *testing.T) {
assert.Equal(t, false, NonCanonical("hort/test_test_test12345"))
})
}

2
pkg/fs/case_test.go
View file

@ -8,7 +8,7 @@ import (
)
func TestCaseInsensitive(t *testing.T) {
t.Run("temp", func(t *testing.T) {
t.Run("Temp", func(t *testing.T) {
if result, err := CaseInsensitive(os.TempDir()); err != nil {
t.Fatal(err)
} else {

12
pkg/fs/directories_test.go
View file

@ -8,7 +8,7 @@ import (
)
func TestDirs(t *testing.T) {
t.Run("recursive", func(t *testing.T) {
t.Run("Recursive", func(t *testing.T) {
result, err := Dirs("testdata", true, true)
if err != nil {
@ -23,7 +23,7 @@ func TestDirs(t *testing.T) {
assert.NotContains(t, result, "/originals/storage")
assert.Contains(t, result, "/linked")
})
t.Run("recursive no-symlinks", func(t *testing.T) {
t.Run("RecursiveNoSymlinks", func(t *testing.T) {
result, err := Dirs("testdata", true, false)
if err != nil {
@ -35,7 +35,7 @@ func TestDirs(t *testing.T) {
assert.Contains(t, result, "/directory/subdirectory/animals")
assert.Contains(t, result, "/linked")
})
t.Run("non-recursive", func(t *testing.T) {
t.Run("NonRecursive", func(t *testing.T) {
result, err := Dirs("testdata", false, true)
if err != nil {
@ -45,7 +45,7 @@ func TestDirs(t *testing.T) {
assert.Contains(t, result, "/directory")
assert.Contains(t, result, "/linked")
})
t.Run("non-recursive no-symlinks", func(t *testing.T) {
t.Run("NonRecursiveNoSymlinks", func(t *testing.T) {
result, err := Dirs("testdata/directory/subdirectory", false, false)
if err != nil {
@ -55,7 +55,7 @@ func TestDirs(t *testing.T) {
assert.Len(t, result, 1)
assert.Contains(t, result, "/animals")
})
t.Run("non-recursive symlinks", func(t *testing.T) {
t.Run("NonRecursiveSymlinks", func(t *testing.T) {
result, err := Dirs("testdata/linked", false, true)
if err != nil {
@ -65,7 +65,7 @@ func TestDirs(t *testing.T) {
assert.Contains(t, result, "/photoprism")
assert.Contains(t, result, "/self")
})
t.Run("no-result", func(t *testing.T) {
t.Run("NoResult", func(t *testing.T) {
result, err := Dirs("testdata/linked", false, false)
if err != nil {

2
pkg/fs/done_test.go
View file

@ -7,7 +7,7 @@ import (
)
func TestProcessed(t *testing.T) {
t.Run("jpeg", func(t *testing.T) {
t.Run("Jpeg", func(t *testing.T) {
assert.True(t, Processed.Processed())
assert.False(t, Found.Processed())
})

50
pkg/fs/file_ext_test.go
View file

@ -7,35 +7,35 @@ import (
)
func TestNormalizeExt(t *testing.T) {
t.Run("none", func(t *testing.T) {
t.Run("None", func(t *testing.T) {
result := NormalizedExt("testdata/test")
assert.Equal(t, "", result)
})
t.Run("dot", func(t *testing.T) {
t.Run("Dot", func(t *testing.T) {
result := NormalizedExt("testdata/test.")
assert.Equal(t, "", result)
})
t.Run("test.z", func(t *testing.T) {
t.Run("TestZ", func(t *testing.T) {
result := NormalizedExt("testdata/test.z")
assert.Equal(t, "z", result)
})
t.Run("test.jpg", func(t *testing.T) {
t.Run("TestJpg", func(t *testing.T) {
result := NormalizedExt("testdata/test.jpg")
assert.Equal(t, "jpg", result)
})
t.Run("test.PNG", func(t *testing.T) {
t.Run("TestPng", func(t *testing.T) {
result := NormalizedExt("testdata/test.PNG")
assert.Equal(t, "png", result)
})
t.Run("test.MOV", func(t *testing.T) {
t.Run("TestMov", func(t *testing.T) {
result := NormalizedExt("testdata/test.MOV")
assert.Equal(t, "mov", result)
})
t.Run("test.xmp", func(t *testing.T) {
t.Run("TestXmp", func(t *testing.T) {
result := NormalizedExt("testdata/test.xMp")
assert.Equal(t, "xmp", result)
})
t.Run("test.MP", func(t *testing.T) {
t.Run("TestMp", func(t *testing.T) {
result := NormalizedExt("testdata/test.mp")
assert.Equal(t, "mp", result)
})
@ -63,69 +63,69 @@ func TestTrimExt(t *testing.T) {
}
func TestStripExt(t *testing.T) {
t.Run("Test.jpg", func(t *testing.T) {
t.Run("TestJpg", func(t *testing.T) {
result := StripExt("/testdata/Test.jpg")
assert.Equal(t, "/testdata/Test", result)
})
t.Run("Test.jpg.json", func(t *testing.T) {
t.Run("TestJpgJson", func(t *testing.T) {
result := StripExt("/testdata/Test.jpg.json")
assert.Equal(t, "/testdata/Test.jpg", result)
})
t.Run("Test copy 3.foo", func(t *testing.T) {
t.Run("TestCopyThreeFoo", func(t *testing.T) {
result := StripExt("/testdata/Test copy 3.foo")
assert.Equal(t, "/testdata/Test copy 3", result)
})
}
func TestStripKnownExt(t *testing.T) {
t.Run("Test.jpg", func(t *testing.T) {
t.Run("TestJpg", func(t *testing.T) {
result := StripKnownExt("/testdata/Test.jpg")
assert.Equal(t, "/testdata/Test", result)
})
t.Run("Test.jpg.json", func(t *testing.T) {
t.Run("TestJpgJson", func(t *testing.T) {
result := StripKnownExt("/testdata/Test.jpg.json")
assert.Equal(t, "/testdata/Test", result)
})
t.Run("Test copy 3.foo", func(t *testing.T) {
t.Run("TestCopyThreeFoo", func(t *testing.T) {
result := StripKnownExt("/testdata/Test copy 3.foo")
assert.Equal(t, "/testdata/Test copy 3.foo", result)
})
t.Run("my/file.jpg.json.xmp", func(t *testing.T) {
t.Run("MyFileJpgJsonXmp", func(t *testing.T) {
result := StripKnownExt("my/file.jpg.json.xmp")
assert.Equal(t, "my/file", result)
})
t.Run("my/jpg/avi.foo.bar.baz", func(t *testing.T) {
t.Run("MyJpgAviFooBarBaz", func(t *testing.T) {
result := StripKnownExt("my/jpg/avi.foo.bar.baz")
assert.Equal(t, "my/jpg/avi.foo.bar.baz", result)
})
t.Run("eps.heic", func(t *testing.T) {
t.Run("EpsHeic", func(t *testing.T) {
result := StripKnownExt("eps.heic")
assert.Equal(t, "eps", result)
})
t.Run("jpg.eps.heic", func(t *testing.T) {
t.Run("JpgEpsHeic", func(t *testing.T) {
result := StripKnownExt("jpg.eps.heic")
assert.Equal(t, "jpg", result)
})
t.Run("eps.jpg.heic", func(t *testing.T) {
t.Run("EpsJpgHeic", func(t *testing.T) {
result := StripKnownExt("eps.jpg.heic")
assert.Equal(t, "eps", result)
})
t.Run("/testdata/eps.heic", func(t *testing.T) {
t.Run("TestdataEpsHeic", func(t *testing.T) {
result := StripKnownExt("/testdata/eps.heic")
assert.Equal(t, "/testdata/eps", result)
})
}
func TestExt(t *testing.T) {
t.Run("Test.jpg", func(t *testing.T) {
t.Run("TestJpg", func(t *testing.T) {
result := Ext("/testdata/Test.jpg")
assert.Equal(t, ".jpg", result)
})
t.Run("Test.jpg.json", func(t *testing.T) {
t.Run("TestJpgJson", func(t *testing.T) {
result := Ext("/testdata/Test.jpg.json")
assert.Equal(t, ".jpg.json", result)
})
t.Run("Test copy 3.foo", func(t *testing.T) {
t.Run("TestCopyThreeFoo", func(t *testing.T) {
result := Ext("/testdata/Test copy 3.foo")
assert.Equal(t, ".foo", result)
})
@ -136,10 +136,10 @@ func TestExt(t *testing.T) {
}
func TestArchiveExt(t *testing.T) {
t.Run("zip", func(t *testing.T) {
t.Run("Zip", func(t *testing.T) {
assert.Equal(t, ExtZip, ArchiveExt("/testdata/archive.ZIP"))
})
t.Run("not archive", func(t *testing.T) {
t.Run("NotArchive", func(t *testing.T) {
assert.Equal(t, "", ArchiveExt("/testdata/file.jpg"))
})
}

10
pkg/fs/file_exts_test.go
View file

@ -10,13 +10,13 @@ func TestFileExtensions_Known(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
assert.False(t, Extensions.Known(""))
})
t.Run("jpg", func(t *testing.T) {
t.Run("Jpg", func(t *testing.T) {
assert.True(t, Extensions.Known("testdata/test.jpg"))
})
t.Run("jpeg", func(t *testing.T) {
t.Run("Jpeg", func(t *testing.T) {
assert.True(t, Extensions.Known("testdata/test.jpeg"))
})
t.Run("cr2", func(t *testing.T) {
t.Run("Cr2", func(t *testing.T) {
assert.True(t, Extensions.Known("testdata/.xxx/test (jpg).cr2"))
})
t.Run("CR2", func(t *testing.T) {
@ -25,10 +25,10 @@ func TestFileExtensions_Known(t *testing.T) {
t.Run("CR5", func(t *testing.T) {
assert.False(t, Extensions.Known("testdata/test (jpg).CR5"))
})
t.Run("mp", func(t *testing.T) {
t.Run("Mp", func(t *testing.T) {
assert.True(t, Extensions.Known("file.mp"))
})
t.Run("mxf", func(t *testing.T) {
t.Run("Mxf", func(t *testing.T) {
assert.True(t, Extensions.Known("file.mxf"))
})
}

58
pkg/fs/file_type_test.go
View file

@ -7,7 +7,7 @@ import (
)
func TestType_String(t *testing.T) {
t.Run("jpg", func(t *testing.T) {
t.Run("Jpg", func(t *testing.T) {
assert.Equal(t, "jpg", ImageJpeg.String())
})
}
@ -17,35 +17,35 @@ func TestType_ToUpper(t *testing.T) {
}
func TestType_Equal(t *testing.T) {
t.Run("jpg", func(t *testing.T) {
t.Run("Jpg", func(t *testing.T) {
assert.True(t, ImageJpeg.Equal("jpg"))
})
}
func TestType_NotEqual(t *testing.T) {
t.Run("jpg", func(t *testing.T) {
t.Run("Jpg", func(t *testing.T) {
assert.False(t, ImageJpeg.NotEqual("JPG"))
assert.True(t, ImageJpeg.NotEqual("xmp"))
})
}
func TestType_DefaultExt(t *testing.T) {
t.Run("jpg", func(t *testing.T) {
t.Run("Jpg", func(t *testing.T) {
assert.Equal(t, ".jpg", ImageJpeg.DefaultExt())
})
t.Run("avif", func(t *testing.T) {
t.Run("Avif", func(t *testing.T) {
assert.Equal(t, ".avif", ImageAvif.DefaultExt())
})
}
func TestToType(t *testing.T) {
t.Run("jpg", func(t *testing.T) {
t.Run("Jpg", func(t *testing.T) {
assert.Equal(t, "jpg", NewType("JPG").String())
})
t.Run("JPEG", func(t *testing.T) {
assert.Equal(t, Type("jpeg"), NewType("JPEG"))
})
t.Run(".jpg", func(t *testing.T) {
t.Run("Jpg", func(t *testing.T) {
assert.Equal(t, "jpg", NewType(".jpg").String())
})
}
@ -66,27 +66,27 @@ func TestType_Is(t *testing.T) {
}
func TestType_Find(t *testing.T) {
t.Run("find jpg", func(t *testing.T) {
t.Run("FindJpg", func(t *testing.T) {
result := ImageJpeg.Find("testdata/test.xmp", false)
assert.Equal(t, "testdata/test.jpg", result)
})
t.Run("upper ext", func(t *testing.T) {
t.Run("UpperExt", func(t *testing.T) {
result := ImageJpeg.Find("testdata/test.XMP", false)
assert.Equal(t, "testdata/test.jpg", result)
})
t.Run("with sequence", func(t *testing.T) {
t.Run("WithSequence", func(t *testing.T) {
result := ImageJpeg.Find("testdata/test (2).xmp", false)
assert.Equal(t, "", result)
})
t.Run("strip sequence", func(t *testing.T) {
t.Run("StripSequence", func(t *testing.T) {
result := ImageJpeg.Find("testdata/test (2).xmp", true)
assert.Equal(t, "testdata/test.jpg", result)
})
t.Run("name upper", func(t *testing.T) {
t.Run("NameUpper", func(t *testing.T) {
result := ImageJpeg.Find("testdata/CATYELLOW.xmp", true)
assert.Equal(t, "testdata/CATYELLOW.jpg", result)
})
t.Run("name lower", func(t *testing.T) {
t.Run("NameLower", func(t *testing.T) {
result := ImageJpeg.Find("testdata/chameleon_lime.xmp", true)
assert.Equal(t, "testdata/chameleon_lime.jpg", result)
})
@ -95,63 +95,63 @@ func TestType_Find(t *testing.T) {
func TestType_FindFirst(t *testing.T) {
dirs := []string{PPHiddenPathname}
t.Run("find xmp", func(t *testing.T) {
t.Run("FindXmp", func(t *testing.T) {
result := SidecarXMP.FindFirst("testdata/test.jpg", dirs, "", false)
assert.Equal(t, "testdata/.photoprism/test.xmp", result)
})
t.Run("find xmp upper ext", func(t *testing.T) {
t.Run("FindXmpUpperExt", func(t *testing.T) {
result := SidecarXMP.FindFirst("testdata/test.PNG", dirs, "", false)
assert.Equal(t, "testdata/.photoprism/test.xmp", result)
})
t.Run("find xmp without sequence", func(t *testing.T) {
t.Run("FindXmpWithoutSequence", func(t *testing.T) {
result := SidecarXMP.FindFirst("testdata/test (2).jpg", dirs, "", false)
assert.Equal(t, "", result)
})
t.Run("find xmp with sequence", func(t *testing.T) {
t.Run("FindXmpWithSequence", func(t *testing.T) {
result := SidecarXMP.FindFirst("testdata/test (2).jpg", dirs, "", true)
assert.Equal(t, "testdata/.photoprism/test.xmp", result)
})
t.Run("find jpg", func(t *testing.T) {
t.Run("FindJpg", func(t *testing.T) {
result := ImageJpeg.FindFirst("testdata/test.xmp", dirs, "", false)
assert.Equal(t, "testdata/test.jpg", result)
})
t.Run("find jpg abs", func(t *testing.T) {
t.Run("FindJpgAbs", func(t *testing.T) {
result := ImageJpeg.FindFirst(Abs("testdata/test.xmp"), dirs, "", false)
assert.Equal(t, Abs("testdata/test.jpg"), result)
})
t.Run("upper ext", func(t *testing.T) {
t.Run("UpperExt", func(t *testing.T) {
result := ImageJpeg.FindFirst("testdata/test.XMP", dirs, "", false)
assert.Equal(t, "testdata/test.jpg", result)
})
t.Run("with sequence", func(t *testing.T) {
t.Run("WithSequence", func(t *testing.T) {
result := ImageJpeg.FindFirst("testdata/test (2).xmp", dirs, "", false)
assert.Equal(t, "", result)
})
t.Run("strip sequence", func(t *testing.T) {
t.Run("StripSequence", func(t *testing.T) {
result := ImageJpeg.FindFirst("testdata/test (2).xmp", dirs, "", true)
assert.Equal(t, "testdata/test.jpg", result)
})
t.Run("name upper", func(t *testing.T) {
t.Run("NameUpper", func(t *testing.T) {
result := ImageJpeg.FindFirst("testdata/CATYELLOW.xmp", dirs, "", true)
assert.Equal(t, "testdata/CATYELLOW.jpg", result)
})
t.Run("name lower", func(t *testing.T) {
t.Run("NameLower", func(t *testing.T) {
result := ImageJpeg.FindFirst("testdata/chameleon_lime.xmp", dirs, "", true)
assert.Equal(t, "testdata/chameleon_lime.jpg", result)
})
t.Run("example_bmp_notfound", func(t *testing.T) {
t.Run("ExampleBmpNotfound", func(t *testing.T) {
result := ImageBmp.FindFirst("testdata/example.00001.jpg", dirs, "", true)
assert.Equal(t, "", result)
})
t.Run("example_bmp_found", func(t *testing.T) {
t.Run("ExampleBmpFound", func(t *testing.T) {
result := ImageBmp.FindFirst("testdata/example.00001.jpg", []string{"directory"}, "", true)
assert.Equal(t, "testdata/directory/example.bmp", result)
})
t.Run("example_png_found", func(t *testing.T) {
t.Run("ExamplePngFound", func(t *testing.T) {
result := ImagePng.FindFirst("testdata/example.00001.jpg", []string{"directory", "directory/subdirectory"}, "", true)
assert.Equal(t, "testdata/directory/subdirectory/example.png", result)
})
t.Run("example_bmp_found", func(t *testing.T) {
t.Run("ExampleBmpFound", func(t *testing.T) {
result := ImageBmp.FindFirst(Abs("testdata/example.00001.jpg"), []string{"directory"}, Abs("testdata"), true)
assert.Equal(t, Abs("testdata/directory/example.bmp"), result)
})
@ -160,7 +160,7 @@ func TestType_FindFirst(t *testing.T) {
func TestType_FindAll(t *testing.T) {
dirs := []string{PPHiddenPathname}
t.Run("CATYELLOW.jpg", func(t *testing.T) {
t.Run("CatyellowJpg", func(t *testing.T) {
result := ImageJpeg.FindAll("testdata/CATYELLOW.JSON", dirs, "", false)
assert.Contains(t, result, "testdata/CATYELLOW.jpg")
})

50
pkg/fs/filepath_test.go
View file

@ -11,82 +11,82 @@ func TestBasePrefix(t *testing.T) {
assert.Equal(t, "", BasePrefix("", true))
assert.Equal(t, "", BasePrefix("", false))
})
t.Run("Screenshot 2019-05-21 at 10.45.52.png", func(t *testing.T) {
t.Run("ScreenshotNum2019Num05Num21AtTenNum45Num52Png", func(t *testing.T) {
regular := BasePrefix("Screenshot 2019-05-21 at 10.45.52.png", false)
assert.Equal(t, "Screenshot 2019-05-21 at 10.45.52", regular)
stripped := BasePrefix("Screenshot 2019-05-21 at 10.45.52.png", true)
assert.Equal(t, "Screenshot 2019-05-21 at 10.45.52", stripped)
})
t.Run("Test.jpg", func(t *testing.T) {
t.Run("TestJpg", func(t *testing.T) {
result := BasePrefix("/testdata/Test.jpg", true)
assert.Equal(t, "Test", result)
})
t.Run("Test.jpg.json", func(t *testing.T) {
t.Run("TestJpgJson", func(t *testing.T) {
result := BasePrefix("/testdata/Test.jpg.json", true)
assert.Equal(t, "Test", result)
})
t.Run("Test copy 3.jpg", func(t *testing.T) {
t.Run("TestCopyThreeJpg", func(t *testing.T) {
result := BasePrefix("/testdata/Test copy 3.jpg", true)
assert.Equal(t, "Test", result)
})
t.Run("Test (3).jpg", func(t *testing.T) {
t.Run("TestThreeJpg", func(t *testing.T) {
result := BasePrefix("/testdata/Test (3).jpg", true)
assert.Equal(t, "Test", result)
})
t.Run("Test.jpg", func(t *testing.T) {
t.Run("TestJpg", func(t *testing.T) {
result := BasePrefix("/testdata/Test.jpg", false)
assert.Equal(t, "Test", result)
})
t.Run("Test.3453453.jpg", func(t *testing.T) {
t.Run("TestNum3453453Jpg", func(t *testing.T) {
regular := BasePrefix("/testdata/Test.3453453.jpg", false)
assert.Equal(t, "Test.3453453", regular)
stripped := BasePrefix("/testdata/Test.3453453.jpg", true)
assert.Equal(t, "Test", stripped)
})
t.Run("/foo/bar.0000.ZIP", func(t *testing.T) {
t.Run("FooBarNum0000Zip", func(t *testing.T) {
regular := BasePrefix("/foo/bar.0000.ZIP", false)
assert.Equal(t, "bar.0000", regular)
stripped := BasePrefix("/foo/bar.0000.ZIP", true)
assert.Equal(t, "bar.0000", stripped)
})
t.Run("/foo/bar.00001.ZIP", func(t *testing.T) {
t.Run("FooBarNum00001Zip", func(t *testing.T) {
regular := BasePrefix("/foo/bar.00001.ZIP", false)
assert.Equal(t, "bar.00001", regular)
stripped := BasePrefix("/foo/bar.00001.ZIP", true)
assert.Equal(t, "bar", stripped)
})
t.Run("Test copy 3.jpg", func(t *testing.T) {
t.Run("TestCopyThreeJpg", func(t *testing.T) {
result := BasePrefix("/testdata/Test copy 3.jpg", false)
assert.Equal(t, "Test copy 3", result)
})
t.Run("Test (3).jpg", func(t *testing.T) {
t.Run("TestThreeJpg", func(t *testing.T) {
result := BasePrefix("/testdata/Test (3).jpg", false)
assert.Equal(t, "Test (3)", result)
})
t.Run("20180506_091537_DSC02122.JPG", func(t *testing.T) {
t.Run("Num20180506Num091537DscNum02122Jpg", func(t *testing.T) {
result := BasePrefix("20180506_091537_DSC02122.JPG", true)
assert.Equal(t, "20180506_091537_DSC02122", result)
})
t.Run("20180506_091537_DSC02122 (+3.3).JPG", func(t *testing.T) {
t.Run("Num20180506Num091537DscNum02122ThreeThreeJpg", func(t *testing.T) {
result := BasePrefix("20180506_091537_DSC02122 (+3.3).JPG", true)
assert.Equal(t, "20180506_091537_DSC02122", result)
})
t.Run("20180506_091537_DSC02122 (-2.7).JPG", func(t *testing.T) {
t.Run("Num20180506Num091537DscNum02122TwoSevenJpg", func(t *testing.T) {
result := BasePrefix("20180506_091537_DSC02122 (-2.7).JPG", true)
assert.Equal(t, "20180506_091537_DSC02122", result)
})
t.Run("20180506_091537_DSC02122(+3.3).JPG", func(t *testing.T) {
t.Run("Num20180506Num091537DscNum02122ThreeThreeJpg", func(t *testing.T) {
result := BasePrefix("20180506_091537_DSC02122(+3.3).JPG", true)
assert.Equal(t, "20180506_091537_DSC02122", result)
})
t.Run("20180506_091537_DSC02122(-2.7).JPG", func(t *testing.T) {
t.Run("Num20180506Num091537DscNum02122TwoSevenJpg", func(t *testing.T) {
result := BasePrefix("20180506_091537_DSC02122(-2.7).JPG", true)
assert.Equal(t, "20180506_091537_DSC02122", result)
})
t.Run("1996 001.jpg", func(t *testing.T) {
t.Run("Num1996Num001Jpg", func(t *testing.T) {
result := BasePrefix("1996 001.jpg", true)
assert.Equal(t, "1996 001", result)
})
@ -97,29 +97,29 @@ func TestRelPrefix(t *testing.T) {
assert.Equal(t, "", RelPrefix("", "", true))
assert.Equal(t, "", RelPrefix("", "", false))
})
t.Run("/foo/bar.0000.ZIP", func(t *testing.T) {
t.Run("FooBarNum0000Zip", func(t *testing.T) {
regular := RelPrefix("/foo/bar.0000.ZIP", "/bar", false)
assert.Equal(t, "/foo/bar.0000", regular)
stripped := RelPrefix("/foo/bar.0000.ZIP", "/bar", true)
assert.Equal(t, "/foo/bar.0000", stripped)
})
t.Run("/foo/bar.00001.ZIP", func(t *testing.T) {
t.Run("FooBarNum00001Zip", func(t *testing.T) {
regular := RelPrefix("/foo/bar.00001.ZIP", "/bar", false)
assert.Equal(t, "/foo/bar.00001", regular)
stripped := RelPrefix("/foo/bar.00001.ZIP", "/bar", true)
assert.Equal(t, "/foo/bar", stripped)
})
t.Run("Test copy 3.jpg", func(t *testing.T) {
t.Run("TestCopyThreeJpg", func(t *testing.T) {
result := RelPrefix("/testdata/foo/Test copy 3.jpg", "/testdata", false)
assert.Equal(t, "foo/Test copy 3", result)
})
t.Run("Test (3).jpg", func(t *testing.T) {
t.Run("TestThreeJpg", func(t *testing.T) {
result := RelPrefix("/testdata/foo/Test (3).jpg", "/testdata", false)
assert.Equal(t, "foo/Test (3)", result)
})
t.Run("Test (3).jpg", func(t *testing.T) {
t.Run("TestThreeJpg", func(t *testing.T) {
result := RelPrefix("/testdata/foo/Test (3).jpg", "/testdata/foo/Test (3).jpg", false)
assert.Equal(t, "Test (3)", result)
})
@ -130,16 +130,16 @@ func TestAbsPrefix(t *testing.T) {
assert.Equal(t, "", AbsPrefix("", true))
assert.Equal(t, "", AbsPrefix("", false))
})
t.Run("IMG_4120", func(t *testing.T) {
t.Run("ImgNum4120", func(t *testing.T) {
assert.Equal(t, "/foo/bar/IMG_4120", AbsPrefix("/foo/bar/IMG_4120.JPG", false))
assert.Equal(t, "/foo/bar/IMG_E4120", AbsPrefix("/foo/bar/IMG_E4120.JPG", false))
})
t.Run("Test copy 3.jpg", func(t *testing.T) {
t.Run("TestCopyThreeJpg", func(t *testing.T) {
result := AbsPrefix("/testdata/Test (4).jpg", true)
assert.Equal(t, "/testdata/Test", result)
})
t.Run("Test (3).jpg", func(t *testing.T) {
t.Run("TestThreeJpg", func(t *testing.T) {
result := AbsPrefix("/testdata/Test (4).jpg", false)
assert.Equal(t, "/testdata/Test (4)", result)

6
pkg/fs/fs_test.go
View file

@ -100,17 +100,17 @@ func TestWritable(t *testing.T) {
}
func TestExpandedFilename(t *testing.T) {
t.Run("test.jpg", func(t *testing.T) {
t.Run("TestJpg", func(t *testing.T) {
filename := Abs("./testdata/test.jpg")
assert.Contains(t, filename, "/testdata/test.jpg")
assert.IsType(t, "", filename)
})
t.Run("empty filename", func(t *testing.T) {
t.Run("EmptyFilename", func(t *testing.T) {
filename := Abs("")
assert.Equal(t, "", filename)
assert.IsType(t, "", filename)
})
t.Run("~ in filename", func(t *testing.T) {
t.Run("InFilename", func(t *testing.T) {
usr, _ := user.Current()
expected := usr.HomeDir + "/test.jpg"
filename := Abs("~/test.jpg")

12
pkg/fs/hash_test.go
View file

@ -7,33 +7,33 @@ import (
)
func TestHash(t *testing.T) {
t.Run("existing image", func(t *testing.T) {
t.Run("ExistingImage", func(t *testing.T) {
hash := Hash("testdata/test.jpg")
assert.Equal(t, "516cb1fefbfd9fa66f1db50b94503a480cee30db", hash)
})
t.Run("not existing image", func(t *testing.T) {
t.Run("NotExistingImage", func(t *testing.T) {
hash := Hash("testdata/xxx.jpg")
assert.Equal(t, "", hash)
})
}
func TestChecksum(t *testing.T) {
t.Run("existing image", func(t *testing.T) {
t.Run("ExistingImage", func(t *testing.T) {
hash := Checksum("testdata/test.jpg")
assert.Equal(t, "5239d867", hash)
})
t.Run("not existing image", func(t *testing.T) {
t.Run("NotExistingImage", func(t *testing.T) {
hash := Checksum("testdata/xxx.jpg")
assert.Equal(t, "", hash)
})
}
func TestIsHash(t *testing.T) {
t.Run("false", func(t *testing.T) {
t.Run("False", func(t *testing.T) {
assert.Equal(t, false, IsHash(""))
assert.Equal(t, false, IsHash("123"))
})
t.Run("true", func(t *testing.T) {
t.Run("True", func(t *testing.T) {
assert.Equal(t, true, IsHash("516cb1fefbfd9fa66f1db50b94503a480cee30db"))
})
}

2
pkg/fs/ignore_test.go
View file

@ -9,7 +9,7 @@ import (
)
func TestIgnoreList_Ignore(t *testing.T) {
t.Run(".ppignore", func(t *testing.T) {
t.Run("Ppignore", func(t *testing.T) {
list := NewIgnoreList(".ppignore", true, false)
assert.False(t, list.Ignore("testdata"))
assert.False(t, list.Ignore("testdata/directory"))

12
pkg/fs/mode_test.go
View file

@ -13,29 +13,29 @@ func TestParseMode(t *testing.T) {
assert.Equal(t, ModeSocket, mode)
assert.Equal(t, os.FileMode(0o666), mode)
})
t.Run("777", func(t *testing.T) {
t.Run("Num777", func(t *testing.T) {
mode := ParseMode("777", ModeSocket)
assert.Equal(t, os.ModePerm, mode)
assert.Equal(t, os.FileMode(0o777), mode)
})
t.Run("0777", func(t *testing.T) {
t.Run("Num0777", func(t *testing.T) {
mode := ParseMode("0777", ModeSocket)
assert.Equal(t, os.ModePerm, mode)
assert.Equal(t, os.FileMode(0o777), mode)
})
t.Run("0770", func(t *testing.T) {
t.Run("Num0770", func(t *testing.T) {
mode := ParseMode("0770", ModeSocket)
assert.Equal(t, os.FileMode(0o770), mode)
})
t.Run("0666", func(t *testing.T) {
t.Run("Num0666", func(t *testing.T) {
mode := ParseMode("0666", ModeSocket)
assert.Equal(t, os.FileMode(0o666), mode)
})
t.Run("0660", func(t *testing.T) {
t.Run("Num0660", func(t *testing.T) {
mode := ParseMode("0660", ModeSocket)
assert.Equal(t, os.FileMode(0o660), mode)
})
t.Run("660", func(t *testing.T) {
t.Run("Num660", func(t *testing.T) {
mode := ParseMode("660", ModeSocket)
assert.Equal(t, os.FileMode(0o660), mode)
})

26
pkg/fs/name_test.go
View file

@ -9,52 +9,52 @@ import (
)
func TestRelName(t *testing.T) {
t.Run("same", func(t *testing.T) {
t.Run("Same", func(t *testing.T) {
assert.Equal(t, "", RelName("/some/path", "/some/path"))
})
t.Run("short", func(t *testing.T) {
t.Run("Short", func(t *testing.T) {
assert.Equal(t, "/some/", RelName("/some/", "/some/path"))
})
t.Run("empty", func(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
assert.Equal(t, "", RelName("", "/some/path"))
})
t.Run("/some/path", func(t *testing.T) {
t.Run("SomePath", func(t *testing.T) {
assert.Equal(t, "foo/bar.baz", RelName("/some/path/foo/bar.baz", "/some/path"))
})
t.Run("/some/path/", func(t *testing.T) {
t.Run("SomePath", func(t *testing.T) {
assert.Equal(t, "foo/bar.baz", RelName("/some/path/foo/bar.baz", "/some/path/"))
})
t.Run("/some/path/bar", func(t *testing.T) {
t.Run("SomePathBar", func(t *testing.T) {
assert.Equal(t, "/some/path/foo/bar.baz", RelName("/some/path/foo/bar.baz", "/some/path/bar"))
})
t.Run("empty dir", func(t *testing.T) {
t.Run("EmptyDir", func(t *testing.T) {
assert.Equal(t, "/some/path/foo/bar.baz", RelName("/some/path/foo/bar.baz", ""))
})
}
func TestFileName(t *testing.T) {
t.Run("Test copy 3.jpg", func(t *testing.T) {
t.Run("TestCopyThreeJpg", func(t *testing.T) {
result, err := FileName("testdata/Test (4).jpg", ".photoprism", Abs("testdata"), ".xmp")
assert.NoError(t, err)
assert.Equal(t, "testdata/.photoprism/Test (4).jpg.xmp", result)
})
t.Run("Test (3).jpg", func(t *testing.T) {
t.Run("TestThreeJpg", func(t *testing.T) {
result, err := FileName("testdata/Test (4).jpg", ".photoprism", Abs("testdata"), ".xmp")
assert.NoError(t, err)
assert.Equal(t, "testdata/.photoprism/Test (4).jpg.xmp", result)
})
t.Run("FOO.XMP", func(t *testing.T) {
t.Run("FooXmp", func(t *testing.T) {
result, err := FileName("testdata/FOO.XMP", ".photoprism/sub", Abs("testdata"), ".jpeg")
assert.NoError(t, err)
assert.Equal(t, "testdata/.photoprism/sub/FOO.XMP.jpeg", result)
})
t.Run("Test copy 3.jpg", func(t *testing.T) {
t.Run("TestCopyThreeJpg", func(t *testing.T) {
tempDir := filepath.Join(os.TempDir(), PPHiddenPathname)
result, err := FileName(Abs("testdata/Test (4).jpg"), tempDir, Abs("testdata"), ".xmp")
assert.NoError(t, err)
assert.Equal(t, tempDir+"/Test (4).jpg.xmp", result)
})
t.Run("empty dir", func(t *testing.T) {
t.Run("EmptyDir", func(t *testing.T) {
result, err := FileName("testdata/FOO.XMP", "", Abs("testdata"), ".jpeg")
assert.NoError(t, err)
assert.Equal(t, "testdata/FOO.XMP.jpeg", result)
@ -88,7 +88,7 @@ func TestFileNameHidden(t *testing.T) {
t.Run("False", func(t *testing.T) {
assert.False(t, FileNameHidden("/some/path/folder"))
})
t.Run("Too short", func(t *testing.T) {
t.Run("TooShort", func(t *testing.T) {
assert.False(t, FileNameHidden("a"))
})
t.Run("Empty", func(t *testing.T) {

24
pkg/geo/pluscode/pluscode_test.go
View file

@ -7,19 +7,19 @@ import (
)
func TestEncode(t *testing.T) {
t.Run("germany", func(t *testing.T) {
t.Run("Germany", func(t *testing.T) {
plusCode := Encode(48.56344833333333, 8.996878333333333)
expected := "8FWCHX7W+"
assert.Equal(t, expected, plusCode)
})
t.Run("lat_overflow", func(t *testing.T) {
t.Run("LatOverflow", func(t *testing.T) {
plusCode := Encode(548.56344833333333, 8.996878333333333)
assert.Equal(t, "", plusCode)
})
t.Run("lng_overflow", func(t *testing.T) {
t.Run("LngOverflow", func(t *testing.T) {
plusCode := Encode(48.56344833333333, 258.996878333333333)
assert.Equal(t, "", plusCode)
@ -27,7 +27,7 @@ func TestEncode(t *testing.T) {
}
func TestEncodeLength(t *testing.T) {
t.Run("germany_9", func(t *testing.T) {
t.Run("GermanyNine", func(t *testing.T) {
plusCode, err := EncodeLength(48.56344833333333, 8.996878333333333, 9)
if err != nil {
t.Fatal(err)
@ -37,7 +37,7 @@ func TestEncodeLength(t *testing.T) {
assert.Equal(t, expected, plusCode)
})
t.Run("germany_8", func(t *testing.T) {
t.Run("GermanyEight", func(t *testing.T) {
plusCode, err := EncodeLength(48.56344833333333, 8.996878333333333, 8)
if err != nil {
t.Fatal(err)
@ -47,7 +47,7 @@ func TestEncodeLength(t *testing.T) {
assert.Equal(t, expected, plusCode)
})
t.Run("germany_7", func(t *testing.T) {
t.Run("GermanySeven", func(t *testing.T) {
plusCode, err := EncodeLength(48.56344833333333, 8.996878333333333, 7)
if err != nil {
t.Fatal(err)
@ -57,7 +57,7 @@ func TestEncodeLength(t *testing.T) {
assert.Equal(t, expected, plusCode)
})
t.Run("germany_6", func(t *testing.T) {
t.Run("GermanySix", func(t *testing.T) {
plusCode, err := EncodeLength(48.56344833333333, 8.996878333333333, 6)
if err != nil {
t.Fatal(err)
@ -67,14 +67,14 @@ func TestEncodeLength(t *testing.T) {
assert.Equal(t, expected, plusCode)
})
t.Run("lat_overflow", func(t *testing.T) {
t.Run("LatOverflow", func(t *testing.T) {
plusCode, err := EncodeLength(548.56344833333333, 8.996878333333333, 7)
if err == nil {
t.Fatal("encode should return error")
}
assert.Equal(t, "", plusCode)
})
t.Run("lng_overflow", func(t *testing.T) {
t.Run("LngOverflow", func(t *testing.T) {
plusCode, err := EncodeLength(48.56344833333333, 258.996878333333333, 7)
if err == nil {
t.Fatal("encode should return error")
@ -84,17 +84,17 @@ func TestEncodeLength(t *testing.T) {
}
func TestS2(t *testing.T) {
t.Run("germany", func(t *testing.T) {
t.Run("Germany", func(t *testing.T) {
token := S2("8FWCHX7W+")
assert.Equal(t, "4799e3772d14", token)
})
t.Run("empty code", func(t *testing.T) {
t.Run("EmptyCode", func(t *testing.T) {
token := S2("")
assert.Equal(t, "", token)
})
t.Run("invalid code", func(t *testing.T) {
t.Run("InvalidCode", func(t *testing.T) {
token := S2("xxx")
assert.Equal(t, "", token)

70
pkg/geo/s2/s2_test.go
View file

@ -8,19 +8,19 @@ import (
)
func TestToken(t *testing.T) {
t.Run("germany", func(t *testing.T) {
t.Run("Germany", func(t *testing.T) {
token := Token(48.56344833333333, 8.996878333333333)
expected := "4799e370"
assert.True(t, strings.HasPrefix(token, expected))
})
t.Run("lat_overflow", func(t *testing.T) {
t.Run("LatOverflow", func(t *testing.T) {
token := Token(548.56344833333333, 8.996878333333333)
expected := ""
assert.Equal(t, expected, token)
})
t.Run("lng_overflow", func(t *testing.T) {
t.Run("LngOverflow", func(t *testing.T) {
token := Token(48.56344833333333, 258.996878333333333)
expected := ""
@ -29,61 +29,61 @@ func TestToken(t *testing.T) {
}
func TestTokenLevel(t *testing.T) {
t.Run("level_30", func(t *testing.T) {
t.Run("LevelNum30", func(t *testing.T) {
token := TokenLevel(48.56344833333333, 8.996878333333333, 30)
expected := "4799e370ca54c8b9"
assert.Equal(t, expected, token)
})
t.Run("level_30_diff", func(t *testing.T) {
t.Run("LevelNum30Diff", func(t *testing.T) {
plusCode := TokenLevel(48.56344839999999, 8.996878339999999, 30)
expected := "4799e370ca54c8b7"
assert.Equal(t, expected, plusCode)
})
t.Run("level_21", func(t *testing.T) {
t.Run("LevelNum21", func(t *testing.T) {
plusCode := TokenLevel(48.56344839999999, 8.996878339999999, 21)
expected := "4799e370ca54"
assert.Equal(t, expected, plusCode)
})
t.Run("level_18", func(t *testing.T) {
t.Run("LevelEighteen", func(t *testing.T) {
token := TokenLevel(48.56344833333333, 8.996878333333333, 18)
expected := "4799e370cb"
assert.Equal(t, expected, token)
})
t.Run("level_18_diff", func(t *testing.T) {
t.Run("LevelEighteenDiff", func(t *testing.T) {
token := TokenLevel(48.56344839999999, 8.996878339999999, 18)
expected := "4799e370cb"
assert.Equal(t, expected, token)
})
t.Run("level_15", func(t *testing.T) {
t.Run("LevelFifteen", func(t *testing.T) {
plusCode := TokenLevel(48.56344833333333, 8.996878333333333, 15)
expected := "4799e370c"
assert.Equal(t, expected, plusCode)
})
t.Run("level_10", func(t *testing.T) {
t.Run("LevelTen", func(t *testing.T) {
token := TokenLevel(48.56344833333333, 8.996878333333333, 10)
expected := "4799e3"
assert.Equal(t, expected, token)
})
t.Run("lat_overflow", func(t *testing.T) {
t.Run("LatOverflow", func(t *testing.T) {
token := TokenLevel(548.56344833333333, 8.996878333333333, 30)
expected := ""
assert.Equal(t, expected, token)
})
t.Run("lng_overflow", func(t *testing.T) {
t.Run("LngOverflow", func(t *testing.T) {
token := TokenLevel(48.56344833333333, 258.996878333333333, 30)
expected := ""
assert.Equal(t, expected, token)
})
t.Run("lat & long 0.0", func(t *testing.T) {
t.Run("LatLongZeroZero", func(t *testing.T) {
token := TokenLevel(0.0, 0.0, 30)
expected := ""
@ -92,70 +92,70 @@ func TestTokenLevel(t *testing.T) {
}
func TestLevel(t *testing.T) {
t.Run("8000", func(t *testing.T) {
t.Run("Num8000", func(t *testing.T) {
assert.Equal(t, 0, Level(8000))
})
t.Run("150", func(t *testing.T) {
t.Run("Num150", func(t *testing.T) {
assert.Equal(t, 6, Level(150))
})
t.Run("0.25", func(t *testing.T) {
t.Run("ZeroNum25", func(t *testing.T) {
assert.Equal(t, 15, Level(0.25))
})
t.Run("0.1", func(t *testing.T) {
t.Run("ZeroOne", func(t *testing.T) {
assert.Equal(t, 17, Level(0.1))
})
t.Run("0", func(t *testing.T) {
t.Run("Zero", func(t *testing.T) {
assert.Equal(t, 21, Level(0))
})
t.Run("3999", func(t *testing.T) {
t.Run("Num3999", func(t *testing.T) {
assert.Equal(t, 1, Level(3999))
})
t.Run("1825", func(t *testing.T) {
t.Run("Num1825", func(t *testing.T) {
assert.Equal(t, 2, Level(1825))
})
t.Run("1500", func(t *testing.T) {
t.Run("Num1500", func(t *testing.T) {
assert.Equal(t, 3, Level(1500))
})
t.Run("600", func(t *testing.T) {
t.Run("Num600", func(t *testing.T) {
assert.Equal(t, 4, Level(600))
})
t.Run("100", func(t *testing.T) {
t.Run("Num100", func(t *testing.T) {
assert.Equal(t, 7, Level(100))
})
t.Run("40", func(t *testing.T) {
t.Run("Num40", func(t *testing.T) {
assert.Equal(t, 8, Level(40))
})
t.Run("25", func(t *testing.T) {
t.Run("Num25", func(t *testing.T) {
assert.Equal(t, 9, Level(25))
})
t.Run("10", func(t *testing.T) {
t.Run("Ten", func(t *testing.T) {
assert.Equal(t, 10, Level(10))
})
t.Run("5", func(t *testing.T) {
t.Run("Five", func(t *testing.T) {
assert.Equal(t, 11, Level(5))
})
t.Run("3", func(t *testing.T) {
t.Run("Three", func(t *testing.T) {
assert.Equal(t, 12, Level(3))
})
t.Run("1.5", func(t *testing.T) {
t.Run("OneFive", func(t *testing.T) {
assert.Equal(t, 13, Level(1.5))
})
t.Run("0.5", func(t *testing.T) {
t.Run("ZeroFive", func(t *testing.T) {
assert.Equal(t, 14, Level(0.5))
})
t.Run("0.15", func(t *testing.T) {
t.Run("ZeroFifteen", func(t *testing.T) {
assert.Equal(t, 16, Level(0.15))
})
t.Run("0.03", func(t *testing.T) {
t.Run("ZeroNum03", func(t *testing.T) {
assert.Equal(t, 18, Level(0.03))
})
t.Run("0.015", func(t *testing.T) {
t.Run("ZeroNum015", func(t *testing.T) {
assert.Equal(t, 19, Level(0.015))
})
t.Run("0.008", func(t *testing.T) {
t.Run("ZeroNum008", func(t *testing.T) {
assert.Equal(t, 20, Level(0.008))
})
t.Run("445", func(t *testing.T) {
t.Run("Num445", func(t *testing.T) {
assert.Equal(t, 5, Level(445))
})
t.Run("Negative", func(t *testing.T) {

12
pkg/geo/s2/token_prefix_test.go
View file

@ -16,7 +16,7 @@ func TestNormalizeToken(t *testing.T) {
assert.Equal(t, "1242342bac", output)
})
t.Run("abc", func(t *testing.T) {
t.Run("Abc", func(t *testing.T) {
input := "abc"
output := NormalizeToken(input)
@ -35,7 +35,7 @@ func TestPrefix(t *testing.T) {
assert.Equal(t, input, output)
})
t.Run("abc", func(t *testing.T) {
t.Run("Abc", func(t *testing.T) {
input := "1242342bac"
output := Prefix(input)
@ -43,7 +43,7 @@ func TestPrefix(t *testing.T) {
assert.Equal(t, TokenPrefix+input, output)
})
t.Run("empty string", func(t *testing.T) {
t.Run("EmptyString", func(t *testing.T) {
output := Prefix("")
assert.Equal(t, "", output)
@ -52,19 +52,19 @@ func TestPrefix(t *testing.T) {
}
func TestPrefixedToken(t *testing.T) {
t.Run("germany", func(t *testing.T) {
t.Run("Germany", func(t *testing.T) {
token := PrefixedToken(48.56344833333333, 8.996878333333333)
expected := TokenPrefix + "4799e370"
assert.True(t, strings.HasPrefix(token, expected))
})
t.Run("lat_overflow", func(t *testing.T) {
t.Run("LatOverflow", func(t *testing.T) {
token := PrefixedToken(548.56344833333333, 8.996878333333333)
expected := ""
assert.Equal(t, expected, token)
})
t.Run("lng_overflow", func(t *testing.T) {
t.Run("LngOverflow", func(t *testing.T) {
token := PrefixedToken(48.56344833333333, 258.996878333333333)
expected := ""

16
pkg/i18n/i18n_test.go
View file

@ -17,15 +17,15 @@ func TestMain(m *testing.M) {
}
func TestMsg(t *testing.T) {
t.Run("already exists", func(t *testing.T) {
t.Run("AlreadyExists", func(t *testing.T) {
msg := Msg(ErrAlreadyExists, "A cat")
assert.Equal(t, "A cat already exists", msg)
})
t.Run("unexpected error", func(t *testing.T) {
t.Run("UnexpectedError", func(t *testing.T) {
msg := Msg(ErrUnexpected, "A cat")
assert.Equal(t, "Something went wrong, try again", msg)
})
t.Run("already exists german", func(t *testing.T) {
t.Run("AlreadyExistsGerman", func(t *testing.T) {
SetLocale("de")
msgTrans := Msg(ErrAlreadyExists, "Eine Katze")
assert.Equal(t, "Eine Katze existiert bereits", msgTrans)
@ -33,7 +33,7 @@ func TestMsg(t *testing.T) {
msgDefault := Msg(ErrAlreadyExists, "A cat")
assert.Equal(t, "A cat already exists", msgDefault)
})
t.Run("already exists polish", func(t *testing.T) {
t.Run("AlreadyExistsPolish", func(t *testing.T) {
SetLocale("pl")
msgTrans := Msg(ErrAlreadyExists, "Kot")
assert.Equal(t, "Kot już istnieje", msgTrans)
@ -41,7 +41,7 @@ func TestMsg(t *testing.T) {
msgDefault := Msg(ErrAlreadyExists, "A cat")
assert.Equal(t, "A cat already exists", msgDefault)
})
t.Run("Brazilian Portuguese", func(t *testing.T) {
t.Run("BrazilianPortuguese", func(t *testing.T) {
SetLocale("pt_BR")
msgTrans := Msg(ErrAlreadyExists, "Gata")
assert.Equal(t, "Gata já existe", msgTrans)
@ -52,15 +52,15 @@ func TestMsg(t *testing.T) {
}
func TestError(t *testing.T) {
t.Run("already exists", func(t *testing.T) {
t.Run("AlreadyExists", func(t *testing.T) {
err := Error(ErrAlreadyExists, "A cat")
assert.EqualError(t, err, "A cat already exists")
})
t.Run("unexpected error", func(t *testing.T) {
t.Run("UnexpectedError", func(t *testing.T) {
err := Error(ErrUnexpected, "A cat")
assert.EqualError(t, err, "Something went wrong, try again")
})
t.Run("already exists german", func(t *testing.T) {
t.Run("AlreadyExistsGerman", func(t *testing.T) {
SetLocale("de")
errGerman := Error(ErrAlreadyExists, "Eine Katze")
assert.EqualError(t, errGerman, "Eine Katze existiert bereits")

30
pkg/i18n/response_test.go
View file

@ -9,19 +9,19 @@ import (
)
func TestNewResponse(t *testing.T) {
t.Run("already exists", func(t *testing.T) {
t.Run("AlreadyExists", func(t *testing.T) {
resp := NewResponse(http.StatusConflict, ErrAlreadyExists, "A cat")
assert.Equal(t, http.StatusConflict, resp.Code)
assert.Equal(t, "A cat already exists", resp.Err)
assert.Equal(t, "", resp.Msg)
})
t.Run("unexpected error", func(t *testing.T) {
t.Run("UnexpectedError", func(t *testing.T) {
resp := NewResponse(http.StatusInternalServerError, ErrUnexpected, "A cat")
assert.Equal(t, http.StatusInternalServerError, resp.Code)
assert.Equal(t, "Something went wrong, try again", resp.Err)
assert.Equal(t, "", resp.Msg)
})
t.Run("changes saved", func(t *testing.T) {
t.Run("ChangesSaved", func(t *testing.T) {
resp := NewResponse(http.StatusOK, MsgChangesSaved)
assert.Equal(t, http.StatusOK, resp.Code)
assert.Equal(t, "", resp.Err)
@ -36,12 +36,12 @@ func TestNewResponse(t *testing.T) {
}
func TestResponse_String(t *testing.T) {
t.Run("error", func(t *testing.T) {
t.Run("Error", func(t *testing.T) {
resp := Response{404, "Not found", "page not found", "xyz"}
assert.Equal(t, "Not found", resp.String())
})
t.Run("no error", func(t *testing.T) {
t.Run("error", func(t *testing.T) {
t.Run("NoError", func(t *testing.T) {
t.Run("Error", func(t *testing.T) {
resp := Response{200, "", "Ok", "xyz"}
assert.Equal(t, "Ok", resp.String())
})
@ -49,12 +49,12 @@ func TestResponse_String(t *testing.T) {
}
func TestResponse_LowerString(t *testing.T) {
t.Run("error", func(t *testing.T) {
t.Run("Error", func(t *testing.T) {
resp := Response{404, "Not found", "page not found", "xyz"}
assert.Equal(t, "not found", resp.LowerString())
})
t.Run("no error", func(t *testing.T) {
t.Run("error", func(t *testing.T) {
t.Run("NoError", func(t *testing.T) {
t.Run("Error", func(t *testing.T) {
resp := Response{200, "", "Ok", "xyz"}
assert.Equal(t, "ok", resp.LowerString())
})
@ -62,12 +62,12 @@ func TestResponse_LowerString(t *testing.T) {
}
func TestResponse_Error(t *testing.T) {
t.Run("error", func(t *testing.T) {
t.Run("Error", func(t *testing.T) {
resp := Response{404, "Not found", "page not found", "xyz"}
assert.Equal(t, "Not found", resp.Error())
})
t.Run("no error", func(t *testing.T) {
t.Run("error", func(t *testing.T) {
t.Run("NoError", func(t *testing.T) {
t.Run("Error", func(t *testing.T) {
resp := Response{200, "", "Ok", "xyz"}
assert.Equal(t, "", resp.Error())
})
@ -75,12 +75,12 @@ func TestResponse_Error(t *testing.T) {
}
func TestResponse_Success(t *testing.T) {
t.Run("error", func(t *testing.T) {
t.Run("Error", func(t *testing.T) {
resp := Response{404, "Not found", "page not found", "xyz"}
assert.Equal(t, false, resp.Success())
})
t.Run("no error", func(t *testing.T) {
t.Run("error", func(t *testing.T) {
t.Run("NoError", func(t *testing.T) {
t.Run("Error", func(t *testing.T) {
resp := Response{200, "", "Ok", "xyz"}
assert.Equal(t, true, resp.Success())
})

2
pkg/log/dummy/logger_test.go
View file

@ -44,7 +44,7 @@ func TestLogger_WithFields(t *testing.T) {
}
func TestLogger_WithError(t *testing.T) {
t.Run("Error for logger test", func(t *testing.T) {
t.Run("ErrorForLoggerTest", func(t *testing.T) {
log := NewLogger()
err := errors.New("Error for logger test")
assert.Equal(t, "Error for logger test", log.WithError(err).Message)

2
pkg/log/level/severity_test.go
View file

@ -31,7 +31,7 @@ func TestLevelUnmarshalText(t *testing.T) {
assert.Equal(t, level, u)
})
}
t.Run("invalid", func(t *testing.T) {
t.Run("Invalid", func(t *testing.T) {
assert.Error(t, u.UnmarshalText([]byte("invalid")))
})
}

22
pkg/media/colors/chroma_test.go
View file

@ -10,11 +10,11 @@ func TestChroma_Percent(t *testing.T) {
lum := []Luminance{1, 16, 2, 4, 15, 16, 1, 0, 8}
lMap := LightMap(lum)
t.Run("chroma 15", func(t *testing.T) {
t.Run("ChromaFifteen", func(t *testing.T) {
perception := ColorPerception{Colors: Colors{Orange, Lime, Cyan}, MainColor: Cyan, Luminance: lMap, Chroma: 15}
assert.Equal(t, int16(15), perception.Chroma.Percent())
})
t.Run("chroma 127", func(t *testing.T) {
t.Run("ChromaNum127", func(t *testing.T) {
perception := ColorPerception{Colors: Colors{Orange, Lime, Cyan}, MainColor: Cyan, Luminance: lMap, Chroma: 127}
assert.Equal(t, int16(100), perception.Chroma.Percent())
})
@ -24,11 +24,11 @@ func TestChroma_Uint(t *testing.T) {
lum := []Luminance{1, 16, 2, 4, 15, 16, 1, 0, 8}
lMap := LightMap(lum)
t.Run("chroma 15", func(t *testing.T) {
t.Run("ChromaFifteen", func(t *testing.T) {
perception := ColorPerception{Colors: Colors{Orange, Lime, Cyan}, MainColor: Cyan, Luminance: lMap, Chroma: 15}
assert.Equal(t, uint(0xf), perception.Chroma.Uint())
})
t.Run("chroma 127", func(t *testing.T) {
t.Run("ChromaNum127", func(t *testing.T) {
perception := ColorPerception{Colors: Colors{Orange, Lime, Cyan}, MainColor: Cyan, Luminance: lMap, Chroma: 127}
assert.Equal(t, uint(100), perception.Chroma.Uint())
})
@ -38,23 +38,23 @@ func TestChroma_Int(t *testing.T) {
lum := []Luminance{1, 16, 2, 4, 15, 16, 1, 0, 8}
lMap := LightMap(lum)
t.Run("chroma 15", func(t *testing.T) {
t.Run("ChromaFifteen", func(t *testing.T) {
perception := ColorPerception{Colors: Colors{Orange, Lime, Cyan}, MainColor: Cyan, Luminance: lMap, Chroma: 15}
assert.Equal(t, 15, perception.Chroma.Int())
})
t.Run("chroma -1", func(t *testing.T) {
t.Run("ChromaOne", func(t *testing.T) {
perception := ColorPerception{Colors: Colors{Orange, Lime, Cyan}, MainColor: Cyan, Luminance: lMap, Chroma: -1}
assert.Equal(t, 0, perception.Chroma.Int())
})
t.Run("chroma -127", func(t *testing.T) {
t.Run("ChromaNum127", func(t *testing.T) {
perception := ColorPerception{Colors: Colors{Orange, Lime, Cyan}, MainColor: Cyan, Luminance: lMap, Chroma: -127}
assert.Equal(t, 0, perception.Chroma.Int())
})
t.Run("chroma 100", func(t *testing.T) {
t.Run("ChromaNum100", func(t *testing.T) {
perception := ColorPerception{Colors: Colors{Orange, Lime, Cyan}, MainColor: Cyan, Luminance: lMap, Chroma: 100}
assert.Equal(t, 100, perception.Chroma.Int())
})
t.Run("chroma 127", func(t *testing.T) {
t.Run("ChromaNum127", func(t *testing.T) {
perception := ColorPerception{Colors: Colors{Orange, Lime, Cyan}, MainColor: Cyan, Luminance: lMap, Chroma: 127}
assert.Equal(t, 100, perception.Chroma.Int())
})
@ -64,11 +64,11 @@ func TestChroma_Hex(t *testing.T) {
lum := []Luminance{1, 16, 2, 4, 15, 16, 1, 0, 8}
lMap := LightMap(lum)
t.Run("chroma 15", func(t *testing.T) {
t.Run("ChromaFifteen", func(t *testing.T) {
perception := ColorPerception{Colors: Colors{Orange, Lime, Cyan}, MainColor: Cyan, Luminance: lMap, Chroma: 15}
assert.Equal(t, "F", perception.Chroma.Hex())
})
t.Run("chroma 127", func(t *testing.T) {
t.Run("ChromaNum127", func(t *testing.T) {
perception := ColorPerception{Colors: Colors{Orange, Lime, Cyan}, MainColor: Cyan, Luminance: lMap, Chroma: 127}
assert.Equal(t, "64", perception.Chroma.Hex())
})

4
pkg/media/colors/colorful_test.go
View file

@ -9,7 +9,7 @@ import (
)
func TestColorful(t *testing.T) {
t.Run("purple", func(t *testing.T) {
t.Run("Purple", func(t *testing.T) {
c := color.RGBA{0x6a, 0x1b, 0x9a, 0xff}
color, ok := colorful.MakeColor(c)
@ -19,7 +19,7 @@ func TestColorful(t *testing.T) {
assert.Equal(t, "purple", Colorful(color).Name())
})
t.Run("cyan", func(t *testing.T) {
t.Run("Cyan", func(t *testing.T) {
c := color.RGBA{0xb2, 0xeb, 0xf2, 0xff}
color, ok := colorful.MakeColor(c)

12
pkg/media/colors/lightmap_test.go
View file

@ -15,7 +15,7 @@ func TestLightMap_Hex(t *testing.T) {
}
func TestLightMap_Diff(t *testing.T) {
t.Run("random", func(t *testing.T) {
t.Run("Random", func(t *testing.T) {
lum := []Luminance{1, 16, 2, 4, 15, 16, 1, 0, 8}
lMap := LightMap(lum)
result := lMap.Diff()
@ -24,7 +24,7 @@ func TestLightMap_Diff(t *testing.T) {
t.Errorf("result should be 845: %d", result)
}
})
t.Run("empty", func(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
var lum []Luminance
lMap := LightMap(lum)
result := lMap.Diff()
@ -33,7 +33,7 @@ func TestLightMap_Diff(t *testing.T) {
t.Errorf("result should be 0: %d", result)
}
})
t.Run("one", func(t *testing.T) {
t.Run("One", func(t *testing.T) {
lum := []Luminance{0}
lMap := LightMap(lum)
result := lMap.Diff()
@ -42,7 +42,7 @@ func TestLightMap_Diff(t *testing.T) {
t.Errorf("result should be 0: %d", result)
}
})
t.Run("same", func(t *testing.T) {
t.Run("Same", func(t *testing.T) {
lum := []Luminance{1, 1, 1, 1, 1, 1, 1, 1, 1}
lMap := LightMap(lum)
result := lMap.Diff()
@ -51,7 +51,7 @@ func TestLightMap_Diff(t *testing.T) {
t.Errorf("result should be 1023: %d", result)
}
})
t.Run("similar", func(t *testing.T) {
t.Run("Similar", func(t *testing.T) {
lum := []Luminance{1, 1, 1, 1, 1, 1, 1, 1, 2}
lMap := LightMap(lum)
result := lMap.Diff()
@ -60,7 +60,7 @@ func TestLightMap_Diff(t *testing.T) {
t.Errorf("result should be 1023: %d", result)
}
})
t.Run("happy", func(t *testing.T) {
t.Run("Happy", func(t *testing.T) {
m1 := LightMap{8, 13, 7, 2, 2, 3, 6, 3, 4}
d1 := m1.Diff()
t.Log(strconv.FormatUint(uint64(d1), 2))

16
pkg/media/filename_test.go
View file

@ -7,37 +7,37 @@ import (
)
func TestFromName(t *testing.T) {
t.Run("jpeg", func(t *testing.T) {
t.Run("Jpeg", func(t *testing.T) {
result := FromName("testdata/test.jpg")
assert.Equal(t, Image, result)
})
t.Run("raw", func(t *testing.T) {
t.Run("Raw", func(t *testing.T) {
result := FromName("testdata/test (jpg).CR2")
assert.Equal(t, Raw, result)
})
t.Run("video", func(t *testing.T) {
t.Run("Video", func(t *testing.T) {
result := FromName("testdata/gopher.mp4")
assert.Equal(t, Video, result)
})
t.Run("sidecar", func(t *testing.T) {
t.Run("Sidecar", func(t *testing.T) {
result := FromName("/IMG_4120.AAE")
assert.Equal(t, Sidecar, result)
})
t.Run("other", func(t *testing.T) {
t.Run("Other", func(t *testing.T) {
result := FromName("/IMG_4120.XXX")
assert.Equal(t, Sidecar, result)
})
t.Run("empty", func(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
result := FromName("")
assert.Equal(t, Unknown, result)
})
}
func TestMainFile(t *testing.T) {
t.Run("true", func(t *testing.T) {
t.Run("True", func(t *testing.T) {
assert.True(t, MainFile("testdata/test.jpg"))
})
t.Run("false", func(t *testing.T) {
t.Run("False", func(t *testing.T) {
assert.False(t, MainFile("/IMG_4120.XXX"))
})
}

6
pkg/media/video/brands_test.go
View file

@ -8,17 +8,17 @@ import (
)
func TestFileTypeOffset(t *testing.T) {
t.Run("mp4v-avc1.mp4", func(t *testing.T) {
t.Run("Mp4vAvc1Mp4", func(t *testing.T) {
index, err := FileTypeOffset("testdata/mp4v-avc1.mp4", CompatibleBrands)
require.NoError(t, err)
assert.Equal(t, 0, index)
})
t.Run("isom-avc1.mp4", func(t *testing.T) {
t.Run("IsomAvc1Mp4", func(t *testing.T) {
index, err := FileTypeOffset("testdata/isom-avc1.mp4", CompatibleBrands)
require.NoError(t, err)
assert.Equal(t, 0, index)
})
t.Run("image-isom-avc1.jpg", func(t *testing.T) {
t.Run("ImageIsomAvc1Jpg", func(t *testing.T) {
index, err := FileTypeOffset("testdata/image-isom-avc1.jpg", CompatibleBrands)
require.NoError(t, err)
assert.Equal(t, 23209, index)

14
pkg/media/video/chunks_test.go
View file

@ -24,22 +24,22 @@ func TestChunk_TypeCast(t *testing.T) {
}
func TestChunk_FileOffset(t *testing.T) {
t.Run("mp4v-avc1.mp4", func(t *testing.T) {
t.Run("Mp4vAvc1Mp4", func(t *testing.T) {
index, err := ChunkFTYP.FileOffset("testdata/mp4v-avc1.mp4")
require.NoError(t, err)
assert.Equal(t, 4, index)
})
t.Run("isom-avc1.mp4", func(t *testing.T) {
t.Run("IsomAvc1Mp4", func(t *testing.T) {
index, err := ChunkFTYP.FileOffset("testdata/isom-avc1.mp4")
require.NoError(t, err)
assert.Equal(t, 4, index)
})
t.Run("image-isom-avc1.jpg", func(t *testing.T) {
t.Run("ImageIsomAvc1Jpg", func(t *testing.T) {
index, err := ChunkFTYP.FileOffset("testdata/image-isom-avc1.jpg")
require.NoError(t, err)
assert.Equal(t, 23213, index)
})
t.Run("motion-photo.heif", func(t *testing.T) {
t.Run("MotionPhotoHeif", func(t *testing.T) {
index, err := ChunkFTYP.FileOffset("testdata/motion-photo.heif")
require.NoError(t, err)
assert.Equal(t, 4, index)
@ -53,7 +53,7 @@ func TestChunk_FileOffset(t *testing.T) {
}
func TestChunks(t *testing.T) {
t.Run("mp4v-avc1.mp4", func(t *testing.T) {
t.Run("Mp4vAvc1Mp4", func(t *testing.T) {
f, fileErr := os.Open("testdata/mp4v-avc1.mp4")
require.NoError(t, fileErr)
defer f.Close()
@ -83,7 +83,7 @@ func TestChunks(t *testing.T) {
assert.Equal(t, ChunkFTYP.Bytes(), startChunk[:4])
assert.Equal(t, ChunkMP4V.Bytes(), subType[:4])
})
t.Run("isom-avc1.mp4", func(t *testing.T) {
t.Run("IsomAvc1Mp4", func(t *testing.T) {
f, fileErr := os.Open("testdata/isom-avc1.mp4")
require.NoError(t, fileErr)
defer f.Close()
@ -100,7 +100,7 @@ func TestChunks(t *testing.T) {
assert.Equal(t, ChunkFTYP[:], b[4:8])
assert.Equal(t, ChunkISOM[:], b[8:12])
})
t.Run("image-isom-avc1.jpg", func(t *testing.T) {
t.Run("ImageIsomAvc1Jpg", func(t *testing.T) {
f, fileErr := os.Open("testdata/image-isom-avc1.jpg")
require.NoError(t, fileErr)
defer f.Close()

20
pkg/media/video/content_type_test.go
View file

@ -27,44 +27,44 @@ func TestContentType(t *testing.T) {
assert.Equal(t, header.ContentTypeMp4HvcMain10, ContentType(header.ContentTypeM4v, "", CodecHvc1, false))
assert.Equal(t, header.ContentTypeMp4HvcMain10, ContentType(header.ContentTypeM4v, "", CodecHvc1, true))
})
t.Run("Mov/Hvc", func(t *testing.T) {
t.Run("MovHvc", func(t *testing.T) {
assert.Equal(t, header.ContentTypeMp4HvcMain10, ContentType(header.ContentTypeMov, "mov", CodecHvc1, false))
})
t.Run("Mp4", func(t *testing.T) {
assert.Equal(t, header.ContentTypeMp4, ContentType(header.ContentTypeMp4, "", "", false))
assert.Equal(t, header.ContentTypeMp4, ContentType(header.ContentTypeMp4, "", "", true))
})
t.Run("Mp4/Avc", func(t *testing.T) {
t.Run("MpFourAvc", func(t *testing.T) {
assert.Equal(t, header.ContentTypeMp4AvcMain, ContentType(header.ContentTypeMp4, "", CodecAvc1, false))
assert.Equal(t, header.ContentTypeMp4AvcHigh10, ContentType(header.ContentTypeMp4, "", CodecAvc1, true))
assert.Equal(t, header.ContentTypeMp4AvcMain, ContentType("", "mp4", CodecAvc1, false))
assert.Equal(t, header.ContentTypeMp4AvcHigh10, ContentType("", "mp4", CodecAvc1, true))
})
t.Run("Mp4/Avc3", func(t *testing.T) {
t.Run("MpFourAvcThree", func(t *testing.T) {
assert.Equal(t, header.ContentTypeMp4Avc3Main, ContentType(header.ContentTypeMp4, "", CodecAvc3, false))
assert.Equal(t, header.ContentTypeMp4Avc3High10, ContentType(header.ContentTypeMp4, "", CodecAvc3, true))
assert.Equal(t, header.ContentTypeMp4Avc3Main, ContentType("", "mp4", CodecAvc3, false))
assert.Equal(t, header.ContentTypeMp4Avc3High10, ContentType("", "mp4", CodecAvc3, true))
})
t.Run("Mp4/Hvc", func(t *testing.T) {
t.Run("MpFourHvc", func(t *testing.T) {
assert.Equal(t, header.ContentTypeMp4HvcMain10, ContentType(header.ContentTypeMp4, "", CodecHvc1, false))
assert.Equal(t, header.ContentTypeMp4HvcMain10, ContentType(header.ContentTypeMp4, "", CodecHvc1, true))
assert.Equal(t, header.ContentTypeMp4HvcMain10, ContentType("", "mp4", CodecHvc1, false))
assert.Equal(t, header.ContentTypeMp4HvcMain10, ContentType("", "mp4", CodecHvc1, true))
})
t.Run("Mp4/Hev", func(t *testing.T) {
t.Run("MpFourHev", func(t *testing.T) {
assert.Equal(t, header.ContentTypeMp4HevMain10, ContentType(header.ContentTypeMp4, "", CodecHev1, false))
assert.Equal(t, header.ContentTypeMp4HevMain10, ContentType(header.ContentTypeMp4, "", CodecHev1, true))
assert.Equal(t, header.ContentTypeMp4HevMain10, ContentType("", "mp4", CodecHev1, false))
assert.Equal(t, header.ContentTypeMp4HevMain10, ContentType("", "mp4", CodecHev1, true))
})
t.Run("Mp4/Vvc", func(t *testing.T) {
t.Run("MpFourVvc", func(t *testing.T) {
assert.Equal(t, header.ContentTypeMp4Vvc, ContentType(header.ContentTypeMp4, "", CodecVvc1, false))
assert.Equal(t, header.ContentTypeMp4Vvc, ContentType(header.ContentTypeMp4, "", CodecVvc1, true))
assert.Equal(t, header.ContentTypeMp4Vvc, ContentType("", "vvc", CodecVvc1, false))
assert.Equal(t, header.ContentTypeMp4Vvc, ContentType("", "vvc", CodecVvc1, true))
})
t.Run("Mp4/Evc", func(t *testing.T) {
t.Run("MpFourEvc", func(t *testing.T) {
assert.Equal(t, header.ContentTypeMp4Evc, ContentType(header.ContentTypeMp4, "", CodecEvc1, false))
assert.Equal(t, header.ContentTypeMp4Evc, ContentType(header.ContentTypeMp4, "", CodecEvc1, true))
assert.Equal(t, header.ContentTypeMp4Evc, ContentType("", "evc", CodecEvc1, false))
@ -82,17 +82,17 @@ func TestContentType(t *testing.T) {
assert.Equal(t, header.ContentTypeWebmVp9Main, ContentType("", "vp9", "", false))
assert.Equal(t, header.ContentTypeWebmVp9Main, ContentType("", "vp9", "", true))
})
t.Run("Webmm/Av1", func(t *testing.T) {
t.Run("WebmmAvOne", func(t *testing.T) {
assert.Equal(t, header.ContentTypeWebmAv1Main10, ContentType("", "webm", CodecAv01, false))
assert.Equal(t, header.ContentTypeWebmAv1Main10, ContentType("", "webm", CodecAv01, true))
})
t.Run("Mp4/Av1", func(t *testing.T) {
t.Run("MpFourAvOne", func(t *testing.T) {
assert.Equal(t, header.ContentTypeMp4Av1Main10, ContentType(header.ContentTypeMp4, "mp4", CodecAv01, false))
assert.Equal(t, header.ContentTypeMp4Av1Main10, ContentType(header.ContentTypeMp4, "mp4", CodecAv01, true))
assert.Equal(t, header.ContentTypeMp4Av1Main10, ContentType("", "mp4", CodecAv01, false))
assert.Equal(t, header.ContentTypeMp4Av1Main10, ContentType("", "mp4", CodecAv01, true))
})
t.Run("Mkv/Av1", func(t *testing.T) {
t.Run("MkvAvOne", func(t *testing.T) {
assert.Equal(t, header.ContentTypeMkvAv1Main10, ContentType("", "mkv", CodecAv01, false))
assert.Equal(t, header.ContentTypeMkvAv1Main10, ContentType("", "mkv", CodecAv01, true))
})

18
pkg/media/video/probe_test.go
View file

@ -25,7 +25,7 @@ func TestProbeFile(t *testing.T) {
require.Error(t, err)
require.NotNil(t, info)
})
t.Run("mp4v-avc1.mp4", func(t *testing.T) {
t.Run("Mp4vAvc1Mp4", func(t *testing.T) {
fileName := "testdata/mp4v-avc1.mp4"
info, err := ProbeFile(fileName)
require.NoError(t, err)
@ -52,7 +52,7 @@ func TestProbeFile(t *testing.T) {
assert.Equal(t, true, info.FastStart)
assert.Equal(t, true, info.Compatible)
})
t.Run("mp42-hvc1.mp4", func(t *testing.T) {
t.Run("Mp42Hvc1Mp4", func(t *testing.T) {
fileName := "testdata/mp42-hvc1.mp4"
info, err := ProbeFile(fileName)
require.NoError(t, err)
@ -79,7 +79,7 @@ func TestProbeFile(t *testing.T) {
assert.Equal(t, false, info.FastStart)
assert.Equal(t, true, info.Compatible)
})
t.Run("quicktime-hvc1.mov", func(t *testing.T) {
t.Run("QuicktimeHvc1Mov", func(t *testing.T) {
fileName := "testdata/quicktime-hvc1.mov"
info, err := ProbeFile(fileName)
require.NoError(t, err)
@ -106,7 +106,7 @@ func TestProbeFile(t *testing.T) {
assert.Equal(t, false, info.FastStart)
assert.Equal(t, true, info.Compatible)
})
t.Run("quicktime-jpeg.mov", func(t *testing.T) {
t.Run("QuicktimeJpegMov", func(t *testing.T) {
fileName := "testdata/quicktime-jpeg.mov"
info, err := ProbeFile(fileName)
require.NoError(t, err)
@ -132,7 +132,7 @@ func TestProbeFile(t *testing.T) {
assert.Equal(t, false, info.FastStart)
assert.Equal(t, false, info.Compatible)
})
t.Run("image-isom-avc1.jpg", func(t *testing.T) {
t.Run("ImageIsomAvc1Jpg", func(t *testing.T) {
fileName := "testdata/image-isom-avc1.jpg"
info, err := ProbeFile(fileName)
require.NoError(t, err)
@ -162,7 +162,7 @@ func TestProbeFile(t *testing.T) {
}
func TestProbe(t *testing.T) {
t.Run("mp4v-avc1.mp4", func(t *testing.T) {
t.Run("Mp4vAvc1Mp4", func(t *testing.T) {
f, fileErr := os.Open("testdata/mp4v-avc1.mp4")
require.NoError(t, fileErr)
defer f.Close()
@ -192,7 +192,7 @@ func TestProbe(t *testing.T) {
assert.Equal(t, true, info.FastStart)
assert.Equal(t, true, info.Compatible)
})
t.Run("isom-avc1.mp4", func(t *testing.T) {
t.Run("IsomAvc1Mp4", func(t *testing.T) {
f, fileErr := os.Open("testdata/isom-avc1.mp4")
require.NoError(t, fileErr)
defer f.Close()
@ -222,7 +222,7 @@ func TestProbe(t *testing.T) {
assert.Equal(t, false, info.FastStart)
assert.Equal(t, true, info.Compatible)
})
t.Run("image-isom-avc1.jpg", func(t *testing.T) {
t.Run("ImageIsomAvc1Jpg", func(t *testing.T) {
f, fileErr := os.Open("testdata/image-isom-avc1.jpg")
require.NoError(t, fileErr)
defer f.Close()
@ -252,7 +252,7 @@ func TestProbe(t *testing.T) {
assert.Equal(t, false, info.FastStart)
assert.Equal(t, true, info.Compatible)
})
t.Run("motion-photo.heif", func(t *testing.T) {
t.Run("MotionPhotoHeif", func(t *testing.T) {
f, fileErr := os.Open("testdata/motion-photo.heif")
require.NoError(t, fileErr)
defer f.Close()

2
pkg/rnd/crc_test.go
View file

@ -7,7 +7,7 @@ import (
)
func TestCrcToken(t *testing.T) {
t.Run("size 4", func(t *testing.T) {
t.Run("SizeFour", func(t *testing.T) {
token := CrcToken()
t.Logf("CrcToken: %s", token)
assert.NotEmpty(t, token)

20
pkg/rnd/token_test.go
View file

@ -7,7 +7,7 @@ import (
)
func TestBase10(t *testing.T) {
t.Run("10", func(t *testing.T) {
t.Run("Ten", func(t *testing.T) {
s := Base10(10)
t.Logf("Base10 (10 chars): %s", s)
assert.NotEmpty(t, s)
@ -21,7 +21,7 @@ func TestBase10(t *testing.T) {
assert.NotEmpty(t, s)
}
})
t.Run("23", func(t *testing.T) {
t.Run("Num23", func(t *testing.T) {
s := Base10(23)
t.Logf("Base10 (23 chars): %s", s)
assert.NotEmpty(t, s)
@ -32,7 +32,7 @@ func TestBase10(t *testing.T) {
}
func TestBase36(t *testing.T) {
t.Run("10", func(t *testing.T) {
t.Run("Ten", func(t *testing.T) {
s := Base36(10)
t.Logf("Base36 (10 chars): %s", s)
assert.NotEmpty(t, s)
@ -46,7 +46,7 @@ func TestBase36(t *testing.T) {
assert.NotEmpty(t, s)
}
})
t.Run("23", func(t *testing.T) {
t.Run("Num23", func(t *testing.T) {
s := Base36(23)
t.Logf("Base36 (23 chars): %s", s)
assert.NotEmpty(t, s)
@ -57,14 +57,14 @@ func TestBase36(t *testing.T) {
}
func TestBase62(t *testing.T) {
t.Run("10", func(t *testing.T) {
t.Run("Ten", func(t *testing.T) {
for n := 0; n < 10; n++ {
s := Base62(10)
t.Logf("Base62 %d: %s", n, s)
assert.NotEmpty(t, s)
}
})
t.Run("23", func(t *testing.T) {
t.Run("Num23", func(t *testing.T) {
s := Base62(23)
t.Logf("Base62 (23 chars): %s", s)
assert.NotEmpty(t, s)
@ -72,7 +72,7 @@ func TestBase62(t *testing.T) {
assert.True(t, InvalidRefID(s))
assert.Equal(t, 23, len(s))
})
t.Run("32", func(t *testing.T) {
t.Run("Num32", func(t *testing.T) {
for n := 0; n < 10; n++ {
s := Base62(32)
t.Logf("Base62 (32 chars) %d: %s", n, s)
@ -85,7 +85,7 @@ func TestBase62(t *testing.T) {
}
func TestCharset(t *testing.T) {
t.Run("23", func(t *testing.T) {
t.Run("Num23", func(t *testing.T) {
s := Charset(23, CharsetBase62)
t.Logf("CharsetBase62 (23 chars): %s", s)
assert.NotEmpty(t, s)
@ -93,12 +93,12 @@ func TestCharset(t *testing.T) {
assert.True(t, InvalidRefID(s))
assert.Equal(t, 23, len(s))
})
t.Run("0", func(t *testing.T) {
t.Run("Zero", func(t *testing.T) {
s := Charset(0, CharsetBase62)
t.Logf("CharsetBase62 (23 chars): %s", s)
assert.Empty(t, s)
})
t.Run("5000", func(t *testing.T) {
t.Run("Num5000", func(t *testing.T) {
s := Charset(5000, CharsetBase62)
t.Logf("CharsetBase62 (23 chars): %s", s)
assert.NotEmpty(t, s)

2
pkg/rnd/uid_test.go
View file

@ -86,7 +86,7 @@ func BenchmarkGenerateUID(b *testing.B) {
}
func TestGenerateUID_Time(t *testing.T) {
t.Run("2017", func(t *testing.T) {
t.Run("Num2017", func(t *testing.T) {
date := time.Date(2017, 1, 1, 0, 0, 0, 0, time.UTC)
t.Logf("Unix Timestamp: %d", date.Unix())
t.Logf("Date Encoded: %s", strconv.FormatInt(date.UTC().Unix(), 36))

14
pkg/time/tz/offset_test.go
View file

@ -223,7 +223,7 @@ func TestUtcOffset(t *testing.T) {
assert.Equal(t, "", UtcOffset(utc, local, "+00:00"))
assert.Equal(t, "UTC", UtcOffset(utc, local, "Z"))
})
t.Run("UTC+2", func(t *testing.T) {
t.Run("UtcTwo", func(t *testing.T) {
local, err := time.Parse("2006-01-02 15:04:05 Z07:00", "2023-10-02 13:20:17 +00:00")
if err != nil {
@ -244,7 +244,7 @@ func TestUtcOffset(t *testing.T) {
assert.Equal(t, "UTC+2", loc.String())
})
t.Run("+02:00", func(t *testing.T) {
t.Run("Num02Num00", func(t *testing.T) {
local, err := time.Parse("2006-01-02 15:04:05 Z07:00", "2023-10-02 13:20:17 +00:00")
if err != nil {
@ -259,7 +259,7 @@ func TestUtcOffset(t *testing.T) {
assert.Equal(t, "UTC+2", UtcOffset(utc, local, "02:00"))
})
t.Run("UTC+2.5", func(t *testing.T) {
t.Run("UtcTwoFive", func(t *testing.T) {
local, err := time.Parse("2006-01-02 15:04:05 Z07:00", "2023-10-02 13:50:17 +00:00")
if err != nil {
@ -274,7 +274,7 @@ func TestUtcOffset(t *testing.T) {
assert.Equal(t, "", UtcOffset(utc, local, ""))
})
t.Run("+02:30", func(t *testing.T) {
t.Run("Num02Num30", func(t *testing.T) {
local, err := time.Parse("2006-01-02 15:04:05 Z07:00", "2023-10-02 13:50:17 +00:00")
if err != nil {
@ -289,7 +289,7 @@ func TestUtcOffset(t *testing.T) {
assert.Equal(t, "", UtcOffset(utc, local, "+02:30"))
})
t.Run("UTC-14", func(t *testing.T) {
t.Run("UtcFourteen", func(t *testing.T) {
local, err := time.Parse("2006-01-02 15:04:05 Z07:00", "2023-10-02 00:20:17 +00:00")
if err != nil {
@ -304,7 +304,7 @@ func TestUtcOffset(t *testing.T) {
assert.Equal(t, "", UtcOffset(utc, local, ""))
})
t.Run("UTC-15", func(t *testing.T) {
t.Run("UtcFifteen", func(t *testing.T) {
local, err := time.Parse("2006-01-02 15:04:05 Z07:00", "2023-10-02 00:20:17 +00:00")
if err != nil {
@ -319,7 +319,7 @@ func TestUtcOffset(t *testing.T) {
assert.Equal(t, "", UtcOffset(utc, local, ""))
})
t.Run("UTC+02:00", func(t *testing.T) {
t.Run("UtcNum02Num00", func(t *testing.T) {
utc, err := time.Parse("2006-01-02 15:04:05 Z07:00", "2023-10-02 13:50:17 +02:00")
if err != nil {

2
pkg/time/tz/position_test.go
View file

@ -10,7 +10,7 @@ func TestPosition(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
assert.Equal(t, "", Position(0, 0))
})
t.Run("Europe/Berlin", func(t *testing.T) {
t.Run("EuropeBerlin", func(t *testing.T) {
assert.Equal(t, "Europe/Berlin", Position(52.472833, 13.407500))
})
}

74
pkg/txt/bool_test.go
View file

@ -7,121 +7,121 @@ import (
)
func TestBool(t *testing.T) {
t.Run("not empty", func(t *testing.T) {
t.Run("NotEmpty", func(t *testing.T) {
assert.Equal(t, true, Bool("Browse your life in pictures"))
})
t.Run("oui", func(t *testing.T) {
t.Run("Oui", func(t *testing.T) {
assert.Equal(t, true, Bool("oui"))
})
t.Run("non", func(t *testing.T) {
t.Run("Non", func(t *testing.T) {
assert.Equal(t, false, Bool("non"))
})
t.Run("ja", func(t *testing.T) {
t.Run("Ja", func(t *testing.T) {
assert.Equal(t, true, Bool("ja"))
})
t.Run("true", func(t *testing.T) {
t.Run("True", func(t *testing.T) {
assert.Equal(t, true, Bool("true"))
})
t.Run("yes", func(t *testing.T) {
t.Run("Yes", func(t *testing.T) {
assert.Equal(t, true, Bool("yes"))
})
t.Run("no", func(t *testing.T) {
t.Run("No", func(t *testing.T) {
assert.Equal(t, false, Bool("no"))
})
t.Run("false", func(t *testing.T) {
t.Run("False", func(t *testing.T) {
assert.Equal(t, false, Bool("false"))
})
t.Run("empty", func(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
assert.Equal(t, false, Bool(""))
})
}
func TestYes(t *testing.T) {
t.Run("not empty", func(t *testing.T) {
t.Run("NotEmpty", func(t *testing.T) {
assert.Equal(t, false, Yes("Browse your life in pictures"))
})
t.Run("oui", func(t *testing.T) {
t.Run("Oui", func(t *testing.T) {
assert.Equal(t, true, Yes("oui"))
})
t.Run("non", func(t *testing.T) {
t.Run("Non", func(t *testing.T) {
assert.Equal(t, false, Yes("non"))
})
t.Run("ja", func(t *testing.T) {
t.Run("Ja", func(t *testing.T) {
assert.Equal(t, true, Yes("ja"))
})
t.Run("true", func(t *testing.T) {
t.Run("True", func(t *testing.T) {
assert.Equal(t, true, Yes("true"))
})
t.Run("yes", func(t *testing.T) {
t.Run("Yes", func(t *testing.T) {
assert.Equal(t, true, Yes("yes"))
})
t.Run("no", func(t *testing.T) {
t.Run("No", func(t *testing.T) {
assert.Equal(t, false, Yes("no"))
})
t.Run("false", func(t *testing.T) {
t.Run("False", func(t *testing.T) {
assert.Equal(t, false, Yes("false"))
})
t.Run("exclude", func(t *testing.T) {
t.Run("Exclude", func(t *testing.T) {
assert.Equal(t, false, Yes("exclude"))
})
t.Run("include", func(t *testing.T) {
t.Run("Include", func(t *testing.T) {
assert.Equal(t, true, Yes("include"))
})
t.Run("unknown", func(t *testing.T) {
t.Run("Unknown", func(t *testing.T) {
assert.Equal(t, false, Yes("unknown"))
})
t.Run("please", func(t *testing.T) {
t.Run("Please", func(t *testing.T) {
assert.Equal(t, true, Yes("please"))
})
t.Run("positive", func(t *testing.T) {
t.Run("Positive", func(t *testing.T) {
assert.Equal(t, true, Yes("positive"))
})
t.Run("empty", func(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
assert.Equal(t, false, Yes(""))
})
}
func TestNo(t *testing.T) {
t.Run("not empty", func(t *testing.T) {
t.Run("NotEmpty", func(t *testing.T) {
assert.Equal(t, false, No("Browse your life in pictures"))
})
t.Run("oui", func(t *testing.T) {
t.Run("Oui", func(t *testing.T) {
assert.Equal(t, false, No("oui"))
})
t.Run("non", func(t *testing.T) {
t.Run("Non", func(t *testing.T) {
assert.Equal(t, true, No("non"))
})
t.Run("ja", func(t *testing.T) {
t.Run("Ja", func(t *testing.T) {
assert.Equal(t, false, No("ja"))
})
t.Run("true", func(t *testing.T) {
t.Run("True", func(t *testing.T) {
assert.Equal(t, false, No("true"))
})
t.Run("yes", func(t *testing.T) {
t.Run("Yes", func(t *testing.T) {
assert.Equal(t, false, No("yes"))
})
t.Run("no", func(t *testing.T) {
t.Run("No", func(t *testing.T) {
assert.Equal(t, true, No("no"))
})
t.Run("false", func(t *testing.T) {
t.Run("False", func(t *testing.T) {
assert.Equal(t, true, No("false"))
})
t.Run("exclude", func(t *testing.T) {
t.Run("Exclude", func(t *testing.T) {
assert.Equal(t, true, No("exclude"))
})
t.Run("include", func(t *testing.T) {
t.Run("Include", func(t *testing.T) {
assert.Equal(t, false, No("include"))
})
t.Run("unknown", func(t *testing.T) {
t.Run("Unknown", func(t *testing.T) {
assert.Equal(t, true, No("unknown"))
})
t.Run("please", func(t *testing.T) {
t.Run("Please", func(t *testing.T) {
assert.Equal(t, false, No("please"))
})
t.Run("positive", func(t *testing.T) {
t.Run("Positive", func(t *testing.T) {
assert.Equal(t, false, No("positive"))
})
t.Run("empty", func(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
assert.Equal(t, false, No(""))
})
}

46
pkg/txt/contains_test.go
View file

@ -16,55 +16,55 @@ func TestContainsNumber(t *testing.T) {
}
func TestContainsSymbols(t *testing.T) {
t.Run("123", func(t *testing.T) {
t.Run("Num123", func(t *testing.T) {
assert.False(t, ContainsSymbols("123"))
})
t.Run("The quick brown fox.", func(t *testing.T) {
t.Run("TheQuickBrownFox", func(t *testing.T) {
assert.False(t, ContainsSymbols("The quick brown fox."))
})
t.Run("bridge", func(t *testing.T) {
t.Run("Bridge", func(t *testing.T) {
assert.False(t, ContainsSymbols("bridge"))
})
t.Run("桥", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.False(t, ContainsSymbols("桥"))
})
t.Run("桥船", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.False(t, ContainsSymbols("桥船"))
})
t.Run("स्थान", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.False(t, ContainsSymbols("स्थान"))
})
t.Run("réseau", func(t *testing.T) {
t.Run("RSeau", func(t *testing.T) {
assert.False(t, ContainsSymbols("réseau"))
})
t.Run("empty", func(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
assert.False(t, ContainsSymbols(""))
})
t.Run("...", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.True(t, ContainsSymbols("😉"))
})
}
func TestContainsLetters(t *testing.T) {
t.Run("123", func(t *testing.T) {
t.Run("Num123", func(t *testing.T) {
assert.False(t, ContainsLetters("123"))
})
t.Run("The quick brown fox.", func(t *testing.T) {
t.Run("TheQuickBrownFox", func(t *testing.T) {
assert.False(t, ContainsLetters("The quick brown fox."))
})
t.Run("bridge", func(t *testing.T) {
t.Run("Bridge", func(t *testing.T) {
assert.True(t, ContainsLetters("bridge"))
})
t.Run("桥", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.True(t, ContainsLetters("桥"))
})
t.Run("桥船", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.True(t, ContainsLetters("桥船"))
})
t.Run("स्थान", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.False(t, ContainsLetters("स्थान"))
})
t.Run("réseau", func(t *testing.T) {
t.Run("RSeau", func(t *testing.T) {
assert.True(t, ContainsLetters("réseau"))
})
t.Run("Empty", func(t *testing.T) {
@ -73,25 +73,25 @@ func TestContainsLetters(t *testing.T) {
}
func TestContainsASCIILetters(t *testing.T) {
t.Run("123", func(t *testing.T) {
t.Run("Num123", func(t *testing.T) {
assert.False(t, ContainsASCIILetters("123"))
})
t.Run("The quick brown fox.", func(t *testing.T) {
t.Run("TheQuickBrownFox", func(t *testing.T) {
assert.False(t, ContainsASCIILetters("The quick brown fox."))
})
t.Run("bridge", func(t *testing.T) {
t.Run("Bridge", func(t *testing.T) {
assert.True(t, ContainsASCIILetters("bridge"))
})
t.Run("桥", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.False(t, ContainsASCIILetters("桥"))
})
t.Run("桥船", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.False(t, ContainsASCIILetters("桥船"))
})
t.Run("स्थान", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.False(t, ContainsASCIILetters("स्थान"))
})
t.Run("réseau", func(t *testing.T) {
t.Run("RSeau", func(t *testing.T) {
assert.False(t, ContainsASCIILetters("réseau"))
})
}

86
pkg/txt/datetime_filepath_test.go
View file

@ -35,209 +35,209 @@ func TestDateFromFilePath(t *testing.T) {
assert.False(t, result.IsZero())
assert.Equal(t, "2005-04-06 15:21:03 +0000 UTC", result.String())
})
t.Run("2016/08/18 iPhone/WRNI2074.jpg", func(t *testing.T) {
t.Run("Num2016Num08EighteenIPhoneWrniNum2074Jpg", func(t *testing.T) {
result := DateFromFilePath("2016/08/18 iPhone/WRNI2074.jpg")
assert.False(t, result.IsZero())
assert.Equal(t, "2016-08-18 00:00:00 +0000 UTC", result.String())
})
t.Run("2016/08/18 iPhone/OZBJ8443.jpg", func(t *testing.T) {
t.Run("Num2016Num08EighteenIPhoneOzbjNum8443Jpg", func(t *testing.T) {
result := DateFromFilePath("2016/08/18 iPhone/OZBJ8443.jpg")
assert.False(t, result.IsZero())
assert.Equal(t, "2016-08-18 00:00:00 +0000 UTC", result.String())
})
t.Run("2018/04 - April/2018-04-12 19:24:49.gif", func(t *testing.T) {
t.Run("Num2018Num04AprilNum2018Num04TwelveNineteenNum24Num49Gif", func(t *testing.T) {
result := DateFromFilePath("2018/04 - April/2018-04-12 19:24:49.gif")
assert.False(t, result.IsZero())
assert.Equal(t, "2018-04-12 19:24:49 +0000 UTC", result.String())
})
t.Run("2018", func(t *testing.T) {
t.Run("Num2018", func(t *testing.T) {
result := DateFromFilePath("2018")
assert.True(t, result.IsZero())
})
t.Run("2018-04-12 19/24/49.gif", func(t *testing.T) {
t.Run("Num2018Num04TwelveNineteenNum24Num49Gif", func(t *testing.T) {
result := DateFromFilePath("2018-04-12 19/24/49.gif")
assert.False(t, result.IsZero())
assert.Equal(t, "2018-04-12 19:24:49 +0000 UTC", result.String())
})
t.Run("/2020/1212/20130518_142022_3D657EBD.jpg", func(t *testing.T) {
t.Run("Num2020Num1212Num20130518Num142022ThreeDNum657EbdJpg", func(t *testing.T) {
result := DateFromFilePath("/2020/1212/20130518_142022_3D657EBD.jpg")
assert.True(t, result.IsZero(), "\"/2020/1212/20130518_142022_3D657EBD.jpg\" should not generate a valid Date. This is the filename which PhotoPrism generates when importing photos")
})
t.Run("20130518_142022_3D657EBD.jpg", func(t *testing.T) {
t.Run("Num20130518Num142022ThreeDNum657EbdJpg", func(t *testing.T) {
result := DateFromFilePath("20130518_142022_3D657EBD.jpg")
assert.True(t, result.IsZero(), "\"20130518_142022_3D657EBD.jpg\" should not generate a valid Date. This is the filename which PhotoPrism generates when importing photos")
})
t.Run("telegram_2020_01_30_09_57_18.jpg", func(t *testing.T) {
t.Run("TelegramNum2020Num01Num30Num09Num57EighteenJpg", func(t *testing.T) {
result := DateFromFilePath("telegram_2020_01_30_09_57_18.jpg")
assert.False(t, result.IsZero())
assert.Equal(t, "2020-01-30 09:57:18 +0000 UTC", result.String())
})
t.Run("Screenshot 2019_05_21 at 10.45.52.png", func(t *testing.T) {
t.Run("ScreenshotNum2019Num05Num21AtTenNum45Num52Png", func(t *testing.T) {
result := DateFromFilePath("Screenshot 2019_05_21 at 10.45.52.png")
assert.False(t, result.IsZero())
assert.Equal(t, "2019-05-21 10:45:52 +0000 UTC", result.String())
})
t.Run("telegram_2020-01-30_09-57-18.jpg", func(t *testing.T) {
t.Run("TelegramNum2020Num01Num30Num09Num57EighteenJpg", func(t *testing.T) {
result := DateFromFilePath("telegram_2020-01-30_09-57-18.jpg")
assert.False(t, result.IsZero())
assert.Equal(t, "2020-01-30 09:57:18 +0000 UTC", result.String())
})
t.Run("Screenshot 2019-05-21 at 10.45.52.png", func(t *testing.T) {
t.Run("ScreenshotNum2019Num05Num21AtTenNum45Num52Png", func(t *testing.T) {
result := DateFromFilePath("Screenshot 2019-05-21 at 10.45.52.png")
assert.False(t, result.IsZero())
assert.Equal(t, "2019-05-21 10:45:52 +0000 UTC", result.String())
})
t.Run("telegram_2020-01-30_09-18.jpg", func(t *testing.T) {
t.Run("TelegramNum2020Num01Num30Num09EighteenJpg", func(t *testing.T) {
result := DateFromFilePath("telegram_2020-01-30_09-18.jpg")
assert.False(t, result.IsZero())
assert.Equal(t, "2020-01-30 00:00:00 +0000 UTC", result.String())
})
t.Run("Screenshot 2019-05-21 at 10545.52.png", func(t *testing.T) {
t.Run("ScreenshotNum2019Num05Num21AtNum10545Num52Png", func(t *testing.T) {
result := DateFromFilePath("Screenshot 2019-05-21 at 10545.52.png")
assert.False(t, result.IsZero())
assert.Equal(t, "2019-05-21 00:00:00 +0000 UTC", result.String())
})
t.Run("/2019-05-21/file2314.JPG", func(t *testing.T) {
t.Run("Num2019Num05Num21File2314Jpg", func(t *testing.T) {
result := DateFromFilePath("/2019-05-21/file2314.JPG")
assert.False(t, result.IsZero())
assert.Equal(t, "2019-05-21 00:00:00 +0000 UTC", result.String())
})
t.Run("/2019.05.21", func(t *testing.T) {
t.Run("Num2019Num05Num21", func(t *testing.T) {
result := DateFromFilePath("/2019.05.21")
assert.True(t, result.IsZero())
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("/05.21.2019", func(t *testing.T) {
t.Run("Num05Num21Num2019", func(t *testing.T) {
result := DateFromFilePath("/05.21.2019")
assert.True(t, result.IsZero())
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("/21.05.2019", func(t *testing.T) {
t.Run("Num21Num05Num2019", func(t *testing.T) {
result := DateFromFilePath("/21.05.2019")
assert.True(t, result.IsZero())
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("05/21/2019", func(t *testing.T) {
t.Run("Num05Num21Num2019", func(t *testing.T) {
result := DateFromFilePath("05/21/2019")
assert.True(t, result.IsZero())
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("2019-07-23", func(t *testing.T) {
t.Run("Num2019Num07Num23", func(t *testing.T) {
result := DateFromFilePath("2019-07-23")
assert.False(t, result.IsZero())
assert.Equal(t, "2019-07-23 00:00:00 +0000 UTC", result.String())
})
t.Run("Photos/2015-01-14", func(t *testing.T) {
t.Run("PhotosNum2015Num01Fourteen", func(t *testing.T) {
result := DateFromFilePath("Photos/2015-01-14")
assert.False(t, result.IsZero())
assert.Equal(t, "2015-01-14 00:00:00 +0000 UTC", result.String())
})
t.Run("21/05/2019", func(t *testing.T) {
t.Run("Num21Num05Num2019", func(t *testing.T) {
result := DateFromFilePath("21/05/2019")
assert.True(t, result.IsZero())
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("2019/05/21", func(t *testing.T) {
t.Run("Num2019Num05Num21", func(t *testing.T) {
result := DateFromFilePath("2019/05/21")
assert.False(t, result.IsZero())
assert.Equal(t, "2019-05-21 00:00:00 +0000 UTC", result.String())
})
t.Run("2019/05/2145", func(t *testing.T) {
t.Run("Num2019Num05Num2145", func(t *testing.T) {
result := DateFromFilePath("2019/05/2145")
assert.True(t, result.IsZero())
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("/05/21/2019", func(t *testing.T) {
t.Run("Num05Num21Num2019", func(t *testing.T) {
result := DateFromFilePath("/05/21/2019")
assert.True(t, result.IsZero())
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("/21/05/2019", func(t *testing.T) {
t.Run("Num21Num05Num2019", func(t *testing.T) {
result := DateFromFilePath("/21/05/2019")
assert.True(t, result.IsZero())
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("/2019/05/21.jpeg", func(t *testing.T) {
t.Run("Num2019Num05Num21Jpeg", func(t *testing.T) {
result := DateFromFilePath("/2019/05/21.jpeg")
assert.False(t, result.IsZero())
assert.Equal(t, "2019-05-21 00:00:00 +0000 UTC", result.String())
})
t.Run("/2019/05/21/foo.txt", func(t *testing.T) {
t.Run("Num2019Num05Num21FooTxt", func(t *testing.T) {
result := DateFromFilePath("/2019/05/21/foo.txt")
assert.False(t, result.IsZero())
assert.Equal(t, "2019-05-21 00:00:00 +0000 UTC", result.String())
})
t.Run("2019/21/05", func(t *testing.T) {
t.Run("Num2019Num21Num05", func(t *testing.T) {
result := DateFromFilePath("2019/21/05")
assert.True(t, result.IsZero())
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("/2019/05/21/foo.jpg", func(t *testing.T) {
t.Run("Num2019Num05Num21FooJpg", func(t *testing.T) {
result := DateFromFilePath("/2019/05/21/foo.jpg")
assert.False(t, result.IsZero())
assert.Equal(t, "2019-05-21 00:00:00 +0000 UTC", result.String())
})
t.Run("/2019/21/05/foo.jpg", func(t *testing.T) {
t.Run("Num2019Num21Num05FooJpg", func(t *testing.T) {
result := DateFromFilePath("/2019/21/05/foo.jpg")
assert.True(t, result.IsZero())
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("/2019/5/foo.jpg", func(t *testing.T) {
t.Run("Num2019FiveFooJpg", func(t *testing.T) {
result := DateFromFilePath("/2019/5/foo.jpg")
assert.False(t, result.IsZero())
assert.Equal(t, "2019-05-01 00:00:00 +0000 UTC", result.String())
})
t.Run("/2019/1/3/foo.jpg", func(t *testing.T) {
t.Run("Num2019OneThreeFooJpg", func(t *testing.T) {
result := DateFromFilePath("/2019/1/3/foo.jpg")
assert.False(t, result.IsZero())
assert.Equal(t, "2019-01-03 00:00:00 +0000 UTC", result.String())
})
t.Run("/1989/1/3/foo.jpg", func(t *testing.T) {
t.Run("Num1989OneThreeFooJpg", func(t *testing.T) {
result := DateFromFilePath("/1989/1/3/foo.jpg")
assert.False(t, result.IsZero())
assert.Equal(t, "1989-01-03 00:00:00 +0000 UTC", result.String())
})
t.Run("/1970/1/3/foo.jpg", func(t *testing.T) {
t.Run("Num1970OneThreeFooJpg", func(t *testing.T) {
result := DateFromFilePath("/1970/1/3/foo.jpg")
assert.False(t, result.IsZero())
assert.Equal(t, "1970-01-03 00:00:00 +0000 UTC", result.String())
})
t.Run("/1969/1/3/foo.jpg", func(t *testing.T) {
t.Run("Num1969OneThreeFooJpg", func(t *testing.T) {
result := DateFromFilePath("/1969/1/3/foo.jpg")
assert.True(t, result.IsZero())
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("545452019/1/3/foo.jpg", func(t *testing.T) {
t.Run("Num545452019OneThreeFooJpg", func(t *testing.T) {
result := DateFromFilePath("/2019/1/3/foo.jpg")
assert.False(t, result.IsZero())
assert.Equal(t, "2019-01-03 00:00:00 +0000 UTC", result.String())
})
t.Run("fo.jpg", func(t *testing.T) {
t.Run("FoJpg", func(t *testing.T) {
result := DateFromFilePath("fo.jpg")
assert.True(t, result.IsZero())
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("n >6", func(t *testing.T) {
t.Run("NGreaterThanSix", func(t *testing.T) {
result := DateFromFilePath("2020-01-30_09-87-18-23.jpg")
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("year < yearmin", func(t *testing.T) {
t.Run("YearLessThanYearmin", func(t *testing.T) {
result := DateFromFilePath("1020-01-30_09-57-18.jpg")
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("hour > hourmax", func(t *testing.T) {
t.Run("HourGreaterThanHourmax", func(t *testing.T) {
result := DateFromFilePath("2020-01-30_25-57-18.jpg")
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("invalid days", func(t *testing.T) {
t.Run("InvalidDays", func(t *testing.T) {
result := DateFromFilePath("2020-01-00.jpg")
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("IMG-20191120-WA0001.jpg", func(t *testing.T) {
t.Run("ImgNum20191120WaNum0001Jpg", func(t *testing.T) {
result := DateFromFilePath("IMG-20191120-WA0001.jpg")
assert.Equal(t, "2019-11-20 00:00:00 +0000 UTC", result.String())
})
t.Run("VID-20191120-WA0001.jpg", func(t *testing.T) {
t.Run("VidNum20191120WaNum0001Jpg", func(t *testing.T) {
result := DateFromFilePath("VID-20191120-WA0001.jpg")
assert.Equal(t, "2019-11-20 00:00:00 +0000 UTC", result.String())
})

90
pkg/txt/datetime_test.go
View file

@ -8,37 +8,37 @@ import (
)
func TestIsTime(t *testing.T) {
t.Run("/2020/1212/20130518_142022_3D657EBD.jpg", func(t *testing.T) {
t.Run("Num2020Num1212Num20130518Num142022ThreeDNum657EbdJpg", func(t *testing.T) {
assert.False(t, IsTime("/2020/1212/20130518_142022_3D657EBD.jpg"))
})
t.Run("telegram_2020_01_30_09_57_18.jpg", func(t *testing.T) {
t.Run("TelegramNum2020Num01Num30Num09Num57EighteenJpg", func(t *testing.T) {
assert.False(t, IsTime("telegram_2020_01_30_09_57_18.jpg"))
})
t.Run("", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.False(t, IsTime(""))
})
t.Run("Screenshot 2019_05_21 at 10.45.52.png", func(t *testing.T) {
t.Run("ScreenshotNum2019Num05Num21AtTenNum45Num52Png", func(t *testing.T) {
assert.False(t, IsTime("Screenshot 2019_05_21 at 10.45.52.png"))
})
t.Run("telegram_2020-01-30_09-57-18.jpg", func(t *testing.T) {
t.Run("TelegramNum2020Num01Num30Num09Num57EighteenJpg", func(t *testing.T) {
assert.False(t, IsTime("telegram_2020-01-30_09-57-18.jpg"))
})
t.Run("2013-05-18", func(t *testing.T) {
t.Run("Num2013Num05Eighteen", func(t *testing.T) {
assert.True(t, IsTime("2013-05-18"))
})
t.Run("2013-05-18 12:01:01", func(t *testing.T) {
t.Run("Num2013Num05EighteenTwelveNum01Num01", func(t *testing.T) {
assert.True(t, IsTime("2013-05-18 12:01:01"))
})
t.Run("20130518_142022", func(t *testing.T) {
t.Run("Num20130518Num142022", func(t *testing.T) {
assert.True(t, IsTime("20130518_142022"))
})
t.Run("2020_01_30_09_57_18", func(t *testing.T) {
t.Run("Num2020Num01Num30Num09Num57Eighteen", func(t *testing.T) {
assert.True(t, IsTime("2020_01_30_09_57_18"))
})
t.Run("2019_05_21 at 10.45.52", func(t *testing.T) {
t.Run("Num2019Num05Num21AtTenNum45Num52", func(t *testing.T) {
assert.True(t, IsTime("2019_05_21 at 10.45.52"))
})
t.Run("2020-01-30_09-57-18", func(t *testing.T) {
t.Run("Num2020Num01Num30Num09Num57Eighteen", func(t *testing.T) {
assert.True(t, IsTime("2020-01-30_09-57-18"))
})
}
@ -50,7 +50,7 @@ func TestDateTime(t *testing.T) {
t.Run("Zero", func(t *testing.T) {
assert.Equal(t, "", DateTime(&time.Time{}))
})
t.Run("1665389030", func(t *testing.T) {
t.Run("Num1665389030", func(t *testing.T) {
now := time.Unix(1665389030, 0)
assert.Equal(t, "2022-10-10 08:03:50", DateTime(&now))
})
@ -60,7 +60,7 @@ func TestUnixTime(t *testing.T) {
t.Run("Zero", func(t *testing.T) {
assert.Equal(t, "", UnixTime(0))
})
t.Run("1665389030", func(t *testing.T) {
t.Run("Num1665389030", func(t *testing.T) {
assert.Equal(t, "2022-10-10 08:03:50", UnixTime(1665389030))
})
}
@ -71,41 +71,41 @@ func TestParseTimeUTC(t *testing.T) {
assert.True(t, result.IsZero())
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("0000-00-00 00:00:00", func(t *testing.T) {
t.Run("Num0000Num00Num00Num00Num00Num00", func(t *testing.T) {
result := ParseTimeUTC("0000-00-00 00:00:00")
assert.True(t, result.IsZero())
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("0001-01-01 00:00:00 +0000 UTC", func(t *testing.T) {
t.Run("Num0001Num01Num01Num00Num00Num00Num0000Utc", func(t *testing.T) {
result := ParseTimeUTC("0001-01-01 00:00:00 +0000 UTC")
assert.True(t, result.IsZero())
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("2016: : : : ", func(t *testing.T) {
t.Run("Num2016", func(t *testing.T) {
result := ParseTimeUTC("2016: : : : ")
assert.Equal(t, "2016-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("2020-12-29", func(t *testing.T) {
t.Run("Num2020TwelveNum29", func(t *testing.T) {
result := ParseTimeUTC("2020-12-29")
assert.Equal(t, "2020-12-29 00:00:00 +0000 UTC", result.String())
})
t.Run("2020/12/29", func(t *testing.T) {
t.Run("Num2020TwelveNum29", func(t *testing.T) {
result := ParseTimeUTC("2020/12/29")
assert.Equal(t, "2020-12-29 00:00:00 +0000 UTC", result.String())
})
t.Run("2020", func(t *testing.T) {
t.Run("Num2020", func(t *testing.T) {
result := ParseTimeUTC("2020")
assert.Equal(t, "2020-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("2020/02", func(t *testing.T) {
t.Run("Num2020Num02", func(t *testing.T) {
result := ParseTimeUTC("2020/02")
assert.Equal(t, "2020-02-01 00:00:00 +0000 UTC", result.String())
})
t.Run("29.12.2020", func(t *testing.T) {
t.Run("Num29TwelveNum2020", func(t *testing.T) {
result := ParseTimeUTC("29.12.2020")
assert.Equal(t, "2020-12-29 00:00:00 +0000 UTC", result.String())
})
t.Run("29/12/2020", func(t *testing.T) {
t.Run("Num29TwelveNum2020", func(t *testing.T) {
result := ParseTimeUTC("29/12/2020")
assert.Equal(t, "2020-12-29 00:00:00 +0000 UTC", result.String())
})
@ -117,89 +117,89 @@ func TestParseTime(t *testing.T) {
assert.True(t, result.IsZero())
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("0000-00-00 00:00:00", func(t *testing.T) {
t.Run("Num0000Num00Num00Num00Num00Num00", func(t *testing.T) {
result := ParseTime("0000-00-00 00:00:00", "")
assert.True(t, result.IsZero())
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("0001-01-01 00:00:00 +0000 UTC", func(t *testing.T) {
t.Run("Num0001Num01Num01Num00Num00Num00Num0000Utc", func(t *testing.T) {
result := ParseTime("0001-01-01 00:00:00 +0000 UTC", "")
assert.True(t, result.IsZero())
assert.Equal(t, "0001-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("2016: : : : ", func(t *testing.T) {
t.Run("Num2016", func(t *testing.T) {
result := ParseTime("2016: : : : ", "")
assert.Equal(t, "2016-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("2016: :__ : : ", func(t *testing.T) {
t.Run("Num2016", func(t *testing.T) {
result := ParseTime("2016: :__ : : ", "")
assert.Equal(t, "2016-01-01 00:00:00 +0000 UTC", result.String())
})
t.Run("2016:06:28 : :??", func(t *testing.T) {
t.Run("Num2016Num06Num28", func(t *testing.T) {
result := ParseTime("2016:06:28 : :??", "")
assert.Equal(t, "2016-06-28 00:00:00 +0000 UTC", result.String())
})
t.Run("2016:06:28 09:45:49", func(t *testing.T) {
t.Run("Num2016Num06Num28Num09Num45Num49", func(t *testing.T) {
result := ParseTime("2016:06:28 09:45:49", "")
assert.Equal(t, "2016-06-28 09:45:49 +0000 UTC", result.String())
})
t.Run("2016:06:28 09:45:49+10:00", func(t *testing.T) {
t.Run("Num2016Num06Num28Num09Num45Num49TenNum00", func(t *testing.T) {
result := ParseTime("2016:06:28 09:45:49+10:00", "")
assert.Equal(t, "2016-06-28 09:45:49 +1000 UTC+10:00", result.String())
})
t.Run("2016:06:28 : :", func(t *testing.T) {
t.Run("Num2016Num06Num28", func(t *testing.T) {
result := ParseTime("2016:06:28 : :", "")
assert.Equal(t, "2016-06-28 00:00:00 +0000 UTC", result.String())
})
t.Run("2016/06/28T09-45:49", func(t *testing.T) {
t.Run("Num2016Num06Num28TNum09Num45Num49", func(t *testing.T) {
result := ParseTime("2016/06/28T09-45:49", "")
assert.Equal(t, "2016-06-28 09:45:49 +0000 UTC", result.String())
})
t.Run("2016:06:28T09:45:49Z", func(t *testing.T) {
t.Run("Num2016Num06Num28TNum09Num45Num49Z", func(t *testing.T) {
result := ParseTime("2016:06:28T09:45:49Z", "")
assert.Equal(t, "2016-06-28 09:45:49 +0000 UTC", result.String())
})
t.Run("2016:06:28T09:45: Z", func(t *testing.T) {
t.Run("Num2016Num06Num28TNum09Num45Z", func(t *testing.T) {
result := ParseTime("2016:06:28T09:45: Z", "")
assert.Equal(t, "2016-06-28 09:45:00 +0000 UTC", result.String())
})
t.Run("2016:06:28T09:45: ", func(t *testing.T) {
t.Run("Num2016Num06Num28TNum09Num45", func(t *testing.T) {
result := ParseTime("2016:06:28T09:45: ", "")
assert.Equal(t, "2016-06-28 09:45:00 +0000 UTC", result.String())
})
t.Run("2016:06:28T09:45: ZABC", func(t *testing.T) {
t.Run("Num2016Num06Num28TNum09Num45Zabc", func(t *testing.T) {
result := ParseTime("2016:06:28T09:45: ZABC", "")
assert.Equal(t, "2016-06-28 09:45:00 +0000 UTC", result.String())
})
t.Run("2016:06:28T09:45: ABC", func(t *testing.T) {
t.Run("Num2016Num06Num28TNum09Num45Abc", func(t *testing.T) {
result := ParseTime("2016:06:28T09:45: ABC", "")
assert.Equal(t, "2016-06-28 09:45:00 +0000 UTC", result.String())
})
t.Run("2016:06:28 09:45:49+10:00ABC", func(t *testing.T) {
t.Run("Num2016Num06Num28Num09Num45Num49TenNum00Abc", func(t *testing.T) {
result := ParseTime("2016:06:28 09:45:49+10:00ABC", "")
assert.Equal(t, "2016-06-28 09:45:49 +1000 UTC+10:00", result.String())
})
t.Run(" 2016:06:28 09:45:49-01:30ABC", func(t *testing.T) {
t.Run("Num2016Num06Num28Num09Num45Num49Num01Num30Abc", func(t *testing.T) {
result := ParseTime(" 2016:06:28 09:45:49-01:30ABC", "")
assert.Equal(t, "2016-06-28 09:45:49 -0130 UTC-01:30", result.String())
})
t.Run("2016:06:28 09:45:49-0130", func(t *testing.T) {
t.Run("Num2016Num06Num28Num09Num45Num49Num0130", func(t *testing.T) {
result := ParseTime("2016:06:28 09:45:49-0130", "")
assert.Equal(t, "2016-06-28 09:45:49 -0130 UTC-01:30", result.String())
})
t.Run("UTC/016:06:28 09:45:49-0130", func(t *testing.T) {
t.Run("UtcNum016Num06Num28Num09Num45Num49Num0130", func(t *testing.T) {
result := ParseTime("2016:06:28 09:45:49-0130", "UTC")
assert.Equal(t, "2016-06-28 11:15:49 +0000 UTC", result.String())
})
t.Run("UTC/016:06:28 09:45:49-0130", func(t *testing.T) {
t.Run("UtcNum016Num06Num28Num09Num45Num49Num0130", func(t *testing.T) {
result := ParseTime("2016:06:28 09:45:49.0130", "UTC")
assert.Equal(t, "2016-06-28 09:45:49.013 +0000 UTC", result.String())
})
t.Run("2012:08:08 22:07:18", func(t *testing.T) {
t.Run("Num2012Num08Num08Num22Num07Eighteen", func(t *testing.T) {
result := ParseTime("2012:08:08 22:07:18", "")
assert.Equal(t, "2012-08-08 22:07:18 +0000 UTC", result.String())
})
t.Run("2020-01-30_09-57-18", func(t *testing.T) {
t.Run("Num2020Num01Num30Num09Num57Eighteen", func(t *testing.T) {
result := ParseTime("2020-01-30_09-57-18", "")
assert.Equal(t, "2020-01-30 09:57:18 +0000 UTC", result.String())
})
@ -227,12 +227,12 @@ func TestParseTime(t *testing.T) {
t.Run("UtcUnknown", func(t *testing.T) {
assert.True(t, ParseTime("0000:00:00 00:00:00", "UTC").IsZero())
})
t.Run("2022-09-03T17:48:26-07:00", func(t *testing.T) {
t.Run("Num2022Num09Num03TSeventeenNum48Num26Num07Num00", func(t *testing.T) {
result := ParseTime("2022-09-03T17:48:26-07:00", "")
assert.Equal(t, "2022-09-04 00:48:26 +0000 UTC", result.UTC().String())
assert.Equal(t, "2022-09-03 17:48:26", result.Format("2006-01-02 15:04:05"))
})
t.Run("2016:06:28 09:45:49 UTC+2", func(t *testing.T) {
t.Run("Num2016Num06Num28Num09Num45Num49UtcTwo", func(t *testing.T) {
result := ParseTime("2016:06:28 09:45:49 +0000 UTC", "UTC+2")
assert.Equal(t, "2016-06-28 09:45:49 +0200 UTC+2", result.String())
assert.Equal(t, "2016-06-28 07:45:49 +0000 UTC", result.UTC().String())

36
pkg/txt/datetime_year_test.go
View file

@ -7,54 +7,54 @@ import (
)
func TestYear(t *testing.T) {
t.Run("London 2002", func(t *testing.T) {
t.Run("LondonNum2002", func(t *testing.T) {
result := Year("/2002/London 81/")
assert.Equal(t, 2002, result)
})
t.Run("San Francisco 2019", func(t *testing.T) {
t.Run("SanFranciscoNum2019", func(t *testing.T) {
result := Year("San Francisco 2019")
assert.Equal(t, 2019, result)
})
t.Run("string with no number", func(t *testing.T) {
t.Run("StringWithNoNumber", func(t *testing.T) {
result := Year("Born in the U.S.A. is a song written and performed by Bruce Springsteen...")
assert.Equal(t, 0, result)
})
t.Run("file name", func(t *testing.T) {
t.Run("FileName", func(t *testing.T) {
result := Year("/share/photos/243546/2003/01/myfile.jpg")
assert.Equal(t, 2003, result)
})
t.Run("1981", func(t *testing.T) {
t.Run("Num1981", func(t *testing.T) {
result := Year("/root/1981/London 2005")
assert.Equal(t, 1981, result)
})
t.Run("1970", func(t *testing.T) {
t.Run("Num1970", func(t *testing.T) {
result := Year("/root/1970/London 2005")
assert.Equal(t, 2005, result)
})
t.Run("1969", func(t *testing.T) {
t.Run("Num1969", func(t *testing.T) {
result := Year("/root/1969/London 2005")
assert.Equal(t, 2005, result)
})
t.Run("1950", func(t *testing.T) {
t.Run("Num1950", func(t *testing.T) {
result := Year("/root/1950/London 2005")
assert.Equal(t, 2005, result)
})
t.Run("empty string", func(t *testing.T) {
t.Run("EmptyString", func(t *testing.T) {
result := Year("")
assert.Equal(t, 0, result)
})
}
func TestExpandYear(t *testing.T) {
t.Run("1977", func(t *testing.T) {
t.Run("Num1977", func(t *testing.T) {
result := ExpandYear("1977")
assert.Equal(t, 1977, result)
})
t.Run("2002", func(t *testing.T) {
t.Run("Num2002", func(t *testing.T) {
result := ExpandYear("2002")
assert.Equal(t, 2002, result)
})
t.Run("2019", func(t *testing.T) {
t.Run("Num2019", func(t *testing.T) {
result := ExpandYear("2019")
assert.Equal(t, 2019, result)
})
@ -62,27 +62,27 @@ func TestExpandYear(t *testing.T) {
result := ExpandYear("XXXX")
assert.Equal(t, -1, result)
})
t.Run("88", func(t *testing.T) {
t.Run("Num88", func(t *testing.T) {
result := ExpandYear("88")
assert.Equal(t, -1, result)
})
t.Run("91", func(t *testing.T) {
t.Run("Num91", func(t *testing.T) {
result := ExpandYear("91")
assert.Equal(t, 1991, result)
})
t.Run("01", func(t *testing.T) {
t.Run("Num01", func(t *testing.T) {
result := ExpandYear("01")
assert.Equal(t, 2001, result)
})
t.Run("1", func(t *testing.T) {
t.Run("One", func(t *testing.T) {
result := ExpandYear("1")
assert.Equal(t, -1, result)
})
t.Run("12", func(t *testing.T) {
t.Run("Twelve", func(t *testing.T) {
result := ExpandYear("12")
assert.Equal(t, 2012, result)
})
t.Run("22", func(t *testing.T) {
t.Run("Num22", func(t *testing.T) {
result := ExpandYear("22")
assert.Equal(t, 2022, result)
})

86
pkg/txt/empty_test.go
View file

@ -28,16 +28,16 @@ func TestEmpty(t *testing.T) {
t.Run("False", func(t *testing.T) {
assert.Equal(t, false, Empty("non"))
})
t.Run("0", func(t *testing.T) {
t.Run("Zero", func(t *testing.T) {
assert.Equal(t, true, Empty("0"))
})
t.Run("-1", func(t *testing.T) {
t.Run("One", func(t *testing.T) {
assert.Equal(t, true, Empty("-1"))
})
t.Run("Date", func(t *testing.T) {
assert.Equal(t, true, Empty("0000:00:00 00:00:00"))
})
t.Run("nil", func(t *testing.T) {
t.Run("Nil", func(t *testing.T) {
assert.Equal(t, true, Empty("nil"))
})
t.Run("NaN", func(t *testing.T) {
@ -46,19 +46,19 @@ func TestEmpty(t *testing.T) {
t.Run("NULL", func(t *testing.T) {
assert.Equal(t, true, Empty("NULL"))
})
t.Run("*", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.Equal(t, true, Empty("*"))
})
t.Run("%", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.Equal(t, true, Empty("%"))
})
t.Run("-", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.True(t, Empty("-"))
})
t.Run("z", func(t *testing.T) {
t.Run("Z", func(t *testing.T) {
assert.True(t, Empty("z"))
})
t.Run("zz", func(t *testing.T) {
t.Run("Zz", func(t *testing.T) {
assert.False(t, Empty("zz"))
})
}
@ -85,16 +85,16 @@ func TestNotEmpty(t *testing.T) {
t.Run("False", func(t *testing.T) {
assert.Equal(t, true, NotEmpty("non"))
})
t.Run("0", func(t *testing.T) {
t.Run("Zero", func(t *testing.T) {
assert.Equal(t, false, NotEmpty("0"))
})
t.Run("-1", func(t *testing.T) {
t.Run("One", func(t *testing.T) {
assert.Equal(t, false, NotEmpty("-1"))
})
t.Run("Date", func(t *testing.T) {
assert.Equal(t, false, NotEmpty("0000:00:00 00:00:00"))
})
t.Run("nil", func(t *testing.T) {
t.Run("Nil", func(t *testing.T) {
assert.Equal(t, false, NotEmpty("nil"))
})
t.Run("NaN", func(t *testing.T) {
@ -103,19 +103,19 @@ func TestNotEmpty(t *testing.T) {
t.Run("NULL", func(t *testing.T) {
assert.Equal(t, false, NotEmpty("NULL"))
})
t.Run("*", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.Equal(t, false, NotEmpty("*"))
})
t.Run("%", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.Equal(t, false, NotEmpty("%"))
})
t.Run("-", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.False(t, NotEmpty("-"))
})
t.Run("z", func(t *testing.T) {
t.Run("Z", func(t *testing.T) {
assert.False(t, NotEmpty("z"))
})
t.Run("zz", func(t *testing.T) {
t.Run("Zz", func(t *testing.T) {
assert.True(t, NotEmpty("zz"))
})
}
@ -124,40 +124,40 @@ func TestEmptyDateTime(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
assert.True(t, EmptyDateTime(""))
})
t.Run("-", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.True(t, EmptyDateTime("-"))
})
t.Run("z", func(t *testing.T) {
t.Run("Z", func(t *testing.T) {
assert.True(t, EmptyDateTime("z"))
})
t.Run("zz", func(t *testing.T) {
t.Run("Zz", func(t *testing.T) {
assert.False(t, EmptyDateTime("zz"))
})
t.Run("0", func(t *testing.T) {
t.Run("Zero", func(t *testing.T) {
assert.True(t, EmptyDateTime("0"))
})
t.Run("00-00-00", func(t *testing.T) {
t.Run("Num00Num00Num00", func(t *testing.T) {
assert.True(t, EmptyDateTime("00-00-00"))
})
t.Run("0000-00-00", func(t *testing.T) {
t.Run("Num0000Num00Num00", func(t *testing.T) {
assert.True(t, EmptyDateTime("0000-00-00"))
})
t.Run("00:00:00", func(t *testing.T) {
t.Run("Num00Num00Num00", func(t *testing.T) {
assert.True(t, EmptyDateTime("00:00:00"))
})
t.Run("0000:00:00", func(t *testing.T) {
t.Run("Num0000Num00Num00", func(t *testing.T) {
assert.True(t, EmptyDateTime("0000:00:00"))
})
t.Run("0000-00-00 00-00-00", func(t *testing.T) {
t.Run("Num0000Num00Num00Num00Num00Num00", func(t *testing.T) {
assert.True(t, EmptyDateTime("0000-00-00 00-00-00"))
})
t.Run("0000:00:00 00:00:00", func(t *testing.T) {
t.Run("Num0000Num00Num00Num00Num00Num00", func(t *testing.T) {
assert.True(t, EmptyDateTime("0000:00:00 00:00:00"))
})
t.Run("0000-00-00 00:00:00", func(t *testing.T) {
t.Run("Num0000Num00Num00Num00Num00Num00", func(t *testing.T) {
assert.True(t, EmptyDateTime("0000-00-00 00:00:00"))
})
t.Run("0001-01-01 00:00:00 +0000 UTC", func(t *testing.T) {
t.Run("Num0001Num01Num01Num00Num00Num00Num0000Utc", func(t *testing.T) {
assert.True(t, EmptyDateTime("0001-01-01 00:00:00 +0000 UTC"))
})
}
@ -166,49 +166,49 @@ func TestDateTimeDefault(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
assert.True(t, DateTimeDefault(""))
})
t.Run("nil", func(t *testing.T) {
t.Run("Nil", func(t *testing.T) {
assert.True(t, DateTimeDefault("nil"))
})
t.Run("2002", func(t *testing.T) {
t.Run("Num2002", func(t *testing.T) {
assert.False(t, DateTimeDefault("2002"))
})
t.Run("1970-01-01", func(t *testing.T) {
t.Run("Num1970Num01Num01", func(t *testing.T) {
assert.True(t, DateTimeDefault("1970-01-01"))
})
t.Run("1980-01-01", func(t *testing.T) {
t.Run("Num1980Num01Num01", func(t *testing.T) {
assert.True(t, DateTimeDefault("1980-01-01"))
})
t.Run("1970-01-01 00:00:00", func(t *testing.T) {
t.Run("Num1970Num01Num01Num00Num00Num00", func(t *testing.T) {
assert.True(t, DateTimeDefault("1970-01-01 00:00:00"))
})
t.Run("1970:01:01 00:00:00", func(t *testing.T) {
t.Run("Num1970Num01Num01Num00Num00Num00", func(t *testing.T) {
assert.True(t, DateTimeDefault("1970:01:01 00:00:00"))
})
t.Run("1980-01-01 00:00:00", func(t *testing.T) {
t.Run("Num1980Num01Num01Num00Num00Num00", func(t *testing.T) {
assert.True(t, DateTimeDefault("1980-01-01 00:00:00"))
})
t.Run("1980:01:01 00:00:00", func(t *testing.T) {
t.Run("Num1980Num01Num01Num00Num00Num00", func(t *testing.T) {
assert.True(t, DateTimeDefault("1980:01:01 00:00:00"))
})
t.Run("2002-12-08 12:00:00", func(t *testing.T) {
t.Run("Num2002TwelveNum08TwelveNum00Num00", func(t *testing.T) {
assert.True(t, DateTimeDefault("2002-12-08 12:00:00"))
})
t.Run("2002:12:08 12:00:00", func(t *testing.T) {
t.Run("Num2002TwelveNum08TwelveNum00Num00", func(t *testing.T) {
assert.True(t, DateTimeDefault("2002:12:08 12:00:00"))
})
t.Run("0000-00-00", func(t *testing.T) {
t.Run("Num0000Num00Num00", func(t *testing.T) {
assert.True(t, DateTimeDefault("0000-00-00"))
})
t.Run("0000-00-00 00-00-00", func(t *testing.T) {
t.Run("Num0000Num00Num00Num00Num00Num00", func(t *testing.T) {
assert.True(t, DateTimeDefault("0000-00-00 00-00-00"))
})
t.Run("0000:00:00 00:00:00", func(t *testing.T) {
t.Run("Num0000Num00Num00Num00Num00Num00", func(t *testing.T) {
assert.True(t, DateTimeDefault("0000:00:00 00:00:00"))
})
t.Run("0000-00-00 00:00:00", func(t *testing.T) {
t.Run("Num0000Num00Num00Num00Num00Num00", func(t *testing.T) {
assert.True(t, DateTimeDefault("0000-00-00 00:00:00"))
})
t.Run("0001-01-01 00:00:00 +0000 UTC", func(t *testing.T) {
t.Run("Num0001Num01Num01Num00Num00Num00Num0000Utc", func(t *testing.T) {
assert.True(t, DateTimeDefault("0001-01-01 00:00:00 +0000 UTC"))
})
}

60
pkg/txt/file_title_test.go
View file

@ -7,55 +7,55 @@ import (
)
func TestFileTitle(t *testing.T) {
t.Run("桥", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.Equal(t, "桥", FileTitle("桥"))
})
t.Run("桥船", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
result := FileTitle("桥船")
assert.Equal(t, "桥船", result)
})
t.Run("桥船猫", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
result := FileTitle("桥船猫")
assert.Equal(t, "桥船猫", result)
})
t.Run("谢谢！", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
result := FileTitle("谢谢！")
assert.Equal(t, "谢谢！", result)
})
t.Run("i_love_you!", func(t *testing.T) {
t.Run("ILoveYou", func(t *testing.T) {
assert.Equal(t, "Love You!", FileTitle("i_love_you!"))
})
t.Run("PhotoPrism", func(t *testing.T) {
assert.Equal(t, "PhotoPrism: Browse Your Life in Pictures", FileTitle("photoprism: Browse your life in pictures"))
})
t.Run("dash", func(t *testing.T) {
t.Run("Dash", func(t *testing.T) {
assert.Equal(t, "Photo Lover", FileTitle("photo-lover"))
})
t.Run("nyc", func(t *testing.T) {
t.Run("Nyc", func(t *testing.T) {
assert.Equal(t, "BRIDGE in, or by, NYC", FileTitle("BRIDGE in, or by, nyc"))
})
t.Run("apple", func(t *testing.T) {
t.Run("Apple", func(t *testing.T) {
assert.Equal(t, "Phil Unveils iPhone, iPad, iPod, 'airpods', Airpod, AirPlay, iMac or MacBook Pro and Max", FileTitle("phil unveils iphone, ipad, ipod, 'airpods', airpod, airplay, imac or macbook 11 pro and max"))
})
t.Run("IMG_4568", func(t *testing.T) {
t.Run("ImgNum4568", func(t *testing.T) {
assert.Equal(t, "", FileTitle("IMG_4568"))
})
t.Run("mr-kitty_life.svg", func(t *testing.T) {
t.Run("MrKittyLifeSvg", func(t *testing.T) {
assert.Equal(t, "Mr Kitty Life", FileTitle("mr-kitty_life.svg"))
})
t.Run("mr-kitty--life.svg", func(t *testing.T) {
t.Run("MrKittyLifeSvg", func(t *testing.T) {
assert.Equal(t, "Mr Kitty / Life", FileTitle("mr-kitty--life.svg"))
})
t.Run("queen-city-yacht-club--toronto-island_7999432607_o.jpg", func(t *testing.T) {
t.Run("QueenCityYachtClubTorontoIslandNum7999432607OJpg", func(t *testing.T) {
assert.Equal(t, "Queen City Yacht Club / Toronto Island", FileTitle("queen-city-yacht-club--toronto-island_7999432607_o.jpg"))
})
t.Run("tim-robbins--tiff-2012_7999233420_o.jpg", func(t *testing.T) {
t.Run("TimRobbinsTiffNum2012Num7999233420OJpg", func(t *testing.T) {
assert.Equal(t, "Tim Robbins / TIFF", FileTitle("tim-robbins--tiff-2012_7999233420_o.jpg"))
})
t.Run("20200102-204030-Berlin-Germany-2020-3h4.jpg", func(t *testing.T) {
t.Run("Num20200102Num204030BerlinGermanyNum2020ThreeH4Jpg", func(t *testing.T) {
assert.Equal(t, "Berlin Germany 2020", FileTitle("20200102-204030-Berlin-Germany-2020-3h4.jpg"))
})
t.Run("changing-of-the-guard--buckingham-palace_7925318070_o.jpg", func(t *testing.T) {
t.Run("ChangingOfTheGuardBuckinghamPalaceNum7925318070OJpg", func(t *testing.T) {
assert.Equal(t, "Changing of the Guard / Buckingham Palace", FileTitle("changing-of-the-guard--buckingham-palace_7925318070_o.jpg"))
})
/*
@ -69,47 +69,47 @@ func TestFileTitle(t *testing.T) {
-rw-r--r-- 1 root root 662922 Jun 15 21:18 dishwasher1910 - Friedrich the smol (82201574) 1ページ.jpg
-rw-r--r-- 1 root root 185971 Jun 19 21:07 EaycddvU0AAfuUR.jpg
*/
t.Run("issue_361_a", func(t *testing.T) {
t.Run("IssueNum361A", func(t *testing.T) {
assert.Equal(t, "えく スカイフレア", FileTitle("えく - スカイフレア (82063926) .png"))
})
t.Run("issue_361_b", func(t *testing.T) {
t.Run("IssueNum361B", func(t *testing.T) {
assert.Equal(t, "紅シャケ お仕事募集中 モスティマ", FileTitle("紅シャケ＠お仕事募集中 - モスティマ (81974640) .jpg"))
})
t.Run("issue_361_c", func(t *testing.T) {
t.Run("IssueNum361C", func(t *testing.T) {
assert.Equal(t, "Cyka Swappable Mag", FileTitle("Cyka - swappable mag (82405706) .jpg"))
})
t.Run("issue_361_d", func(t *testing.T) {
t.Run("IssueNum361D", func(t *testing.T) {
assert.Equal(t, "Dishwasher1910 Friedrich the Smol", FileTitle("dishwasher1910 - Friedrich the smol (82201574) 1ページ.jpg"))
})
t.Run("issue_361_e", func(t *testing.T) {
t.Run("IssueNum361E", func(t *testing.T) {
assert.Equal(t, "EaycddvU0AAfuUR", FileTitle("EaycddvU0AAfuUR.jpg"))
})
t.Run("Eigene Bilder 1013/2007/oldies/neumühle", func(t *testing.T) {
t.Run("EigeneBilderNum1013Num2007OldiesNeumuHle", func(t *testing.T) {
// TODO: Normalize strings, see https://godoc.org/golang.org/x/text/unicode/norm
assert.Equal(t, "Neumu", FileTitle("Eigene Bilder 1013/2007/oldies/neumühle"))
})
t.Run("Neumühle", func(t *testing.T) {
t.Run("NeumHle", func(t *testing.T) {
assert.Equal(t, "Neumühle", FileTitle("Neumühle"))
})
t.Run("IQVG4929", func(t *testing.T) {
assert.Equal(t, "IQVG4929", FileTitle("IQVG4929.jpg"))
})
t.Run("IMG_1234", func(t *testing.T) {
t.Run("ImgNum1234", func(t *testing.T) {
assert.Equal(t, "", FileTitle("IMG_1234.jpg"))
})
t.Run("du,-ich,-er, Sie und es", func(t *testing.T) {
t.Run("DuIchErSieUndEs", func(t *testing.T) {
assert.Equal(t, "Du, Ich, Er, Sie und Es", FileTitle("du,-ich,-er, Sie und es"))
})
t.Run("Title too short", func(t *testing.T) {
t.Run("TitleTooShort", func(t *testing.T) {
assert.Equal(t, "", FileTitle("jg.jpg"))
})
t.Run("invalid words", func(t *testing.T) {
t.Run("InvalidWords", func(t *testing.T) {
assert.Equal(t, "", FileTitle("jg hg "))
})
t.Run("ampersand", func(t *testing.T) {
t.Run("Ampersand", func(t *testing.T) {
assert.Equal(t, "Coouussinen, Du & Ich", FileTitle("coouussinen, du & ich"))
})
t.Run("plus", func(t *testing.T) {
t.Run("Plus", func(t *testing.T) {
assert.Equal(t, "Foo+Bar, Du + Ich & Er", FileTitle("Foo+bar, du + ich & er +"))
})
t.Run("NewYears", func(t *testing.T) {
@ -136,10 +136,10 @@ func TestFileTitle(t *testing.T) {
t.Run("Boeing737", func(t *testing.T) {
assert.Equal(t, "Boeing", FileTitle("Boeing 737.jpg"))
})
t.Run("Boeing747-8F", func(t *testing.T) {
t.Run("BoeingNum747EightF", func(t *testing.T) {
assert.Equal(t, "Boeing 747 8F", FileTitle("Boeing 747-8F.jpg"))
})
t.Run("Boeing747-100SR", func(t *testing.T) {
t.Run("BoeingNum747Num100Sr", func(t *testing.T) {
assert.Equal(t, "Boeing 747 100SR", FileTitle("Boeing 747-100SR.jpg"))
})
t.Run("Apostrophe", func(t *testing.T) {

14
pkg/txt/float_test.go
View file

@ -13,19 +13,19 @@ func TestIsFloat(t *testing.T) {
t.Run("Zero", func(t *testing.T) {
assert.True(t, IsFloat("0"))
})
t.Run("0.5", func(t *testing.T) {
t.Run("ZeroFive", func(t *testing.T) {
assert.True(t, IsFloat("0.5"))
})
t.Run("0,5", func(t *testing.T) {
t.Run("ZeroFive", func(t *testing.T) {
assert.True(t, IsFloat("0,5"))
})
t.Run("123000.45245", func(t *testing.T) {
t.Run("Num123000Num45245", func(t *testing.T) {
assert.True(t, IsFloat("123000.45245 "))
})
t.Run("123000.", func(t *testing.T) {
t.Run("Num123000", func(t *testing.T) {
assert.True(t, IsFloat("123000. "))
})
t.Run("01:00", func(t *testing.T) {
t.Run("Num01Num00", func(t *testing.T) {
assert.False(t, IsFloat("01:00"))
})
t.Run("LeadingZeros", func(t *testing.T) {
@ -49,11 +49,11 @@ func TestFloat64(t *testing.T) {
result := Float64("0")
assert.Equal(t, 0.0, result)
})
t.Run("0.5", func(t *testing.T) {
t.Run("ZeroFive", func(t *testing.T) {
result := Float64("0.5")
assert.Equal(t, 0.5, result)
})
t.Run("01:00", func(t *testing.T) {
t.Run("Num01Num00", func(t *testing.T) {
result := Float64("01:00")
assert.Equal(t, 100.0, result)
})

104
pkg/txt/is_test.go
View file

@ -8,68 +8,68 @@ import (
)
func TestIs(t *testing.T) {
t.Run("The quick brown fox.", func(t *testing.T) {
t.Run("TheQuickBrownFox", func(t *testing.T) {
assert.False(t, Is(unicode.Latin, "The quick brown fox."))
assert.False(t, Is(unicode.L, "The quick brown fox."))
assert.False(t, Is(unicode.Letter, "The quick brown fox."))
})
t.Run("bridge", func(t *testing.T) {
t.Run("Bridge", func(t *testing.T) {
assert.True(t, Is(unicode.Latin, "bridge"))
assert.True(t, Is(unicode.L, "bridge"))
assert.True(t, Is(unicode.Letter, "bridge"))
})
t.Run("桥", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.False(t, Is(unicode.Latin, "桥"))
assert.True(t, Is(unicode.L, "桥"))
assert.True(t, Is(unicode.Letter, "桥"))
})
t.Run("桥船", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.False(t, Is(unicode.Latin, "桥船"))
assert.True(t, Is(unicode.L, "桥船"))
assert.True(t, Is(unicode.Letter, "桥船"))
})
t.Run("स्थान", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.False(t, Is(unicode.Latin, "स्थान"))
assert.False(t, Is(unicode.L, "स्थान"))
assert.False(t, Is(unicode.Letter, "स्थान"))
assert.False(t, Is(unicode.Tamil, "स्थान"))
})
t.Run("réseau", func(t *testing.T) {
t.Run("RSeau", func(t *testing.T) {
assert.True(t, Is(unicode.Latin, "réseau"))
assert.True(t, Is(unicode.L, "réseau"))
assert.True(t, Is(unicode.Letter, "réseau"))
})
t.Run("empty", func(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
assert.False(t, Is(unicode.Latin, ""))
})
}
func TestIsASCII(t *testing.T) {
t.Run("1", func(t *testing.T) {
t.Run("One", func(t *testing.T) {
assert.True(t, IsASCII("1"))
})
t.Run("123", func(t *testing.T) {
t.Run("Num123", func(t *testing.T) {
assert.True(t, IsASCII("123"))
})
t.Run("The quick brown fox.", func(t *testing.T) {
t.Run("TheQuickBrownFox", func(t *testing.T) {
assert.True(t, IsASCII("The quick brown fox."))
})
t.Run("bridge", func(t *testing.T) {
t.Run("Bridge", func(t *testing.T) {
assert.True(t, IsASCII("bridge"))
})
t.Run("桥", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.False(t, IsASCII("桥"))
})
t.Run("桥船", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.False(t, IsASCII("桥船"))
})
t.Run("स्थान", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.False(t, IsASCII("स्थान"))
})
t.Run("réseau", func(t *testing.T) {
t.Run("RSeau", func(t *testing.T) {
assert.False(t, IsASCII("réseau"))
})
t.Run("80s", func(t *testing.T) {
t.Run("Num80S", func(t *testing.T) {
assert.True(t, IsASCII("80s"))
})
}
@ -78,31 +78,31 @@ func TestIsNumeric(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
assert.False(t, IsNumeric(""))
})
t.Run("1", func(t *testing.T) {
t.Run("One", func(t *testing.T) {
assert.True(t, IsNumeric("1"))
})
t.Run("123", func(t *testing.T) {
t.Run("Num123", func(t *testing.T) {
assert.True(t, IsNumeric("123"))
})
t.Run("123.", func(t *testing.T) {
t.Run("Num123", func(t *testing.T) {
assert.False(t, IsNumeric("123."))
})
t.Run("2024-10-23", func(t *testing.T) {
t.Run("Num2024TenNum23", func(t *testing.T) {
assert.True(t, IsNumeric("2024-10-23"))
})
t.Run("20200102-204030", func(t *testing.T) {
t.Run("Num20200102Num204030", func(t *testing.T) {
assert.True(t, IsNumeric("20200102-204030"))
})
t.Run("ABC", func(t *testing.T) {
assert.False(t, IsNumeric("ABC"))
})
t.Run("80s", func(t *testing.T) {
t.Run("Num80S", func(t *testing.T) {
assert.False(t, IsNumeric("80s"))
})
t.Run("2e4", func(t *testing.T) {
t.Run("TwoE4", func(t *testing.T) {
assert.True(t, IsNumeric("2e4"))
})
t.Run("2e", func(t *testing.T) {
t.Run("TwoE", func(t *testing.T) {
assert.False(t, IsNumeric("2e"))
})
}
@ -111,43 +111,43 @@ func TestIsNumeral(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
assert.False(t, IsNumeral(""))
})
t.Run("1", func(t *testing.T) {
t.Run("One", func(t *testing.T) {
assert.False(t, IsNumeral("1"))
})
t.Run("123", func(t *testing.T) {
t.Run("Num123", func(t *testing.T) {
assert.False(t, IsNumeral("123"))
})
t.Run("123.", func(t *testing.T) {
t.Run("Num123", func(t *testing.T) {
assert.False(t, IsNumeral("123."))
})
t.Run("2024-10-23", func(t *testing.T) {
t.Run("Num2024TenNum23", func(t *testing.T) {
assert.False(t, IsNumeral("2024-10-23"))
})
t.Run("20200102-204030", func(t *testing.T) {
t.Run("Num20200102Num204030", func(t *testing.T) {
assert.False(t, IsNumeral("20200102-204030"))
})
t.Run("ABC", func(t *testing.T) {
assert.False(t, IsNumeral("ABC"))
})
t.Run("1st", func(t *testing.T) {
t.Run("OneSt", func(t *testing.T) {
assert.True(t, IsNumeral("1st"))
})
t.Run("2ND", func(t *testing.T) {
t.Run("TwoNd", func(t *testing.T) {
assert.True(t, IsNumeral("1ND")) // codespell:ignore
})
t.Run("40th", func(t *testing.T) {
t.Run("Num40Th", func(t *testing.T) {
assert.True(t, IsNumeral("40th"))
})
t.Run("-1.", func(t *testing.T) {
t.Run("One", func(t *testing.T) {
assert.False(t, IsNumeral("-1."))
})
t.Run("1.", func(t *testing.T) {
t.Run("One", func(t *testing.T) {
assert.False(t, IsNumeral("1."))
})
t.Run("40.", func(t *testing.T) {
t.Run("Num40", func(t *testing.T) {
assert.False(t, IsNumeral("40."))
})
t.Run("80s", func(t *testing.T) {
t.Run("Num80S", func(t *testing.T) {
assert.True(t, IsNumeral("80s"))
})
}
@ -156,22 +156,22 @@ func TestIsNumber(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
assert.False(t, IsNumber(""))
})
t.Run("1", func(t *testing.T) {
t.Run("One", func(t *testing.T) {
assert.True(t, IsNumber("1"))
})
t.Run("123", func(t *testing.T) {
t.Run("Num123", func(t *testing.T) {
assert.True(t, IsNumber("123"))
})
t.Run("123.", func(t *testing.T) {
t.Run("Num123", func(t *testing.T) {
assert.False(t, IsNumber("123."))
})
t.Run("2024-10-23", func(t *testing.T) {
t.Run("Num2024TenNum23", func(t *testing.T) {
assert.False(t, IsNumber("2024-10-23"))
})
t.Run("ABC", func(t *testing.T) {
assert.False(t, IsNumber("ABC"))
})
t.Run("80s", func(t *testing.T) {
t.Run("Num80S", func(t *testing.T) {
assert.False(t, IsNumber("80s"))
})
}
@ -180,16 +180,16 @@ func TestIsDateNumber(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
assert.False(t, IsDateNumber(""))
})
t.Run("123", func(t *testing.T) {
t.Run("Num123", func(t *testing.T) {
assert.True(t, IsDateNumber("123"))
})
t.Run("123.", func(t *testing.T) {
t.Run("Num123", func(t *testing.T) {
assert.False(t, IsDateNumber("123."))
})
t.Run("2024-10-23", func(t *testing.T) {
t.Run("Num2024TenNum23", func(t *testing.T) {
assert.True(t, IsDateNumber("2024-10-23"))
})
t.Run("20200102-204030", func(t *testing.T) {
t.Run("Num20200102Num204030", func(t *testing.T) {
assert.True(t, IsDateNumber("20200102-204030"))
})
t.Run("ABC", func(t *testing.T) {
@ -198,25 +198,25 @@ func TestIsDateNumber(t *testing.T) {
}
func TestIsLatin(t *testing.T) {
t.Run("The quick brown fox.", func(t *testing.T) {
t.Run("TheQuickBrownFox", func(t *testing.T) {
assert.False(t, IsLatin("The quick brown fox."))
})
t.Run("bridge", func(t *testing.T) {
t.Run("Bridge", func(t *testing.T) {
assert.True(t, IsLatin("bridge"))
})
t.Run("桥", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.False(t, IsLatin("桥"))
})
t.Run("桥船", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.False(t, IsLatin("桥船"))
})
t.Run("स्थान", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.False(t, IsLatin("स्थान"))
})
t.Run("réseau", func(t *testing.T) {
t.Run("RSeau", func(t *testing.T) {
assert.True(t, IsLatin("réseau"))
})
t.Run("empty", func(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
assert.False(t, IsLatin(""))
})
}

12
pkg/txt/log_test.go
View file

@ -7,13 +7,13 @@ import (
)
func TestLogParam(t *testing.T) {
t.Run("The quick brown fox.", func(t *testing.T) {
t.Run("TheQuickBrownFox", func(t *testing.T) {
assert.Equal(t, "'The quick brown fox.'", LogParam("The quick brown fox."))
})
t.Run("filename.txt", func(t *testing.T) {
t.Run("FilenameTxt", func(t *testing.T) {
assert.Equal(t, "filename.txt", LogParam("filename.txt"))
})
t.Run("empty string", func(t *testing.T) {
t.Run("EmptyString", func(t *testing.T) {
assert.Equal(t, "''", LogParam(""))
})
t.Run("Log4j", func(t *testing.T) {
@ -25,13 +25,13 @@ func TestLogParam(t *testing.T) {
}
func TestLogParamLower(t *testing.T) {
t.Run("The quick brown fox.", func(t *testing.T) {
t.Run("TheQuickBrownFox", func(t *testing.T) {
assert.Equal(t, "'the quick brown fox.'", LogParamLower("The quick brown fox."))
})
t.Run("filename.txt", func(t *testing.T) {
t.Run("FilenameTxt", func(t *testing.T) {
assert.Equal(t, "filename.txt", LogParamLower("filename.TXT"))
})
t.Run("empty string", func(t *testing.T) {
t.Run("EmptyString", func(t *testing.T) {
assert.Equal(t, "''", LogParamLower(""))
})
t.Run("Log4j", func(t *testing.T) {

2
pkg/txt/names_test.go
View file

@ -104,7 +104,7 @@ func TestNameKeywords(t *testing.T) {
result := NameKeywords("William Henry Gates III", "Windows Guru")
assert.Equal(t, []string{"william", "henry", "gates", "iii", "windows", "guru"}, result)
})
t.Run("Empty arguments", func(t *testing.T) {
t.Run("EmptyArguments", func(t *testing.T) {
result := NameKeywords("", "")
assert.Equal(t, []string{}, result)
})

10
pkg/txt/ntimes_test.go
View file

@ -7,19 +7,19 @@ import (
)
func TestNTimes(t *testing.T) {
t.Run("-2", func(t *testing.T) {
t.Run("Two", func(t *testing.T) {
assert.Equal(t, "", NTimes(-2))
})
t.Run("-1", func(t *testing.T) {
t.Run("One", func(t *testing.T) {
assert.Equal(t, "", NTimes(-1))
})
t.Run("0", func(t *testing.T) {
t.Run("Zero", func(t *testing.T) {
assert.Equal(t, "", NTimes(0))
})
t.Run("1", func(t *testing.T) {
t.Run("One", func(t *testing.T) {
assert.Equal(t, "", NTimes(1))
})
t.Run("999", func(t *testing.T) {
t.Run("Num999", func(t *testing.T) {
assert.Equal(t, "999 times", NTimes(999))
})
}

4
pkg/txt/numeric_test.go
View file

@ -19,11 +19,11 @@ func TestNumeric(t *testing.T) {
result := Numeric("0")
assert.Equal(t, "0", result)
})
t.Run("0.5", func(t *testing.T) {
t.Run("ZeroFive", func(t *testing.T) {
result := Numeric("0.5")
assert.Equal(t, "0.5", result)
})
t.Run("01:00", func(t *testing.T) {
t.Run("Num01Num00", func(t *testing.T) {
result := Numeric("01:00")
assert.Equal(t, "0100", result)
})

12
pkg/txt/quote_test.go
View file

@ -7,25 +7,25 @@ import (
)
func TestQuote(t *testing.T) {
t.Run("The quick brown fox.", func(t *testing.T) {
t.Run("TheQuickBrownFox", func(t *testing.T) {
assert.Equal(t, "“The quick brown fox.”", Quote("The quick brown fox."))
})
t.Run("filename.txt", func(t *testing.T) {
t.Run("FilenameTxt", func(t *testing.T) {
assert.Equal(t, "filename.txt", Quote("filename.txt"))
})
t.Run("empty string", func(t *testing.T) {
t.Run("EmptyString", func(t *testing.T) {
assert.Equal(t, "“”", Quote(""))
})
}
func TestQuoteLower(t *testing.T) {
t.Run("The quick brown fox.", func(t *testing.T) {
t.Run("TheQuickBrownFox", func(t *testing.T) {
assert.Equal(t, "“the quick brown fox.”", QuoteLower("The quick brown fox."))
})
t.Run("filename.txt", func(t *testing.T) {
t.Run("FilenameTxt", func(t *testing.T) {
assert.Equal(t, "filename.txt", QuoteLower("filename.txt"))
})
t.Run("empty string", func(t *testing.T) {
t.Run("EmptyString", func(t *testing.T) {
assert.Equal(t, "“”", QuoteLower(""))
})
}

4
pkg/txt/report/timestamp_test.go
View file

@ -14,7 +14,7 @@ func TestDateTime(t *testing.T) {
t.Run("Zero", func(t *testing.T) {
assert.Equal(t, "", DateTime(&time.Time{}))
})
t.Run("1665389030", func(t *testing.T) {
t.Run("Num1665389030", func(t *testing.T) {
now := time.Unix(1665389030, 0)
assert.Equal(t, "2022-10-10 08:03:50", DateTime(&now))
})
@ -24,7 +24,7 @@ func TestUnixTime(t *testing.T) {
t.Run("Zero", func(t *testing.T) {
assert.Equal(t, "", UnixTime(0))
})
t.Run("1665389030", func(t *testing.T) {
t.Run("Num1665389030", func(t *testing.T) {
assert.Equal(t, "2022-10-10 08:03:50", UnixTime(1665389030))
})
}

16
pkg/txt/separator_test.go
View file

@ -7,28 +7,28 @@ import (
)
func TestIsSeparator(t *testing.T) {
t.Run("rune A", func(t *testing.T) {
t.Run("RuneA", func(t *testing.T) {
assert.Equal(t, false, isSeparator('A'))
})
t.Run("rune 99", func(t *testing.T) {
t.Run("RuneNum99", func(t *testing.T) {
assert.Equal(t, false, isSeparator('9'))
})
t.Run("rune /", func(t *testing.T) {
t.Run("Rune", func(t *testing.T) {
assert.Equal(t, true, isSeparator('/'))
})
t.Run("rune \\", func(t *testing.T) {
t.Run("Rune", func(t *testing.T) {
assert.Equal(t, true, isSeparator('\\'))
})
t.Run("rune ♥ ", func(t *testing.T) {
t.Run("Rune", func(t *testing.T) {
assert.Equal(t, false, isSeparator('♥'))
})
t.Run("rune space", func(t *testing.T) {
t.Run("RuneSpace", func(t *testing.T) {
assert.Equal(t, true, isSeparator(' '))
})
t.Run("rune '", func(t *testing.T) {
t.Run("Rune", func(t *testing.T) {
assert.Equal(t, false, isSeparator('\''))
})
t.Run("rune ý", func(t *testing.T) {
t.Run("Rune", func(t *testing.T) {
assert.Equal(t, false, isSeparator('ý'))
})
}

24
pkg/txt/title_test.go
View file

@ -7,22 +7,22 @@ import (
)
func TestTitle(t *testing.T) {
t.Run("Cour d'Honneur", func(t *testing.T) {
t.Run("CourDHonneur", func(t *testing.T) {
assert.Equal(t, "Cour d'Honneur", Title("Cour d'Honneur"))
})
t.Run("Ducs de La Force", func(t *testing.T) {
t.Run("DucsDeLaForce", func(t *testing.T) {
assert.Equal(t, "Ducs de la Force", Title("Ducs de La Force"))
})
t.Run("ducs de la force", func(t *testing.T) {
t.Run("DucsDeLaForce", func(t *testing.T) {
assert.Equal(t, "Ducs de la Force", Title("ducs de la force"))
})
t.Run("Broglie", func(t *testing.T) {
assert.Equal(t, "Broglie, des Cars", Title("broglie, des cars"))
})
t.Run("Île-de-France", func(t *testing.T) {
t.Run("LeDeFrance", func(t *testing.T) {
assert.Equal(t, "Île-de-France", Title("Île-de-France"))
})
t.Run("ile-de-France", func(t *testing.T) {
t.Run("IleDeFrance", func(t *testing.T) {
assert.Equal(t, "Île-de-France", Title("ile-de-France"))
})
t.Run("BrowseYourLife", func(t *testing.T) {
@ -44,31 +44,31 @@ func TestTitle(t *testing.T) {
t.Run("AirportBer", func(t *testing.T) {
assert.Equal(t, "Around the Terminal / Airport BER", Title("Around the Terminal / Airport Ber"))
})
t.Run("KwaZulu-Natal", func(t *testing.T) {
t.Run("KwaZuluNatal", func(t *testing.T) {
assert.Equal(t, "KwaZulu-Natal", Title("KwaZulu-Natal"))
})
t.Run("testAddLabel", func(t *testing.T) {
t.Run("TestAddLabel", func(t *testing.T) {
assert.Equal(t, "TestAddLabel", Title("testAddLabel"))
})
t.Run("PhotoPrism", func(t *testing.T) {
assert.Equal(t, "PhotoPrism", Title("photoprism"))
})
t.Run("youtube", func(t *testing.T) {
t.Run("Youtube", func(t *testing.T) {
assert.Equal(t, "YouTube", Title("youtube"))
})
t.Run("interpunction-1", func(t *testing.T) {
t.Run("InterpunctionOne", func(t *testing.T) {
assert.Equal(t, "This,,, Is !a ! a Very Strange Title....", Title("this,,, is !a ! a very strange title...."))
})
t.Run("interpunction-2", func(t *testing.T) {
t.Run("InterpunctionTwo", func(t *testing.T) {
assert.Equal(t, "This Is a Not So Strange Title!", Title("This is a not so strange title!"))
})
t.Run("horse", func(t *testing.T) {
t.Run("Horse", func(t *testing.T) {
assert.Equal(t, "A Horse Is Not a Cow :-)", Title("a horse is not a cow :-)"))
})
t.Run("NewYears", func(t *testing.T) {
assert.Equal(t, "Boston New Year's", Title("boston new year's"))
})
t.Run("empty", func(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
assert.Empty(t, Title(""))
})
t.Run("NYC", func(t *testing.T) {

4
pkg/txt/titles_test.go
View file

@ -7,10 +7,10 @@ import (
)
func TestTitlesAndRanks(t *testing.T) {
t.Run("king", func(t *testing.T) {
t.Run("King", func(t *testing.T) {
assert.True(t, TitlesAndRanks["king"])
})
t.Run("fool", func(t *testing.T) {
t.Run("Fool", func(t *testing.T) {
assert.False(t, TitlesAndRanks["fool"])
})
}

8
pkg/txt/upperfirst_test.go
View file

@ -7,16 +7,16 @@ import (
)
func TestUcFirst(t *testing.T) {
t.Run("photo-lover", func(t *testing.T) {
t.Run("PhotoLover", func(t *testing.T) {
assert.Equal(t, "Photo-lover", UpperFirst("photo-lover"))
})
t.Run("cat", func(t *testing.T) {
t.Run("Cat", func(t *testing.T) {
assert.Equal(t, "Cat", UpperFirst("Cat"))
})
t.Run("KwaZulu natal", func(t *testing.T) {
t.Run("KwaZuluNatal", func(t *testing.T) {
assert.Equal(t, "KwaZulu natal", UpperFirst("KwaZulu natal"))
})
t.Run("empty string", func(t *testing.T) {
t.Run("EmptyString", func(t *testing.T) {
assert.Equal(t, "", UpperFirst(""))
})
}

106
pkg/txt/words_test.go
View file

@ -10,71 +10,71 @@ func TestUnknownWord(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
assert.True(t, UnknownWord(""))
})
t.Run("qx", func(t *testing.T) {
t.Run("Qx", func(t *testing.T) {
assert.True(t, UnknownWord("qx"))
})
t.Run("atz", func(t *testing.T) {
t.Run("Atz", func(t *testing.T) {
assert.True(t, UnknownWord("atz"))
})
t.Run("xqx", func(t *testing.T) {
t.Run("Xqx", func(t *testing.T) {
assert.True(t, UnknownWord("xqx"))
})
t.Run("kuh", func(t *testing.T) {
t.Run("Kuh", func(t *testing.T) {
assert.False(t, UnknownWord("kuh"))
})
t.Run("muh", func(t *testing.T) {
t.Run("Muh", func(t *testing.T) {
assert.False(t, UnknownWord("muh"))
})
t.Run("桥", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.False(t, UnknownWord("桥"))
})
t.Run("桥船", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.False(t, UnknownWord("桥船"))
})
}
func TestWords(t *testing.T) {
t.Run("桥", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
result := Words("桥")
assert.Equal(t, []string{"桥"}, result)
})
t.Run("桥船", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
result := Words("桥船")
assert.Equal(t, []string{"桥船"}, result)
})
t.Run("桥船猫", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
result := Words("桥船猫")
assert.Equal(t, []string{"桥船猫"}, result)
})
t.Run("谢谢！", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
result := Words("谢谢！")
assert.Equal(t, []string{"谢谢"}, result)
})
t.Run("I'm a lazy-brown fox!", func(t *testing.T) {
t.Run("IMALazyBrownFox", func(t *testing.T) {
result := Words("I'm a lazy-BRoWN fox!")
assert.Equal(t, []string{"I'm", "lazy-BRoWN", "fox"}, result)
})
t.Run("no result", func(t *testing.T) {
t.Run("NoResult", func(t *testing.T) {
result := Words("x")
assert.Equal(t, []string(nil), result)
})
t.Run("Österreich Urlaub", func(t *testing.T) {
t.Run("SterreichUrlaub", func(t *testing.T) {
result := Words("Österreich Urlaub")
assert.Equal(t, []string{"Österreich", "Urlaub"}, result)
})
t.Run("Schäferhund", func(t *testing.T) {
t.Run("SchFerhund", func(t *testing.T) {
result := Words("Schäferhund")
assert.Equal(t, []string{"Schäferhund"}, result)
})
t.Run("Île de la Réunion", func(t *testing.T) {
t.Run("LeDeLaRUnion", func(t *testing.T) {
result := Words("Île de la Réunion")
assert.Equal(t, []string{"Île", "de", "la", "Réunion"}, result)
})
t.Run("empty", func(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
result := Words("")
assert.Empty(t, result)
})
t.Run("trim", func(t *testing.T) {
t.Run("Trim", func(t *testing.T) {
result := Words(" -foo- -")
assert.Equal(t, []string{"foo"}, result)
})
@ -86,122 +86,122 @@ func TestWords(t *testing.T) {
}
func TestReplaceSpaces(t *testing.T) {
t.Run("I love Cats", func(t *testing.T) {
t.Run("ILoveCats", func(t *testing.T) {
result := ReplaceSpaces("I love Cats", "dog")
assert.Equal(t, "IdoglovedogCats", result)
})
}
func TestFilenameWords(t *testing.T) {
t.Run("I'm a lazy-brown fox!", func(t *testing.T) {
t.Run("IMALazyBrownFox", func(t *testing.T) {
result := FilenameWords("I'm a lazy-BRoWN fox!")
assert.Equal(t, []string{"lazy", "BRoWN", "fox"}, result)
})
t.Run("no result", func(t *testing.T) {
t.Run("NoResult", func(t *testing.T) {
result := FilenameWords("x")
assert.Equal(t, []string(nil), result)
})
t.Run("Österreich Urlaub", func(t *testing.T) {
t.Run("SterreichUrlaub", func(t *testing.T) {
result := FilenameWords("Österreich Urlaub")
assert.Equal(t, []string{"Österreich", "Urlaub"}, result)
})
t.Run("Schäferhund", func(t *testing.T) {
t.Run("SchFerhund", func(t *testing.T) {
result := FilenameWords("Schäferhund")
assert.Equal(t, []string{"Schäferhund"}, result)
})
t.Run("Île de la Réunion", func(t *testing.T) {
t.Run("LeDeLaRUnion", func(t *testing.T) {
result := FilenameWords("Île de la Réunion")
assert.Equal(t, []string{"Île", "Réunion"}, result)
})
t.Run("empty", func(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
result := FilenameWords("")
assert.Empty(t, result)
})
}
func TestAddToWords(t *testing.T) {
t.Run("I'm a lazy-BRoWN fox!", func(t *testing.T) {
t.Run("IMALazyBRoWnFox", func(t *testing.T) {
result := AddToWords([]string{"foo", "bar", "fox"}, "Yellow banana, apple; pan-pot")
assert.Equal(t, []string{"apple", "banana", "bar", "foo", "fox", "pan-pot", "yellow"}, result)
})
}
func TestMergeWords(t *testing.T) {
t.Run("I'm a lazy-BRoWN fox!", func(t *testing.T) {
t.Run("IMALazyBRoWnFox", func(t *testing.T) {
result := MergeWords("I'm a lazy-BRoWN fox!", "Yellow banana, apple; pan-pot")
assert.Equal(t, "apple, banana, fox, i'm, lazy-brown, pan-pot, yellow", result)
})
}
func TestFilenameKeywords(t *testing.T) {
t.Run("桥.jpg", func(t *testing.T) {
t.Run("Jpg", func(t *testing.T) {
result := FilenameKeywords("桥.jpg")
assert.Equal(t, []string{"桥"}, result)
})
t.Run("I'm a lazy-brown var fox.jpg!", func(t *testing.T) {
t.Run("IMALazyBrownVarFoxJpg", func(t *testing.T) {
result := FilenameKeywords("I'm a lazy-brown var fox.jpg!")
assert.Equal(t, []string{"lazy", "brown", "fox"}, result)
})
t.Run("no result", func(t *testing.T) {
t.Run("NoResult", func(t *testing.T) {
result := FilenameKeywords("x")
assert.Equal(t, []string(nil), result)
})
t.Run("Österreich Urlaub", func(t *testing.T) {
t.Run("SterreichUrlaub", func(t *testing.T) {
result := FilenameKeywords("Österreich Urlaub")
assert.Equal(t, []string{"österreich", "urlaub"}, result)
})
t.Run("Schäferhund", func(t *testing.T) {
t.Run("SchFerhund", func(t *testing.T) {
result := FilenameKeywords("Schäferhund")
assert.Equal(t, []string{"schäferhund"}, result)
})
t.Run("Île de la Réunion", func(t *testing.T) {
t.Run("LeDeLaRUnion", func(t *testing.T) {
result := FilenameKeywords("Île de la Réunion")
assert.Equal(t, []string{"île", "réunion"}, result)
})
t.Run("empty", func(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
result := FilenameKeywords("")
assert.Empty(t, result)
})
}
func TestKeywords(t *testing.T) {
t.Run("桥", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
result := Keywords("桥")
assert.Equal(t, []string{"桥"}, result)
})
t.Run("桥船", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
result := Keywords("桥船")
assert.Equal(t, []string{"桥船"}, result)
})
t.Run("桥船猫", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
result := Keywords("桥船猫")
assert.Equal(t, []string{"桥船猫"}, result)
})
t.Run("谢谢！", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
result := Keywords("谢谢！")
assert.Equal(t, []string{"谢谢"}, result)
})
t.Run("I'm a lazy brown fox!", func(t *testing.T) {
t.Run("IMALazyBrownFox", func(t *testing.T) {
result := Keywords("I'm a lazy BRoWN img!")
assert.Equal(t, []string{"lazy", "brown"}, result)
})
t.Run("no result", func(t *testing.T) {
t.Run("NoResult", func(t *testing.T) {
result := Keywords("was")
assert.Equal(t, []string(nil), result)
})
t.Run("Österreich Urlaub", func(t *testing.T) {
t.Run("SterreichUrlaub", func(t *testing.T) {
result := Keywords("Österreich Urlaub")
assert.Equal(t, []string{"österreich", "urlaub"}, result)
})
t.Run("Schäferhund", func(t *testing.T) {
t.Run("SchFerhund", func(t *testing.T) {
result := Keywords("Schäferhund")
assert.Equal(t, []string{"schäferhund"}, result)
})
t.Run("Île de la Réunion", func(t *testing.T) {
t.Run("LeDeLaRUnion", func(t *testing.T) {
result := Keywords("Île de la Réunion")
assert.Equal(t, []string{"île", "réunion"}, result)
})
t.Run("empty", func(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
result := Keywords("")
assert.Empty(t, result)
})
@ -238,11 +238,11 @@ func TestUniqueKeywords(t *testing.T) {
}
func TestRemoveFromWords(t *testing.T) {
t.Run("brown apple", func(t *testing.T) {
t.Run("BrownApple", func(t *testing.T) {
result := RemoveFromWords([]string{"lazy", "jpg", "Brown", "apple", "brown", "new-york", "JPG"}, "brown apple")
assert.Equal(t, []string{"jpg", "lazy", "new-york"}, result)
})
t.Run("empty", func(t *testing.T) {
t.Run("Empty", func(t *testing.T) {
result := RemoveFromWords([]string{"lazy", "jpg", "Brown", "apple"}, "")
assert.Equal(t, []string{"apple", "brown", "jpg", "lazy"}, result)
})
@ -258,25 +258,25 @@ func TestStopwordsOnly(t *testing.T) {
t.Run("FoldersDateienFile", func(t *testing.T) {
assert.False(t, StopwordsOnly("Folders Dateien Meme File"))
})
t.Run("qx", func(t *testing.T) {
t.Run("Qx", func(t *testing.T) {
assert.True(t, StopwordsOnly("qx"))
})
t.Run("atz", func(t *testing.T) {
t.Run("Atz", func(t *testing.T) {
assert.True(t, StopwordsOnly("atz"))
})
t.Run("xqx", func(t *testing.T) {
t.Run("Xqx", func(t *testing.T) {
assert.True(t, StopwordsOnly("xqx"))
})
t.Run("kuh", func(t *testing.T) {
t.Run("Kuh", func(t *testing.T) {
assert.False(t, StopwordsOnly("kuh"))
})
t.Run("muh", func(t *testing.T) {
t.Run("Muh", func(t *testing.T) {
assert.False(t, StopwordsOnly("muh"))
})
t.Run("桥", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.False(t, StopwordsOnly("桥"))
})
t.Run("桥船", func(t *testing.T) {
t.Run("Case", func(t *testing.T) {
assert.False(t, StopwordsOnly("桥船"))
})
}

2
setup/cloud/digitalocean/setup.sh
View file

@ -121,4 +121,4 @@ apt-get autoremove
# show public server URL and initial admin password
printf "\nServer URL:\n\n https://%s/\n\nInitial admin password:\n\n %s\n\n" "${PUBLIC_IP}" "${ADMIN_PASSWORD}"
printf "\nPhotoprism is now installed and running. For documentation, visit:\n\n https://docs.photoprism.app/\n\n"
printf "\nPhotoPrism is now installed and running. For documentation, visit:\n\n https://docs.photoprism.app/\n\n"