mesh-sdk/go/buildstep/stale_test.go

package buildstep

import (
	"encoding/json"
	"fmt"
	stdio "git.novox.be/novox/mesh-sdk/go"
	"strings"
	"testing"
	"time"

	"git.novox.be/novox/mesh-sdk/go/delivery"
)

// scanOf is the steps a keys double holds, last value per key, its revision the count of its puts; a write through
// Update lands only at the revision read, as the state's does. race, when set, runs once before the next Update's check.
func scanOf(k *keys, race func(key string)) Scan {
	return Scan{
		Keys: func() ([]string, error) {
			k.mu.Lock()
			defer k.mu.Unlock()
			var out []string
			for key := range k.puts {
				out = append(out, key)
			}
			return out, nil
		},
		Get: func(key string) (json.RawMessage, uint64, error) {
			k.mu.Lock()
			defer k.mu.Unlock()
			s, ok := k.puts[key]
			if !ok {
				return nil, 0, nil
			}
			raw, err := delivery.EncodeStep(s[len(s)-1])
			return raw, uint64(len(s)), err
		},
		Delete: func(key string, revision uint64) error {
			k.mu.Lock()
			defer k.mu.Unlock()
			if uint64(len(k.puts[key])) != revision {
				return stdio.ErrChanged
			}
			delete(k.puts, key)
			return nil
		},
		Update: func(key string, value any, revision uint64) (uint64, error) {
			if race != nil {
				race(key)
			}
			k.mu.Lock()
			n := uint64(len(k.puts[key]))
			k.mu.Unlock()
			if n != revision {
				return 0, stdio.ErrChanged
			}
			return k.put(key, value)
		},
	}
}

// 1890 and 1890/AC6: EndStale ends this node's hand-started running steps of another owner at once, whatever their age,
// and deletes its asks of another owner (the stream redelivers them, ADR 0525 §6); of
// the steps with no owner (an older build's), the hand-started ones left running before the process began and the asks
// past the step bound (a younger ask is the stream's to redeliver); never a step this process owns or a key written
// meanwhile. EndOne ends one by hand, never one this process owns or started.
func TestEndStaleAndEndOne(t *testing.T) {
	k := newKeys()
	boot := time.Now()
	oldBoot := Boot
	Boot = boot
	defer func() { Boot = oldBoot }()
	gone := ownerOf("b00t", 4242, boot.Add(-time.Hour))
	put := func(node, id, tool, state string, started time.Time, owner string) {
		key, _ := delivery.StepKey(node, id)
		_, _ = k.put(key, json.RawMessage(mustStep(t, delivery.Step{ID: id, Tool: tool, Node: node, State: state, Started: started, Owner: owner})))
	}
	put("ace", "old1", "build_go_fetch", delivery.StepRunning, boot.Add(-time.Hour), "")
	put("ace", "mjk3l9x0abcdef", "check ask", delivery.StepRunning, boot.Add(-time.Hour), "")
	put("ace", "mjk3l9x0abcdee", "check ask", delivery.StepRunning, time.Now().Add(-5*time.Minute), "")
	put("ace", "mjk3l9x0abcded", "check ask", delivery.StepRunning, time.Now().Add(-5*time.Minute), gone) // note 21's ghost
	put("ace", "gone2", "build_go_test", delivery.StepRunning, boot.Add(time.Second), gone)
	put("ace", "mine1", "check ask", delivery.StepRunning, boot.Add(-time.Hour), Owner)
	put("ace", "raced1", "build_go_test", delivery.StepRunning, boot.Add(-time.Hour), "")
	put("ace", "new1", "build_go_fetch", delivery.StepRunning, boot.Add(time.Second), "")
	put("ace", "done1", "build_go_fetch", delivery.StepPassed, boot.Add(-time.Hour), gone)
	put("g14", "other1", "build_go_fetch", delivery.StepRunning, boot.Add(-time.Hour), gone)
	// raced1 is ended by its own run between the read and the write.
	raced := false
	scan := scanOf(k, func(key string) {
		if key == "ace.raced1" && !raced {
			raced = true
			put("ace", "raced1", "build_go_test", delivery.StepPassed, boot.Add(-time.Hour), "")
		}
	})
	var said []string
	ended, err := EndStale(scan, "ace", boot, func(f string, a ...any) { said = append(said, fmt.Sprintf(f, a...)) })
	if err != nil || len(ended) != 4 {
		t.Fatalf("ended %v, %v", ended, err)
	}
	if _, held := k.puts["ace.mjk3l9x0abcded"]; held {
		t.Errorf("the ghost ask's key is still held: %+v", k.last("ace.mjk3l9x0abcded"))
	}
	for _, key := range []string{"ace.old1", "ace.gone2"} {
		if s := k.last(key); s.State != delivery.StepFailed || s.Reason != RestartReason || s.Ended.IsZero() {
			t.Errorf("%s = %+v", key, s)
		}
	}
	if s := k.last("ace.mjk3l9x0abcdef"); s.State != delivery.StepFailed || !strings.HasPrefix(s.Reason, "past the step bound: its asker stopped waiting at ") {
		t.Errorf("the old ask = %+v", s)
	}
	if log := strings.Join(said, "\n"); !strings.Contains(log, "ace.mjk3l9x0abcded") || !strings.Contains(log, "deleted, left to the stream's redelivery") || !strings.Contains(log, "its owner "+gone+" is not this process "+Owner) {
		t.Errorf("the log does not name the ghost and its owner:\n%s", log)
	}
	for key, state := range map[string]string{"ace.mjk3l9x0abcdee": delivery.StepRunning, "ace.mine1": delivery.StepRunning, "ace.raced1": delivery.StepPassed,
		"ace.new1": delivery.StepRunning, "ace.done1": delivery.StepPassed, "g14.other1": delivery.StepRunning} {
		if s := k.last(key); s.State != state {
			t.Errorf("%s = %s, want %s", key, s.State, state)
		}
	}
	// EndOne: refuses without why, a held step, one this process owns or (with no owner) started, a step not running and
	// another node's; ends a step a previous process left.
	for _, c := range []struct{ id, why string }{{"old1", ""}, {"new1", "stuck"}, {"mine1", "stuck"}, {"done1", "x"}, {"g14.other1", "x"}} {
		if _, err := EndOne(scan, "ace", c.id, c.why, nil); err == nil {
			t.Errorf("ended %s with why %q", c.id, c.why)
		}
	}
	put("ace", "old2", "build_go_fetch", delivery.StepRunning, boot.Add(time.Second), gone)
	if _, err := EndOne(scan, "ace", "old2", "x", func(string) bool { return true }); err == nil {
		t.Error("ended a held step")
	}
	if _, err := EndOne(scan, "ace", "ace.old2", "stuck for good", nil); err != nil {
		t.Fatal(err)
	}
	if s := k.last("ace.old2"); s.State != delivery.StepFailed || s.Reason != "stuck for good" || s.Owner != gone {
		t.Errorf("old2 = %+v", s)
	}
	if a, b := ownerOf("b", 1, boot), ownerOf("b", 1, boot.Add(time.Second)); a == b {
		t.Errorf("two starts of one pid share the owner %q", a)
	}
}

func mustStep(t *testing.T, s delivery.Step) []byte {
	t.Helper()
	raw, err := delivery.EncodeStep(s)
	if err != nil {
		t.Fatal(err)
	}
	return raw
}

// 1890: AskWhat names the repository, head and levels of a check ask and the module of a build ask.
func TestAskWhat(t *testing.T) {
	check := delivery.StepAsk{Kind: "check", Check: &delivery.CheckJob{Fetch: map[string]any{"repository": "novox/mesh-sdk", "commit": "0123456789abcdef0123"}, Levels: []string{"unit", "integration"}}}
	if got, want := AskWhat(check), "check ask, novox/mesh-sdk@0123456789ab, levels unit,integration"; got != want {
		t.Errorf("check = %q", got)
	}
	build := delivery.StepAsk{Kind: "delivery", Build: &delivery.BuildJob{Module: "mesh-x", FP: "abcdef0123456789"}}
	if got, want := AskWhat(build), "delivery ask, module mesh-x, fp abcdef012345"; got != want {
		t.Errorf("build = %q", got)
	}
}