Let a bundle write a state key with its own time to live and hear its end, so wakes need no in-process timer (issue 1952)

mesh/state.create and mesh/state.put take ttl_seconds (mesh-sdk 32f5ce3's
CreateTTL/RenewTTL contract); a bucket not declared key-ttl is refused,
naming it; a watch hands an expired key as op "expire". Pins mesh-sdk 32f5ce3.

node-tools/internal/runtime/state_counter_test.go

@@ -4,8 +4,10 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"strings"
 	"sync"
 	"testing"
+	"time"
 
 	"github.com/novox/mesh-tools/node-tools/internal/bus"
 	"github.com/novox/mesh-tools/node-tools/internal/launch"
@@ -18,8 +20,10 @@ func counterBus(t *testing.T) launch.Bus {
 	t.Helper()
 	mesh := mt.New(t)
 	mesh.Bucket(t, "issues_numbers")
+	mesh.BucketKeyTTL(t, "issues_wakes")
 	m := mt.MembershipOf("issues", "anchor", false, nil)
-	m.State = []bus.StateIssued{{Name: "numbers", Bucket: "issues_numbers", Writes: true}}
+	m.State = []bus.StateIssued{{Name: "numbers", Bucket: "issues_numbers", Writes: true},
+		{Name: "wakes", Bucket: "issues_wakes", Writes: true}}
 	mesh.Issue(t, m)
 	conn := connect(t, "node-tools", "anchor")
 	conn.Follow("issues")
@@ -131,6 +135,9 @@ func TestTwoWritersIncrementingOneCounterOnTheBusLoseNoUpdate(t *testing.T) {
 // A write at a revision that is no longer the key's is refused with the lost-write code and writes
 // nothing; create is refused for a key with a value and taken for one deleted; an update names the
 // revision it read, never zero.
+// A key's own time to live (issue 1952, mesh-sdk process.State.CreateTTL and RenewTTL): created once, renewed whole by a
+// put, its end heard by a watch as an expiry; refused, writing nothing, on a bucket that takes none, under a second, and
+// on an update.
 func TestAStaleWriteIsRefusedAndWritesNothing(t *testing.T) {
 	b := counterBus(t)
 	state := func(verb string, extra map[string]any) (uint64, error) {
@@ -200,4 +207,57 @@ func TestAStaleWriteIsRefusedAndWritesNothing(t *testing.T) {
 	if v := value(); v != "1" {
 		t.Fatalf("after delete and create: %s", v)
 	}
+
+	// A time to live per key: refused where it cannot be kept, writing nothing.
+	for _, c := range []struct {
+		verb, state, why string
+		ttl              int
+	}{
+		{"create", "numbers", "does not take keys with their own time to live", 60},
+		{"put", "numbers", "does not take keys with their own time to live", 60},
+		{"create", "wakes", "shorter than the bus keeps", -1},
+		{"update", "wakes", "gives no time to live", 60},
+	} {
+		_, err := ask(b, c.verb, map[string]any{"state": c.state, "key": "late", "value": 1, "revision": 1, "ttl_seconds": c.ttl})
+		if err == nil || !strings.Contains(err.Error(), c.why) {
+			t.Errorf("%s with ttl %d on %s: want refused for %q, got %v", c.verb, c.ttl, c.state, c.why, err)
+		}
+		if raw, _ := ask(b, "get", map[string]any{"state": c.state, "key": "late"}); string(raw) != "null" {
+			t.Errorf("%s with ttl %d on %s wrote %s", c.verb, c.ttl, c.state, raw)
+		}
+	}
+
+	// Created once, renewed whole, and its end heard: a wake with no timer.
+	heard := make(chan bus.StateChange, 8)
+	stop, err := b.Watch(json.RawMessage(`{"state":"wakes"}`), func(raw json.RawMessage) error {
+		var c bus.StateChange
+		_ = json.Unmarshal(raw, &c)
+		heard <- c
+		return nil
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer stop()
+	if _, err := ask(b, "create", map[string]any{"state": "wakes", "key": "settle", "value": 1, "ttl_seconds": 60}); err != nil {
+		t.Fatalf("create with a time to live: %v", err)
+	}
+	if _, err := ask(b, "create", map[string]any{"state": "wakes", "key": "settle", "value": 2, "ttl_seconds": 60}); !isLost(err) {
+		t.Fatalf("a second create with a time to live: %v", err)
+	}
+	if _, err := ask(b, "put", map[string]any{"state": "wakes", "key": "settle", "value": 3, "ttl_seconds": 1}); err != nil {
+		t.Fatalf("a put renewing the time to live: %v", err)
+	}
+	var ops []string
+	for want := "put delete put expire"; strings.Join(ops, " ") != want; {
+		select {
+		case c := <-heard:
+			ops = append(ops, c.Op)
+			if c.Op == "put" && len(ops) == 3 && string(c.Value) != "3" {
+				t.Fatalf("the renewed key holds %s", c.Value)
+			}
+		case <-time.After(5 * time.Second):
+			t.Fatalf("the watch heard %q, want %q", strings.Join(ops, " "), want)
+		}
+	}
 }