343 lines
9.1 KiB
Go
343 lines
9.1 KiB
Go
/*
|
|
* Copyright (C) 2019 Philipp Haefelfinger (http://www.haefelfinger.ch/). All Rights Reserved.
|
|
* This application is licensed under GPLv2. See the LICENSE file in the root directory of the project.
|
|
*/
|
|
|
|
package datastore
|
|
|
|
import (
|
|
"os"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
var databaseFile = "./metadatatest.db"
|
|
var dbinitOk bool
|
|
|
|
func TestDataStoreInitialize(t *testing.T) {
|
|
_ = setupDatabase(t)
|
|
cleanupDatabase(t)
|
|
}
|
|
|
|
func Test_save_and_load_metadata(t *testing.T) {
|
|
if !dbinitOk {
|
|
t.Skip("Skipping test as TestDataStoreInitialize failed!")
|
|
}
|
|
dataStore := setupDatabase(t)
|
|
defer cleanupDatabase(t)
|
|
|
|
filePath := "blah/foo/bar.jpg"
|
|
img := getExampleImageMetadata(filePath)
|
|
|
|
saveImageShouldNotFail("insert", dataStore, img, t)
|
|
img.ImageId = 1
|
|
|
|
imgLoad := loadMetadataShouldNotFail("insert", dataStore, filePath, t)
|
|
EnsureMetadataAreEqual("insert", img, imgLoad, t)
|
|
|
|
// updated the image again
|
|
img.Md5Sum = "123456"
|
|
saveImageShouldNotFail("update", dataStore, img, t)
|
|
|
|
imgLoad = loadMetadataShouldNotFail("update", dataStore, filePath, t)
|
|
EnsureMetadataAreEqual("update", img, imgLoad, t)
|
|
}
|
|
|
|
func Test_save_and_query_for_all_entries(t *testing.T) {
|
|
if !dbinitOk {
|
|
t.Skip("Skipping test as TestDataStoreInitialize failed!")
|
|
}
|
|
dataStore := setupDatabase(t)
|
|
defer cleanupDatabase(t)
|
|
|
|
img1 := getExampleImageMetadata("blah/foo/bar.jpg")
|
|
|
|
img2 := getExampleImageMetadata("blah/foo/bar2.jpg")
|
|
img2.DeleteRequired = true
|
|
|
|
saveImageShouldNotFail("allimages", dataStore, img1, t)
|
|
img1.ImageId = 1
|
|
|
|
saveImageShouldNotFail("allimages", dataStore, img2, t)
|
|
img2.ImageId = 2
|
|
|
|
images, err := dataStore.ImageMetadataAll()
|
|
if err != nil {
|
|
t.Fatalf("Could not query images to upload! %s", err)
|
|
}
|
|
|
|
if len(images) != 2 {
|
|
t.Fatalf("Got incorrect number of images (%d). Expected two.", len(images))
|
|
}
|
|
|
|
imgLoad := images[0]
|
|
EnsureMetadataAreEqual("allimages", img1, imgLoad, t)
|
|
}
|
|
|
|
func Test_save_and_query_for_upload_records(t *testing.T) {
|
|
if !dbinitOk {
|
|
t.Skip("Skipping test as TestDataStoreInitialize failed!")
|
|
}
|
|
dataStore := setupDatabase(t)
|
|
defer cleanupDatabase(t)
|
|
|
|
img := getExampleImageMetadata("blah/foo/bar.jpg")
|
|
|
|
saveImageShouldNotFail("toupload", dataStore, img, t)
|
|
img.ImageId = 1
|
|
|
|
images, err := dataStore.ImageMetadataToUpload()
|
|
if err != nil {
|
|
t.Fatalf("Could not query images to upload! %s", err)
|
|
}
|
|
|
|
if len(images) != 1 {
|
|
t.Fatal("Did not get any saved images to upload!")
|
|
}
|
|
|
|
imgLoad := images[0]
|
|
EnsureMetadataAreEqual("toupload", img, imgLoad, t)
|
|
|
|
}
|
|
|
|
func Test_save_and_query_for_upload_records_do_not_contain_images_to_delete(t *testing.T) {
|
|
if !dbinitOk {
|
|
t.Skip("Skipping test as TestDataStoreInitialize failed!")
|
|
}
|
|
dataStore := setupDatabase(t)
|
|
defer cleanupDatabase(t)
|
|
|
|
img1 := getExampleImageMetadata("blah/foo/bar.jpg")
|
|
|
|
img2 := getExampleImageMetadata("blah/foo/bar2.jpg")
|
|
img2.DeleteRequired = true
|
|
|
|
saveImageShouldNotFail("toupload1", dataStore, img1, t)
|
|
img1.ImageId = 1
|
|
|
|
saveImageShouldNotFail("toupload2", dataStore, img2, t)
|
|
img2.ImageId = 2
|
|
|
|
images, err := dataStore.ImageMetadataToUpload()
|
|
if err != nil {
|
|
t.Fatalf("Could not query images to upload! %s", err)
|
|
}
|
|
|
|
if len(images) > 1 {
|
|
t.Fatal("Got more than one image to upload but only one is expected")
|
|
}
|
|
|
|
if len(images) != 1 {
|
|
t.Fatal("Did not get the saved images to upload!")
|
|
}
|
|
|
|
imgLoad := images[0]
|
|
EnsureMetadataAreEqual("toupload", img1, imgLoad, t)
|
|
}
|
|
|
|
func Test_save_and_query_for_deleted_records_do_contain_images(t *testing.T) {
|
|
if !dbinitOk {
|
|
t.Skip("Skipping test as TestDataStoreInitialize failed!")
|
|
}
|
|
dataStore := setupDatabase(t)
|
|
defer cleanupDatabase(t)
|
|
|
|
img1 := getExampleImageMetadata("blah/foo/bar.jpg")
|
|
img1.UploadRequired = false
|
|
img1.DeleteRequired = true
|
|
|
|
saveImageShouldNotFail("todelete", dataStore, img1, t)
|
|
img1.ImageId = 1
|
|
|
|
images, err := dataStore.ImageMetadataToDelete()
|
|
if err != nil {
|
|
t.Fatalf("Could not query images to delete! %s", err)
|
|
}
|
|
|
|
if len(images) > 1 {
|
|
t.Fatal("Got more than one image to delete but only one is expected")
|
|
}
|
|
|
|
if len(images) < 1 {
|
|
t.Fatal("Got no image to delete but one is expected!")
|
|
}
|
|
|
|
imgLoad := images[0]
|
|
EnsureMetadataAreEqual("todelete", img1, imgLoad, t)
|
|
}
|
|
|
|
func Test_load_metadata_not_found(t *testing.T) {
|
|
if !dbinitOk {
|
|
t.Skip("Skipping test as TestDataStoreInitialize failed!")
|
|
}
|
|
dataStore := setupDatabase(t)
|
|
defer cleanupDatabase(t)
|
|
|
|
filePath := "blah/foo/bar.jpg"
|
|
imgLoad, err := dataStore.ImageMetadata(filePath)
|
|
if err != ErrorRecordNotFound {
|
|
t.Errorf("Unexpected error on loading non existing file %s: %s", filePath, err)
|
|
}
|
|
if imgLoad.ImageId > 0 {
|
|
t.Error("Found an image metadata that should not exist on an emtpy database.")
|
|
}
|
|
}
|
|
|
|
func Test_unique_index_on_relativeFilePath(t *testing.T) {
|
|
if !dbinitOk {
|
|
t.Skip("Skipping test as TestDataStoreInitialize failed!")
|
|
}
|
|
dataStore := setupDatabase(t)
|
|
defer cleanupDatabase(t)
|
|
|
|
img := getExampleImageMetadata("blah/foo/bar.jpg")
|
|
|
|
saveImageShouldNotFail("insert", dataStore, img, t)
|
|
|
|
err := dataStore.SaveImageMetadata(img)
|
|
if err == nil {
|
|
t.Errorf("Could save duplicated image metadata. Expected error but got none!")
|
|
}
|
|
|
|
// check if the error contains the expected column as name. If not, this indicates another problem than
|
|
// the expected duplicated insert error.
|
|
if !strings.Contains(err.Error(), "fullImagePath") {
|
|
t.Errorf("Got a unexpected error on saving duplicate records: %s", err)
|
|
}
|
|
}
|
|
|
|
func Test_update_piwigoId_by_checksum(t *testing.T) {
|
|
if !dbinitOk {
|
|
t.Skip("Skipping test as TestDataStoreInitialize failed!")
|
|
}
|
|
dataStore := setupDatabase(t)
|
|
defer cleanupDatabase(t)
|
|
|
|
filePath := "blah/foo/bar.jpg"
|
|
img := getExampleImageMetadata(filePath)
|
|
|
|
saveImageShouldNotFail("SavePiwigoIdAndUpdateUploadFlag", dataStore, img, t)
|
|
img.ImageId = 1
|
|
img.PiwigoId = 1234
|
|
img.UploadRequired = false
|
|
|
|
err := dataStore.SavePiwigoIdAndUpdateUploadFlag(img.Md5Sum, img.PiwigoId)
|
|
if err != nil {
|
|
t.Errorf("SavePiwigoIdAndUpdateUploadFlag: Could not update piwigo id: %s", err)
|
|
}
|
|
|
|
imgLoad := loadMetadataShouldNotFail("update", dataStore, filePath, t)
|
|
EnsureMetadataAreEqual("SavePiwigoIdAndUpdateUploadFlag", img, imgLoad, t)
|
|
}
|
|
|
|
func Test_update_piwigoId_by_checksum_found_no_image(t *testing.T) {
|
|
if !dbinitOk {
|
|
t.Skip("Skipping test as TestDataStoreInitialize failed!")
|
|
}
|
|
dataStore := setupDatabase(t)
|
|
defer cleanupDatabase(t)
|
|
|
|
filePath := "blah/foo/bar.jpg"
|
|
img := getExampleImageMetadata(filePath)
|
|
|
|
saveImageShouldNotFail("SavePiwigoIdAndUpdateUploadFlag", dataStore, img, t)
|
|
img.ImageId = 1
|
|
img.PiwigoId = 0
|
|
img.UploadRequired = true
|
|
|
|
err := dataStore.SavePiwigoIdAndUpdateUploadFlag(img.Md5Sum, img.PiwigoId)
|
|
if err != nil {
|
|
t.Errorf("SavePiwigoIdAndUpdateUploadFlag: Could not update piwigo id: %s", err)
|
|
}
|
|
|
|
imgLoad := loadMetadataShouldNotFail("update", dataStore, filePath, t)
|
|
EnsureMetadataAreEqual("SavePiwigoIdAndUpdateUploadFlag", img, imgLoad, t)
|
|
}
|
|
|
|
func Test_deleteMarkedImages_should_remove_records(t *testing.T) {
|
|
if !dbinitOk {
|
|
t.Skip("Skipping test as TestDataStoreInitialize failed!")
|
|
}
|
|
dataStore := setupDatabase(t)
|
|
defer cleanupDatabase(t)
|
|
|
|
img1 := getExampleImageMetadata("blah/foo/bar.jpg")
|
|
|
|
img2 := getExampleImageMetadata("blah/foo/bar2.jpg")
|
|
img2.DeleteRequired = true
|
|
|
|
saveImageShouldNotFail("allimages", dataStore, img1, t)
|
|
img1.ImageId = 1
|
|
|
|
saveImageShouldNotFail("allimages", dataStore, img2, t)
|
|
img2.ImageId = 2
|
|
|
|
err := dataStore.DeleteMarkedImages()
|
|
if err != nil {
|
|
t.Fatalf("Could not delete marked records! %s", err)
|
|
}
|
|
|
|
images, err := dataStore.ImageMetadataAll()
|
|
if err != nil {
|
|
t.Fatalf("Could not query images to upload! %s", err)
|
|
}
|
|
|
|
if len(images) != 1 {
|
|
t.Fatalf("Got incorrect number of images (%d). Expected one.", len(images))
|
|
}
|
|
}
|
|
|
|
func saveImageShouldNotFail(action string, dataStore *LocalDataStore, img ImageMetaData, t *testing.T) {
|
|
err := dataStore.SaveImageMetadata(img)
|
|
if err != nil {
|
|
t.Errorf("%s: Could not save Metadata: %s", action, err)
|
|
}
|
|
}
|
|
|
|
func loadMetadataShouldNotFail(action string, dataStore *LocalDataStore, filePath string, t *testing.T) ImageMetaData {
|
|
imgLoad, err := dataStore.ImageMetadata(filePath)
|
|
if err != nil {
|
|
t.Errorf("%s: Could not load saved Metadata: %s - %s", action, filePath, err)
|
|
}
|
|
return imgLoad
|
|
}
|
|
|
|
func EnsureMetadataAreEqual(action string, img ImageMetaData, imgLoad ImageMetaData, t *testing.T) {
|
|
// check if both instances serialize to the same string representation
|
|
if img.String() != imgLoad.String() {
|
|
t.Errorf("%s: Invalid image loaded! expected (ignore ImageId) %s but got %s", action, img.String(), imgLoad.String())
|
|
}
|
|
}
|
|
|
|
func getExampleImageMetadata(filePath string) ImageMetaData {
|
|
return ImageMetaData{
|
|
FullImagePath: filePath,
|
|
PiwigoId: 1,
|
|
Md5Sum: "aabbccddeeff",
|
|
LastChange: time.Now().UTC(),
|
|
Filename: "bar.jpg",
|
|
CategoryPath: "blah/foo",
|
|
CategoryPiwigoId: 100,
|
|
UploadRequired: true,
|
|
}
|
|
}
|
|
|
|
func cleanupDatabase(t *testing.T) {
|
|
err := os.Remove(databaseFile)
|
|
if err != nil {
|
|
t.Errorf("Failed remove test database %s: %s", databaseFile, err)
|
|
}
|
|
}
|
|
|
|
func setupDatabase(t *testing.T) *LocalDataStore {
|
|
dataStore := &LocalDataStore{}
|
|
err := dataStore.Initialize(databaseFile)
|
|
if err != nil {
|
|
t.Errorf("Failed to init datastore: %s", err)
|
|
return nil
|
|
}
|
|
dbinitOk = true
|
|
return dataStore
|
|
}
|