mirror of
https://github.com/TwiN/gatus.git
synced 2024-11-07 16:44:25 +01:00
450 lines
14 KiB
Go
450 lines
14 KiB
Go
package watchdog
|
|
|
|
import (
|
|
"os"
|
|
"testing"
|
|
|
|
"github.com/TwiN/gatus/v5/alerting"
|
|
"github.com/TwiN/gatus/v5/alerting/alert"
|
|
"github.com/TwiN/gatus/v5/alerting/provider/custom"
|
|
"github.com/TwiN/gatus/v5/alerting/provider/discord"
|
|
"github.com/TwiN/gatus/v5/alerting/provider/email"
|
|
"github.com/TwiN/gatus/v5/alerting/provider/matrix"
|
|
"github.com/TwiN/gatus/v5/alerting/provider/mattermost"
|
|
"github.com/TwiN/gatus/v5/alerting/provider/messagebird"
|
|
"github.com/TwiN/gatus/v5/alerting/provider/pagerduty"
|
|
"github.com/TwiN/gatus/v5/alerting/provider/slack"
|
|
"github.com/TwiN/gatus/v5/alerting/provider/teams"
|
|
"github.com/TwiN/gatus/v5/alerting/provider/telegram"
|
|
"github.com/TwiN/gatus/v5/alerting/provider/twilio"
|
|
"github.com/TwiN/gatus/v5/config"
|
|
"github.com/TwiN/gatus/v5/core"
|
|
)
|
|
|
|
func TestHandleAlerting(t *testing.T) {
|
|
_ = os.Setenv("MOCK_ALERT_PROVIDER", "true")
|
|
defer os.Clearenv()
|
|
|
|
cfg := &config.Config{
|
|
Debug: true,
|
|
Alerting: &alerting.Config{
|
|
Custom: &custom.AlertProvider{
|
|
URL: "https://twin.sh/health",
|
|
Method: "GET",
|
|
},
|
|
},
|
|
}
|
|
enabled := true
|
|
endpoint := &core.Endpoint{
|
|
URL: "https://example.com",
|
|
Alerts: []*alert.Alert{
|
|
{
|
|
Type: alert.TypeCustom,
|
|
Enabled: &enabled,
|
|
FailureThreshold: 2,
|
|
SuccessThreshold: 3,
|
|
SendOnResolved: &enabled,
|
|
Triggered: false,
|
|
},
|
|
},
|
|
}
|
|
|
|
verify(t, endpoint, 0, 0, false, "The alert shouldn't start triggered")
|
|
HandleAlerting(endpoint, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
|
|
verify(t, endpoint, 1, 0, false, "The alert shouldn't have triggered")
|
|
HandleAlerting(endpoint, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
|
|
verify(t, endpoint, 2, 0, true, "The alert should've triggered")
|
|
HandleAlerting(endpoint, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
|
|
verify(t, endpoint, 3, 0, true, "The alert should still be triggered")
|
|
HandleAlerting(endpoint, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
|
|
verify(t, endpoint, 4, 0, true, "The alert should still be triggered")
|
|
HandleAlerting(endpoint, &core.Result{Success: true}, cfg.Alerting, cfg.Debug)
|
|
verify(t, endpoint, 0, 1, true, "The alert should still be triggered (because endpoint.Alerts[0].SuccessThreshold is 3)")
|
|
HandleAlerting(endpoint, &core.Result{Success: true}, cfg.Alerting, cfg.Debug)
|
|
verify(t, endpoint, 0, 2, true, "The alert should still be triggered (because endpoint.Alerts[0].SuccessThreshold is 3)")
|
|
HandleAlerting(endpoint, &core.Result{Success: true}, cfg.Alerting, cfg.Debug)
|
|
verify(t, endpoint, 0, 3, false, "The alert should've been resolved")
|
|
HandleAlerting(endpoint, &core.Result{Success: true}, cfg.Alerting, cfg.Debug)
|
|
verify(t, endpoint, 0, 4, false, "The alert should no longer be triggered")
|
|
}
|
|
|
|
func TestHandleAlertingWhenAlertingConfigIsNil(t *testing.T) {
|
|
_ = os.Setenv("MOCK_ALERT_PROVIDER", "true")
|
|
defer os.Clearenv()
|
|
HandleAlerting(nil, nil, nil, true)
|
|
}
|
|
|
|
func TestHandleAlertingWithBadAlertProvider(t *testing.T) {
|
|
_ = os.Setenv("MOCK_ALERT_PROVIDER", "true")
|
|
defer os.Clearenv()
|
|
|
|
enabled := true
|
|
endpoint := &core.Endpoint{
|
|
URL: "http://example.com",
|
|
Alerts: []*alert.Alert{
|
|
{
|
|
Type: alert.TypeCustom,
|
|
Enabled: &enabled,
|
|
FailureThreshold: 1,
|
|
SuccessThreshold: 1,
|
|
SendOnResolved: &enabled,
|
|
Triggered: false,
|
|
},
|
|
},
|
|
}
|
|
|
|
verify(t, endpoint, 0, 0, false, "The alert shouldn't start triggered")
|
|
HandleAlerting(endpoint, &core.Result{Success: false}, &alerting.Config{}, false)
|
|
verify(t, endpoint, 1, 0, false, "The alert shouldn't have triggered")
|
|
HandleAlerting(endpoint, &core.Result{Success: false}, &alerting.Config{}, false)
|
|
verify(t, endpoint, 2, 0, false, "The alert shouldn't have triggered, because the provider wasn't configured properly")
|
|
}
|
|
|
|
func TestHandleAlertingWhenTriggeredAlertIsAlmostResolvedButendpointStartFailingAgain(t *testing.T) {
|
|
_ = os.Setenv("MOCK_ALERT_PROVIDER", "true")
|
|
defer os.Clearenv()
|
|
|
|
cfg := &config.Config{
|
|
Debug: true,
|
|
Alerting: &alerting.Config{
|
|
Custom: &custom.AlertProvider{
|
|
URL: "https://twin.sh/health",
|
|
Method: "GET",
|
|
},
|
|
},
|
|
}
|
|
enabled := true
|
|
endpoint := &core.Endpoint{
|
|
URL: "https://example.com",
|
|
Alerts: []*alert.Alert{
|
|
{
|
|
Type: alert.TypeCustom,
|
|
Enabled: &enabled,
|
|
FailureThreshold: 2,
|
|
SuccessThreshold: 3,
|
|
SendOnResolved: &enabled,
|
|
Triggered: true,
|
|
},
|
|
},
|
|
NumberOfFailuresInARow: 1,
|
|
}
|
|
|
|
// This test simulate an alert that was already triggered
|
|
HandleAlerting(endpoint, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
|
|
verify(t, endpoint, 2, 0, true, "The alert was already triggered at the beginning of this test")
|
|
}
|
|
|
|
func TestHandleAlertingWhenTriggeredAlertIsResolvedButSendOnResolvedIsFalse(t *testing.T) {
|
|
_ = os.Setenv("MOCK_ALERT_PROVIDER", "true")
|
|
defer os.Clearenv()
|
|
|
|
cfg := &config.Config{
|
|
Debug: true,
|
|
Alerting: &alerting.Config{
|
|
Custom: &custom.AlertProvider{
|
|
URL: "https://twin.sh/health",
|
|
Method: "GET",
|
|
},
|
|
},
|
|
}
|
|
enabled := true
|
|
disabled := false
|
|
endpoint := &core.Endpoint{
|
|
URL: "https://example.com",
|
|
Alerts: []*alert.Alert{
|
|
{
|
|
Type: alert.TypeCustom,
|
|
Enabled: &enabled,
|
|
FailureThreshold: 1,
|
|
SuccessThreshold: 1,
|
|
SendOnResolved: &disabled,
|
|
Triggered: true,
|
|
},
|
|
},
|
|
NumberOfFailuresInARow: 1,
|
|
}
|
|
|
|
HandleAlerting(endpoint, &core.Result{Success: true}, cfg.Alerting, cfg.Debug)
|
|
verify(t, endpoint, 0, 1, false, "The alert should've been resolved")
|
|
}
|
|
|
|
func TestHandleAlertingWhenTriggeredAlertIsResolvedPagerDuty(t *testing.T) {
|
|
_ = os.Setenv("MOCK_ALERT_PROVIDER", "true")
|
|
defer os.Clearenv()
|
|
|
|
cfg := &config.Config{
|
|
Debug: true,
|
|
Alerting: &alerting.Config{
|
|
PagerDuty: &pagerduty.AlertProvider{
|
|
IntegrationKey: "00000000000000000000000000000000",
|
|
},
|
|
},
|
|
}
|
|
enabled := true
|
|
endpoint := &core.Endpoint{
|
|
URL: "https://example.com",
|
|
Alerts: []*alert.Alert{
|
|
{
|
|
Type: alert.TypePagerDuty,
|
|
Enabled: &enabled,
|
|
FailureThreshold: 1,
|
|
SuccessThreshold: 1,
|
|
SendOnResolved: &enabled,
|
|
Triggered: false,
|
|
},
|
|
},
|
|
NumberOfFailuresInARow: 0,
|
|
}
|
|
|
|
HandleAlerting(endpoint, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
|
|
verify(t, endpoint, 1, 0, true, "")
|
|
|
|
HandleAlerting(endpoint, &core.Result{Success: true}, cfg.Alerting, cfg.Debug)
|
|
verify(t, endpoint, 0, 1, false, "The alert should've been resolved")
|
|
}
|
|
|
|
func TestHandleAlertingWithProviderThatReturnsAnError(t *testing.T) {
|
|
_ = os.Setenv("MOCK_ALERT_PROVIDER", "true")
|
|
defer os.Clearenv()
|
|
enabled := true
|
|
scenarios := []struct {
|
|
Name string
|
|
AlertingConfig *alerting.Config
|
|
AlertType alert.Type
|
|
}{
|
|
{
|
|
Name: "custom",
|
|
AlertType: alert.TypeCustom,
|
|
AlertingConfig: &alerting.Config{
|
|
Custom: &custom.AlertProvider{
|
|
URL: "https://twin.sh/health",
|
|
Method: "GET",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "discord",
|
|
AlertType: alert.TypeDiscord,
|
|
AlertingConfig: &alerting.Config{
|
|
Discord: &discord.AlertProvider{
|
|
WebhookURL: "https://example.com",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "email",
|
|
AlertType: alert.TypeEmail,
|
|
AlertingConfig: &alerting.Config{
|
|
Email: &email.AlertProvider{
|
|
From: "from@example.com",
|
|
Password: "hunter2",
|
|
Host: "mail.example.com",
|
|
Port: 587,
|
|
To: "to@example.com",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "mattermost",
|
|
AlertType: alert.TypeMattermost,
|
|
AlertingConfig: &alerting.Config{
|
|
Mattermost: &mattermost.AlertProvider{
|
|
WebhookURL: "https://example.com",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "messagebird",
|
|
AlertType: alert.TypeMessagebird,
|
|
AlertingConfig: &alerting.Config{
|
|
Messagebird: &messagebird.AlertProvider{
|
|
AccessKey: "1",
|
|
Originator: "2",
|
|
Recipients: "3",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "pagerduty",
|
|
AlertType: alert.TypePagerDuty,
|
|
AlertingConfig: &alerting.Config{
|
|
PagerDuty: &pagerduty.AlertProvider{
|
|
IntegrationKey: "00000000000000000000000000000000",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "slack",
|
|
AlertType: alert.TypeSlack,
|
|
AlertingConfig: &alerting.Config{
|
|
Slack: &slack.AlertProvider{
|
|
WebhookURL: "https://example.com",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "teams",
|
|
AlertType: alert.TypeTeams,
|
|
AlertingConfig: &alerting.Config{
|
|
Teams: &teams.AlertProvider{
|
|
WebhookURL: "https://example.com",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "telegram",
|
|
AlertType: alert.TypeTelegram,
|
|
AlertingConfig: &alerting.Config{
|
|
Telegram: &telegram.AlertProvider{
|
|
Token: "1",
|
|
ID: "2",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "twilio",
|
|
AlertType: alert.TypeTwilio,
|
|
AlertingConfig: &alerting.Config{
|
|
Twilio: &twilio.AlertProvider{
|
|
SID: "1",
|
|
Token: "2",
|
|
From: "3",
|
|
To: "4",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Name: "matrix",
|
|
AlertType: alert.TypeMatrix,
|
|
AlertingConfig: &alerting.Config{
|
|
Matrix: &matrix.AlertProvider{
|
|
MatrixProviderConfig: matrix.MatrixProviderConfig{
|
|
ServerURL: "https://example.com",
|
|
AccessToken: "1",
|
|
InternalRoomID: "!a:example.com",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, scenario := range scenarios {
|
|
t.Run(scenario.Name, func(t *testing.T) {
|
|
endpoint := &core.Endpoint{
|
|
URL: "https://example.com",
|
|
Alerts: []*alert.Alert{
|
|
{
|
|
Type: scenario.AlertType,
|
|
Enabled: &enabled,
|
|
FailureThreshold: 2,
|
|
SuccessThreshold: 2,
|
|
SendOnResolved: &enabled,
|
|
Triggered: false,
|
|
},
|
|
},
|
|
}
|
|
_ = os.Setenv("MOCK_ALERT_PROVIDER_ERROR", "true")
|
|
HandleAlerting(endpoint, &core.Result{Success: false}, scenario.AlertingConfig, true)
|
|
verify(t, endpoint, 1, 0, false, "")
|
|
HandleAlerting(endpoint, &core.Result{Success: false}, scenario.AlertingConfig, true)
|
|
verify(t, endpoint, 2, 0, false, "The alert should have failed to trigger, because the alert provider is returning an error")
|
|
HandleAlerting(endpoint, &core.Result{Success: false}, scenario.AlertingConfig, true)
|
|
verify(t, endpoint, 3, 0, false, "The alert should still not be triggered, because the alert provider is still returning an error")
|
|
HandleAlerting(endpoint, &core.Result{Success: false}, scenario.AlertingConfig, true)
|
|
verify(t, endpoint, 4, 0, false, "The alert should still not be triggered, because the alert provider is still returning an error")
|
|
_ = os.Setenv("MOCK_ALERT_PROVIDER_ERROR", "false")
|
|
HandleAlerting(endpoint, &core.Result{Success: false}, scenario.AlertingConfig, true)
|
|
verify(t, endpoint, 5, 0, true, "The alert should've been triggered because the alert provider is no longer returning an error")
|
|
HandleAlerting(endpoint, &core.Result{Success: true}, scenario.AlertingConfig, true)
|
|
verify(t, endpoint, 0, 1, true, "The alert should've still been triggered")
|
|
_ = os.Setenv("MOCK_ALERT_PROVIDER_ERROR", "true")
|
|
HandleAlerting(endpoint, &core.Result{Success: true}, scenario.AlertingConfig, true)
|
|
verify(t, endpoint, 0, 2, false, "The alert should've been resolved DESPITE THE ALERT PROVIDER RETURNING AN ERROR. See Alert.Triggered for further explanation.")
|
|
_ = os.Setenv("MOCK_ALERT_PROVIDER_ERROR", "false")
|
|
|
|
// Make sure that everything's working as expected after a rough patch
|
|
HandleAlerting(endpoint, &core.Result{Success: false}, scenario.AlertingConfig, true)
|
|
verify(t, endpoint, 1, 0, false, "")
|
|
HandleAlerting(endpoint, &core.Result{Success: false}, scenario.AlertingConfig, true)
|
|
verify(t, endpoint, 2, 0, true, "The alert should have triggered")
|
|
HandleAlerting(endpoint, &core.Result{Success: true}, scenario.AlertingConfig, true)
|
|
verify(t, endpoint, 0, 1, true, "The alert should still be triggered")
|
|
HandleAlerting(endpoint, &core.Result{Success: true}, scenario.AlertingConfig, true)
|
|
verify(t, endpoint, 0, 2, false, "The alert should have been resolved")
|
|
})
|
|
}
|
|
|
|
}
|
|
|
|
func TestHandleAlertingWithProviderThatOnlyReturnsErrorOnResolve(t *testing.T) {
|
|
_ = os.Setenv("MOCK_ALERT_PROVIDER", "true")
|
|
defer os.Clearenv()
|
|
|
|
cfg := &config.Config{
|
|
Debug: true,
|
|
Alerting: &alerting.Config{
|
|
Custom: &custom.AlertProvider{
|
|
URL: "https://twin.sh/health",
|
|
Method: "GET",
|
|
},
|
|
},
|
|
}
|
|
enabled := true
|
|
endpoint := &core.Endpoint{
|
|
URL: "https://example.com",
|
|
Alerts: []*alert.Alert{
|
|
{
|
|
Type: alert.TypeCustom,
|
|
Enabled: &enabled,
|
|
FailureThreshold: 1,
|
|
SuccessThreshold: 1,
|
|
SendOnResolved: &enabled,
|
|
Triggered: false,
|
|
},
|
|
},
|
|
}
|
|
|
|
HandleAlerting(endpoint, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
|
|
verify(t, endpoint, 1, 0, true, "")
|
|
_ = os.Setenv("MOCK_ALERT_PROVIDER_ERROR", "true")
|
|
HandleAlerting(endpoint, &core.Result{Success: true}, cfg.Alerting, cfg.Debug)
|
|
verify(t, endpoint, 0, 1, false, "")
|
|
_ = os.Setenv("MOCK_ALERT_PROVIDER_ERROR", "false")
|
|
HandleAlerting(endpoint, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
|
|
verify(t, endpoint, 1, 0, true, "")
|
|
_ = os.Setenv("MOCK_ALERT_PROVIDER_ERROR", "true")
|
|
HandleAlerting(endpoint, &core.Result{Success: true}, cfg.Alerting, cfg.Debug)
|
|
verify(t, endpoint, 0, 1, false, "")
|
|
_ = os.Setenv("MOCK_ALERT_PROVIDER_ERROR", "false")
|
|
|
|
// Make sure that everything's working as expected after a rough patch
|
|
HandleAlerting(endpoint, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
|
|
verify(t, endpoint, 1, 0, true, "")
|
|
HandleAlerting(endpoint, &core.Result{Success: false}, cfg.Alerting, cfg.Debug)
|
|
verify(t, endpoint, 2, 0, true, "")
|
|
HandleAlerting(endpoint, &core.Result{Success: true}, cfg.Alerting, cfg.Debug)
|
|
verify(t, endpoint, 0, 1, false, "")
|
|
HandleAlerting(endpoint, &core.Result{Success: true}, cfg.Alerting, cfg.Debug)
|
|
verify(t, endpoint, 0, 2, false, "")
|
|
}
|
|
|
|
func verify(t *testing.T, endpoint *core.Endpoint, expectedNumberOfFailuresInARow, expectedNumberOfSuccessInARow int, expectedTriggered bool, expectedTriggeredReason string) {
|
|
if endpoint.NumberOfFailuresInARow != expectedNumberOfFailuresInARow {
|
|
t.Errorf("endpoint.NumberOfFailuresInARow should've been %d, got %d", expectedNumberOfFailuresInARow, endpoint.NumberOfFailuresInARow)
|
|
}
|
|
if endpoint.NumberOfSuccessesInARow != expectedNumberOfSuccessInARow {
|
|
t.Errorf("endpoint.NumberOfSuccessesInARow should've been %d, got %d", expectedNumberOfSuccessInARow, endpoint.NumberOfSuccessesInARow)
|
|
}
|
|
if endpoint.Alerts[0].Triggered != expectedTriggered {
|
|
if len(expectedTriggeredReason) != 0 {
|
|
t.Error(expectedTriggeredReason)
|
|
} else {
|
|
if expectedTriggered {
|
|
t.Error("The alert should've been triggered")
|
|
} else {
|
|
t.Error("The alert shouldn't have been triggered")
|
|
}
|
|
}
|
|
}
|
|
}
|