mirror of
https://github.com/jkl1337/duplicacy.git
synced 2026-01-02 11:44:45 -06:00
330 lines
6.9 KiB
Go
330 lines
6.9 KiB
Go
// Copyright (c) Acrosync LLC. All rights reserved.
|
|
// Free for personal use and commercial trial
|
|
// Commercial use requires per-user licenses available from https://duplicacy.com
|
|
|
|
package duplicacy
|
|
|
|
import (
|
|
"io/ioutil"
|
|
"math/rand"
|
|
"os"
|
|
"path/filepath"
|
|
"runtime"
|
|
"sort"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/gilbertchen/xattr"
|
|
)
|
|
|
|
func TestEntrySort(t *testing.T) {
|
|
|
|
DATA := [...]string{
|
|
"ab",
|
|
"ab-",
|
|
"ab0",
|
|
"ab1",
|
|
"\xBB\xDDfile",
|
|
"\xFF\xDDfile",
|
|
"ab/",
|
|
"ab/c",
|
|
"ab+/c-",
|
|
"ab+/c0",
|
|
"ab+/c/",
|
|
"ab+/c/d",
|
|
"ab+/c+/",
|
|
"ab+/c+/d",
|
|
"ab+/c0/",
|
|
"ab+/c0/d",
|
|
"ab-/",
|
|
"ab-/c",
|
|
"ab0/",
|
|
"ab1/",
|
|
"ab1/c",
|
|
"ab1/\xBB\xDDfile",
|
|
"ab1/\xFF\xDDfile",
|
|
}
|
|
|
|
var entry1, entry2 *Entry
|
|
|
|
for i, p1 := range DATA {
|
|
if p1[len(p1)-1] == '/' {
|
|
entry1 = CreateEntry(p1, 0, 0, 0700|uint32(os.ModeDir))
|
|
} else {
|
|
entry1 = CreateEntry(p1, 0, 0, 0700)
|
|
}
|
|
for j, p2 := range DATA {
|
|
|
|
if p2[len(p2)-1] == '/' {
|
|
entry2 = CreateEntry(p2, 0, 0, 0700|uint32(os.ModeDir))
|
|
} else {
|
|
entry2 = CreateEntry(p2, 0, 0, 0700)
|
|
}
|
|
|
|
compared := entry1.Compare(entry2)
|
|
|
|
if compared < 0 {
|
|
compared = -1
|
|
} else if compared > 0 {
|
|
compared = 1
|
|
}
|
|
|
|
var expected int
|
|
if i < j {
|
|
expected = -1
|
|
} else if i > j {
|
|
expected = 1
|
|
} else {
|
|
expected = 0
|
|
}
|
|
|
|
if compared != expected {
|
|
t.Errorf("%s vs %s: %d, expected: %d", p1, p2, compared, expected)
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestEntryList(t *testing.T) {
|
|
|
|
testDir := filepath.Join(os.TempDir(), "duplicacy_test")
|
|
os.RemoveAll(testDir)
|
|
os.MkdirAll(testDir, 0700)
|
|
|
|
DATA := [...]string{
|
|
"ab",
|
|
"ab-",
|
|
"ab0",
|
|
"ab1",
|
|
"ab+/",
|
|
"ab+/c",
|
|
"ab+/c+",
|
|
"ab+/c1",
|
|
"ab+/c-/",
|
|
"ab+/c-/d",
|
|
"ab+/c0/",
|
|
"ab+/c0/d",
|
|
"ab2/",
|
|
"ab2/c",
|
|
"ab3/",
|
|
"ab3/c",
|
|
}
|
|
|
|
var entry1, entry2 *Entry
|
|
|
|
for i, p1 := range DATA {
|
|
if p1[len(p1)-1] == '/' {
|
|
entry1 = CreateEntry(p1, 0, 0, 0700|uint32(os.ModeDir))
|
|
} else {
|
|
entry1 = CreateEntry(p1, 0, 0, 0700)
|
|
}
|
|
for j, p2 := range DATA {
|
|
|
|
if p2[len(p2)-1] == '/' {
|
|
entry2 = CreateEntry(p2, 0, 0, 0700|uint32(os.ModeDir))
|
|
} else {
|
|
entry2 = CreateEntry(p2, 0, 0, 0700)
|
|
}
|
|
|
|
compared := entry1.Compare(entry2)
|
|
|
|
if compared < 0 {
|
|
compared = -1
|
|
} else if compared > 0 {
|
|
compared = 1
|
|
}
|
|
|
|
var expected int
|
|
if i < j {
|
|
expected = -1
|
|
} else if i > j {
|
|
expected = 1
|
|
} else {
|
|
expected = 0
|
|
}
|
|
|
|
if compared != expected {
|
|
t.Errorf("%s vs %s: %d, expected: %d", p1, p2, compared, expected)
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
for _, file := range DATA {
|
|
|
|
fullPath := filepath.Join(testDir, file)
|
|
if file[len(file)-1] == '/' {
|
|
err := os.Mkdir(fullPath, 0700)
|
|
if err != nil {
|
|
t.Errorf("Mkdir(%s) returned an error: %s", fullPath, err)
|
|
}
|
|
continue
|
|
}
|
|
|
|
err := ioutil.WriteFile(fullPath, []byte(file), 0700)
|
|
if err != nil {
|
|
t.Errorf("WriteFile(%s) returned an error: %s", fullPath, err)
|
|
}
|
|
}
|
|
|
|
directories := make([]*Entry, 0, 4)
|
|
directories = append(directories, CreateEntry("", 0, 0, 0))
|
|
|
|
entries := make([]*Entry, 0, 4)
|
|
|
|
for len(directories) > 0 {
|
|
directory := directories[len(directories)-1]
|
|
directories = directories[:len(directories)-1]
|
|
entries = append(entries, directory)
|
|
subdirectories, _, err := ListEntries(testDir, directory.Path, &entries, nil, "", false, false)
|
|
if err != nil {
|
|
t.Errorf("ListEntries(%s, %s) returned an error: %s", testDir, directory.Path, err)
|
|
}
|
|
directories = append(directories, subdirectories...)
|
|
}
|
|
|
|
entries = entries[1:]
|
|
|
|
for _, entry := range entries {
|
|
t.Logf("entry: %s", entry.Path)
|
|
}
|
|
|
|
if len(entries) != len(DATA) {
|
|
t.Errorf("Got %d entries instead of %d", len(entries), len(DATA))
|
|
return
|
|
}
|
|
|
|
for i := 0; i < len(entries); i++ {
|
|
if entries[i].Path != DATA[i] {
|
|
t.Errorf("entry: %s, expected: %s", entries[i].Path, DATA[i])
|
|
}
|
|
}
|
|
|
|
t.Logf("shuffling %d entries", len(entries))
|
|
for i := range entries {
|
|
j := rand.Intn(i + 1)
|
|
entries[i], entries[j] = entries[j], entries[i]
|
|
}
|
|
|
|
sort.Sort(ByName(entries))
|
|
|
|
for i := 0; i < len(entries); i++ {
|
|
if entries[i].Path != DATA[i] {
|
|
t.Errorf("entry: %s, expected: %s", entries[i].Path, DATA[i])
|
|
}
|
|
}
|
|
|
|
if !t.Failed() {
|
|
os.RemoveAll(testDir)
|
|
}
|
|
|
|
}
|
|
|
|
// TestEntryExcludeByAttribute tests the excludeByAttribute parameter to the ListEntries function
|
|
func TestEntryExcludeByAttribute(t *testing.T) {
|
|
|
|
if !(runtime.GOOS == "darwin" || runtime.GOOS == "linux") {
|
|
t.Skip("skipping test not darwin or linux")
|
|
}
|
|
|
|
testDir := filepath.Join(os.TempDir(), "duplicacy_test")
|
|
|
|
os.RemoveAll(testDir)
|
|
os.MkdirAll(testDir, 0700)
|
|
|
|
// Files or folders named with "exclude" below will have the exclusion attribute set on them
|
|
// When ListEntries is called with excludeByAttribute true, they should be excluded.
|
|
DATA := [...]string{
|
|
"excludefile",
|
|
"includefile",
|
|
"excludedir/",
|
|
"excludedir/file",
|
|
"includedir/",
|
|
"includedir/includefile",
|
|
"includedir/excludefile",
|
|
}
|
|
|
|
for _, file := range DATA {
|
|
fullPath := filepath.Join(testDir, file)
|
|
if file[len(file)-1] == '/' {
|
|
err := os.Mkdir(fullPath, 0700)
|
|
if err != nil {
|
|
t.Errorf("Mkdir(%s) returned an error: %s", fullPath, err)
|
|
}
|
|
continue
|
|
}
|
|
|
|
err := ioutil.WriteFile(fullPath, []byte(file), 0700)
|
|
if err != nil {
|
|
t.Errorf("WriteFile(%s) returned an error: %s", fullPath, err)
|
|
}
|
|
}
|
|
|
|
for _, file := range DATA {
|
|
fullPath := filepath.Join(testDir, file)
|
|
if strings.Contains(file, "exclude") {
|
|
xattr.Setxattr(fullPath, "com.apple.metadata:com_apple_backup_excludeItem", []byte("com.apple.backupd"))
|
|
}
|
|
}
|
|
|
|
for _, excludeByAttribute := range [2]bool{true, false} {
|
|
t.Logf("testing excludeByAttribute: %t", excludeByAttribute)
|
|
directories := make([]*Entry, 0, 4)
|
|
directories = append(directories, CreateEntry("", 0, 0, 0))
|
|
|
|
entries := make([]*Entry, 0, 4)
|
|
|
|
for len(directories) > 0 {
|
|
directory := directories[len(directories)-1]
|
|
directories = directories[:len(directories)-1]
|
|
entries = append(entries, directory)
|
|
subdirectories, _, err := ListEntries(testDir, directory.Path, &entries, nil, "", false, excludeByAttribute)
|
|
if err != nil {
|
|
t.Errorf("ListEntries(%s, %s) returned an error: %s", testDir, directory.Path, err)
|
|
}
|
|
directories = append(directories, subdirectories...)
|
|
}
|
|
|
|
entries = entries[1:]
|
|
|
|
for _, entry := range entries {
|
|
t.Logf("entry: %s", entry.Path)
|
|
}
|
|
|
|
i := 0
|
|
for _, file := range DATA {
|
|
entryFound := false
|
|
var entry *Entry
|
|
for _, entry = range entries {
|
|
if entry.Path == file {
|
|
entryFound = true
|
|
break
|
|
}
|
|
}
|
|
|
|
if excludeByAttribute && strings.Contains(file, "exclude") {
|
|
if entryFound {
|
|
t.Errorf("file: %s, expected to be excluded but wasn't. attributes: %v", file, entry.Attributes)
|
|
i++
|
|
} else {
|
|
t.Logf("file: %s, excluded", file)
|
|
}
|
|
} else {
|
|
if entryFound {
|
|
t.Logf("file: %s, included. attributes: %v", file, entry.Attributes)
|
|
i++
|
|
} else {
|
|
t.Errorf("file: %s, expected to be included but wasn't", file)
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
if !t.Failed() {
|
|
os.RemoveAll(testDir)
|
|
}
|
|
|
|
}
|