99 lines
2.8 KiB
Go
99 lines
2.8 KiB
Go
//go:build integration
|
|
|
|
package buildstep
|
|
|
|
import (
|
|
"context"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/nats-io/nats.go"
|
|
"github.com/nats-io/nats.go/jetstream"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/delivery"
|
|
"git.novox.be/novox/mesh-sdk/go/testbus"
|
|
)
|
|
|
|
func askBus(t *testing.T, ackWait time.Duration) jetstream.JetStream {
|
|
t.Helper()
|
|
nc, err := nats.Connect(testbus.URL(t))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(nc.Close)
|
|
js, err := jetstream.New(nc)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := DeclareAskWorkers(context.Background(), js, delivery.AskGo, ackWait); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return js
|
|
}
|
|
|
|
func publishAsk(t *testing.T, js jetstream.JetStream, a delivery.StepAsk) {
|
|
t.Helper()
|
|
raw, err := delivery.EncodeStepAsk(a)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
subject, _ := delivery.AskSubject(a.Language, a.Kind)
|
|
if _, err := js.Publish(context.Background(), subject, raw); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// 1887/A2a, 1887/AC-order, 1887/AC-pull on the real server: a check ask published before a delivery ask runs after it;
|
|
// with capacity 2 and three asks two run, the third waits in the stream and starts when one ends.
|
|
func TestPullOrderAndCapacityOnTheBus(t *testing.T) {
|
|
js := askBus(t, 30*time.Second)
|
|
check, first, second := testAsk(delivery.AskCheck), testAsk(delivery.AskDelivery), testAsk(delivery.AskDelivery)
|
|
publishAsk(t, js, check)
|
|
publishAsk(t, js, first)
|
|
publishAsk(t, js, second)
|
|
release := make(chan struct{})
|
|
var mu sync.Mutex
|
|
var order []string
|
|
st := newSteps()
|
|
p := &Puller{Source: &JetStreamAsks{JS: js, Language: delivery.AskGo}, Language: delivery.AskGo, Node: "shanks", Put: st.put,
|
|
Capacity: func() int { return 2 }, PullWait: 200 * time.Millisecond,
|
|
Run: func(ctx context.Context, a delivery.StepAsk) (any, error) {
|
|
mu.Lock()
|
|
order = append(order, a.ID)
|
|
mu.Unlock()
|
|
<-release
|
|
return nil, nil
|
|
}}
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
go p.Pull(ctx)
|
|
waitFor(t, "two in hand", func() bool { return p.InHand() == 2 })
|
|
time.Sleep(500 * time.Millisecond)
|
|
mu.Lock()
|
|
if len(order) != 2 || order[0] != first.ID || order[1] != second.ID {
|
|
t.Fatalf("ran %v, want the two delivery asks %s %s first", order, first.ID, second.ID)
|
|
}
|
|
mu.Unlock()
|
|
release <- struct{}{}
|
|
waitFor(t, "the check taken", func() bool { mu.Lock(); defer mu.Unlock(); return len(order) == 3 })
|
|
close(release)
|
|
waitFor(t, "every step ended", func() bool {
|
|
for _, a := range []delivery.StepAsk{check, first, second} {
|
|
key, _ := delivery.AskStepKey("shanks", a.ID)
|
|
if s, ok := st.get(key); !ok || s.State != delivery.StepPassed {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
info, err := js.Stream(ctx, "SEAT_NODE_BUILD_GO")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
waitFor(t, "the stream empty (every ask acknowledged)", func() bool {
|
|
si, err := info.Info(ctx)
|
|
return err == nil && si.State.Msgs == 0
|
|
})
|
|
}
|