restic-scheduler/scheduler_test.go at main · IamTheFij/restic-scheduler · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
package main_test

import (
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"testing"

	main "git.iamthefij.com/iamthefij/restic-scheduler"
	"github.com/stretchr/testify/assert"
)

func TestJobResultFormat(t *testing.T) {
	t.Parallel()

	result := main.JobResult{
		JobName:   "TestJob",
		JobType:   "backup",
		Success:   true,
		LastError: nil,
		Message:   "",
	}

	formatted := result.Format()
	assert.Contains(t, formatted, "TestJob")
	assert.Contains(t, formatted, "backup")
	assert.Contains(t, formatted, "true")
}

func TestJobComplete(t *testing.T) {
	t.Parallel()

	// Create a test job result
	result := main.JobResult{
		JobName:   "TestCompleteJob",
		JobType:   "backup",
		Success:   true,
		LastError: nil,
		Message:   "",
	}

	// Since JobComplete modifies global state, it's hard to test directly
	// This is more of a smoke test to ensure it doesn't panic

	// Call JobComplete
	main.JobComplete(result)
}

func TestHealthHandleFunc(t *testing.T) {
	t.Parallel()

	// Test general health endpoint
	req, err := http.NewRequest("GET", "/health", nil)
	if err != nil {
		t.Fatal(err)
	}

	rr := httptest.NewRecorder()
	handler := http.HandlerFunc(main.HealthHandleFunc)
	handler.ServeHTTP(rr, req)

	assert.Equal(t, http.StatusOK, rr.Code)
	assert.Equal(t, "ok", rr.Body.String())

	// Test job-specific health endpoint
	// First register a job result
	result := main.JobResult{
		JobName:   "TestHealthJob",
		JobType:   "backup",
		Success:   true,
		LastError: nil,
		Message:   "Test job successful",
	}
	main.JobComplete(result)

	// Now query that job
	req, err = http.NewRequest("GET", "/health?job=TestHealthJob", nil)
	if err != nil {
		t.Fatal(err)
	}

	rr = httptest.NewRecorder()
	handler.ServeHTTP(rr, req)

	assert.Equal(t, http.StatusOK, rr.Code)

	// Decode the response
	var responseResult main.JobResult

	err = json.Unmarshal(rr.Body.Bytes(), &responseResult)
	if err != nil {
		t.Fatal(err)
	}

	assert.Equal(t, "TestHealthJob", responseResult.JobName)
	assert.Equal(t, "backup", responseResult.JobType)
	assert.True(t, responseResult.Success)
}

func TestHealthHandleFuncUnknownJob(t *testing.T) {
	t.Parallel()

	req, err := http.NewRequest("GET", "/health?job=NonExistentJob", nil)
	if err != nil {
		t.Fatal(err)
	}

	rr := httptest.NewRecorder()
	handler := http.HandlerFunc(main.HealthHandleFunc)
	handler.ServeHTTP(rr, req)

	assert.Equal(t, http.StatusNotFound, rr.Code)
	assert.Contains(t, rr.Body.String(), "Unknown job")
}

func TestHealthHandleFuncFailedJob(t *testing.T) {
	t.Parallel()

	// Register a failed job result
	result := main.JobResult{
		JobName:   "TestFailedJob",
		JobType:   "backup",
		Success:   false,
		LastError: nil,
		Message:   "Job failed with error",
	}
	main.JobComplete(result)

	// Query the failed job
	req, err := http.NewRequest("GET", "/health?job=TestFailedJob", nil)
	if err != nil {
		t.Fatal(err)
	}

	rr := httptest.NewRecorder()
	handler := http.HandlerFunc(main.HealthHandleFunc)
	handler.ServeHTTP(rr, req)

	assert.Equal(t, http.StatusServiceUnavailable, rr.Code)

	// Decode the response
	var responseResult main.JobResult

	err = json.Unmarshal(rr.Body.Bytes(), &responseResult)
	if err != nil {
		t.Fatal(err)
	}

	assert.Equal(t, "TestFailedJob", responseResult.JobName)
	assert.False(t, responseResult.Success)
	assert.NotEmpty(t, responseResult.Message)
}