268 lines
9.2 KiB
Go
268 lines
9.2 KiB
Go
package media
|
||
|
||
import (
|
||
"fmt"
|
||
"path/filepath"
|
||
"strings"
|
||
"testing"
|
||
"unicode"
|
||
"unicode/utf8"
|
||
)
|
||
|
||
func TestRelativeVideoPath(t *testing.T) {
|
||
got, err := RelativeVideoPath("番組名", "第1話", "ep123")
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
want := filepath.Join("番組名", "番組名 第1話 [ep123].mp4")
|
||
if got != want {
|
||
t.Fatalf("path=%q want=%q", got, want)
|
||
}
|
||
other, err := RelativeVideoPath("番組名", "第1話", "ep456")
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if got == other || !strings.Contains(other, "[ep456]") {
|
||
t.Fatalf("ID による衝突回避: %q %q", got, other)
|
||
}
|
||
}
|
||
|
||
func TestRelativeVideoPathSanitizesComponents(t *testing.T) {
|
||
got, err := RelativeVideoPath(" 番組:/\\*?<>|\"\x00\n\t\x7f\u0085. ", "\x00\n", "../")
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if filepath.IsAbs(got) || strings.ContainsAny(got, `:*?<>|"`) || strings.Contains(got, "..") {
|
||
t.Fatalf("禁止文字が残った: %q", got)
|
||
}
|
||
for _, r := range got {
|
||
if unicode.IsControl(r) {
|
||
t.Errorf("制御文字が残った: %U in %q", r, got)
|
||
}
|
||
}
|
||
parts := strings.Split(filepath.ToSlash(got), "/")
|
||
if len(parts) != 2 || parts[0] == "" || !strings.HasSuffix(got, ".mp4") {
|
||
t.Fatalf("相対パスの形: %q", got)
|
||
}
|
||
}
|
||
|
||
func TestRelativeVideoPathHandlesEmptyAndLongNames(t *testing.T) {
|
||
for _, name := range []string{"", " ", ".", "..", "..."} {
|
||
got, err := RelativeVideoPath(name, name, "")
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if !strings.Contains(got, "名称未設定") {
|
||
t.Errorf("空の代替名 %q: %q", name, got)
|
||
}
|
||
}
|
||
long := strings.Repeat("界", 200)
|
||
got, err := RelativeVideoPath(long, long, "id")
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
parts := strings.Split(filepath.ToSlash(got), "/")
|
||
if len(parts) != 2 || len([]byte(parts[0])) != maxSeriesBytes || !utf8.ValidString(parts[0]) {
|
||
t.Fatalf("番組名の%dバイト境界: %q (%d bytes)", maxSeriesBytes, parts[0], len([]byte(parts[0])))
|
||
}
|
||
if len([]byte(parts[1])) > maxFilenameBytes || !utf8.ValidString(parts[1]) {
|
||
t.Fatalf("ファイル名の上限: %q (%d bytes)", parts[1], len([]byte(parts[1])))
|
||
}
|
||
if got := sanitizeComponent(strings.Repeat("a", maxEpisodeBytes+1), maxEpisodeBytes); len([]byte(got)) != maxEpisodeBytes {
|
||
t.Fatalf("ASCII の%dバイト境界: %d %q", maxEpisodeBytes, len([]byte(got)), got)
|
||
}
|
||
}
|
||
|
||
func TestRelativeVideoPathEpisodeIDLimit(t *testing.T) {
|
||
id := strings.Repeat("i", maxEpisodeIDBytes)
|
||
got, err := RelativeVideoPath(strings.Repeat("s", maxSeriesBytes), strings.Repeat("t", maxEpisodeBytes), id)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
parts := strings.Split(filepath.ToSlash(got), "/")
|
||
if len(parts) != 2 || len([]byte(parts[1])) > maxFilenameBytes || !strings.Contains(parts[1], "["+id+"]") {
|
||
t.Fatalf("64バイトIDのファイル名=%q", got)
|
||
}
|
||
if _, err := RelativeVideoPath("series", "episode", strings.Repeat("i", maxEpisodeIDBytes+1)); err == nil {
|
||
t.Fatal("65バイトのエピソードIDを受理した")
|
||
}
|
||
}
|
||
|
||
func TestRelativeVideoPathUsesFilenameBudgetInRequiredOrder(t *testing.T) {
|
||
series := strings.Repeat("s", maxSeriesBytes)
|
||
title := strings.Repeat("t", maxEpisodeBytes)
|
||
for _, tt := range []struct {
|
||
name string
|
||
idBytes int
|
||
wantSeriesInFile int
|
||
wantEpisodeInFile int
|
||
wantFilenameBytes int
|
||
}{
|
||
{"ちょうど255バイト", 17, 90, 140, 255},
|
||
{"回タイトルから1バイト削る", 18, 90, 139, 255},
|
||
{"64バイトIDでも番組名を維持", 64, 90, 93, 255},
|
||
} {
|
||
t.Run(tt.name, func(t *testing.T) {
|
||
id := strings.Repeat("i", tt.idBytes)
|
||
path, err := RelativeVideoPath(series, title, id)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
parts := strings.Split(filepath.ToSlash(path), "/")
|
||
if len(parts) != 2 || parts[0] != series {
|
||
t.Fatalf("ディレクトリ名=%q", parts)
|
||
}
|
||
wantFilename := strings.Repeat("s", tt.wantSeriesInFile) + " " + strings.Repeat("t", tt.wantEpisodeInFile) + " [" + id + "].mp4"
|
||
if parts[1] != wantFilename || len([]byte(parts[1])) != tt.wantFilenameBytes {
|
||
t.Fatalf("filename=%q (%d bytes) want=%q (%d bytes)", parts[1], len([]byte(parts[1])), wantFilename, tt.wantFilenameBytes)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
func TestRelativeVideoPathEpisodeIDNearAndBeyondFilenameLimit(t *testing.T) {
|
||
for _, idBytes := range []int{64, 65, 248, 255, 256} {
|
||
t.Run(fmt.Sprintf("id_%d_bytes", idBytes), func(t *testing.T) {
|
||
id := strings.Repeat("i", idBytes)
|
||
path, err := RelativeVideoPath("series", "episode", id)
|
||
if idBytes > 64 {
|
||
if err == nil || path != "" {
|
||
t.Fatalf("%dバイトID: path=%q err=%v, want error", idBytes, path, err)
|
||
}
|
||
if !strings.Contains(err.Error(), "64バイト以下") {
|
||
t.Fatalf("%dバイトIDのエラー理由=%q", idBytes, err)
|
||
}
|
||
return
|
||
}
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
parts := strings.Split(filepath.ToSlash(path), "/")
|
||
if len(parts) != 2 {
|
||
t.Fatalf("parts=%q", parts)
|
||
}
|
||
if !strings.Contains(parts[1], "["+id+"]") {
|
||
t.Fatalf("episode ID was changed: %q", parts[1])
|
||
}
|
||
if got := len([]byte(parts[1])); got > maxFilenameBytes {
|
||
t.Fatalf("episode ID %d bytes produced %d-byte filename above %d: %q", idBytes, got, maxFilenameBytes, parts[1])
|
||
}
|
||
if !utf8.ValidString(parts[1]) {
|
||
t.Fatalf("filename is not valid UTF-8: %q", parts[1])
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
func TestRelativeVideoPathHasNoRuneLimit(t *testing.T) {
|
||
series := strings.Repeat("a", 90)
|
||
title := strings.Repeat("b", 100)
|
||
got, err := RelativeVideoPath(series, title, "id")
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
parts := strings.Split(filepath.ToSlash(got), "/")
|
||
if parts[0] != series || !strings.Contains(parts[1], " "+title+" [id].mp4") {
|
||
t.Fatalf("80 rune limit remains: %q", got)
|
||
}
|
||
}
|
||
|
||
func TestSanitizeComponentTrimsWhitespaceBeforeLengthLimit(t *testing.T) {
|
||
for _, tt := range []struct {
|
||
name, input, want string
|
||
}{
|
||
{"前後の空白", " \t 番組名\n ", "_ 番組名_"},
|
||
{"空白のみ", " ", "名称未設定"},
|
||
{"制御文字のみ", "\t\n", "_"},
|
||
{"多数の先頭空白", strings.Repeat(" ", 100) + "番組名", "番組名"},
|
||
{"先頭空白と長い名前", strings.Repeat(" ", 70) + strings.Repeat("a", 100), strings.Repeat("a", maxSeriesBytes)},
|
||
} {
|
||
t.Run(tt.name, func(t *testing.T) {
|
||
if got := sanitizeComponent(tt.input, maxSeriesBytes); got != tt.want {
|
||
t.Errorf("sanitizeComponent()=%q want=%q", got, tt.want)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
func TestSanitizeComponentTrimsAgainAfterLengthLimit(t *testing.T) {
|
||
for _, tt := range []struct {
|
||
name, input, want string
|
||
}{
|
||
{"90バイト目が空白", strings.Repeat("a", 89) + " " + "b", strings.Repeat("a", 89)},
|
||
{"90バイト目がドット", strings.Repeat("a", 89) + "." + "b", strings.Repeat("a", 89)},
|
||
{"切り詰め部分が空白のみ", "a" + strings.Repeat(" ", 89) + "b", "a"},
|
||
{"切り詰め部分がドットのみ", "a" + strings.Repeat(".", 89) + "b", "a"},
|
||
{"複数バイト文字の直後がドット", strings.Repeat("界", 29) + ".続", strings.Repeat("界", 29)},
|
||
} {
|
||
t.Run(tt.name, func(t *testing.T) {
|
||
got := sanitizeComponent(tt.input, maxSeriesBytes)
|
||
if got != tt.want {
|
||
t.Errorf("sanitizeComponent()=%q want=%q", got, tt.want)
|
||
}
|
||
if strings.Trim(got, " .") != got || got == "" {
|
||
t.Errorf("切り詰め後の名前が不正: %q", got)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
|
||
func TestSanitizeComponentSafetyProperties(t *testing.T) {
|
||
var controls strings.Builder
|
||
for r := rune(0); r <= 0x9f; r++ {
|
||
if unicode.IsControl(r) {
|
||
controls.WriteRune(r)
|
||
}
|
||
}
|
||
inputs := []string{
|
||
"", " ", ".", "..", "...", `<>:"/\|?*`, controls.String(),
|
||
" \t 番組名\n. ", "a/b\\c", strings.Repeat("a", 500),
|
||
strings.Repeat("界", 500), strings.Repeat("😀", 500),
|
||
strings.Repeat(".", 100) + "name" + strings.Repeat(" ", 100),
|
||
string([]byte{0xff, 0xfe, 'a', 0xc0, 0xaf}),
|
||
}
|
||
for i, input := range inputs {
|
||
got := sanitizeComponent(input, maxEpisodeBytes)
|
||
if got == "" || got == "." || got == ".." {
|
||
t.Errorf("case %d: 空またはdot segment: %q", i, got)
|
||
}
|
||
if strings.Trim(got, " .") != got {
|
||
t.Errorf("case %d: 前後に空白またはdot: %q", i, got)
|
||
}
|
||
if len([]byte(got)) > 140 {
|
||
t.Errorf("case %d: 上限超過: bytes=%d %q", i, len([]byte(got)), got)
|
||
}
|
||
if !utf8.ValidString(got) {
|
||
t.Errorf("case %d: 不正なUTF-8: %q", i, got)
|
||
}
|
||
if strings.ContainsAny(got, `<>:"/\|?*`) {
|
||
t.Errorf("case %d: 禁止文字が残った: %q", i, got)
|
||
}
|
||
for _, r := range got {
|
||
if unicode.IsControl(r) {
|
||
t.Errorf("case %d: 制御文字が残った: %U in %q", i, r, got)
|
||
}
|
||
}
|
||
if again := sanitizeComponent(got, maxEpisodeBytes); again != got {
|
||
t.Errorf("case %d: 再適用で変化: %q -> %q", i, got, again)
|
||
}
|
||
|
||
path, err := RelativeVideoPath(input, input, "id")
|
||
if err != nil {
|
||
t.Errorf("case %d: パス生成エラー: %v", i, err)
|
||
continue
|
||
}
|
||
parts := strings.Split(filepath.ToSlash(path), "/")
|
||
if filepath.IsAbs(path) || len(parts) != 2 || parts[0] == "" || parts[0] == "." || parts[0] == ".." || !strings.HasSuffix(parts[1], ".mp4") {
|
||
t.Errorf("case %d: 安全でない相対パス: %q parts=%q", i, path, parts)
|
||
continue
|
||
}
|
||
if len([]byte(parts[0])) > 90 || len([]byte(parts[1])) > 255 {
|
||
t.Errorf("case %d: パス要素の上限超過: dir=%d filename=%d path=%q", i, len([]byte(parts[0])), len([]byte(parts[1])), path)
|
||
}
|
||
if !utf8.ValidString(path) {
|
||
t.Errorf("case %d: パスが不正なUTF-8: %q", i, path)
|
||
}
|
||
}
|
||
}
|