142 lines
3.1 KiB
Go
142 lines
3.1 KiB
Go
package exif
|
|
|
|
import (
|
|
"os"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
_ "github.com/photoview/photoview/api/test_utils/flags"
|
|
)
|
|
|
|
func resetForTest() {
|
|
globalMu.Lock()
|
|
defer globalMu.Unlock()
|
|
if globalExifParser != nil {
|
|
_ = globalExifParser.Close()
|
|
}
|
|
globalExifParser = nil
|
|
// Allow Initialize() to run again in subsequent tests
|
|
globalInit = sync.Once{}
|
|
}
|
|
|
|
func TestParseWithoutInit(t *testing.T) {
|
|
resetForTest()
|
|
if _, err := Parse("./test_data/bird.jpg"); err == nil {
|
|
t.Fatalf("Parse() without Init() doesn't return an error")
|
|
}
|
|
}
|
|
|
|
func TestParse(t *testing.T) {
|
|
resetForTest()
|
|
|
|
cleanup, err := Initialize()
|
|
if err != nil {
|
|
t.Fatalf("Initialize() error: %v", err)
|
|
}
|
|
defer cleanup()
|
|
|
|
filename := "./test_data/bird.jpg"
|
|
|
|
metadata, err := Parse(filename)
|
|
if err != nil {
|
|
t.Fatalf("Parse() returns an error: %v", err)
|
|
}
|
|
|
|
if metadata == nil {
|
|
t.Errorf("Parse(%q) should not return nil", filename)
|
|
}
|
|
}
|
|
|
|
func TestMIMEType(t *testing.T) {
|
|
resetForTest()
|
|
|
|
cleanup, err := Initialize()
|
|
if err != nil {
|
|
t.Fatalf("Initialize() error: %v", err)
|
|
}
|
|
defer cleanup()
|
|
|
|
filename := "./test_data/bird.jpg"
|
|
|
|
mime, err := MIMEType(filename)
|
|
if err != nil {
|
|
t.Fatalf("MIMEType() returns an error: %v", err)
|
|
}
|
|
|
|
if mime == "" {
|
|
t.Errorf("MIMEType(%q) should not return an empty string", filename)
|
|
}
|
|
}
|
|
|
|
func fileModifyDateLiteralInUTC(t *testing.T, file string) time.Time {
|
|
fstat, err := os.Stat(file)
|
|
if err != nil {
|
|
t.Fatalf("os.Stat(%q) error: %v", file, err)
|
|
}
|
|
|
|
ret := fstat.ModTime().Truncate(time.Second)
|
|
_, offset := ret.Zone()
|
|
ret = ret.Add(time.Duration(offset) * time.Second).UTC()
|
|
|
|
return ret
|
|
}
|
|
|
|
func mustParseNoTimeZone(t *testing.T, timeStr string) time.Time {
|
|
layout := "2006:01:02 15:04:05.999"
|
|
ret, err := time.ParseInLocation(layout, timeStr, time.UTC)
|
|
if err != nil {
|
|
t.Fatalf("time.Parse(%q) error: %v", timeStr, err)
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func TestSamplesTime(t *testing.T) {
|
|
resetForTest()
|
|
|
|
cleanup, err := Initialize()
|
|
if err != nil {
|
|
t.Fatalf("Initialize() error: %v", err)
|
|
}
|
|
defer cleanup()
|
|
|
|
tests := []struct {
|
|
file string
|
|
wantTime time.Time
|
|
wantOffsetSec *int
|
|
}{
|
|
{"./test_data/sample1.heif", fileModifyDateLiteralInUTC(t, "./test_data/sample1.heif"), nil},
|
|
{"./test_data/sample1_nef.jpg", mustParseNoTimeZone(t, "2008:03:15 07:44:21.49"), new(-7 * 60 * 60)},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.file, func(t *testing.T) {
|
|
metadata, err := Parse(tc.file)
|
|
if err != nil {
|
|
t.Fatalf("Parse(%q) returns an error: %v", tc.file, err)
|
|
}
|
|
|
|
if metadata == nil {
|
|
t.Fatalf("metadata == nil")
|
|
}
|
|
if metadata.DateShot == nil {
|
|
t.Fatalf("metadata.DateShot == nil")
|
|
}
|
|
|
|
if got := *metadata.DateShot; !got.Equal(tc.wantTime) {
|
|
t.Errorf("metadata.DateShot = %v, want: %v", got, tc.wantTime)
|
|
}
|
|
|
|
if tc.wantOffsetSec == nil {
|
|
if got := metadata.OffsetSecShot; got != nil {
|
|
t.Errorf("metadata.OffsetSecShot = %+v, want: nil", got)
|
|
}
|
|
} else {
|
|
if got, want := *metadata.OffsetSecShot, *tc.wantOffsetSec; got != want {
|
|
t.Errorf("metadata.OffsetSecShot = &(%v), want: &(%v)", got, want)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|