gochat/backend/internal/handler/api/v1/integration_hook_handler_test.go

package v1

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

	"github.com/gin-gonic/gin"
	"github.com/stretchr/testify/assert"

	"github.com/gochat/gochat/internal/service"
)

// mockAuthMiddlewareForHook simulates auth middleware for hook handler tests.
func mockAuthMiddlewareForHook() gin.HandlerFunc {
	return func(c *gin.Context) {
		c.Set("user_id", uint(1))
		if accID, err := strconv.ParseUint(c.Param("account_id"), 10, 32); err == nil {
			c.Set("account_id", uint(accID))
		}
		c.Next()
	}
}

func setupIntegrationHookTestRouter(handler *IntegrationHookHandler) *gin.Engine {
	gin.SetMode(gin.TestMode)
	r := gin.New()
	r.Use(gin.Recovery(), mockAuthMiddlewareForHook())

	g := r.Group("/api/v1/accounts/:account_id/integrations")
	apps := g.Group("/apps")
	{
		apps.GET("/", handler.ListApps)
		apps.GET("/:id", handler.GetApp)
	}
	hooks := g.Group("/hooks")
	{
		hooks.GET("/", handler.ListHooks)
		hooks.GET("/:id", handler.GetHook)
		hooks.POST("/", handler.CreateHook)
		hooks.PUT("/:id", handler.UpdateHook)
		hooks.DELETE("/:id", handler.DeleteHook)
		hooks.POST("/:id/process_event", handler.ProcessHookEvent)
	}
	return r
}

func TestIntegrationHookHandler_ListHooks_InvalidAccountID(t *testing.T) {
	handler := NewIntegrationHookHandler(&service.IntegrationHookService{})
	router := setupIntegrationHookTestRouter(handler)

	w := httptest.NewRecorder()
	req, _ := http.NewRequest("GET", "/api/v1/accounts/abc/integrations/hooks/", nil)
	router.ServeHTTP(w, req)
	assert.Equal(t, http.StatusBadRequest, w.Code)
}

func TestIntegrationHookHandler_CreateHook_InvalidJSON(t *testing.T) {
	handler := NewIntegrationHookHandler(&service.IntegrationHookService{})
	router := setupIntegrationHookTestRouter(handler)

	w := httptest.NewRecorder()
	req, _ := http.NewRequest("POST", "/api/v1/accounts/1/integrations/hooks/", bytes.NewBufferString("{invalid"))
	req.Header.Set("Content-Type", "application/json")
	router.ServeHTTP(w, req)
	assert.Equal(t, http.StatusBadRequest, w.Code)
}

func TestIntegrationHookHandler_CreateHook_MissingHookType(t *testing.T) {
	handler := NewIntegrationHookHandler(&service.IntegrationHookService{})
	router := setupIntegrationHookTestRouter(handler)

	body, _ := json.Marshal(map[string]interface{}{"hook": map[string]string{"url": "https://example.com"}})
	w := httptest.NewRecorder()
	req, _ := http.NewRequest("POST", "/api/v1/accounts/1/integrations/hooks/", bytes.NewBuffer(body))
	req.Header.Set("Content-Type", "application/json")
	router.ServeHTTP(w, req)
	assert.True(t, w.Code == http.StatusBadRequest || w.Code == http.StatusUnprocessableEntity)
}

func TestIntegrationHookHandler_CreateHook_InvalidHookType(t *testing.T) {
	handler := NewIntegrationHookHandler(&service.IntegrationHookService{})
	router := setupIntegrationHookTestRouter(handler)

	body, _ := json.Marshal(map[string]interface{}{"hook": map[string]string{"hook_type": "invalid_type", "url": "https://example.com"}})
	w := httptest.NewRecorder()
	req, _ := http.NewRequest("POST", "/api/v1/accounts/1/integrations/hooks/", bytes.NewBuffer(body))
	req.Header.Set("Content-Type", "application/json")
	router.ServeHTTP(w, req)
	assert.True(t, w.Code == http.StatusBadRequest || w.Code == http.StatusUnprocessableEntity)
}

func TestIntegrationHookHandler_GetHook_InvalidID(t *testing.T) {
	handler := NewIntegrationHookHandler(&service.IntegrationHookService{})
	router := setupIntegrationHookTestRouter(handler)

	w := httptest.NewRecorder()
	req, _ := http.NewRequest("GET", "/api/v1/accounts/1/integrations/hooks/abc", nil)
	router.ServeHTTP(w, req)
	assert.Equal(t, http.StatusBadRequest, w.Code)
}

func TestIntegrationHookHandler_DeleteHook_InvalidID(t *testing.T) {
	handler := NewIntegrationHookHandler(&service.IntegrationHookService{})
	router := setupIntegrationHookTestRouter(handler)

	w := httptest.NewRecorder()
	req, _ := http.NewRequest("DELETE", "/api/v1/accounts/1/integrations/hooks/abc", nil)
	router.ServeHTTP(w, req)
	assert.Equal(t, http.StatusBadRequest, w.Code)
}

func TestIntegrationHookHandler_UpdateHook_InvalidJSON(t *testing.T) {
	handler := NewIntegrationHookHandler(&service.IntegrationHookService{})
	router := setupIntegrationHookTestRouter(handler)

	w := httptest.NewRecorder()
	req, _ := http.NewRequest("PUT", "/api/v1/accounts/1/integrations/hooks/1", bytes.NewBufferString("{bad"))
	req.Header.Set("Content-Type", "application/json")
	router.ServeHTTP(w, req)
	assert.Equal(t, http.StatusBadRequest, w.Code)
}

func TestIntegrationHookHandler_ListApps_NilService(t *testing.T) {
	handler := NewIntegrationHookHandler(&service.IntegrationHookService{})
	router := setupIntegrationHookTestRouter(handler)

	w := httptest.NewRecorder()
	req, _ := http.NewRequest("GET", "/api/v1/accounts/1/integrations/apps/", nil)
	router.ServeHTTP(w, req)
	assert.True(t, w.Code == http.StatusUnprocessableEntity || w.Code == http.StatusOK)
}