The execution transition table refuses most of the pairs shipped fixtures wrote to build a finished task -- running -> merged, queued -> parked, queued -> waiting_human, queued -> merged -- so those fixtures fail the moment the store enforces it. internal/taskstate/taskstatetest seeds a status by walking the table's legal edges (shortest route, computed from taskstate.CanTransition), so a fixture cannot write an illegal pair and fails loudly when no route exists. The fixtures in internal/daemon, internal/app/archied, internal/webui and internal/infrastructure/postgres go through it, and the table's own test names running -> merged as refused.
125 lines
4.4 KiB
Go
125 lines
4.4 KiB
Go
package archied
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"log/slog"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strconv"
|
|
"testing"
|
|
|
|
"github.com/samcharles93/archie-core/internal/config"
|
|
"github.com/samcharles93/archie-core/internal/domain/storecontract"
|
|
"github.com/samcharles93/archie-core/internal/domain/workflow"
|
|
"github.com/samcharles93/archie-core/internal/gateway"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/postgres/pgstore"
|
|
"github.com/samcharles93/archie-core/internal/taskstate/taskstatetest"
|
|
"github.com/samcharles93/archie-core/internal/webui"
|
|
)
|
|
|
|
// The dashboard and chat both let an operator approve or decline a task, and
|
|
// they had drifted: declining from the dashboard left the task
|
|
// closed_wont_do, cancelling the same task from chat left it rejected. Two
|
|
// operators looking at one queue saw different states for the same decision,
|
|
// and "rejected" -- which reconcilePRs uses for a pull request closed without
|
|
// merging -- no longer meant one thing.
|
|
//
|
|
// This drives both real surfaces against one store and asserts they agree.
|
|
// It lives in cmd/archied because that is the only place both are wired.
|
|
func TestDashboardAndChatAgreeOnTerminalStates(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
// viaChat runs the action through the chat router; otherwise it
|
|
// goes through the dashboard's HTTP handler.
|
|
viaChat bool
|
|
action string
|
|
want string
|
|
}{
|
|
{name: "dashboard reject", action: "reject", want: workflow.StatusClosedWontDo},
|
|
{name: "chat cancel", viaChat: true, action: "cancel", want: workflow.StatusClosedWontDo},
|
|
{name: "dashboard approve", action: "approve", want: workflow.StatusQueued},
|
|
{name: "chat approve", viaChat: true, action: "approve", want: workflow.StatusQueued},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
ctx := context.Background()
|
|
st := pgstore.Open(t)
|
|
t.Cleanup(func() { _ = st.Close() })
|
|
|
|
task, err := st.EnqueueChatTask(ctx, "acme", "widget", "decide on me", "", "", "reviewer")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
taskstatetest.Seed(ctx, t, st, task.ID, workflow.StatusQueued, workflow.StatusWaitingHuman, "await")
|
|
|
|
if tc.viaChat {
|
|
runChatAction(t, ctx, st, tc.action, task.ID)
|
|
} else {
|
|
runDashboardAction(t, ctx, st, tc.action, task.ID)
|
|
}
|
|
|
|
got, err := st.TaskByID(ctx, task.ID)
|
|
if err != nil || got == nil {
|
|
t.Fatalf("TaskByID = (%+v, %v)", got, err)
|
|
}
|
|
if got.Status != tc.want {
|
|
t.Errorf("status = %q, want %q: the two surfaces disagree about "+
|
|
"what this action means", got.Status, tc.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// runChatAction performs the approve/cancel action through the chat
|
|
// controller path and fails the test on error.
|
|
func runChatAction(t *testing.T, ctx context.Context, st storecontract.TaskStore, action string, taskID int64) {
|
|
t.Helper()
|
|
controller := gateway.NewStoreTaskController(chatTaskControllerAdapter{
|
|
taskByID: st.TaskByID,
|
|
requeue: st.Requeue,
|
|
transition: st.Transition,
|
|
})
|
|
var err error
|
|
if action == "approve" {
|
|
err = controller.Approve(ctx, taskID, "reviewer")
|
|
} else {
|
|
err = controller.Cancel(ctx, taskID, "reviewer")
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("chat %s: %v", action, err)
|
|
}
|
|
}
|
|
|
|
// runDashboardAction performs the approve/cancel action through the
|
|
// dashboard's HTTP handler and fails the test when the request is
|
|
// rejected.
|
|
func runDashboardAction(t *testing.T, ctx context.Context, st storecontract.TaskStore, action string, taskID int64) {
|
|
t.Helper()
|
|
// The dashboard reaches task actions through the Gateway contract, which
|
|
// in production carries them back to this daemon's own service. Wiring
|
|
// that service behind a local adapter keeps both surfaces in this test
|
|
// driving the one implementation, which is the whole point of it.
|
|
actor := testTaskActor{&boot{
|
|
st: st, stateStore: st,
|
|
cfg: config.Config{MaxRetries: 3},
|
|
cfgHolder: config.NewHolder(config.Config{MaxRetries: 3}),
|
|
log: slog.New(slog.DiscardHandler),
|
|
}}
|
|
srv := &webui.Server{
|
|
Store: st,
|
|
Chat: &webui.ChatService{Contract: &gateway.LocalChatAdapter{TaskActor: actor}},
|
|
}
|
|
req := httptest.NewRequestWithContext(ctx, http.MethodPost,
|
|
"/api/tasks/"+strconv.FormatInt(taskID, 10)+"/action",
|
|
bytes.NewBufferString(`{"action":"`+action+`"}`))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Archie-CSRF", "1")
|
|
w := httptest.NewRecorder()
|
|
srv.Handler().ServeHTTP(w, req)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("dashboard %s: status %d, body %s", action, w.Code, w.Body)
|
|
}
|
|
}
|