e6c4e46dd8
- Removed redundant `gin.SetMode(gin.TestMode)` calls from individual test files. - Introduced a centralized `TestMain` function in `testmain_test.go` to set the Gin mode for all tests. - Ensured consistent test environment setup across various handler test files.
1055 lines
32 KiB
Go
1055 lines
32 KiB
Go
package handlers
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"gorm.io/gorm"
|
|
|
|
"github.com/Wikid82/charon/backend/internal/models"
|
|
"github.com/Wikid82/charon/backend/internal/services"
|
|
"github.com/Wikid82/charon/backend/internal/trace"
|
|
)
|
|
|
|
func setupNotificationCoverageDB(t *testing.T) *gorm.DB {
|
|
t.Helper()
|
|
db := OpenTestDB(t)
|
|
_ = db.AutoMigrate(&models.Notification{}, &models.NotificationProvider{}, &models.NotificationTemplate{})
|
|
return db
|
|
}
|
|
|
|
func setAdminContext(c *gin.Context) {
|
|
c.Set("role", "admin")
|
|
c.Set("userID", uint(1))
|
|
}
|
|
|
|
// Notification Handler Tests
|
|
|
|
func TestNotificationHandler_List_Error(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationHandler(svc)
|
|
|
|
// Drop the table to cause error
|
|
_ = db.Migrator().DropTable(&models.Notification{})
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
setAdminContext(c)
|
|
setAdminContext(c)
|
|
c.Request = httptest.NewRequest("GET", "/notifications", http.NoBody)
|
|
|
|
h.List(c)
|
|
|
|
assert.Equal(t, 500, w.Code)
|
|
assert.Contains(t, w.Body.String(), "Failed to list notifications")
|
|
}
|
|
|
|
func TestNotificationHandler_List_UnreadOnly(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationHandler(svc)
|
|
|
|
// Create some notifications
|
|
_, _ = svc.Create(models.NotificationTypeInfo, "Test 1", "Message 1")
|
|
_, _ = svc.Create(models.NotificationTypeInfo, "Test 2", "Message 2")
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Request = httptest.NewRequest("GET", "/notifications?unread=true", http.NoBody)
|
|
|
|
h.List(c)
|
|
|
|
assert.Equal(t, 200, w.Code)
|
|
}
|
|
|
|
func TestNotificationHandler_MarkAsRead_Error(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationHandler(svc)
|
|
|
|
// Drop table to cause error
|
|
_ = db.Migrator().DropTable(&models.Notification{})
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Params = gin.Params{{Key: "id", Value: "test-id"}}
|
|
|
|
h.MarkAsRead(c)
|
|
|
|
assert.Equal(t, 500, w.Code)
|
|
assert.Contains(t, w.Body.String(), "Failed to mark notification as read")
|
|
}
|
|
|
|
func TestNotificationHandler_MarkAllAsRead_Error(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationHandler(svc)
|
|
|
|
// Drop table to cause error
|
|
_ = db.Migrator().DropTable(&models.Notification{})
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
|
|
h.MarkAllAsRead(c)
|
|
|
|
assert.Equal(t, 500, w.Code)
|
|
assert.Contains(t, w.Body.String(), "Failed to mark all notifications as read")
|
|
}
|
|
|
|
// Notification Provider Handler Tests
|
|
|
|
func TestNotificationProviderHandler_List_Error(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationProviderHandler(svc)
|
|
|
|
// Drop table to cause error
|
|
_ = db.Migrator().DropTable(&models.NotificationProvider{})
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
|
|
h.List(c)
|
|
|
|
assert.Equal(t, 500, w.Code)
|
|
assert.Contains(t, w.Body.String(), "Failed to list providers")
|
|
}
|
|
|
|
func TestNotificationProviderHandler_Create_InvalidJSON(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationProviderHandler(svc)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Request = httptest.NewRequest("POST", "/providers", bytes.NewBufferString("invalid json"))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Create(c)
|
|
|
|
assert.Equal(t, 400, w.Code)
|
|
}
|
|
|
|
func TestNotificationProviderHandler_Create_DBError(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationProviderHandler(svc)
|
|
|
|
// Drop table to cause error
|
|
_ = db.Migrator().DropTable(&models.NotificationProvider{})
|
|
|
|
provider := models.NotificationProvider{
|
|
Name: "Test",
|
|
Type: "discord",
|
|
URL: "https://discord.com/api/webhooks/123/abc",
|
|
Template: "minimal",
|
|
}
|
|
body, _ := json.Marshal(provider)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Request = httptest.NewRequest("POST", "/providers", bytes.NewBuffer(body))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Create(c)
|
|
|
|
assert.Equal(t, 500, w.Code)
|
|
}
|
|
|
|
func TestNotificationProviderHandler_Create_InvalidTemplate(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationProviderHandler(svc)
|
|
|
|
provider := models.NotificationProvider{
|
|
Name: "Test",
|
|
Type: "discord",
|
|
URL: "https://discord.com/api/webhooks/123/abc",
|
|
Template: "custom",
|
|
Config: "{{.Invalid", // Invalid template syntax
|
|
}
|
|
body, _ := json.Marshal(provider)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Request = httptest.NewRequest("POST", "/providers", bytes.NewBuffer(body))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Create(c)
|
|
|
|
assert.Equal(t, 400, w.Code)
|
|
}
|
|
|
|
func TestNotificationProviderHandler_Update_InvalidJSON(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationProviderHandler(svc)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Params = gin.Params{{Key: "id", Value: "test-id"}}
|
|
c.Request = httptest.NewRequest("PUT", "/providers/test-id", bytes.NewBufferString("invalid"))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Update(c)
|
|
|
|
assert.Equal(t, 400, w.Code)
|
|
}
|
|
|
|
func TestNotificationProviderHandler_Update_InvalidTemplate(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationProviderHandler(svc)
|
|
|
|
// Create a provider first
|
|
provider := models.NotificationProvider{
|
|
Name: "Test",
|
|
Type: "discord",
|
|
URL: "https://discord.com/api/webhooks/123/abc",
|
|
Template: "minimal",
|
|
}
|
|
require.NoError(t, svc.CreateProvider(&provider))
|
|
|
|
// Update with invalid template
|
|
provider.Template = "custom"
|
|
provider.Config = "{{.Invalid" // Invalid
|
|
body, _ := json.Marshal(provider)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Params = gin.Params{{Key: "id", Value: provider.ID}}
|
|
c.Request = httptest.NewRequest("PUT", "/providers/"+provider.ID, bytes.NewBuffer(body))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Update(c)
|
|
|
|
assert.Equal(t, 400, w.Code)
|
|
}
|
|
|
|
func TestNotificationProviderHandler_Update_DBError(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationProviderHandler(svc)
|
|
|
|
// Drop table to cause error
|
|
_ = db.Migrator().DropTable(&models.NotificationProvider{})
|
|
|
|
provider := models.NotificationProvider{
|
|
Name: "Test",
|
|
Type: "discord",
|
|
URL: "https://discord.com/api/webhooks/123/abc",
|
|
Template: "minimal",
|
|
}
|
|
body, _ := json.Marshal(provider)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Params = gin.Params{{Key: "id", Value: "test-id"}}
|
|
c.Request = httptest.NewRequest("PUT", "/providers/test-id", bytes.NewBuffer(body))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Update(c)
|
|
|
|
assert.Equal(t, 500, w.Code)
|
|
}
|
|
|
|
func TestNotificationProviderHandler_Delete_Error(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationProviderHandler(svc)
|
|
|
|
// Drop table to cause error
|
|
_ = db.Migrator().DropTable(&models.NotificationProvider{})
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Params = gin.Params{{Key: "id", Value: "test-id"}}
|
|
|
|
h.Delete(c)
|
|
|
|
assert.Equal(t, 500, w.Code)
|
|
assert.Contains(t, w.Body.String(), "Failed to delete provider")
|
|
}
|
|
|
|
func TestNotificationProviderHandler_Test_InvalidJSON(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationProviderHandler(svc)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Request = httptest.NewRequest("POST", "/providers/test", bytes.NewBufferString("invalid"))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Test(c)
|
|
|
|
assert.Equal(t, 400, w.Code)
|
|
}
|
|
|
|
func TestNotificationProviderHandler_Test_RejectsClientSuppliedGotifyToken(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationProviderHandler(svc)
|
|
|
|
payload := map[string]any{
|
|
"type": "gotify",
|
|
"url": "https://gotify.example/message",
|
|
"token": "super-secret-client-token",
|
|
}
|
|
body, _ := json.Marshal(payload)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Set(string(trace.RequestIDKey), "req-token-reject-1")
|
|
c.Request = httptest.NewRequest(http.MethodPost, "/providers/test", bytes.NewBuffer(body))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Test(c)
|
|
|
|
assert.Equal(t, http.StatusBadRequest, w.Code)
|
|
var resp map[string]any
|
|
require.NoError(t, json.Unmarshal(w.Body.Bytes(), &resp))
|
|
assert.Equal(t, "TOKEN_WRITE_ONLY", resp["code"])
|
|
assert.Equal(t, "validation", resp["category"])
|
|
assert.Equal(t, "Gotify token is accepted only on provider create/update", resp["error"])
|
|
assert.Equal(t, "req-token-reject-1", resp["request_id"])
|
|
assert.NotContains(t, w.Body.String(), "super-secret-client-token")
|
|
}
|
|
|
|
func TestNotificationProviderHandler_Test_RejectsGotifyTokenWithWhitespace(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationProviderHandler(svc)
|
|
|
|
payload := map[string]any{
|
|
"type": "gotify",
|
|
"token": " secret-with-space ",
|
|
}
|
|
body, _ := json.Marshal(payload)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Request = httptest.NewRequest(http.MethodPost, "/providers/test", bytes.NewBuffer(body))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Test(c)
|
|
|
|
assert.Equal(t, http.StatusBadRequest, w.Code)
|
|
assert.Contains(t, w.Body.String(), "TOKEN_WRITE_ONLY")
|
|
assert.NotContains(t, w.Body.String(), "secret-with-space")
|
|
}
|
|
|
|
func TestClassifyProviderTestFailure_NilError(t *testing.T) {
|
|
code, category, message := classifyProviderTestFailure(nil)
|
|
|
|
assert.Equal(t, "PROVIDER_TEST_FAILED", code)
|
|
assert.Equal(t, "dispatch", category)
|
|
assert.Equal(t, "Provider test failed", message)
|
|
}
|
|
|
|
func TestClassifyProviderTestFailure_DefaultStatusCode(t *testing.T) {
|
|
code, category, message := classifyProviderTestFailure(errors.New("provider returned status 500"))
|
|
|
|
assert.Equal(t, "PROVIDER_TEST_REMOTE_REJECTED", code)
|
|
assert.Equal(t, "dispatch", category)
|
|
assert.Contains(t, message, "HTTP 500")
|
|
}
|
|
|
|
func TestClassifyProviderTestFailure_GenericError(t *testing.T) {
|
|
code, category, message := classifyProviderTestFailure(errors.New("something completely unexpected"))
|
|
|
|
assert.Equal(t, "PROVIDER_TEST_FAILED", code)
|
|
assert.Equal(t, "dispatch", category)
|
|
assert.Equal(t, "Provider test failed", message)
|
|
}
|
|
|
|
func TestClassifyProviderTestFailure_InvalidDiscordWebhookURL(t *testing.T) {
|
|
code, category, message := classifyProviderTestFailure(errors.New("invalid discord webhook url"))
|
|
|
|
assert.Equal(t, "PROVIDER_TEST_URL_INVALID", code)
|
|
assert.Equal(t, "validation", category)
|
|
assert.Contains(t, message, "Provider URL")
|
|
}
|
|
|
|
func TestClassifyProviderTestFailure_URLValidation(t *testing.T) {
|
|
code, category, message := classifyProviderTestFailure(errors.New("destination URL validation failed"))
|
|
|
|
assert.Equal(t, "PROVIDER_TEST_URL_INVALID", code)
|
|
assert.Equal(t, "validation", category)
|
|
assert.Contains(t, message, "Provider URL")
|
|
}
|
|
|
|
func TestClassifyProviderTestFailure_AuthRejected(t *testing.T) {
|
|
code, category, message := classifyProviderTestFailure(errors.New("failed to send webhook: provider returned status 401"))
|
|
|
|
assert.Equal(t, "PROVIDER_TEST_AUTH_REJECTED", code)
|
|
assert.Equal(t, "dispatch", category)
|
|
assert.Contains(t, message, "rejected authentication")
|
|
}
|
|
|
|
func TestClassifyProviderTestFailure_EndpointNotFound(t *testing.T) {
|
|
code, category, message := classifyProviderTestFailure(errors.New("failed to send webhook: provider returned status 404"))
|
|
|
|
assert.Equal(t, "PROVIDER_TEST_ENDPOINT_NOT_FOUND", code)
|
|
assert.Equal(t, "dispatch", category)
|
|
assert.Contains(t, message, "endpoint was not found")
|
|
}
|
|
|
|
func TestClassifyProviderTestFailure_UnreachableEndpoint(t *testing.T) {
|
|
code, category, message := classifyProviderTestFailure(errors.New("failed to send webhook: outbound request failed"))
|
|
|
|
assert.Equal(t, "PROVIDER_TEST_UNREACHABLE", code)
|
|
assert.Equal(t, "dispatch", category)
|
|
assert.Contains(t, message, "Could not reach provider endpoint")
|
|
}
|
|
|
|
func TestClassifyProviderTestFailure_DNSLookupFailed(t *testing.T) {
|
|
code, category, message := classifyProviderTestFailure(errors.New("failed to send webhook: outbound request failed: dns lookup failed"))
|
|
|
|
assert.Equal(t, "PROVIDER_TEST_DNS_FAILED", code)
|
|
assert.Equal(t, "dispatch", category)
|
|
assert.Contains(t, message, "DNS lookup failed")
|
|
}
|
|
|
|
func TestClassifyProviderTestFailure_ConnectionRefused(t *testing.T) {
|
|
code, category, message := classifyProviderTestFailure(errors.New("failed to send webhook: outbound request failed: connection refused"))
|
|
|
|
assert.Equal(t, "PROVIDER_TEST_CONNECTION_REFUSED", code)
|
|
assert.Equal(t, "dispatch", category)
|
|
assert.Contains(t, message, "refused the connection")
|
|
}
|
|
|
|
func TestClassifyProviderTestFailure_Timeout(t *testing.T) {
|
|
code, category, message := classifyProviderTestFailure(errors.New("failed to send webhook: outbound request failed: request timed out"))
|
|
|
|
assert.Equal(t, "PROVIDER_TEST_TIMEOUT", code)
|
|
assert.Equal(t, "dispatch", category)
|
|
assert.Contains(t, message, "timed out")
|
|
}
|
|
|
|
func TestClassifyProviderTestFailure_TLSHandshakeFailed(t *testing.T) {
|
|
code, category, message := classifyProviderTestFailure(errors.New("failed to send webhook: outbound request failed: tls handshake failed"))
|
|
|
|
assert.Equal(t, "PROVIDER_TEST_TLS_FAILED", code)
|
|
assert.Equal(t, "dispatch", category)
|
|
assert.Contains(t, message, "TLS handshake failed")
|
|
}
|
|
|
|
func TestClassifyProviderTestFailure_SlackInvalidPayload(t *testing.T) {
|
|
code, category, message := classifyProviderTestFailure(errors.New("invalid_payload"))
|
|
|
|
assert.Equal(t, "PROVIDER_TEST_VALIDATION_FAILED", code)
|
|
assert.Equal(t, "validation", category)
|
|
assert.Contains(t, message, "Slack rejected the payload")
|
|
}
|
|
|
|
func TestClassifyProviderTestFailure_SlackMissingTextOrFallback(t *testing.T) {
|
|
code, category, message := classifyProviderTestFailure(errors.New("missing_text_or_fallback"))
|
|
|
|
assert.Equal(t, "PROVIDER_TEST_VALIDATION_FAILED", code)
|
|
assert.Equal(t, "validation", category)
|
|
assert.Contains(t, message, "Slack rejected the payload")
|
|
}
|
|
|
|
func TestClassifyProviderTestFailure_SlackNoService(t *testing.T) {
|
|
code, category, message := classifyProviderTestFailure(errors.New("no_service"))
|
|
|
|
assert.Equal(t, "PROVIDER_TEST_AUTH_REJECTED", code)
|
|
assert.Equal(t, "dispatch", category)
|
|
assert.Contains(t, message, "Slack webhook is revoked")
|
|
}
|
|
|
|
func TestNotificationProviderHandler_Test_RejectsSlackTokenInTestRequest(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationProviderHandler(svc)
|
|
|
|
payload := map[string]any{
|
|
"type": "slack",
|
|
"url": "#alerts",
|
|
"token": "https://hooks.slack.com/services/T00/B00/secret",
|
|
}
|
|
body, _ := json.Marshal(payload)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Set(string(trace.RequestIDKey), "req-slack-token-reject")
|
|
c.Request = httptest.NewRequest(http.MethodPost, "/providers/test", bytes.NewBuffer(body))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Test(c)
|
|
|
|
assert.Equal(t, http.StatusBadRequest, w.Code)
|
|
var resp map[string]any
|
|
require.NoError(t, json.Unmarshal(w.Body.Bytes(), &resp))
|
|
assert.Equal(t, "TOKEN_WRITE_ONLY", resp["code"])
|
|
assert.Equal(t, "validation", resp["category"])
|
|
assert.Equal(t, "Slack webhook URL is accepted only on provider create/update", resp["error"])
|
|
assert.NotContains(t, w.Body.String(), "hooks.slack.com")
|
|
}
|
|
|
|
func TestNotificationProviderHandler_Templates(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationProviderHandler(svc)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
|
|
h.Templates(c)
|
|
|
|
assert.Equal(t, 200, w.Code)
|
|
assert.Contains(t, w.Body.String(), "minimal")
|
|
assert.Contains(t, w.Body.String(), "detailed")
|
|
assert.Contains(t, w.Body.String(), "custom")
|
|
}
|
|
|
|
func TestNotificationProviderHandler_Preview_InvalidJSON(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationProviderHandler(svc)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Request = httptest.NewRequest("POST", "/providers/preview", bytes.NewBufferString("invalid"))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Preview(c)
|
|
|
|
assert.Equal(t, 400, w.Code)
|
|
}
|
|
|
|
func TestNotificationProviderHandler_Preview_WithData(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationProviderHandler(svc)
|
|
|
|
payload := map[string]any{
|
|
"template": "minimal",
|
|
"data": map[string]any{
|
|
"Title": "Custom Title",
|
|
"Message": "Custom Message",
|
|
},
|
|
}
|
|
body, _ := json.Marshal(payload)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Request = httptest.NewRequest("POST", "/providers/preview", bytes.NewBuffer(body))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Preview(c)
|
|
|
|
assert.Equal(t, 200, w.Code)
|
|
}
|
|
|
|
func TestNotificationProviderHandler_Preview_InvalidTemplate(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationProviderHandler(svc)
|
|
|
|
payload := map[string]any{
|
|
"template": "custom",
|
|
"config": "{{.Invalid",
|
|
}
|
|
body, _ := json.Marshal(payload)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Request = httptest.NewRequest("POST", "/providers/preview", bytes.NewBuffer(body))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Preview(c)
|
|
|
|
assert.Equal(t, 400, w.Code)
|
|
}
|
|
|
|
// Notification Template Handler Tests
|
|
|
|
func TestNotificationTemplateHandler_List_Error(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationTemplateHandler(svc)
|
|
|
|
// Drop table to cause error
|
|
_ = db.Migrator().DropTable(&models.NotificationTemplate{})
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
|
|
h.List(c)
|
|
|
|
assert.Equal(t, 500, w.Code)
|
|
assert.Contains(t, w.Body.String(), "failed to list templates")
|
|
}
|
|
|
|
func TestNotificationTemplateHandler_Create_BadJSON(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationTemplateHandler(svc)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Request = httptest.NewRequest("POST", "/templates", bytes.NewBufferString("invalid"))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Create(c)
|
|
|
|
assert.Equal(t, 400, w.Code)
|
|
}
|
|
|
|
func TestNotificationTemplateHandler_Create_DBError(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationTemplateHandler(svc)
|
|
|
|
// Drop table to cause error
|
|
_ = db.Migrator().DropTable(&models.NotificationTemplate{})
|
|
|
|
tmpl := models.NotificationTemplate{
|
|
Name: "Test",
|
|
Config: `{"test": true}`,
|
|
}
|
|
body, _ := json.Marshal(tmpl)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Request = httptest.NewRequest("POST", "/templates", bytes.NewBuffer(body))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Create(c)
|
|
|
|
assert.Equal(t, 500, w.Code)
|
|
}
|
|
|
|
func TestNotificationTemplateHandler_Update_BadJSON(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationTemplateHandler(svc)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Params = gin.Params{{Key: "id", Value: "test-id"}}
|
|
c.Request = httptest.NewRequest("PUT", "/templates/test-id", bytes.NewBufferString("invalid"))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Update(c)
|
|
|
|
assert.Equal(t, 400, w.Code)
|
|
}
|
|
|
|
func TestNotificationTemplateHandler_Update_DBError(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationTemplateHandler(svc)
|
|
|
|
// Drop table to cause error
|
|
_ = db.Migrator().DropTable(&models.NotificationTemplate{})
|
|
|
|
tmpl := models.NotificationTemplate{
|
|
Name: "Test",
|
|
Config: `{"test": true}`,
|
|
}
|
|
body, _ := json.Marshal(tmpl)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Params = gin.Params{{Key: "id", Value: "test-id"}}
|
|
c.Request = httptest.NewRequest("PUT", "/templates/test-id", bytes.NewBuffer(body))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Update(c)
|
|
|
|
assert.Equal(t, 500, w.Code)
|
|
}
|
|
|
|
func TestNotificationTemplateHandler_Delete_Error(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationTemplateHandler(svc)
|
|
|
|
// Drop table to cause error
|
|
_ = db.Migrator().DropTable(&models.NotificationTemplate{})
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Params = gin.Params{{Key: "id", Value: "test-id"}}
|
|
|
|
h.Delete(c)
|
|
|
|
assert.Equal(t, 500, w.Code)
|
|
assert.Contains(t, w.Body.String(), "failed to delete template")
|
|
}
|
|
|
|
func TestNotificationTemplateHandler_Preview_BadJSON(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationTemplateHandler(svc)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Request = httptest.NewRequest("POST", "/templates/preview", bytes.NewBufferString("invalid"))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Preview(c)
|
|
|
|
assert.Equal(t, 400, w.Code)
|
|
}
|
|
|
|
func TestNotificationTemplateHandler_Preview_TemplateNotFound(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationTemplateHandler(svc)
|
|
|
|
payload := map[string]any{
|
|
"template_id": "nonexistent",
|
|
}
|
|
body, _ := json.Marshal(payload)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Request = httptest.NewRequest("POST", "/templates/preview", bytes.NewBuffer(body))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Preview(c)
|
|
|
|
assert.Equal(t, 400, w.Code)
|
|
assert.Contains(t, w.Body.String(), "template not found")
|
|
}
|
|
|
|
func TestNotificationTemplateHandler_Preview_WithStoredTemplate(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationTemplateHandler(svc)
|
|
|
|
// Create a template
|
|
tmpl := &models.NotificationTemplate{
|
|
Name: "Test",
|
|
Config: `{"title": "{{.Title}}"}`,
|
|
}
|
|
require.NoError(t, svc.CreateTemplate(tmpl))
|
|
|
|
payload := map[string]any{
|
|
"template_id": tmpl.ID,
|
|
"data": map[string]any{
|
|
"Title": "Test Title",
|
|
},
|
|
}
|
|
body, _ := json.Marshal(payload)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Request = httptest.NewRequest("POST", "/templates/preview", bytes.NewBuffer(body))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Preview(c)
|
|
|
|
assert.Equal(t, 200, w.Code)
|
|
}
|
|
|
|
func TestNotificationTemplateHandler_Preview_InvalidTemplate(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationTemplateHandler(svc)
|
|
|
|
payload := map[string]any{
|
|
"template": "{{.Invalid",
|
|
}
|
|
body, _ := json.Marshal(payload)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Request = httptest.NewRequest("POST", "/templates/preview", bytes.NewBuffer(body))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Preview(c)
|
|
|
|
assert.Equal(t, 400, w.Code)
|
|
}
|
|
|
|
func TestNotificationProviderHandler_Preview_TokenWriteOnly(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationProviderHandler(svc)
|
|
|
|
payload := map[string]any{
|
|
"template": "minimal",
|
|
"token": "secret-token-value",
|
|
}
|
|
body, _ := json.Marshal(payload)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Request = httptest.NewRequest("POST", "/providers/preview", bytes.NewBuffer(body))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Preview(c)
|
|
|
|
assert.Equal(t, 400, w.Code)
|
|
assert.Contains(t, w.Body.String(), "TOKEN_WRITE_ONLY")
|
|
}
|
|
|
|
func TestNotificationProviderHandler_Update_TypeChangeRejected(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationProviderHandler(svc)
|
|
|
|
existing := models.NotificationProvider{
|
|
ID: "update-type-test",
|
|
Name: "Discord Provider",
|
|
Type: "discord",
|
|
URL: "https://discord.com/api/webhooks/123/abc",
|
|
}
|
|
require.NoError(t, db.Create(&existing).Error)
|
|
|
|
payload := map[string]any{
|
|
"name": "Changed Type Provider",
|
|
"type": "gotify",
|
|
"url": "https://gotify.example.com",
|
|
}
|
|
body, _ := json.Marshal(payload)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Params = gin.Params{{Key: "id", Value: "update-type-test"}}
|
|
c.Request = httptest.NewRequest("PUT", "/providers/update-type-test", bytes.NewBuffer(body))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Update(c)
|
|
|
|
assert.Equal(t, 400, w.Code)
|
|
assert.Contains(t, w.Body.String(), "PROVIDER_TYPE_IMMUTABLE")
|
|
}
|
|
|
|
func TestNotificationProviderHandler_Test_MissingProviderID(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationProviderHandler(svc)
|
|
|
|
payload := map[string]any{
|
|
"type": "discord",
|
|
}
|
|
body, _ := json.Marshal(payload)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Request = httptest.NewRequest("POST", "/providers/test", bytes.NewBuffer(body))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Test(c)
|
|
|
|
assert.Equal(t, 400, w.Code)
|
|
assert.Contains(t, w.Body.String(), "MISSING_PROVIDER_ID")
|
|
}
|
|
|
|
func TestNotificationProviderHandler_Test_ProviderNotFound(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationProviderHandler(svc)
|
|
|
|
payload := map[string]any{
|
|
"type": "discord",
|
|
"id": "nonexistent-provider",
|
|
}
|
|
body, _ := json.Marshal(payload)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Request = httptest.NewRequest("POST", "/providers/test", bytes.NewBuffer(body))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Test(c)
|
|
|
|
assert.Equal(t, 404, w.Code)
|
|
assert.Contains(t, w.Body.String(), "PROVIDER_NOT_FOUND")
|
|
}
|
|
|
|
func TestNotificationProviderHandler_Test_EmptyProviderURL(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationProviderHandler(svc)
|
|
|
|
existing := models.NotificationProvider{
|
|
ID: "empty-url-test",
|
|
Name: "Empty URL Provider",
|
|
Type: "discord",
|
|
URL: "",
|
|
}
|
|
require.NoError(t, db.Create(&existing).Error)
|
|
|
|
payload := map[string]any{
|
|
"type": "discord",
|
|
"id": "empty-url-test",
|
|
}
|
|
body, _ := json.Marshal(payload)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Request = httptest.NewRequest("POST", "/providers/test", bytes.NewBuffer(body))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Test(c)
|
|
|
|
assert.Equal(t, 400, w.Code)
|
|
assert.Contains(t, w.Body.String(), "PROVIDER_CONFIG_MISSING")
|
|
}
|
|
|
|
func TestIsProviderValidationError_Comprehensive(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
err error
|
|
expect bool
|
|
}{
|
|
{"nil", nil, false},
|
|
{"invalid_custom_template", errors.New("invalid custom template: missing field"), true},
|
|
{"rendered_template", errors.New("rendered template exceeds maximum"), true},
|
|
{"failed_to_parse", errors.New("failed to parse template: unexpected end"), true},
|
|
{"failed_to_render", errors.New("failed to render template: missing key"), true},
|
|
{"invalid_discord_webhook", errors.New("invalid Discord webhook URL"), true},
|
|
{"unrelated_error", errors.New("database connection failed"), false},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
assert.Equal(t, tc.expect, isProviderValidationError(tc.err))
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestNotificationProviderHandler_Update_UnsupportedType(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationProviderHandler(svc)
|
|
|
|
existing := models.NotificationProvider{
|
|
ID: "unsupported-type",
|
|
Name: "Custom Provider",
|
|
Type: "sms",
|
|
URL: "https://sms.example.com/test",
|
|
}
|
|
require.NoError(t, db.Create(&existing).Error)
|
|
|
|
payload := map[string]any{
|
|
"name": "Updated SMS Provider",
|
|
"url": "https://sms.example.com/updated",
|
|
}
|
|
body, _ := json.Marshal(payload)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Params = gin.Params{{Key: "id", Value: "unsupported-type"}}
|
|
c.Request = httptest.NewRequest("PUT", "/providers/unsupported-type", bytes.NewBuffer(body))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Update(c)
|
|
|
|
assert.Equal(t, 400, w.Code)
|
|
assert.Contains(t, w.Body.String(), "UNSUPPORTED_PROVIDER_TYPE")
|
|
}
|
|
|
|
func TestNotificationProviderHandler_Update_GotifyKeepsExistingToken(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationProviderHandler(svc)
|
|
|
|
existing := models.NotificationProvider{
|
|
ID: "gotify-keep-token",
|
|
Name: "Gotify Provider",
|
|
Type: "gotify",
|
|
URL: "https://gotify.example.com",
|
|
Token: "existing-secret-token",
|
|
}
|
|
require.NoError(t, db.Create(&existing).Error)
|
|
|
|
payload := map[string]any{
|
|
"name": "Updated Gotify",
|
|
"url": "https://gotify.example.com/new",
|
|
"template": "minimal",
|
|
}
|
|
body, _ := json.Marshal(payload)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Params = gin.Params{{Key: "id", Value: "gotify-keep-token"}}
|
|
c.Request = httptest.NewRequest("PUT", "/providers/gotify-keep-token", bytes.NewBuffer(body))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Update(c)
|
|
|
|
assert.Equal(t, 200, w.Code)
|
|
|
|
var updated models.NotificationProvider
|
|
require.NoError(t, db.Where("id = ?", "gotify-keep-token").First(&updated).Error)
|
|
assert.Equal(t, "existing-secret-token", updated.Token)
|
|
}
|
|
|
|
func TestNotificationProviderHandler_Test_ReadDBError(t *testing.T) {
|
|
db := setupNotificationCoverageDB(t)
|
|
svc := services.NewNotificationService(db, nil)
|
|
h := NewNotificationProviderHandler(svc)
|
|
|
|
_ = db.Migrator().DropTable(&models.NotificationProvider{})
|
|
|
|
payload := map[string]any{
|
|
"type": "discord",
|
|
"id": "some-provider",
|
|
}
|
|
body, _ := json.Marshal(payload)
|
|
|
|
w := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(w)
|
|
setAdminContext(c)
|
|
c.Request = httptest.NewRequest("POST", "/providers/test", bytes.NewBuffer(body))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
|
|
h.Test(c)
|
|
|
|
assert.Equal(t, 500, w.Code)
|
|
assert.Contains(t, w.Body.String(), "PROVIDER_READ_FAILED")
|
|
}
|