a733a927f3
Preserve Settings as an independent navigation destination while landing the reviewed notification and skill-management updates. Keep the server and CLI skill contracts versioned and validated so the merged tree can be verified by the delivery gate.
490 lines
19 KiB
Go
490 lines
19 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"git.a-wan.net/alan/pipelines/examples"
|
|
"git.a-wan.net/alan/pipelines/internal/pipeline"
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
"git.a-wan.net/alan/pipelines/internal/stage"
|
|
"io"
|
|
"mime"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync/atomic"
|
|
"syscall"
|
|
"testing"
|
|
)
|
|
|
|
func TestStageNotificationEventsAndArtifactAudit(t *testing.T) {
|
|
t.Setenv("PIPELINES_WEB_PUBLIC_URL", "https://pipelines.example.com/")
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
store, err := pipeline.Open(filepath.Join(t.TempDir(), "notify.db"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer store.Close()
|
|
workspace := t.TempDir()
|
|
if err := os.WriteFile(filepath.Join(workspace, "report.txt"), []byte("created file"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var calls atomic.Int32
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
count := calls.Add(1)
|
|
if click, actions := r.Header.Get("Click"), r.Header.Get("Actions"); !strings.HasPrefix(click, "pipelines://run/") || actions != "view, Open in browser, https://pipelines.example.com/runs/"+strings.TrimPrefix(click, "pipelines://run/") {
|
|
t.Errorf("stage notification lacks app click/web action: %q %q", click, actions)
|
|
}
|
|
filename, _ := new(mime.WordDecoder).DecodeHeader(r.Header.Get("Filename"))
|
|
body, _ := io.ReadAll(r.Body)
|
|
if filename == "report.txt" && string(body) != "created file" {
|
|
t.Error("wrong file content")
|
|
}
|
|
if filename == "digest.md" && string(body) != "# Digest" {
|
|
t.Error("wrong markdown")
|
|
}
|
|
ack := map[string]any{"id": fmt.Sprintf("msg%d", count), "event": "message"}
|
|
if filename != "" {
|
|
ack["attachment"] = map[string]string{"name": filename, "url": "https://ntfy.example.com/file/" + filename}
|
|
}
|
|
_ = json.NewEncoder(w).Encode(ack)
|
|
}))
|
|
defer srv.Close()
|
|
t.Setenv("PIPELINES_NTFY_URL", srv.URL+"/pipelines")
|
|
if _, err := store.Submit(ctx, "notifications", pipeline.Template([]string{"one"}, true)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
items, _ := store.List(ctx)
|
|
d, _ := store.Get(ctx, items[0].ID, 0)
|
|
r, _ := newRunner(ctx, store)
|
|
for i, test := range []struct {
|
|
status, outcome, target, on string
|
|
attachments bool
|
|
expected int32
|
|
}{
|
|
{"completed", "success", protocol.SuccessEnd, "success", true, 2},
|
|
{"completed", "blocked", protocol.FailureEnd, "failure", false, 1},
|
|
{"failed", "error", protocol.FailureEnd, "failure", false, 1},
|
|
{"completed", "error", protocol.FailureEnd, "success", false, 0},
|
|
} {
|
|
id, _, err := store.CreateRun(ctx, d, fmt.Sprintf("case%d", i), workspace, false, nil, map[string]any{"prompt": "task"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := store.BeginStep(ctx, id, 1, "one", nil); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
step := protocol.RunStep{Sequence: 1, Stage: "one", Status: test.status, Outcome: test.outcome, Target: test.target, Output: map[string]any{}}
|
|
policy := &protocol.NotificationPolicy{On: []string{test.on}, Destination: "anime"}
|
|
if test.attachments {
|
|
policy.Artifacts = []string{"markdown", "files"}
|
|
step.Output = map[string]any{"markdown": "# Digest", "artifacts": []any{"report.txt"}}
|
|
}
|
|
if err := store.FinishStep(ctx, id, step); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
before := calls.Load()
|
|
r.notifyStep(id, d.Name, workspace, policy, step)
|
|
detail, err := store.GetRun(ctx, id)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if calls.Load()-before != test.expected || len(detail.Steps[0].Notifications) != int(test.expected) {
|
|
t.Fatal("event/attachments mismatch", detail, calls.Load()-before)
|
|
}
|
|
for _, receipt := range detail.Steps[0].Notifications {
|
|
if receipt.Status != "sent" || receipt.MessageID == "" {
|
|
t.Fatal("notification receipt not persisted", receipt)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Regress the terminal-path recipe from the authoring guide on the bundled
|
|
// research -> report starter.
|
|
// A completion-alert request must not require native delivery or change run routing.
|
|
func TestTerminalNotificationRecipe(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
store, err := pipeline.Open(filepath.Join(t.TempDir(), "recipe.db"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer store.Close()
|
|
var source string
|
|
for _, template := range examples.Catalog() {
|
|
if template.Key == "research" {
|
|
source = template.Source
|
|
}
|
|
}
|
|
if source == "" {
|
|
t.Fatal("research template missing")
|
|
}
|
|
source = strings.Replace(source, "# stage report", "# stage report\n```notify\non=success,failure\n```", 1)
|
|
if _, err = store.Submit(ctx, "research notification recipe", source); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
items, err := store.List(ctx)
|
|
if err != nil || len(items) != 1 {
|
|
t.Fatal("recipe missing", err)
|
|
}
|
|
id := items[0].ID
|
|
var calls atomic.Int32
|
|
var deliveryFailure atomic.Bool
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
|
|
calls.Add(1)
|
|
if req.Header.Get("Filename") != "" {
|
|
t.Error("event alert unexpectedly changed output to add attachments")
|
|
}
|
|
if deliveryFailure.Load() {
|
|
http.Error(w, "unavailable", http.StatusServiceUnavailable)
|
|
return
|
|
}
|
|
_ = json.NewEncoder(w).Encode(map[string]string{"id": "recipe-receipt", "event": "message"})
|
|
}))
|
|
defer srv.Close()
|
|
t.Setenv("PIPELINES_NTFY_URL", srv.URL+"/pipelines")
|
|
t.Setenv("PIPELINES_NTFY_TOKEN", "")
|
|
t.Setenv("PIPELINES_NTFY_TOKEN_FILE", "")
|
|
r, err := newRunner(ctx, store)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for index, test := range []struct {
|
|
name, stage, outcome, status string
|
|
executionError, deliveryError bool
|
|
notify bool
|
|
}{
|
|
{"success", "report", "success", "succeeded", false, false, true},
|
|
{"research blocked", "research", "blocked", "failed", false, false, false},
|
|
{"research execution error", "research", "error", "failed", true, false, true},
|
|
{"report blocked", "report", "blocked", "failed", false, false, false},
|
|
{"report execution error", "report", "error", "failed", true, false, true},
|
|
{"delivery error preserves success", "report", "success", "succeeded", false, true, true},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
deliveryFailure.Store(test.deliveryError)
|
|
r.execute = func(_ context.Context, def stage.Definition, _ stage.Values) (stage.Result, error) {
|
|
if def.Key == test.stage {
|
|
if test.executionError {
|
|
return stage.Result{}, errors.New("fixture execution failed")
|
|
}
|
|
return stage.Result{Outcome: test.outcome, Output: stage.Values{"report": "retained evidence"}}, nil
|
|
}
|
|
return stage.Result{Outcome: "success", Output: stage.Values{"question": "topic", "evidence": []any{"source fact"}}}, nil
|
|
}
|
|
before := calls.Load()
|
|
run, err := r.start(protocol.Message{PipelineID: id, Version: 1, RequestKey: fmt.Sprintf("recipe-%d", index), Workspace: t.TempDir(), Input: map[string]any{"prompt": "research a topic"}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r.wg.Wait()
|
|
detail, err := store.GetRun(ctx, run.ID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if detail.Status != test.status || (calls.Load()-before == 1) != test.notify {
|
|
t.Fatal("wrong verdict or duplicate/missing terminal alert", detail.Status, calls.Load()-before)
|
|
}
|
|
last := detail.Steps[len(detail.Steps)-1]
|
|
if last.Stage != test.stage || (len(last.Notifications) == 1) != test.notify {
|
|
t.Fatal("notification not retained on terminal stage", last)
|
|
}
|
|
if !test.notify {
|
|
return
|
|
}
|
|
for _, step := range detail.Steps[:len(detail.Steps)-1] {
|
|
if len(step.Notifications) != 0 {
|
|
t.Fatal("intermediate success alerted", step)
|
|
}
|
|
}
|
|
want := "sent"
|
|
if test.deliveryError {
|
|
want = "failed"
|
|
}
|
|
if last.Notifications[0].Status != want {
|
|
t.Fatal("delivery receipt wrong", last.Notifications)
|
|
}
|
|
if !test.executionError && detail.Output["report"] != "retained evidence" {
|
|
t.Fatal("notification changed output handoff", detail.Output)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestNotificationFailureDoesNotChangeRunRouting(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
store, err := pipeline.Open(filepath.Join(t.TempDir(), "routing.db"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer store.Close()
|
|
source := strings.Replace(pipeline.Template([]string{"one"}, true), "# stage one", "# stage one\n```notify\non=success\ndestination=anime\nartifacts=markdown\n```", 1)
|
|
if _, err := store.Submit(ctx, "test", source); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
items, _ := store.List(ctx)
|
|
r, _ := newRunner(ctx, store)
|
|
r.execute = func(context.Context, stage.Definition, stage.Values) (stage.Result, error) {
|
|
return stage.Result{Outcome: "success", Output: stage.Values{"markdown": "# Result"}}, nil
|
|
}
|
|
t.Setenv("PIPELINES_NTFY_URL", "")
|
|
run, err := r.start(protocol.Message{PipelineID: items[0].ID, Version: 1, RequestKey: "once", Input: map[string]any{"prompt": "task"}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r.wg.Wait()
|
|
detail, _ := store.GetRun(ctx, run.ID)
|
|
if detail.Status != "succeeded" || len(detail.Steps[0].Notifications) != 1 || detail.Steps[0].Notifications[0].Status != "failed" {
|
|
t.Fatal("notification altered routing or lost failure audit", detail)
|
|
}
|
|
}
|
|
|
|
func TestNotificationArtifactPathSafety(t *testing.T) {
|
|
root := t.TempDir()
|
|
os.WriteFile(filepath.Join(root, "safe.txt"), []byte("safe"), 0600)
|
|
os.WriteFile(filepath.Join(root, ".env"), []byte("secret"), 0600)
|
|
os.Symlink(filepath.Join(root, ".env"), filepath.Join(root, "alias.txt"))
|
|
outside := filepath.Join(t.TempDir(), "outside.txt")
|
|
os.WriteFile(outside, []byte("secret"), 0600)
|
|
os.Symlink(outside, filepath.Join(root, "external.txt"))
|
|
os.Mkdir(filepath.Join(root, "directory"), 0700)
|
|
os.WriteFile(filepath.Join(root, "large.bin"), []byte(strings.Repeat("x", (1<<20)+1)), 0600)
|
|
if err := syscall.Mkfifo(filepath.Join(root, "pipe"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, name := range []string{"../outside.txt", outside, ".env", "alias.txt", "external.txt", "directory", "large.bin", "pipe", "pipelines.db", "secret.key", "secrets/file.txt", "sub/../safe.txt"} {
|
|
if _, err := notificationArtifact(root, name); err == nil {
|
|
t.Fatal("unsafe artifact accepted", name)
|
|
}
|
|
}
|
|
if data, err := notificationArtifact(root, "safe.txt"); err != nil || string(data) != "safe" {
|
|
t.Fatal("safe artifact rejected", err)
|
|
}
|
|
}
|
|
|
|
// TestRunAttentionEventMapping pins the single decision of whether a run needs
|
|
// the operator: a run parked on a person (waiting) or a failed run, and nothing
|
|
// else. A queued, running, succeeded, canceled or interrupted run never notifies.
|
|
func TestRunAttentionEventMapping(t *testing.T) {
|
|
for _, test := range []struct{ status, want string }{
|
|
{"waiting", protocol.NotifyWaiting},
|
|
{"failed", "failed"},
|
|
{"Warning", ""},
|
|
{"queued", ""},
|
|
{"running", ""},
|
|
{"succeeded", ""},
|
|
{"canceled", ""},
|
|
{"interrupted", "interrupted"},
|
|
{"", ""},
|
|
} {
|
|
if got := runAttentionEvent(test.status); got != test.want {
|
|
t.Errorf("runAttentionEvent(%q) = %q, want %q", test.status, got, test.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestRunAttentionNotificationDelivery proves the operator-facing contract: the
|
|
// already-configured "system" destination and topic are used, the payload names
|
|
// the run and its pipeline, the click action opens the run, only waiting/failed
|
|
// publish, and a run that stays waiting is never republished.
|
|
func TestRunAttentionNotificationDelivery(t *testing.T) {
|
|
t.Setenv("PIPELINES_WEB_PUBLIC_URL", "https://pipelines.example.com")
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
store, err := pipeline.Open(filepath.Join(t.TempDir(), "attention.db"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer store.Close()
|
|
type delivered struct {
|
|
method, path, title, message, click, authorization, actions string
|
|
}
|
|
deliveries := make(chan delivered, 8)
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
decoder := new(mime.WordDecoder)
|
|
title, _ := decoder.DecodeHeader(r.Header.Get("Title"))
|
|
message, _ := decoder.DecodeHeader(r.Header.Get("Message"))
|
|
deliveries <- delivered{r.Method, r.URL.Path, title, message, r.Header.Get("Click"), r.Header.Get("Authorization"), r.Header.Get("Actions")}
|
|
_ = json.NewEncoder(w).Encode(map[string]string{"id": "attention-receipt", "event": "message"})
|
|
}))
|
|
defer srv.Close()
|
|
t.Setenv("PIPELINES_NTFY_URL", srv.URL+"/pipelines")
|
|
t.Setenv("PIPELINES_NTFY_TOKEN", "")
|
|
t.Setenv("PIPELINES_NTFY_TOKEN_FILE", "")
|
|
r, err := newRunner(ctx, store)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// A run that needs nobody publishes nothing.
|
|
for _, status := range []string{"queued", "running", "succeeded", "canceled"} {
|
|
r.notifyRun(7, "release", status, 1, "build", "")
|
|
}
|
|
select {
|
|
case got := <-deliveries:
|
|
t.Fatalf("a run that needs nobody published: %+v", got)
|
|
default:
|
|
}
|
|
// A waiting run publishes once, with the destination, identity and click.
|
|
r.notifyRun(7, "release", protocol.RunStatusWaiting, 1, "approve", "")
|
|
// A run that stays waiting is never republished, on a later call or a re-request.
|
|
r.notifyRun(7, "release", protocol.RunStatusWaiting, 1, "approve", "")
|
|
// An auto run's failure announces its end.
|
|
r.notifyRun(8, "release", "failed", 2, "deploy", "provider returned 500")
|
|
// A failed run marked "on" publishes once, with its diagnostic.
|
|
r.setNotifyMode(7, "on")
|
|
r.notifyRun(7, "release", "failed", 2, "deploy", "provider returned 500")
|
|
|
|
first := <-deliveries
|
|
if first.method != http.MethodPost || first.path != "/pipelines" {
|
|
t.Fatalf("wrong destination/topic: %+v", first)
|
|
}
|
|
if first.title != "Run needs your decision" || !strings.Contains(first.message, "Run #7") || !strings.Contains(first.message, "release") || !strings.Contains(first.message, "decision") || !strings.Contains(first.message, "approve") {
|
|
t.Fatalf("waiting notification does not identify the run/pipeline/need: %+v", first)
|
|
}
|
|
if first.click != "pipelines://run/7" || first.actions != "view, Open in browser, https://pipelines.example.com/runs/7" {
|
|
t.Fatalf("waiting notification click does not open the run: %q", first.click)
|
|
}
|
|
if first.authorization != "" {
|
|
t.Fatalf("notification leaked an authorization header: %q", first.authorization)
|
|
}
|
|
second := <-deliveries
|
|
if second.title != "Run failed" || !strings.Contains(second.message, "Run #8") {
|
|
t.Fatalf("failed notification is not actionable: %+v", second)
|
|
}
|
|
if second.click != "pipelines://run/8" || second.actions != "view, Open in browser, https://pipelines.example.com/runs/8" {
|
|
t.Fatalf("failed notification click does not open the run: %q", second.click)
|
|
}
|
|
third := <-deliveries
|
|
if third.title != "Run failed" || !strings.Contains(third.message, "Run #7") {
|
|
t.Fatalf("marked failed notification is not actionable: %+v", third)
|
|
}
|
|
select {
|
|
case got := <-deliveries:
|
|
t.Fatalf("third notification delivered for two genuine events: %+v", got)
|
|
default:
|
|
}
|
|
}
|
|
|
|
// TestRunAttentionSuppressedByStagePolicy proves a stage's own notify policy and
|
|
// the run-level default cannot both fire for the same event: the author's policy
|
|
// wins, so the operator gets exactly one notification.
|
|
func TestRunAttentionSuppressedByStagePolicy(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
store, err := pipeline.Open(filepath.Join(t.TempDir(), "suppress.db"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer store.Close()
|
|
r, err := newRunner(ctx, store)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r.markAttentionSent(11, 5, "failed")
|
|
r.markAttentionSent(11, 6, "waiting")
|
|
if !r.attentionAlready(11, 5, "failed") || !r.attentionAlready(11, 6, "waiting") {
|
|
t.Fatal("stage-policy coverage not recorded")
|
|
}
|
|
var calls atomic.Int32
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
|
|
calls.Add(1)
|
|
_ = json.NewEncoder(w).Encode(map[string]string{"id": "suppressed", "event": "message"})
|
|
}))
|
|
defer srv.Close()
|
|
t.Setenv("PIPELINES_NTFY_URL", srv.URL+"/pipelines")
|
|
r.notifyRun(11, "release", "failed", 5, "deploy", "")
|
|
r.notifyRun(11, "release", protocol.RunStatusWaiting, 6, "approve", "")
|
|
if calls.Load() != 0 {
|
|
t.Fatalf("run-level default repeated a stage-policy event %d times", calls.Load())
|
|
}
|
|
}
|
|
|
|
// TestHumanRunAttentionNotification proves the run loop publishes the run-level
|
|
// attention notification itself when the pipeline declares no notify policy: the
|
|
// transition to waiting reaches the operator's configured destination exactly
|
|
// once, with the run, pipeline and a run-opening click.
|
|
func TestHumanRunAttentionNotification(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
store, err := pipeline.Open(filepath.Join(t.TempDir(), "human-attention.db"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer store.Close()
|
|
type delivered struct{ title, message, click string }
|
|
deliveries := make(chan delivered, 4)
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
decoder := new(mime.WordDecoder)
|
|
title, _ := decoder.DecodeHeader(r.Header.Get("Title"))
|
|
message, _ := decoder.DecodeHeader(r.Header.Get("Message"))
|
|
deliveries <- delivered{title, message, r.Header.Get("Click")}
|
|
_ = json.NewEncoder(w).Encode(map[string]string{"id": "human-attention", "event": "message"})
|
|
}))
|
|
defer srv.Close()
|
|
t.Setenv("PIPELINES_NTFY_URL", srv.URL+"/pipelines")
|
|
if _, err := store.Submit(ctx, "human", humanPipelineSource); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
items, _ := store.List(ctx)
|
|
r, err := newRunner(ctx, store)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer r.wg.Wait()
|
|
r.execute = successExecute
|
|
run, err := r.start(protocol.Message{PipelineID: items[0].ID, Version: 1, RequestKey: "human-attention", Workspace: t.TempDir(), Input: map[string]any{"prompt": "task"}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r.wg.Wait()
|
|
got := <-deliveries
|
|
if got.title != "Run needs your decision" || !strings.Contains(got.message, fmt.Sprintf("Run #%d", run.ID)) || !strings.Contains(got.message, "human") {
|
|
t.Fatalf("run-level waiting notification wrong: %+v", got)
|
|
}
|
|
if got.click != fmt.Sprintf("pipelines://run/%d", run.ID) {
|
|
t.Fatalf("run-level waiting notification click wrong: %q", got.click)
|
|
}
|
|
select {
|
|
case extra := <-deliveries:
|
|
t.Fatalf("waiting run notified again: %+v", extra)
|
|
default:
|
|
}
|
|
}
|
|
|
|
// TestRunAttentionNotifiesEachGenuineWait proves the step sequence is part of the
|
|
// dedup key: a run that waits on a person twice notifies each time (two genuine
|
|
// events), while the same wait is never repeated.
|
|
func TestRunAttentionNotifiesEachGenuineWait(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
store, err := pipeline.Open(filepath.Join(t.TempDir(), "waits.db"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer store.Close()
|
|
r, err := newRunner(ctx, store)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var calls atomic.Int32
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
|
|
calls.Add(1)
|
|
_ = json.NewEncoder(w).Encode(map[string]string{"id": "wait", "event": "message"})
|
|
}))
|
|
defer srv.Close()
|
|
t.Setenv("PIPELINES_NTFY_URL", srv.URL+"/pipelines")
|
|
r.notifyRun(1, "release", protocol.RunStatusWaiting, 1, "gate", "")
|
|
r.notifyRun(1, "release", protocol.RunStatusWaiting, 1, "gate", "")
|
|
r.notifyRun(1, "release", protocol.RunStatusWaiting, 5, "gate-again", "")
|
|
if calls.Load() != 2 {
|
|
t.Fatalf("two genuine waits produced %d notifications, want 2", calls.Load())
|
|
}
|
|
}
|