kandev/apps/backend/internal/sentry/mock_controller.go

package sentry

import (
	"errors"
	"net/http"
	"strings"
	"time"

	"github.com/gin-gonic/gin"

	"github.com/kandev/kandev/internal/common/logger"
)

// MockController exposes HTTP endpoints that drive the in-memory MockClient
// during E2E tests. Mounted by RegisterMockRoutes only when the service was
// built with a MockClient. Every data endpoint is scoped to an instance via the
// `?instanceId=` query param so tests can seed distinct datasets per instance.
type MockController struct {
	mock  *MockClient
	store *Store
	log   *logger.Logger
}

// NewMockController wires the controller to the mock + store so auth-health
// writes can be triggered synchronously from tests.
func NewMockController(mock *MockClient, store *Store, log *logger.Logger) *MockController {
	return &MockController{mock: mock, store: store, log: log}
}

// RegisterRoutes mounts the mock control routes under /api/v1/sentry/mock.
func (c *MockController) RegisterRoutes(router *gin.Engine) {
	api := router.Group("/api/v1/sentry/mock")
	api.PUT("/auth-result", c.setAuthResult)
	api.PUT("/auth-health", c.setAuthHealth)
	api.POST("/organizations", c.setOrganizations)
	api.POST("/projects", c.setProjects)
	api.POST("/issues", c.addIssues)
	api.PUT("/get-issue-error", c.setGetIssueError)
	api.DELETE("/reset", c.reset)
}

func (c *MockController) requireInstanceID(ctx *gin.Context) (string, bool) {
	instanceID := strings.TrimSpace(ctx.Query("instanceId"))
	if instanceID == "" {
		writeErr(ctx, http.StatusBadRequest, "instanceId query parameter required")
		return "", false
	}
	return instanceID, true
}

// setAuthResult seeds an instance's TestAuth response. instanceId is
// optional (unlike the other seed routes): TestConnectionCandidate builds a
// client for a not-yet-persisted config using the empty-string instance ID,
// so pre-save "Test connection" specs must be able to seed that dataset too.
func (c *MockController) setAuthResult(ctx *gin.Context) {
	var req TestConnectionResult
	if err := ctx.ShouldBindJSON(&req); err != nil {
		writeBadPayload(ctx)
		return
	}
	instanceID := strings.TrimSpace(ctx.Query("instanceId"))
	r := req
	c.mock.SetAuthResult(instanceID, &r)
	ctx.JSON(http.StatusOK, gin.H{"set": true})
}

func (c *MockController) setAuthHealth(ctx *gin.Context) {
	var req struct {
		OK    bool   `json:"ok"`
		Error string `json:"error"`
	}
	if err := ctx.ShouldBindJSON(&req); err != nil {
		writeBadPayload(ctx)
		return
	}
	instanceID, ok := c.requireInstanceID(ctx)
	if !ok {
		return
	}
	if err := c.store.UpdateAuthHealthForInstance(ctx.Request.Context(), instanceID, req.OK, req.Error, time.Now().UTC()); err != nil {
		if errors.Is(err, ErrInstanceNotFound) {
			writeErr(ctx, http.StatusNotFound, err.Error())
			return
		}
		writeErr(ctx, http.StatusInternalServerError, err.Error())
		return
	}
	ctx.JSON(http.StatusOK, gin.H{"set": true})
}

func (c *MockController) setOrganizations(ctx *gin.Context) {
	var req struct {
		Organizations []SentryOrganization `json:"organizations"`
	}
	if err := ctx.ShouldBindJSON(&req); err != nil {
		writeBadPayload(ctx)
		return
	}
	instanceID, ok := c.requireInstanceID(ctx)
	if !ok {
		return
	}
	c.mock.SetOrganizations(instanceID, req.Organizations)
	ctx.JSON(http.StatusOK, gin.H{"count": len(req.Organizations)})
}

func (c *MockController) setProjects(ctx *gin.Context) {
	var req struct {
		Projects []SentryProject `json:"projects"`
	}
	if err := ctx.ShouldBindJSON(&req); err != nil {
		writeBadPayload(ctx)
		return
	}
	instanceID, ok := c.requireInstanceID(ctx)
	if !ok {
		return
	}
	c.mock.SetProjects(instanceID, req.Projects)
	ctx.JSON(http.StatusOK, gin.H{"count": len(req.Projects)})
}

func (c *MockController) addIssues(ctx *gin.Context) {
	var req struct {
		Issues []SentryIssue `json:"issues"`
	}
	if err := ctx.ShouldBindJSON(&req); err != nil {
		writeBadPayload(ctx)
		return
	}
	instanceID, ok := c.requireInstanceID(ctx)
	if !ok {
		return
	}
	for i := range req.Issues {
		c.mock.AddIssue(instanceID, &req.Issues[i])
	}
	ctx.JSON(http.StatusOK, gin.H{"added": len(req.Issues)})
}

func (c *MockController) setGetIssueError(ctx *gin.Context) {
	var req struct {
		StatusCode int    `json:"statusCode"`
		Message    string `json:"message"`
	}
	if err := ctx.ShouldBindJSON(&req); err != nil {
		writeBadPayload(ctx)
		return
	}
	instanceID, ok := c.requireInstanceID(ctx)
	if !ok {
		return
	}
	if req.StatusCode == 0 {
		c.mock.SetGetIssueError(instanceID, nil)
	} else {
		c.mock.SetGetIssueError(instanceID, &APIError{StatusCode: req.StatusCode, Message: req.Message})
	}
	ctx.JSON(http.StatusOK, gin.H{"set": true})
}

func (c *MockController) reset(ctx *gin.Context) {
	c.mock.Reset()
	ctx.JSON(http.StatusOK, gin.H{"reset": true})
}