Builds: design 47 G A-373 (G-22-lead-answers-2.md), the tools' read of the keys list and pass Claude-Session: https://claude.ai/code/session_01NcbgfGKaxw984XyAPfLm4h
67 lines
2.5 KiB
Go
67 lines
2.5 KiB
Go
package grants
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
// limitStore refuses a value over the bucket's 262144 bytes, as the bus does.
|
|
type limitStore struct{ memStore }
|
|
|
|
func (l limitStore) Put(state, key string, value []byte) (uint64, error) {
|
|
if len(value) > 262144 {
|
|
return 0, errors.New("the value is over the 262144 bytes the bucket takes")
|
|
}
|
|
return l.memStore.Put(state, key, value)
|
|
}
|
|
|
|
type memObjects map[string][]byte
|
|
|
|
func (m memObjects) PutObject(name string, data []byte) error { m[name] = data; return nil }
|
|
func (m memObjects) GetObject(name string) ([]byte, error) {
|
|
if d, ok := m[name]; ok {
|
|
return d, nil
|
|
}
|
|
return nil, errors.New("no such object")
|
|
}
|
|
|
|
// Design 47 G A-373: the user list and the pass result, over 256 KB each, are written and read back through objects the keys name.
|
|
func TestAListOverTheBucketsValueIsKeptAsAnObject(t *testing.T) {
|
|
big := []byte(`{"sealed":"held: for the test","v":"` + strings.Repeat("x", 450000) + `"}`)
|
|
for _, key := range []string{KeyList, KeyPass} {
|
|
raw := limitStore{memStore{}}
|
|
if _, err := raw.Put(StateUserList, key, big); err == nil {
|
|
t.Fatal("the bucket takes a value over its limit")
|
|
}
|
|
objects := memObjects{}
|
|
s := BigValues(raw, objects)
|
|
if _, err := s.Put(StateUserList, key, big); err != nil {
|
|
t.Fatalf("%s: %v", key, err)
|
|
}
|
|
got, _, found, err := s.Get(StateUserList, key)
|
|
if err != nil || !found || !bytes.Equal(got, big) {
|
|
t.Fatalf("%s read back: %d bytes, found %v, %v", key, len(got), found, err)
|
|
}
|
|
// The tools' reader holds no objects: it is shown the small fields and where the rest is, never an empty answer.
|
|
part, _, found, err := BigValues(raw, nil).Get(StateUserList, key)
|
|
if err != nil || !found || !strings.Contains(string(part), BigObjectName(key)) || !strings.Contains(string(part), `"partial"`) || !strings.Contains(string(part), "held: for the test") {
|
|
t.Errorf("%s read with no objects: %s, %v", key, part, err)
|
|
}
|
|
// A write that cannot be made stays an error.
|
|
if _, err := BigValues(raw, failingObjects{}).Put(StateUserList, key, big); err == nil {
|
|
t.Errorf("%s: an object that could not be put is no error", key)
|
|
}
|
|
// Another key and a small value are kept as they were.
|
|
small := []byte(`{"a":1}`)
|
|
if _, err := s.Put(StateUserList, KeyAsked, small); err != nil || len(objects) != 1 {
|
|
t.Errorf("another key: %v, objects %v", err, objects)
|
|
}
|
|
}
|
|
}
|
|
|
|
type failingObjects struct{ memObjects }
|
|
|
|
func (failingObjects) PutObject(string, []byte) error { return errors.New("refused") }
|