Updated for go 1.16 modules1.2

4 files changed, 150 insertions, 0 deletions

diff --git a/pkg/job/job.go b/pkg/job/job.go
new file mode 100644
index 0000000..4241844
--- /dev/null
+++ b/pkg/job/job.go
@@ -0,0 +1,14 @@
+package job
+
+import "fmt"
+
+// Job is a bareos job
+type Job struct {
+	Name      string
+	Timestamp uint64
+	Success   bool
+}
+
+func (job Job) String() string {
+	return fmt.Sprintf("Job { Name: \"%s\", Timestamp: \"%d\", Success: \"%t\" }", job.Name, job.Timestamp, job.Success)
+}
diff --git a/pkg/job/job_test.go b/pkg/job/job_test.go
new file mode 100644
index 0000000..cb50e31
--- /dev/null
+++ b/pkg/job/job_test.go
@@ -0,0 +1,33 @@
+package job
+
+import (
+	"testing"
+)
+
+func TestJob_String(t *testing.T) {
+	type fields struct {
+		Name      string
+		Timestamp uint64
+		Success   bool
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   string
+	}{
+		{"default job", fields{}, "Job { Name: \"\", Timestamp: \"0\", Success: \"false\" }"},
+		{"a job", fields{Name: "a", Timestamp: 10, Success: true}, "Job { Name: \"a\", Timestamp: \"10\", Success: \"true\" }"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			job := Job{
+				Name:      tt.fields.Name,
+				Timestamp: tt.fields.Timestamp,
+				Success:   tt.fields.Success,
+			}
+			if got := job.String(); got != tt.want {
+				t.Errorf("Job.String() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
diff --git a/pkg/job/utils.go b/pkg/job/utils.go
new file mode 100644
index 0000000..6537474
--- /dev/null
+++ b/pkg/job/utils.go
@@ -0,0 +1,35 @@
+package job
+
+// KeepOldestOnly filters a job list and keeps only the most recent entry for a job name
+func KeepOldestOnly(jobs []Job) (results []Job) {
+outerLoop:
+	for i := 0; i < len(jobs); i++ {
+		job := jobs[i]
+		for j := 0; j < len(results); j++ {
+			result := results[j]
+			if result.Name == job.Name {
+				continue outerLoop
+			}
+		}
+		for j := i + 1; j < len(jobs); j++ {
+			sec := jobs[j]
+			if sec.Name == job.Name && sec.Timestamp > job.Timestamp {
+				job = sec
+			}
+		}
+		results = append(results, job)
+	}
+	return
+}
+
+// KeepSuccessOnly returns only the successful jobs from a job list (suiatble to write a new spool file)
+func KeepSuccessOnly(jobs []Job) (result []Job) {
+	result = make([]Job, 0)
+	for i := 0; i < len(jobs); i++ {
+		job := jobs[i]
+		if job.Success {
+			result = append(result, job)
+		}
+	}
+	return
+}
diff --git a/pkg/job/utils_test.go b/pkg/job/utils_test.go
new file mode 100644
index 0000000..250ae2c
--- /dev/null
+++ b/pkg/job/utils_test.go
@@ -0,0 +1,68 @@
+package job
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestKeepOldestOnly(t *testing.T) {
+	emptyList := []Job{}
+	oneJob := []Job{{Name: "a", Timestamp: 10, Success: true}}
+	twoJobs := []Job{
+		{Name: "a", Timestamp: 5, Success: true},
+		{Name: "a", Timestamp: 10, Success: true},
+	}
+	threeJobs := []Job{
+		{Name: "a", Timestamp: 5, Success: true},
+		{Name: "a", Timestamp: 10, Success: true},
+		{Name: "a", Timestamp: 8, Success: false},
+	}
+	type args struct {
+		jobs []Job
+	}
+	tests := []struct {
+		name string
+		args args
+		want []Job
+	}{
+		{"empty list", args{emptyList}, nil},
+		{"one job", args{oneJob}, oneJob},
+		{"two jobs", args{twoJobs}, oneJob},
+		{"three jobs", args{threeJobs}, oneJob},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := KeepOldestOnly(tt.args.jobs); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("KeepOldestOnly() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestKeepSuccessOnly(t *testing.T) {
+	emptyList := []Job{}
+	oneJob := []Job{{Name: "a", Timestamp: 10, Success: true}}
+	twoJobs := []Job{
+		{Name: "a", Timestamp: 10, Success: true},
+		{Name: "a", Timestamp: 5, Success: false},
+	}
+	type args struct {
+		jobs []Job
+	}
+	tests := []struct {
+		name       string
+		args       args
+		wantResult []Job
+	}{
+		{"empty list", args{emptyList}, emptyList},
+		{"one job", args{oneJob}, oneJob},
+		{"two jobs", args{twoJobs}, oneJob},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if gotResult := KeepSuccessOnly(tt.args.jobs); !reflect.DeepEqual(gotResult, tt.wantResult) {
+				t.Errorf("KeepSuccessOnly() = %v, want %v", gotResult, tt.wantResult)
+			}
+		})
+	}
+}