Files
archie/internal/daemon/binding_dispatch_test.go
T

130 lines
4.2 KiB
Go

package daemon
import (
"context"
"errors"
"log/slog"
"sync"
"testing"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/domain/binding"
"github.com/samcharles93/archie-core/internal/domain/mapping"
"github.com/samcharles93/archie-core/internal/domain/org"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
"github.com/samcharles93/archie-core/internal/domain/workflow"
"github.com/samcharles93/archie-core/internal/events"
)
// ledgerStore models the State Store's dispatch ledger: EnqueueBindingTask
// claims and creates as one unit, and any ledger write the daemon makes for
// a capture refuses a later claim of it, as the real unique index does.
type ledgerStore struct {
storecontract.TaskStore
storecontract.BindingStore
storecontract.MappingStore
mu sync.Mutex
claimed map[string]bool
tasks int
markers int
failures int // enqueues to fail before any commits
listed *sync.WaitGroup // holds listers until every admitter has listed
}
func (s *ledgerStore) ListBindings(context.Context) ([]binding.Binding, error) {
return []binding.Binding{dispatchBinding}, nil
}
func (s *ledgerStore) ListUndispatchedCaptures(context.Context, []string, int) ([]storecontract.CapturedEvent, error) {
s.mu.Lock()
pending := !s.claimed["capture"]
s.mu.Unlock()
if s.listed != nil {
s.listed.Done()
s.listed.Wait()
}
if !pending {
return nil, nil
}
return []storecontract.CapturedEvent{{ID: "capture", Source: "forge", EventType: "push", Body: "{}", Authenticated: true}}, nil
}
func (s *ledgerStore) RecordDispatch(_ context.Context, _ string, _ int64, captureID string, _ int64, _ string) error {
s.mu.Lock()
defer s.mu.Unlock()
if s.claimed[captureID] {
return storecontract.ErrAlreadyDispatched
}
s.claimed[captureID] = true
return nil
}
func (s *ledgerStore) EnqueueBindingTask(_ context.Context, _, _, _, _, _, _, _ string, _ int, captureID string, _ map[string]any) (*workflow.Task, error) {
s.mu.Lock()
defer s.mu.Unlock()
if s.claimed[captureID] {
return nil, storecontract.ErrAlreadyDispatched
}
if s.failures > 0 {
s.failures--
return nil, errors.New("state store unavailable")
}
s.claimed[captureID] = true
s.tasks++
return &workflow.Task{ID: int64(s.tasks)}, nil
}
func (s *ledgerStore) GetMapping(context.Context, string) (*mapping.Mapping, error) {
return &mapping.Mapping{ID: "push", EventTypeID: "push"}, nil
}
func (s *ledgerStore) InsertEvent(context.Context, events.Event) (int64, error) {
s.mu.Lock()
defer s.mu.Unlock()
s.markers++
return 0, nil
}
var dispatchBinding = binding.Binding{
ID: "on-push", Name: "on-push", Version: 1, MappingID: "push", Matcher: binding.Matcher{Source: "forge"},
OrgID: org.DefaultOrgID, Workflow: "deploy", Status: binding.StatusArmed,
}
// A delivery dispatches exactly one task however its admissions go: replayed
// cycles, a failure after the claim, or concurrent dispatchers.
func TestBindingDispatchCreatesOneTask(t *testing.T) {
for _, tc := range []struct {
name string
failures int
cycles int
concurrent int
}{
{name: "replay", cycles: 3, concurrent: 1},
{name: "failure after the claim", failures: 1, cycles: 2, concurrent: 1},
{name: "concurrent admission", cycles: 1, concurrent: 4},
} {
t.Run(tc.name, func(t *testing.T) {
store := &ledgerStore{claimed: map[string]bool{}, failures: tc.failures}
d := wired(&Daemon{
Cfg: config.NewHolder(config.Config{}), Store: store, Log: slog.New(slog.DiscardHandler),
WorkflowDefinitions: orgDefinitions{org.DefaultOrgID: "id: deploy\nrepository: none\nsteps:\n - type: workflow.finish\n"},
})
d.BindingDispatch.bindings, d.BindingDispatch.dispatcher = store, store
d.BindingDispatch.creator, d.BindingDispatch.mappings = store, store
for range tc.cycles {
var listed, done sync.WaitGroup
listed.Add(tc.concurrent)
store.listed = &listed
for range tc.concurrent {
done.Go(func() { d.BindingDispatch.dispatchBindings(t.Context()) })
}
done.Wait()
}
if store.tasks != 1 || store.markers != 1 {
t.Fatalf("tasks %d, start markers %d; want exactly one of each", store.tasks, store.markers)
}
})
}
}