mirror of
https://github.com/cupcakearmy/autorestic.git
synced 2026-04-06 13:49:18 +00:00
281 lines
6.9 KiB
Go
281 lines
6.9 KiB
Go
package integration_test
|
|
|
|
import (
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func runAutorestic(t *testing.T, dir string, configPath string, args ...string) string {
|
|
// Find project root dynamically
|
|
wd, err := os.Getwd()
|
|
assert.NoError(t, err)
|
|
root := filepath.Dir(wd)
|
|
|
|
mainGo := filepath.Join(root, "main.go")
|
|
|
|
// Get restic path from mise
|
|
resticPath := "/Users/cupcakearmy/.local/share/mise/installs/restic/0.18.1/restic"
|
|
|
|
// Convert configPath to absolute path
|
|
absConfigPath, err := filepath.Abs(configPath)
|
|
assert.NoError(t, err)
|
|
|
|
cmd := exec.Command("go", append([]string{"run", mainGo, "--restic-bin", resticPath, "-c", absConfigPath}, args...)...)
|
|
|
|
// Run from root to find go.mod
|
|
cmd.Dir = root
|
|
|
|
// Add mise path to environment and set dummy password
|
|
cmd.Env = os.Environ()
|
|
cmd.Env = append(cmd.Env, "PATH="+os.Getenv("PATH"))
|
|
cmd.Env = append(cmd.Env, "RESTIC_PASSWORD=password")
|
|
|
|
output, err := cmd.CombinedOutput()
|
|
// NOTE: We don't assert NoError here because tests might expect failures
|
|
return string(output)
|
|
}
|
|
|
|
func initRepo(t *testing.T, repoPath string) {
|
|
resticPath := "/Users/cupcakearmy/.local/share/mise/installs/restic/0.18.1/restic"
|
|
cmd := exec.Command(resticPath, "-r", repoPath, "init")
|
|
cmd.Env = append(os.Environ(), "RESTIC_PASSWORD=password")
|
|
output, err := cmd.CombinedOutput()
|
|
assert.NoError(t, err, string(output))
|
|
}
|
|
|
|
func TestAutoresticCheck(t *testing.T) {
|
|
tempDir := t.TempDir()
|
|
|
|
configContent := `
|
|
version: 2
|
|
locations:
|
|
my-data:
|
|
from: ` + tempDir + `
|
|
to: local
|
|
backends:
|
|
local:
|
|
type: local
|
|
path: ` + filepath.Join(tempDir, "repo") + `
|
|
key: password
|
|
`
|
|
configPath := filepath.Join(tempDir, "autorestic.yml")
|
|
err := os.WriteFile(configPath, []byte(configContent), 0644)
|
|
assert.NoError(t, err)
|
|
|
|
_ = runAutorestic(t, tempDir, configPath, "check")
|
|
}
|
|
|
|
func TestBackupRestore(t *testing.T) {
|
|
tempDir := t.TempDir()
|
|
|
|
// 1. Create a source file
|
|
sourceFile := "source.txt"
|
|
err := os.WriteFile(filepath.Join(tempDir, sourceFile), []byte("hello world"), 0644)
|
|
assert.NoError(t, err)
|
|
|
|
repoPath := filepath.Join(tempDir, "repo")
|
|
initRepo(t, repoPath)
|
|
|
|
configContent := `
|
|
version: 2
|
|
locations:
|
|
my-data:
|
|
from:
|
|
- ` + sourceFile + `
|
|
to: local
|
|
backends:
|
|
local:
|
|
type: local
|
|
path: ` + repoPath + `
|
|
key: password
|
|
`
|
|
configPath := filepath.Join(tempDir, "autorestic.yml")
|
|
err = os.WriteFile(configPath, []byte(configContent), 0644)
|
|
assert.NoError(t, err)
|
|
|
|
// 2. Backup
|
|
output := runAutorestic(t, tempDir, configPath, "backup", "-l", "my-data")
|
|
assert.Contains(t, output, "Done")
|
|
|
|
// 3. Restore
|
|
restoreDir := filepath.Join(tempDir, "restore")
|
|
err = os.MkdirAll(restoreDir, 0755)
|
|
assert.NoError(t, err)
|
|
output = runAutorestic(t, tempDir, configPath, "restore", "-l", "my-data", "--to", restoreDir)
|
|
t.Logf("Restore output: %s", output)
|
|
|
|
// DEBUG: List files in restoreDir and subdirectories
|
|
err = filepath.Walk(restoreDir, func(path string, info os.FileInfo, err error) error {
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.Logf("Found: %s", path)
|
|
return nil
|
|
})
|
|
assert.NoError(t, err)
|
|
|
|
// 4. Verify
|
|
// It might be nested depending on how it was backed up
|
|
// Let's look for source.txt in any subdirectory
|
|
var restoredFile string
|
|
err = filepath.Walk(restoreDir, func(path string, info os.FileInfo, err error) error {
|
|
if !info.IsDir() && info.Name() == "source.txt" {
|
|
restoredFile = path
|
|
}
|
|
return nil
|
|
})
|
|
assert.NoError(t, err)
|
|
assert.NotEmpty(t, restoredFile, "source.txt not found")
|
|
|
|
content, err := os.ReadFile(restoredFile)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, "hello world", string(content))
|
|
}
|
|
|
|
func TestHooks(t *testing.T) {
|
|
tempDir := t.TempDir()
|
|
|
|
// Create a dummy file to back up
|
|
sourceFile := "source.txt"
|
|
err := os.WriteFile(filepath.Join(tempDir, sourceFile), []byte("data"), 0644)
|
|
assert.NoError(t, err)
|
|
|
|
repoPath := filepath.Join(tempDir, "repo")
|
|
initRepo(t, repoPath)
|
|
|
|
configContent := `
|
|
version: 2
|
|
locations:
|
|
my-data:
|
|
from:
|
|
- ` + sourceFile + `
|
|
to: local
|
|
hooks:
|
|
before:
|
|
- touch before.txt
|
|
after:
|
|
- touch after.txt
|
|
backends:
|
|
local:
|
|
type: local
|
|
path: ` + repoPath + `
|
|
key: password
|
|
`
|
|
configPath := filepath.Join(tempDir, "autorestic.yml")
|
|
err = os.WriteFile(configPath, []byte(configContent), 0644)
|
|
assert.NoError(t, err)
|
|
|
|
// Run backup
|
|
runAutorestic(t, tempDir, configPath, "backup", "-l", "my-data")
|
|
|
|
// Verify
|
|
assert.FileExists(t, filepath.Join(tempDir, "before.txt"))
|
|
assert.FileExists(t, filepath.Join(tempDir, "after.txt"))
|
|
}
|
|
|
|
func TestCopy(t *testing.T) {
|
|
tempDir := t.TempDir()
|
|
|
|
// Create a dummy file to back up
|
|
sourceFile := "source.txt"
|
|
err := os.WriteFile(filepath.Join(tempDir, sourceFile), []byte("data"), 0644)
|
|
assert.NoError(t, err)
|
|
|
|
repoPath := filepath.Join(tempDir, "repo")
|
|
initRepo(t, repoPath)
|
|
|
|
remoteRepoPath := filepath.Join(tempDir, "remote_repo")
|
|
initRepo(t, remoteRepoPath)
|
|
|
|
configContent := `
|
|
version: 2
|
|
locations:
|
|
my-data:
|
|
from:
|
|
- ` + sourceFile + `
|
|
to: local
|
|
copy:
|
|
local:
|
|
- remote
|
|
backends:
|
|
local:
|
|
type: local
|
|
path: ` + repoPath + `
|
|
key: password
|
|
remote:
|
|
type: local
|
|
path: ` + remoteRepoPath + `
|
|
key: password
|
|
`
|
|
configPath := filepath.Join(tempDir, "autorestic.yml")
|
|
err = os.WriteFile(configPath, []byte(configContent), 0644)
|
|
assert.NoError(t, err)
|
|
|
|
// Run backup
|
|
output := runAutorestic(t, tempDir, configPath, "backup", "-l", "my-data")
|
|
|
|
// Verify copy in output
|
|
assert.Contains(t, output, "Copying local → remote")
|
|
}
|
|
|
|
func TestPermissions(t *testing.T) {
|
|
tempDir := t.TempDir()
|
|
|
|
// 1. Create a source file with specific permissions (0600)
|
|
sourceFile := "source.txt"
|
|
sourcePath := filepath.Join(tempDir, sourceFile)
|
|
err := os.WriteFile(sourcePath, []byte("data"), 0600)
|
|
assert.NoError(t, err)
|
|
|
|
repoPath := filepath.Join(tempDir, "repo")
|
|
initRepo(t, repoPath)
|
|
|
|
configContent := `
|
|
version: 2
|
|
locations:
|
|
my-data:
|
|
from:
|
|
- ` + sourceFile + `
|
|
to: local
|
|
backends:
|
|
local:
|
|
type: local
|
|
path: ` + repoPath + `
|
|
key: password
|
|
`
|
|
configPath := filepath.Join(tempDir, "autorestic.yml")
|
|
err = os.WriteFile(configPath, []byte(configContent), 0644)
|
|
assert.NoError(t, err)
|
|
|
|
// 2. Backup
|
|
runAutorestic(t, tempDir, configPath, "backup", "-l", "my-data")
|
|
|
|
// 3. Restore
|
|
restoreDir := filepath.Join(tempDir, "restore")
|
|
err = os.MkdirAll(restoreDir, 0755)
|
|
assert.NoError(t, err)
|
|
runAutorestic(t, tempDir, configPath, "restore", "-l", "my-data", "--to", restoreDir)
|
|
|
|
// 4. Verify permissions
|
|
// Use walk to find the restored file
|
|
var restoredFile string
|
|
err = filepath.Walk(restoreDir, func(path string, info os.FileInfo, err error) error {
|
|
if !info.IsDir() && info.Name() == "source.txt" {
|
|
restoredFile = path
|
|
}
|
|
return nil
|
|
})
|
|
assert.NoError(t, err)
|
|
assert.NotEmpty(t, restoredFile, "source.txt not found")
|
|
|
|
info, err := os.Stat(restoredFile)
|
|
assert.NoError(t, err)
|
|
|
|
// Check permissions (masking only for permission bits)
|
|
assert.Equal(t, os.FileMode(0600), info.Mode().Perm())
|
|
}
|