Merge pull request #1166 from k8up-io/add-unit-tests-coverage

Add unit tests for restic config validation and API types

Author: Kidswiss

api/v1/backend_string_test.go

@@ -0,0 +1,63 @@
+package v1
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestIsNil(t *testing.T) {
+	assert.True(t, IsNil(nil))
+	assert.True(t, IsNil((*S3Spec)(nil)))
+	assert.True(t, IsNil((*BackupSchedule)(nil)))
+	assert.False(t, IsNil(&S3Spec{}))
+	assert.False(t, IsNil("not nil"))
+	assert.False(t, IsNil(42))
+}
+
+func TestRestServerSpec_String(t *testing.T) {
+	tests := map[string]struct {
+		url      string
+		expected string
+	}{
+		"https URL": {
+			url:      "https://backup.example.com/repo",
+			expected: "rest:https://$(USER):$(PASSWORD)@backup.example.com/repo",
+		},
+		"http URL": {
+			url:      "http://localhost:8000/repo",
+			expected: "rest:http://$(USER):$(PASSWORD)@localhost:8000/repo",
+		},
+		"no protocol": {
+			url:      "backup.example.com",
+			expected: "rest:backup.example.com://$(USER):$(PASSWORD)@",
+		},
+	}
+	for name, tc := range tests {
+		t.Run(name, func(t *testing.T) {
+			spec := &RestServerSpec{URL: tc.url}
+			assert.Equal(t, tc.expected, spec.String())
+		})
+	}
+}
+
+func TestAzureSpec_String(t *testing.T) {
+	t.Run("with path", func(t *testing.T) {
+		spec := &AzureSpec{Container: "mycontainer", Path: "/backups"}
+		assert.Equal(t, "azure:mycontainer:/backups", spec.String())
+	})
+	t.Run("without path defaults to /", func(t *testing.T) {
+		spec := &AzureSpec{Container: "mycontainer"}
+		assert.Equal(t, "azure:mycontainer:/", spec.String())
+	})
+}
+
+func TestSwiftSpec_String(t *testing.T) {
+	spec := &SwiftSpec{Container: "mycontainer", Path: "backups"}
+	assert.Equal(t, "swift:mycontainer:backups", spec.String())
+}
+
+func TestB2Spec_String(t *testing.T) {
+	spec := &B2Spec{Bucket: "mybucket", Path: "backups"}
+	assert.Equal(t, "b2:mybucket:backups", spec.String())
+}

api/v1/schedule_definition_test.go

@@ -0,0 +1,53 @@
+package v1
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestScheduleDefinition_String(t *testing.T) {
+	assert.Equal(t, "*/5 * * * *", ScheduleDefinition("*/5 * * * *").String())
+	assert.Equal(t, "", ScheduleDefinition("").String())
+}
+
+func TestScheduleDefinition_IsNonStandard(t *testing.T) {
+	tests := map[string]struct {
+		input    ScheduleDefinition
+		expected bool
+	}{
+		"standard cron":  {input: "*/5 * * * *", expected: false},
+		"@daily":         {input: "@daily", expected: true},
+		"@weekly-random": {input: "@weekly-random", expected: true},
+		"@hourly-random": {input: "@hourly-random", expected: true},
+		"empty":          {input: "", expected: false},
+		"just @":         {input: "@", expected: true},
+		"no @ prefix":    {input: "daily", expected: false},
+	}
+	for name, tc := range tests {
+		t.Run(name, func(t *testing.T) {
+			assert.Equal(t, tc.expected, tc.input.IsNonStandard())
+		})
+	}
+}
+
+func TestScheduleDefinition_IsRandom(t *testing.T) {
+	tests := map[string]struct {
+		input    ScheduleDefinition
+		expected bool
+	}{
+		"@daily-random":  {input: "@daily-random", expected: true},
+		"@weekly-random": {input: "@weekly-random", expected: true},
+		"@daily":         {input: "@daily", expected: false},
+		"standard cron":  {input: "*/5 * * * *", expected: false},
+		"empty":          {input: "", expected: false},
+		"random no @":    {input: "daily-random", expected: false},
+		"just -random":   {input: "-random", expected: false},
+		"@-random":       {input: "@-random", expected: true},
+	}
+	for name, tc := range tests {
+		t.Run(name, func(t *testing.T) {
+			assert.Equal(t, tc.expected, tc.input.IsRandom())
+		})
+	}
+}

restic/cfg/config_test.go

@@ -0,0 +1,165 @@
+package cfg
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestValidate_NoOperations(t *testing.T) {
+	c := &Configuration{}
+	assert.NoError(t, c.Validate())
+}
+
+func TestValidatePrune_NotEnabled(t *testing.T) {
+	c := &Configuration{DoPrune: false}
+	assert.NoError(t, c.Validate())
+}
+
+func TestValidatePrune_ValidKeepN(t *testing.T) {
+	c := &Configuration{
+		DoPrune:        true,
+		PruneKeepLast:  5,
+		PruneKeepDaily: 14,
+	}
+	assert.NoError(t, c.Validate())
+}
+
+func TestValidatePrune_NegativeKeepN(t *testing.T) {
+	c := &Configuration{
+		DoPrune:       true,
+		PruneKeepLast: -1,
+	}
+	err := c.Validate()
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "keepLast")
+	assert.Contains(t, err.Error(), "must not be negative")
+}
+
+func TestValidatePrune_ValidKeepWithin(t *testing.T) {
+	c := &Configuration{
+		DoPrune:         true,
+		PruneKeepWithin: "24h",
+	}
+	assert.NoError(t, c.Validate())
+}
+
+func TestValidatePrune_InvalidKeepWithinDuration(t *testing.T) {
+	c := &Configuration{
+		DoPrune:         true,
+		PruneKeepWithin: "not-a-duration",
+	}
+	err := c.Validate()
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "not valid")
+}
+
+func TestValidatePrune_NegativeKeepWithinDuration(t *testing.T) {
+	c := &Configuration{
+		DoPrune:         true,
+		PruneKeepWithin: "-1h",
+	}
+	err := c.Validate()
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "must not be negative")
+}
+
+func TestValidatePrune_EmptyKeepWithinSkipped(t *testing.T) {
+	c := &Configuration{
+		DoPrune:         true,
+		PruneKeepWithin: "",
+	}
+	assert.NoError(t, c.Validate())
+}
+
+func TestValidateRestore_NotEnabled(t *testing.T) {
+	c := &Configuration{DoRestore: false}
+	assert.NoError(t, c.Validate())
+}
+
+func TestValidateRestore_S3Valid(t *testing.T) {
+	c := &Configuration{
+		DoRestore:          true,
+		RestoreType:        "s3",
+		RestoreS3Endpoint:  "http://minio:9000",
+		RestoreS3AccessKey: "access",
+		RestoreS3SecretKey: "secret",
+	}
+	assert.NoError(t, c.Validate())
+}
+
+func TestValidateRestore_S3MissingEndpoint(t *testing.T) {
+	c := &Configuration{
+		DoRestore:          true,
+		RestoreType:        "s3",
+		RestoreS3AccessKey: "access",
+		RestoreS3SecretKey: "secret",
+	}
+	err := c.Validate()
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "endpoint")
+}
+
+func TestValidateRestore_S3MissingAccessKey(t *testing.T) {
+	c := &Configuration{
+		DoRestore:          true,
+		RestoreType:        "s3",
+		RestoreS3Endpoint:  "http://minio:9000",
+		RestoreS3SecretKey: "secret",
+	}
+	err := c.Validate()
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "access key")
+}
+
+func TestValidateRestore_S3MissingSecretKey(t *testing.T) {
+	c := &Configuration{
+		DoRestore:          true,
+		RestoreType:        "s3",
+		RestoreS3Endpoint:  "http://minio:9000",
+		RestoreS3AccessKey: "access",
+	}
+	err := c.Validate()
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "secret key")
+}
+
+func TestValidateRestore_FolderValid(t *testing.T) {
+	c := &Configuration{
+		DoRestore:   true,
+		RestoreType: "folder",
+		RestoreDir:  "/restore",
+	}
+	assert.NoError(t, c.Validate())
+}
+
+func TestValidateRestore_FolderMissingDir(t *testing.T) {
+	c := &Configuration{
+		DoRestore:   true,
+		RestoreType: "folder",
+	}
+	err := c.Validate()
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "directory")
+}
+
+func TestValidateRestore_UnknownType(t *testing.T) {
+	c := &Configuration{
+		DoRestore:   true,
+		RestoreType: "unknown",
+	}
+	err := c.Validate()
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "unknown")
+}
+
+func TestValidateRestore_TypeCaseInsensitive(t *testing.T) {
+	c := &Configuration{
+		DoRestore:          true,
+		RestoreType:        "S3",
+		RestoreS3Endpoint:  "http://minio:9000",
+		RestoreS3AccessKey: "access",
+		RestoreS3SecretKey: "secret",
+	}
+	assert.NoError(t, c.Validate())
+}