Update config.go

Bumps restic/restic from 0.14.0 to 0.15.0.

---
updated-dependencies:
- dependency-name: restic/restic
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.github/dependabot.yml

@@ -0,0 +1,8 @@
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: "docker"
+    directory: "/"
+    schedule:
+      interval: "weekly"

CHANGELOG.md

@@ -5,6 +5,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.7.4] - 2023-01-18
+
+### Fixed
+
+- Transformer for extracting information. @11mariom
+
+### Changed
+
+- Bump docker restic version.
+- Docs dependencies updated.
+
 ## [1.7.1] - 2022-04-27
 
 ### Fixed

Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.18-alpine as builder
+FROM golang:1.19-alpine as builder
 
 WORKDIR /app
 COPY go.* .
@@ -6,7 +6,8 @@ RUN go mod download
 COPY . .
 RUN go build
 
-FROM alpine
+FROM restic/restic:0.15.0
-RUN apk add --no-cache restic rclone bash openssh
+RUN apk add --no-cache rclone bash
 COPY --from=builder /app/autorestic /usr/bin/autorestic
+ENTRYPOINT []
 CMD [ "autorestic" ]

build/build.go

@@ -17,11 +17,14 @@ import (
 var DIR, _ = filepath.Abs("./dist")
 
 var targets = map[string][]string{
+	// "aix":     {"ppc64"}, // Not supported by fsnotify
 	"darwin":  {"amd64", "arm64"},
 	"freebsd": {"386", "amd64", "arm"},
-	"linux":   {"386", "amd64", "arm", "arm64"},
+	"linux":   {"386", "amd64", "arm", "arm64", "ppc64le", "mips", "mipsle", "mips64", "mips64le", "s390x"},
 	"netbsd":  {"386", "amd64"},
 	"openbsd": {"386", "amd64"},
+	// "windows": {"386", "amd64"}, // Not supported by autorestic
+	"solaris": {"amd64"},
 }
 
 type buildOptions struct {

cmd/exec.go

@@ -1,6 +1,8 @@
 package cmd
 
 import (
+	"fmt"
+
 	"github.com/cupcakearmy/autorestic/internal"
 	"github.com/cupcakearmy/autorestic/internal/colors"
 	"github.com/cupcakearmy/autorestic/internal/lock"
@@ -18,10 +20,23 @@ var execCmd = &cobra.Command{
 
 		selected, err := internal.GetAllOrSelected(cmd, true)
 		CheckErr(err)
+
+		var errors []error
 		for _, name := range selected {
 			colors.PrimaryPrint("  Executing on \"%s\"  ", name)
 			backend, _ := internal.GetBackend(name)
-			backend.Exec(args)
+			err := backend.Exec(args)
+			if err != nil {
+				errors = append(errors, err)
+			}
+		}
+
+		if len(errors) > 0 {
+			for _, err := range errors {
+				colors.Error.Printf("%s\n\n", err)
+			}
+
+			CheckErr(fmt.Errorf("%d errors were found", len(errors)))
 		}
 	},
 }

cmd/root.go

@@ -41,6 +41,7 @@ func init() {
 	rootCmd.PersistentFlags().BoolVar(&flags.CI, "ci", false, "CI mode disabled interactive mode and colors and enables verbosity")
 	rootCmd.PersistentFlags().BoolVarP(&flags.VERBOSE, "verbose", "v", false, "verbose mode")
 	rootCmd.PersistentFlags().StringVar(&flags.RESTIC_BIN, "restic-bin", "restic", "specify custom restic binary")
+	rootCmd.PersistentFlags().StringVar(&flags.DOCKER_IMAGE, "docker-image", "cupcakearmy/autorestic:"+internal.VERSION, "specify a custom docker image")
 	cobra.OnInitialize(initConfig)
 }
 

docs/.codedoc/package.json

@@ -1,5 +1,5 @@
 {
   "dependencies": {
-    "@codedoc/core": "^0.2.24"
+    "@codedoc/core": "^0.3.2"
   }
 }

docs/markdown/community.md

@@ -2,10 +2,12 @@
 
 A list of community driven projects. (No official affiliation)
 
-- SystemD Units: https://gitlab.com/py_crash/autorestic-systemd-units
+- SystemD Units: <https://gitlab.com/py_crash/autorestic-systemd-units>
-- Docker image: https://github.com/pascaliske/docker-autorestic
+- Docker image: <https://github.com/pascaliske/docker-autorestic>
-- Ansible Role: https://github.com/adsanz/ansible-restic-role
+- Ansible Role: <https://github.com/adsanz/ansible-restic-role>
-- Ansible Role: https://github.com/ItsNotGoodName/ansible-role-autorestic
+- Ansible Role: <https://github.com/ItsNotGoodName/ansible-role-autorestic>
-- Ansible Role: https://github.com/FuzzyMistborn/ansible-role-autorestic
+- Ansible Role: <https://github.com/FuzzyMistborn/ansible-role-autorestic>
+- Ansible Role: <https://0xacab.org/varac-projects/ansible-role-autorestic>
+- Ansible Role: <https://github.com/dbrennand/ansible-role-autorestic>
 
 > :ToCPrevNext

docs/markdown/installation.md

@@ -5,7 +5,7 @@ Linux & macOS. Windows is not supported. If you have problems installing please
 Autorestic requires `bash`, `wget` and `bzip2` to be installed. For most systems these should be already installed.
 
 ```bash
-wget -qO - https://raw.githubusercontent.com/CupCakeArmy/autorestic/master/install.sh | bash
+wget -qO - https://raw.githubusercontent.com/cupcakearmy/autorestic/master/install.sh | bash
 ```
 
 ## Alternatives

docs/markdown/location/forget.md

@@ -21,7 +21,7 @@ locations:
         keep-weekly: 1 # keep 1 last weekly snapshots
         keep-monthly: 12 # keep 12 last monthly snapshots
         keep-yearly: 7 # keep 7 last yearly snapshots
-        keep-within: '2w' # keep snapshots from the last 2 weeks
+        keep-within: '14d' # keep snapshots from the last 14 days
 ```
 
 ## Globally

docs/markdown/quick.md

@@ -3,7 +3,7 @@
 ## Installation
 
 ```bash
-wget -qO - https://raw.githubusercontent.com/CupCakeArmy/autorestic/master/install.sh | bash
+wget -qO - https://raw.githubusercontent.com/cupcakearmy/autorestic/master/install.sh | bash
 ```
 
 See [installation](/installation) for alternative options.

docs/package.json

@@ -5,6 +5,6 @@
     "dev": "codedoc serve"
   },
   "dependencies": {
-    "@codedoc/cli": "^0.2.8"
+    "@codedoc/cli": "^0.3.0"
   }
 }

install.sh

@@ -31,6 +31,11 @@ else
 fi
 echo $ARCH
 
+if ! command -v bzip2 &>/dev/null; then
+    echo "Missing bzip2 command. Please install the bzip2 package for your system."
+    exit 1
+fi
+
 wget -qO - https://api.github.com/repos/cupcakearmy/autorestic/releases/latest \
 | grep "browser_download_url.*_${OS}_${ARCH}" \
 | cut -d : -f 2,3 \

internal/backend.go

@@ -9,6 +9,7 @@ import (
 	"strings"
 
 	"github.com/cupcakearmy/autorestic/internal/colors"
+	"github.com/cupcakearmy/autorestic/internal/flags"
 )
 
 type BackendRest struct {
@@ -121,13 +122,17 @@ func (b Backend) validate() error {
 	}
 	options := ExecuteOptions{Envs: env, Silent: true}
 	// Check if already initialized
-	_, _, err = ExecuteResticCommand(options, "check")
+	cmd := []string{"check"}
+	cmd = append(cmd, combineBackendOptions("check", b)...)
+	_, _, err = ExecuteResticCommand(options, cmd...)
 	if err == nil {
 		return nil
 	} else {
 		// If not initialize
 		colors.Body.Printf("Initializing backend \"%s\"...\n", b.name)
-		_, _, err := ExecuteResticCommand(options, "init")
+		cmd := []string{"init"}
+		cmd = append(cmd, combineBackendOptions("init", b)...)
+		_, _, err := ExecuteResticCommand(options, cmd...)
 		return err
 	}
 }
@@ -160,7 +165,6 @@ func (b Backend) ExecDocker(l Location, args []string) (int, string, error) {
 	args = append([]string{"restic"}, args...)
 	docker := []string{
 		"run", "--rm",
-		"--pull", "always",
 		"--entrypoint", "ash",
 		"--workdir", dir,
 		"--volume", volume + ":" + dir,
@@ -194,6 +198,7 @@ func (b Backend) ExecDocker(l Location, args []string) (int, string, error) {
 	for key, value := range env {
 		docker = append(docker, "--env", key+"="+value)
 	}
-	docker = append(docker, "cupcakearmy/autorestic:"+VERSION, "-c", strings.Join(args, " "))
+
+	docker = append(docker, flags.DOCKER_IMAGE, "-c", strings.Join(args, " "))
 	return ExecuteCommand(options, docker...)
 }

internal/backend_test.go

@@ -0,0 +1,225 @@
+package internal
+
+import (
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/spf13/viper"
+)
+
+func TestGenerateRepo(t *testing.T) {
+
+	t.Run("empty backend", func(t *testing.T) {
+		b := Backend{
+			name: "empty backend",
+			Type: "",
+		}
+		_, err := b.generateRepo()
+		if err == nil {
+			t.Errorf("Error expected for empty backend type")
+		}
+	})
+
+	t.Run("local backend", func(t *testing.T) {
+		b := Backend{
+			name: "local backend",
+			Type: "local",
+			Path: "/foo/bar",
+		}
+		result, err := b.generateRepo()
+		if err != nil {
+			t.Errorf("unexpected error %v", err)
+		}
+		assertEqual(t, result, "/foo/bar")
+	})
+
+	t.Run("local backend with homedir prefix", func(t *testing.T) {
+		b := Backend{
+			name: "local backend",
+			Type: "local",
+			Path: "~/foo/bar",
+		}
+		result, err := b.generateRepo()
+		if err != nil {
+			t.Errorf("unexpected error %v", err)
+		}
+		assertEqual(t, result, fmt.Sprintf("%s/foo/bar", os.Getenv("HOME")))
+	})
+
+	t.Run("local backend with config file", func(t *testing.T) {
+		// config file path should always be present from initConfig
+		viper.SetConfigFile("/tmp/.autorestic.yml")
+		defer viper.Reset()
+
+		b := Backend{
+			name: "local backend",
+			Type: "local",
+		}
+		result, err := b.generateRepo()
+		if err != nil {
+			t.Errorf("unexpected error %v", err)
+		}
+		assertEqual(t, result, "/tmp")
+	})
+
+	t.Run("rest backend with valid path", func(t *testing.T) {
+		b := Backend{
+			name: "rest backend",
+			Type: "rest",
+			Path: "http://localhost:8000/foo",
+		}
+		result, err := b.generateRepo()
+		if err != nil {
+			t.Errorf("unexpected error %v", err)
+		}
+		assertEqual(t, result, "rest:http://localhost:8000/foo")
+	})
+
+	t.Run("rest backend with user", func(t *testing.T) {
+		b := Backend{
+			name: "rest backend",
+			Type: "rest",
+			Path: "http://localhost:8000/foo",
+			Rest: BackendRest{
+				User:     "user",
+				Password: "",
+			},
+		}
+		result, err := b.generateRepo()
+		if err != nil {
+			t.Errorf("unexpected error %v", err)
+		}
+		assertEqual(t, result, "rest:http://user@localhost:8000/foo")
+	})
+
+	t.Run("rest backend with user and password", func(t *testing.T) {
+		b := Backend{
+			name: "rest backend",
+			Type: "rest",
+			Path: "http://localhost:8000/foo",
+			Rest: BackendRest{
+				User:     "user",
+				Password: "pass",
+			},
+		}
+		result, err := b.generateRepo()
+		if err != nil {
+			t.Errorf("unexpected error %v", err)
+		}
+		assertEqual(t, result, "rest:http://user:pass@localhost:8000/foo")
+	})
+
+	backendTests := []struct {
+		name    string
+		backend Backend
+		want    string
+	}{
+		{name: "b2 backend", backend: Backend{name: "b2", Type: "b2", Path: "foo"}, want: "b2:foo"},
+		{name: "azure backend", backend: Backend{name: "azure", Type: "azure", Path: "foo"}, want: "azure:foo"},
+		{name: "gs backend", backend: Backend{name: "gs", Type: "gs", Path: "foo"}, want: "gs:foo"},
+		{name: "s3 backend", backend: Backend{name: "s3", Type: "s3", Path: "foo"}, want: "s3:foo"},
+		{name: "sftp backend", backend: Backend{name: "sftp", Type: "sftp", Path: "foo"}, want: "sftp:foo"},
+		{name: "rclone backend", backend: Backend{name: "rclone", Type: "rclone", Path: "foo"}, want: "rclone:foo"},
+	}
+
+	for _, tt := range backendTests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := tt.backend.generateRepo()
+			if err != nil {
+				t.Errorf("unexpected error %v", err)
+			}
+			assertEqual(t, got, tt.want)
+		})
+	}
+}
+
+func TestGetEnv(t *testing.T) {
+	t.Run("env in key field", func(t *testing.T) {
+		b := Backend{
+			name: "",
+			Type: "local",
+			Path: "/foo/bar",
+			Key:  "secret123",
+		}
+		result, err := b.getEnv()
+		if err != nil {
+			t.Errorf("unexpected error %v", err)
+		}
+		assertEqual(t, result["RESTIC_REPOSITORY"], "/foo/bar")
+		assertEqual(t, result["RESTIC_PASSWORD"], "secret123")
+	})
+
+	t.Run("env in config file", func(t *testing.T) {
+		b := Backend{
+			name: "",
+			Type: "local",
+			Path: "/foo/bar",
+			Env: map[string]string{
+				"B2_ACCOUNT_ID":  "foo123",
+				"B2_ACCOUNT_KEY": "foo456",
+			},
+		}
+		result, err := b.getEnv()
+		if err != nil {
+			t.Errorf("unexpected error %v", err)
+		}
+		assertEqual(t, result["RESTIC_REPOSITORY"], "/foo/bar")
+		assertEqual(t, result["RESTIC_PASSWORD"], "")
+		assertEqual(t, result["B2_ACCOUNT_ID"], "foo123")
+		assertEqual(t, result["B2_ACCOUNT_KEY"], "foo456")
+	})
+
+	t.Run("env in Envfile or env vars", func(t *testing.T) {
+		// generate env variables
+		// TODO better way to teardown
+		defer os.Unsetenv("AUTORESTIC_FOO_RESTIC_PASSWORD")
+		defer os.Unsetenv("AUTORESTIC_FOO_B2_ACCOUNT_ID")
+		defer os.Unsetenv("AUTORESTIC_FOO_B2_ACCOUNT_KEY")
+		os.Setenv("AUTORESTIC_FOO_RESTIC_PASSWORD", "secret123")
+		os.Setenv("AUTORESTIC_FOO_B2_ACCOUNT_ID", "foo123")
+		os.Setenv("AUTORESTIC_FOO_B2_ACCOUNT_KEY", "foo456")
+
+		b := Backend{
+			name: "foo",
+			Type: "local",
+			Path: "/foo/bar",
+		}
+		result, err := b.getEnv()
+		if err != nil {
+			t.Errorf("unexpected error %v", err)
+		}
+		assertEqual(t, result["RESTIC_REPOSITORY"], "/foo/bar")
+		assertEqual(t, result["RESTIC_PASSWORD"], "secret123")
+		assertEqual(t, result["B2_ACCOUNT_ID"], "foo123")
+		assertEqual(t, result["B2_ACCOUNT_KEY"], "foo456")
+	})
+}
+
+func TestValidate(t *testing.T) {
+	t.Run("no type given", func(t *testing.T) {
+		b := Backend{
+			name: "foo",
+			Type: "",
+			Path: "/foo/bar",
+		}
+		err := b.validate()
+		if err == nil {
+			t.Error("expected to get error")
+		}
+		assertEqual(t, err.Error(), "Backend \"foo\" has no \"type\"")
+	})
+
+	t.Run("no path given", func(t *testing.T) {
+		b := Backend{
+			name: "foo",
+			Type: "local",
+			Path: "",
+		}
+		err := b.validate()
+		if err == nil {
+			t.Error("expected to get error")
+		}
+		assertEqual(t, err.Error(), "Backend \"foo\" has no \"path\"")
+	})
+}

internal/config.go

@@ -17,7 +17,7 @@ import (
 	"github.com/spf13/viper"
 )
 
-const VERSION = "1.7.1"
+const VERSION = "1.7.5"
 
 type OptionMap map[string][]interface{}
 type Options map[string]OptionMap
@@ -303,7 +303,17 @@ func getOptions(options Options, keys []string) []string {
 	return selected
 }
 
-func combineOptions(key string, l Location, b Backend) []string {
+func combineBackendOptions(key string, b Backend) []string {
+	// Priority: backend > global
+	var options []string
+	gFlags := getOptions(GetConfig().Global, []string{key})
+	bFlags := getOptions(b.Options, []string{"all", key})
+	options = append(options, gFlags...)
+	options = append(options, bFlags...)
+	return options
+}
+
+func combineAllOptions(key string, l Location, b Backend) []string {
 	// Priority: location > backend > global
 	var options []string
 	gFlags := getOptions(GetConfig().Global, []string{key})

internal/config_test.go

@@ -0,0 +1,164 @@
+package internal
+
+import (
+	"reflect"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestOptionToString(t *testing.T) {
+	t.Run("no prefix", func(t *testing.T) {
+		opt := "test"
+		result := optionToString(opt)
+		assertEqual(t, result, "--test")
+	})
+
+	t.Run("single prefix", func(t *testing.T) {
+		opt := "-test"
+		result := optionToString(opt)
+		assertEqual(t, result, "-test")
+	})
+
+	t.Run("double prefix", func(t *testing.T) {
+		opt := "--test"
+		result := optionToString(opt)
+		assertEqual(t, result, "--test")
+	})
+}
+
+func TestAppendOneOptionToSlice(t *testing.T) {
+	t.Run("string flag", func(t *testing.T) {
+		result := []string{}
+		optionMap := OptionMap{"string-flag": []interface{}{"/root"}}
+
+		appendOptionsToSlice(&result, optionMap)
+		expected := []string{
+			"--string-flag", "/root",
+		}
+		assertSliceEqual(t, result, expected)
+	})
+
+	t.Run("bool flag", func(t *testing.T) {
+		result := []string{}
+		optionMap := OptionMap{"boolean-flag": []interface{}{true}}
+
+		appendOptionsToSlice(&result, optionMap)
+		expected := []string{
+			"--boolean-flag",
+		}
+		assertSliceEqual(t, result, expected)
+	})
+
+	t.Run("int flag", func(t *testing.T) {
+		result := []string{}
+		optionMap := OptionMap{"int-flag": []interface{}{123}}
+
+		appendOptionsToSlice(&result, optionMap)
+		expected := []string{
+			"--int-flag", "123",
+		}
+		assertSliceEqual(t, result, expected)
+	})
+}
+
+func TestAppendMultipleOptionsToSlice(t *testing.T) {
+	result := []string{}
+	optionMap := OptionMap{
+		"string-flag": []interface{}{"/root"},
+		"int-flag":    []interface{}{123},
+	}
+
+	appendOptionsToSlice(&result, optionMap)
+	expected := []string{
+		"--string-flag", "/root",
+		"--int-flag", "123",
+	}
+	if len(result) != len(expected) {
+		t.Errorf("got length %d, want length %d", len(result), len(expected))
+	}
+
+	// checks that expected option comes after flag, regardless of key order in map
+	for i, v := range expected {
+		v = strings.TrimPrefix(v, "--")
+
+		if value, ok := optionMap[v]; ok {
+			if val, ok := value[0].(int); ok {
+				if expected[i+1] != strconv.Itoa(val) {
+					t.Errorf("Flags and options order are mismatched. got %v, want %v", result, expected)
+				}
+			}
+		}
+	}
+}
+
+func TestAppendOptionWithMultipleValuesToSlice(t *testing.T) {
+	result := []string{}
+	optionMap := OptionMap{
+		"string-flag": []interface{}{"/root", "/bin"},
+	}
+
+	appendOptionsToSlice(&result, optionMap)
+	expected := []string{
+		"--string-flag", "/root",
+		"--string-flag", "/bin",
+	}
+	assertSliceEqual(t, result, expected)
+}
+
+func TestGetOptionsOneKey(t *testing.T) {
+	optionMap := OptionMap{
+		"string-flag": []interface{}{"/root"},
+	}
+	options := Options{"backend": optionMap}
+	keys := []string{"backend"}
+
+	result := getOptions(options, keys)
+	expected := []string{
+		"--string-flag", "/root",
+	}
+	assertSliceEqual(t, result, expected)
+}
+
+func TestGetOptionsMultipleKeys(t *testing.T) {
+	firstOptionMap := OptionMap{
+		"string-flag": []interface{}{"/root"},
+	}
+	secondOptionMap := OptionMap{
+		"boolean-flag": []interface{}{true},
+		"int-flag":     []interface{}{123},
+	}
+	options := Options{
+		"all":    firstOptionMap,
+		"forget": secondOptionMap,
+	}
+	keys := []string{"all", "forget"}
+
+	result := getOptions(options, keys)
+	expected := []string{
+		"--string-flag", "/root",
+		"--boolean-flag",
+		"--int-flag", "123",
+	}
+	reflect.DeepEqual(result, expected)
+}
+
+func assertEqual[T comparable](t testing.TB, result, expected T) {
+	t.Helper()
+
+	if result != expected {
+		t.Errorf("got %v, want %v", result, expected)
+	}
+}
+
+func assertSliceEqual(t testing.TB, result, expected []string) {
+	t.Helper()
+
+	if len(result) != len(expected) {
+		t.Errorf("got length %d, want length %d", len(result), len(expected))
+	}
+
+	for i := range result {
+		assertEqual(t, result[i], expected[i])
+	}
+}

internal/flags/flags.go

@@ -5,4 +5,5 @@ var (
 	VERBOSE    bool = false
 	CRON_LEAN  bool = false
 	RESTIC_BIN string
+	DOCKER_IMAGE string
 )

internal/location.go

@@ -74,12 +74,8 @@ func (l Location) validate() error {
 			if from, err := GetPathRelativeToConfig(path); err != nil {
 				return err
 			} else {
-				if stat, err := os.Stat(from); err != nil {
+				if _, err := os.Stat(from); err != nil {
 					return err
-				} else {
-					if !stat.IsDir() {
-						return fmt.Errorf("\"%s\" is not valid directory for location \"%s\"", from, l.name)
-					}
 				}
 			}
 		}
@@ -220,7 +216,7 @@ func (l Location) Backup(cron bool, specificBackend string) []error {
 		}
 
 		cmd := []string{"backup"}
-		cmd = append(cmd, combineOptions("backup", l, backend)...)
+		cmd = append(cmd, combineAllOptions("backup", l, backend)...)
 		if cron {
 			cmd = append(cmd, "--tag", buildTag("cron"))
 		}
@@ -312,7 +308,10 @@ after:
 
 	// Forget and optionally prune
 	if isSuccess && l.ForgetOption != "" && l.ForgetOption != LocationForgetNo {
-		l.Forget(l.ForgetOption == LocationForgetPrune, false)
+		err := l.Forget(l.ForgetOption == LocationForgetPrune, false)
+		if err != nil {
+			errors = append(errors, err)
+		}
 	}
 
 	if len(errors) == 0 {
@@ -324,7 +323,12 @@ after:
 func (l Location) Forget(prune bool, dry bool) error {
 	colors.PrimaryPrint("Forgetting for location \"%s\"", l.name)
 
-	for _, to := range l.To {
+	backendsToForget := l.To
+	for _, copyBackends := range l.CopyOption {
+		backendsToForget = append(backendsToForget, copyBackends...)
+	}
+
+	for _, to := range backendsToForget {
 		backend, _ := GetBackend(to)
 		colors.Secondary.Printf("For backend \"%s\"\n", backend.name)
 		env, err := backend.getEnv()
@@ -341,7 +345,7 @@ func (l Location) Forget(prune bool, dry bool) error {
 		if dry {
 			cmd = append(cmd, "--dry-run")
 		}
-		cmd = append(cmd, combineOptions("forget", l, backend)...)
+		cmd = append(cmd, combineAllOptions("forget", l, backend)...)
 		_, _, err = ExecuteResticCommand(options, cmd...)
 		if err != nil {
 			return err

internal/location_test.go

@@ -0,0 +1,93 @@
+package internal
+
+import "testing"
+
+func TestGetType(t *testing.T) {
+
+	t.Run("TypeLocal", func(t *testing.T) {
+		l := Location{
+			Type: "local",
+		}
+		result, err := l.getType()
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+		assertEqual(t, result, TypeLocal)
+	})
+
+	t.Run("TypeVolume", func(t *testing.T) {
+		l := Location{
+			Type: "volume",
+		}
+		result, err := l.getType()
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+		assertEqual(t, result, TypeVolume)
+	})
+
+	t.Run("Empty type", func(t *testing.T) {
+		l := Location{
+			Type: "",
+		}
+		result, err := l.getType()
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+		assertEqual(t, result, TypeLocal)
+	})
+
+	t.Run("Invalid type", func(t *testing.T) {
+		l := Location{
+			Type: "foo",
+		}
+		_, err := l.getType()
+		if err == nil {
+			t.Error("expected error")
+		}
+	})
+}
+
+func TestBuildTag(t *testing.T) {
+	result := buildTag("foo", "bar")
+	expected := "ar:foo:bar"
+	assertEqual(t, result, expected)
+}
+
+func TestGetLocationTags(t *testing.T) {
+	l := Location{
+		name: "foo",
+	}
+	result := l.getLocationTags()
+	expected := "ar:location:foo"
+	assertEqual(t, result, expected)
+}
+
+func TestHasBackend(t *testing.T) {
+	t.Run("backend present", func(t *testing.T) {
+		l := Location{
+			name: "foo",
+			To:   []string{"foo", "bar"},
+		}
+		result := l.hasBackend("foo")
+		assertEqual(t, result, true)
+	})
+
+	t.Run("backend absent", func(t *testing.T) {
+		l := Location{
+			name: "foo",
+			To:   []string{"bar", "baz"},
+		}
+		result := l.hasBackend("foo")
+		assertEqual(t, result, false)
+	})
+}
+
+func TestBuildRestoreCommand(t *testing.T) {
+	l := Location{
+		name: "foo",
+	}
+	result := buildRestoreCommand(l, "to", "snapshot", []string{"options"})
+	expected := []string{"restore", "--target", "to", "--tag", "ar:location:foo", "snapshot", "options"}
+	assertSliceEqual(t, result, expected)
+}

internal/lock/lock.go

@@ -14,6 +14,10 @@ var lock *viper.Viper
 var file string
 var once sync.Once
 
+const (
+	RUNNING = "running"
+)
+
 func getLock() *viper.Viper {
 	if lock == nil {
 
@@ -37,36 +41,38 @@ func getLock() *viper.Viper {
 	return lock
 }
 
-func setLock(locked bool) error {
+func setLockValue(key string, value interface{}) (*viper.Viper, error) {
 	lock := getLock()
-	if locked {
+
-		running := lock.GetBool("running")
+	if key == RUNNING {
-		if running {
+		value := value.(bool)
+		if value && lock.GetBool(key) {
 			colors.Error.Println("an instance is already running. exiting")
 			os.Exit(1)
 		}
 	}
-	lock.Set("running", locked)
+
+	lock.Set(key, value)
 	if err := lock.WriteConfigAs(file); err != nil {
-		return err
+		return nil, err
 	}
-	return nil
+	return lock, nil
 }
 
 func GetCron(location string) int64 {
-	lock := getLock()
+	return getLock().GetInt64("cron." + location)
-	return lock.GetInt64("cron." + location)
 }
 
 func SetCron(location string, value int64) {
-	lock.Set("cron."+location, value)
+	setLockValue("cron."+location, value)
-	lock.WriteConfigAs(file)
 }
 
 func Lock() error {
-	return setLock(true)
+	_, err := setLockValue(RUNNING, true)
+	return err
 }
 
 func Unlock() error {
-	return setLock(false)
+	_, err := setLockValue(RUNNING, false)
+	return err
 }

internal/lock/lock_test.go

@@ -0,0 +1,114 @@
+package lock
+
+import (
+	"log"
+	"os"
+	"os/exec"
+	"strconv"
+	"testing"
+
+	"github.com/spf13/viper"
+)
+
+var testDirectory = "autorestic_test_tmp"
+
+// All tests must share the same lock file as it is only initialized once
+func setup(t *testing.T) {
+	d, err := os.MkdirTemp("", testDirectory)
+	if err != nil {
+		log.Fatalf("error creating temp dir: %v", err)
+		return
+	}
+	// set config file location
+	viper.SetConfigFile(d + "/.autorestic.yml")
+
+	t.Cleanup(func() {
+		os.RemoveAll(d)
+		viper.Reset()
+	})
+}
+
+func TestLock(t *testing.T) {
+	setup(t)
+
+	t.Run("getLock", func(t *testing.T) {
+		result := getLock().GetBool(RUNNING)
+
+		if result {
+			t.Errorf("got %v, want %v", result, false)
+		}
+	})
+
+	t.Run("lock", func(t *testing.T) {
+		lock, err := setLockValue(RUNNING, true)
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+
+		result := lock.GetBool(RUNNING)
+		if !result {
+			t.Errorf("got %v, want %v", result, true)
+		}
+	})
+
+	t.Run("unlock", func(t *testing.T) {
+		lock, err := setLockValue(RUNNING, false)
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+
+		result := lock.GetBool(RUNNING)
+		if result {
+			t.Errorf("got %v, want %v", result, false)
+		}
+	})
+
+	// locking a locked instance exits the instance
+	// this trick to capture os.Exit(1) is discussed here:
+	// https://talks.golang.org/2014/testing.slide#23
+	t.Run("lock twice", func(t *testing.T) {
+		if os.Getenv("CRASH") == "1" {
+			err := Lock()
+			if err != nil {
+				t.Errorf("unexpected error: %v", err)
+			}
+			// should fail
+			Lock()
+		}
+
+		cmd := exec.Command(os.Args[0], "-test.run=TestLock/lock_twice")
+		cmd.Env = append(os.Environ(), "CRASH=1")
+		err := cmd.Run()
+
+		err, ok := err.(*exec.ExitError)
+		if !ok {
+			t.Error("unexpected error")
+		}
+		expected := "exit status 1"
+		if err.Error() != expected {
+			t.Errorf("got %q, want %q", err.Error(), expected)
+		}
+	})
+
+	t.Run("set cron", func(t *testing.T) {
+		expected := int64(5)
+		SetCron("foo", expected)
+
+		result, err := strconv.ParseInt(getLock().GetString("cron.foo"), 10, 64)
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+		if result != expected {
+			t.Errorf("got %d, want %d", result, expected)
+		}
+	})
+
+	t.Run("get cron", func(t *testing.T) {
+		expected := int64(5)
+		result := GetCron("foo")
+
+		if result != expected {
+			t.Errorf("got %d, want %d", result, expected)
+		}
+	})
+}

internal/metadata/extractor_added.go

@@ -14,9 +14,9 @@ func (e addedExtractor) Matches(line string) bool {
 }
 func (e addedExtractor) Extract(metadata *BackupLogMetadata, line string) {
 	// Sample line: "Added to the repo: 0 B"
-	metadata.AddedSize = strings.TrimSpace(e.re.ReplaceAllString(line, ""))
+	metadata.AddedSize = strings.TrimSpace(e.re.ReplaceAllString(line, "$2"))
 }
 
 func NewAddedExtractor() MetadatExtractor {
-	return addedExtractor{regexp.MustCompile(`(?i)^Added to the repo:`)}
+	return addedExtractor{regexp.MustCompile(`(?i)^Added to the repo(sitory)?: ([\d\.]+ \w+)( \([\d\.]+[\w\s]+\))?`)}
 }