mesh-sdk/go/process/state_test.go

package process

import (
	"context"
	"errors"
	"sort"
	"strings"
	"sync"
	"testing"

	"github.com/nats-io/nats.go/jetstream"

	stdio "git.novox.be/novox/mesh-sdk/go"
	"git.novox.be/novox/mesh-sdk/go/asker"
)

// fakeEntry is a fakeKV's KeyValueEntry: only Key, Value and Revision are read by State.
type fakeEntry struct {
	jetstream.KeyValueEntry
	key   string
	value []byte
	rev   uint64
}

func (e fakeEntry) Key() string      { return e.key }
func (e fakeEntry) Value() []byte    { return e.value }
func (e fakeEntry) Revision() uint64 { return e.rev }

// fakeKV is an in-memory jetstream.KeyValue: embedding the nil interface satisfies every method this test
// never calls, so only Get, Create and Update need a body (1188/AC2's "a fake KV").
type fakeKV struct {
	jetstream.KeyValue
	mu     sync.Mutex
	values map[string][]byte
	revs   map[string]uint64
	next   uint64
}

func newFakeKV() *fakeKV { return &fakeKV{values: map[string][]byte{}, revs: map[string]uint64{}} }

func (f *fakeKV) Get(_ context.Context, key string) (jetstream.KeyValueEntry, error) {
	f.mu.Lock()
	defer f.mu.Unlock()
	v, ok := f.values[key]
	if !ok {
		return nil, jetstream.ErrKeyNotFound
	}
	return fakeEntry{key: key, value: v, rev: f.revs[key]}, nil
}

func (f *fakeKV) Create(_ context.Context, key string, value []byte, _ ...jetstream.KVCreateOpt) (uint64, error) {
	f.mu.Lock()
	defer f.mu.Unlock()
	if _, ok := f.values[key]; ok {
		return 0, jetstream.ErrKeyExists
	}
	f.next++
	f.values[key], f.revs[key] = value, f.next
	return f.next, nil
}

func (f *fakeKV) Update(_ context.Context, key string, value []byte, revision uint64) (uint64, error) {
	f.mu.Lock()
	defer f.mu.Unlock()
	if f.revs[key] != revision {
		return 0, jetstream.ErrKeyRevisionMismatch
	}
	f.next++
	f.values[key], f.revs[key] = value, f.next
	return f.next, nil
}

func (f *fakeKV) Put(_ context.Context, key string, value []byte) (uint64, error) {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.next++
	f.values[key], f.revs[key] = value, f.next
	return f.next, nil
}

func (f *fakeKV) Keys(_ context.Context, _ ...jetstream.WatchOpt) ([]string, error) {
	f.mu.Lock()
	defer f.mu.Unlock()
	if len(f.values) == 0 {
		return nil, jetstream.ErrNoKeysFound
	}
	keys := make([]string, 0, len(f.values))
	for k := range f.values {
		keys = append(keys, k)
	}
	sort.Sort(sort.Reverse(sort.StringSlice(keys))) // as a bucket lists them: in no order the caller may rely on
	return keys, nil
}

func stateOn(kv jetstream.KeyValue) State {
	return State{Module: "mesh-mail", Name: "sends", kv: func(context.Context) (jetstream.KeyValue, error) { return kv, nil }}
}

// 1188/AC2: given the process connection's state type, when used as go/asker's Store, then it compiles and
// behaves as the interface says, against a fake KV.
func TestStateSatisfiesAskerStore(t *testing.T) {
	var _ asker.Store = State{}

	s := stateOn(newFakeKV())
	if e, err := s.Get("ask.1"); err != nil || e != nil {
		t.Fatalf("Get of an absent key: %v, %v", e, err)
	}
	rev, err := s.Create("ask.1", map[string]any{"a": 1})
	if err != nil {
		t.Fatalf("Create: %v", err)
	}
	e, err := s.Get("ask.1")
	if err != nil || e == nil || e.Revision != rev {
		t.Fatalf("Get after Create: %+v, %v", e, err)
	}
	if _, err := s.Create("ask.1", map[string]any{"a": 2}); !errors.Is(err, stdio.ErrChanged) {
		t.Fatalf("Create of an existing key: %v, want stdio.ErrChanged", err)
	}
	rev2, err := s.Update("ask.1", map[string]any{"a": 3}, rev)
	if err != nil {
		t.Fatalf("Update at the revision read: %v", err)
	}
	if _, err := s.Update("ask.1", map[string]any{"a": 4}, rev); !errors.Is(err, stdio.ErrChanged) {
		t.Fatalf("Update at a stale revision: %v, want stdio.ErrChanged", err)
	}
	if rev2 == rev {
		t.Fatal("Update did not advance the revision")
	}
}

// 1840/S1: given a state, when a key is put twice, then each Put returns a new revision and the key reads
// back the last value, whether or not it had one.
func TestStatePutWritesAKeyWhole(t *testing.T) {
	s := stateOn(newFakeKV())
	rev, err := s.Put("k", map[string]any{"a": 1})
	if err != nil || rev == 0 {
		t.Fatalf("Put of a new key: %d, %v", rev, err)
	}
	rev2, err := s.Put("k", map[string]any{"a": 2})
	if err != nil || rev2 <= rev {
		t.Fatalf("Put over a key: %d, %v, want a revision after %d", rev2, err, rev)
	}
	e, err := s.Get("k")
	if err != nil || e == nil || e.Revision != rev2 || string(e.Value) != `{"a":2}` {
		t.Fatalf("Get after Put: %+v, %v", e, err)
	}
}

// 1840/S1: given a state, when its keys are listed, then they come sorted, and none is an empty list, not an error.
func TestStateKeysAreSortedAndEmptyWhenNone(t *testing.T) {
	s := stateOn(newFakeKV())
	if keys, err := s.Keys(); err != nil || len(keys) != 0 {
		t.Fatalf("Keys of an empty state: %v, %v", keys, err)
	}
	for _, k := range []string{"b", "c", "a"} {
		if _, err := s.Put(k, 1); err != nil {
			t.Fatal(err)
		}
	}
	keys, err := s.Keys()
	if err != nil || strings.Join(keys, ",") != "a,b,c" {
		t.Fatalf("Keys: %v, %v, want a,b,c", keys, err)
	}
}