aboutsummaryrefslogtreecommitdiffhomepage
path: root/internal/store/store_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'internal/store/store_test.go')
-rw-r--r--internal/store/store_test.go83
1 files changed, 44 insertions, 39 deletions
diff --git a/internal/store/store_test.go b/internal/store/store_test.go
index db1a4c71..0e013177 100644
--- a/internal/store/store_test.go
+++ b/internal/store/store_test.go
@@ -1,4 +1,4 @@
-package store
+package store_test
import (
"cmp"
@@ -10,18 +10,23 @@ import (
"strings"
"syscall"
"testing"
+ _ "unsafe"
"hakurei.app/container/check"
"hakurei.app/hst"
+ "hakurei.app/internal/store"
)
+//go:linkname bigLock hakurei.app/internal/store.(*Store).bigLock
+func bigLock(s *store.Store) (unlock func(), err error)
+
func TestStateStoreBigLock(t *testing.T) {
t.Parallel()
{
- s := newStore(check.MustAbs(t.TempDir()).Append("state"))
+ s := store.New(check.MustAbs(t.TempDir()).Append("state"))
for i := 0; i < 2; i++ { // check once behaviour
- if unlock, err := s.bigLock(); err != nil {
+ if unlock, err := bigLock(s); err != nil {
t.Fatalf("bigLock: error = %v", err)
} else {
unlock()
@@ -35,7 +40,7 @@ func TestStateStoreBigLock(t *testing.T) {
wantErr := &hst.AppError{Step: "create state store directory",
Err: &os.PathError{Op: "mkdir", Path: "/proc/nonexistent", Err: syscall.ENOENT}}
for i := 0; i < 2; i++ { // check once behaviour
- if _, err := newStore(check.MustAbs("/proc/nonexistent")).bigLock(); !reflect.DeepEqual(err, wantErr) {
+ if _, err := bigLock(store.New(check.MustAbs("/proc/nonexistent"))); !reflect.DeepEqual(err, wantErr) {
t.Errorf("bigLock: error = %#v, want %#v", err, wantErr)
}
}
@@ -50,35 +55,35 @@ func TestStateStoreBigLock(t *testing.T) {
}
wantErr := &hst.AppError{Step: "acquire lock on the state store",
- Err: &os.PathError{Op: "open", Path: base.Append(storeMutexName).String(), Err: syscall.EACCES}}
- if _, err := newStore(base).bigLock(); !reflect.DeepEqual(err, wantErr) {
+ Err: &os.PathError{Op: "open", Path: base.Append(store.MutexName).String(), Err: syscall.EACCES}}
+ if _, err := bigLock(store.New(base)); !reflect.DeepEqual(err, wantErr) {
t.Errorf("bigLock: error = %#v, want %#v", err, wantErr)
}
})
}
-func TestStateStoreIdentityHandle(t *testing.T) {
+func TestStateStoreHandle(t *testing.T) {
t.Parallel()
t.Run("loadstore", func(t *testing.T) {
t.Parallel()
- s := newStore(check.MustAbs(t.TempDir()).Append("store"))
+ s := store.New(check.MustAbs(t.TempDir()).Append("store"))
- var handleAddr [8]*storeHandle
+ var handleAddr [8]*store.Handle
checkHandle := func(identity int, load bool) {
- if h, err := s.identityHandle(identity); err != nil {
- t.Fatalf("identityHandle: error = %v", err)
+ if h, err := s.Handle(identity); err != nil {
+ t.Fatalf("Handle: error = %v", err)
} else if load != (handleAddr[identity] != nil) {
- t.Fatalf("identityHandle: load = %v, want %v", load, handleAddr[identity] != nil)
+ t.Fatalf("Handle: load = %v, want %v", load, handleAddr[identity] != nil)
} else if !load {
handleAddr[identity] = h
- if h.identity != identity {
- t.Errorf("identityHandle: identity = %d, want %d", h.identity, identity)
+ if h.Identity != identity {
+ t.Errorf("Handle: identity = %d, want %d", h.Identity, identity)
}
} else if h != handleAddr[identity] {
- t.Fatalf("identityHandle: %p, want %p", h, handleAddr[identity])
+ t.Fatalf("Handle: %p, want %p", h, handleAddr[identity])
}
}
@@ -103,9 +108,9 @@ func TestStateStoreIdentityHandle(t *testing.T) {
}
wantErr := &hst.AppError{Step: "acquire lock on the state store",
- Err: &os.PathError{Op: "open", Path: base.Append(storeMutexName).String(), Err: syscall.EACCES}}
- if _, err := newStore(base).identityHandle(0); !reflect.DeepEqual(err, wantErr) {
- t.Errorf("identityHandle: error = %#v, want %#v", err, wantErr)
+ Err: &os.PathError{Op: "open", Path: base.Append(store.MutexName).String(), Err: syscall.EACCES}}
+ if _, err := store.New(base).Handle(0); !reflect.DeepEqual(err, wantErr) {
+ t.Errorf("Handle: error = %#v, want %#v", err, wantErr)
}
})
@@ -116,7 +121,7 @@ func TestStateStoreIdentityHandle(t *testing.T) {
if err := os.MkdirAll(base.String(), 0700); err != nil {
t.Fatal(err.Error())
}
- if f, err := os.Create(base.Append(storeMutexName).String()); err != nil {
+ if f, err := os.Create(base.Append(store.MutexName).String()); err != nil {
t.Fatal(err.Error())
} else if err = f.Close(); err != nil {
t.Fatal(err.Error())
@@ -132,8 +137,8 @@ func TestStateStoreIdentityHandle(t *testing.T) {
wantErr := &hst.AppError{Step: "create store segment directory",
Err: &os.PathError{Op: "mkdir", Path: base.Append("0").String(), Err: syscall.EACCES}}
- if _, err := newStore(base).identityHandle(0); !reflect.DeepEqual(err, wantErr) {
- t.Errorf("identityHandle: error = %#v, want %#v", err, wantErr)
+ if _, err := store.New(base).Handle(0); !reflect.DeepEqual(err, wantErr) {
+ t.Errorf("Handle: error = %#v, want %#v", err, wantErr)
}
})
}
@@ -144,8 +149,8 @@ func TestStateStoreSegments(t *testing.T) {
testCases := []struct {
name string
ents [2][]string
- want []segmentIdentity
- ext func(t *testing.T, segments iter.Seq[segmentIdentity], n int)
+ want []store.SegmentIdentity
+ ext func(t *testing.T, segments iter.Seq[store.SegmentIdentity], n int)
}{
{"errors", [2][]string{{
"f0-invalid-file",
@@ -153,7 +158,7 @@ func TestStateStoreSegments(t *testing.T) {
"f1-invalid-syntax",
"9999",
"16384",
- }}, []segmentIdentity{
+ }}, []store.SegmentIdentity{
{-1, &hst.AppError{Step: "process store segment", Err: syscall.EISDIR,
Msg: `skipped non-directory entry "f0-invalid-file"`}},
{-1, &hst.AppError{Step: "process store segment", Err: syscall.ERANGE,
@@ -180,7 +185,7 @@ func TestStateStoreSegments(t *testing.T) {
"20",
"31",
"197",
- }}, []segmentIdentity{
+ }}, []store.SegmentIdentity{
{0, nil},
{1, nil},
{2, nil},
@@ -194,9 +199,9 @@ func TestStateStoreSegments(t *testing.T) {
{20, nil},
{31, nil},
{197, nil},
- }, func(t *testing.T, segments iter.Seq[segmentIdentity], n int) {
+ }, func(t *testing.T, segments iter.Seq[store.SegmentIdentity], n int) {
if n != 13 {
- t.Fatalf("segments: n = %d", n)
+ t.Fatalf("Segments: n = %d", n)
}
// check partial drain
@@ -215,24 +220,24 @@ func TestStateStoreSegments(t *testing.T) {
}
createEntries(t, base, tc.ents)
- var got []segmentIdentity
- if segments, n, err := newStore(base).segments(); err != nil {
- t.Fatalf("segments: error = %v", err)
+ var got []store.SegmentIdentity
+ if segments, n, err := store.New(base).Segments(); err != nil {
+ t.Fatalf("Segments: error = %v", err)
} else {
- got = slices.AppendSeq(make([]segmentIdentity, 0, n), segments)
+ got = slices.AppendSeq(make([]store.SegmentIdentity, 0, n), segments)
if tc.ext != nil {
tc.ext(t, segments, n)
}
}
- slices.SortFunc(got, func(a, b segmentIdentity) int {
- if a.identity == b.identity {
- return strings.Compare(a.err.Error(), b.err.Error())
+ slices.SortFunc(got, func(a, b store.SegmentIdentity) int {
+ if a.Identity == b.Identity {
+ return strings.Compare(a.Err.Error(), b.Err.Error())
}
- return cmp.Compare(a.identity, b.identity)
+ return cmp.Compare(a.Identity, b.Identity)
})
if !reflect.DeepEqual(got, tc.want) {
- t.Errorf("segments: %#v, want %#v", got, tc.want)
+ t.Errorf("Segments: %#v, want %#v", got, tc.want)
}
})
}
@@ -246,9 +251,9 @@ func TestStateStoreSegments(t *testing.T) {
}
wantErr := &hst.AppError{Step: "acquire lock on the state store",
- Err: &os.PathError{Op: "open", Path: base.Append(storeMutexName).String(), Err: syscall.EACCES}}
- if _, _, err := newStore(base).segments(); !reflect.DeepEqual(err, wantErr) {
- t.Errorf("segments: error = %#v, want %#v", err, wantErr)
+ Err: &os.PathError{Op: "open", Path: base.Append(store.MutexName).String(), Err: syscall.EACCES}}
+ if _, _, err := store.New(base).Segments(); !reflect.DeepEqual(err, wantErr) {
+ t.Errorf("Segments: error = %#v, want %#v", err, wantErr)
}
})
}
generated by cgit v1.3.1 (git 2.54.0) at 2026-08-29 23:59:12 +0000