106 lines
2.9 KiB
Go
106 lines
2.9 KiB
Go
package k2v_test
|
|
|
|
import (
|
|
k2v "code.notaphish.fyi/milas/garage-k2v-go"
|
|
"fmt"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"math/rand/v2"
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestClient_ReadBatch(t *testing.T) {
|
|
f, ctx := newFixture(t)
|
|
|
|
pk1 := randomKey("pk1")
|
|
sk1 := randomKey("sk1")
|
|
require.NoError(t, f.cli.InsertItem(ctx, f.bucket, pk1, sk1, "", []byte(strings.Join([]string{"hello", pk1, sk1}, "-"))))
|
|
|
|
pk2 := randomKey("pk2")
|
|
sk2 := randomKey("sk2")
|
|
for i := range 5 {
|
|
require.NoError(t, f.cli.InsertItem(ctx, f.bucket, pk2, sk2, "", []byte(strings.Join([]string{"hello", pk2, sk2, strconv.Itoa(i)}, "-"))))
|
|
}
|
|
|
|
pk3 := randomKey("pk3")
|
|
for i := range 5 {
|
|
skN := randomKey(fmt.Sprintf("sk%d", i+3))
|
|
require.NoError(t, f.cli.InsertItem(ctx, f.bucket, pk3, skN, "", []byte(strings.Join([]string{"hello", pk3, skN, strconv.Itoa(i)}, "-"))))
|
|
}
|
|
|
|
q := []k2v.BatchSearch{
|
|
{
|
|
PartitionKey: pk1,
|
|
},
|
|
{
|
|
PartitionKey: pk2,
|
|
SingleItem: true,
|
|
Start: sk2,
|
|
},
|
|
{
|
|
PartitionKey: pk3,
|
|
},
|
|
}
|
|
|
|
results, err := f.cli.ReadBatch(ctx, f.bucket, q)
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, results)
|
|
require.Len(t, results, 3)
|
|
|
|
assert.Equal(t, pk1, results[0].PartitionKey)
|
|
if assert.Len(t, results[0].Items, 1) && assert.Len(t, results[0].Items[0].Values, 1) {
|
|
assert.Equal(t, sk1, results[0].Items[0].SortKey)
|
|
assert.NotEmpty(t, results[0].Items[0].CausalityToken)
|
|
assert.Contains(t, results[0].Items[0].Values[0].GoString(), "hello")
|
|
}
|
|
|
|
assert.Equal(t, pk2, results[1].PartitionKey)
|
|
if assert.Len(t, results[1].Items, 1) && assert.Len(t, results[1].Items[0].Values, 5) {
|
|
assert.Equal(t, sk2, results[1].Items[0].SortKey)
|
|
assert.NotEmpty(t, results[1].Items[0].CausalityToken)
|
|
for i := range results[1].Items[0].Values {
|
|
assert.Contains(t, results[1].Items[0].Values[i].GoString(), "hello")
|
|
}
|
|
}
|
|
|
|
assert.Equal(t, pk3, results[2].PartitionKey)
|
|
if assert.Len(t, results[2].Items, 5) {
|
|
for _, item := range results[2].Items {
|
|
assert.NotEmpty(t, item.SortKey)
|
|
assert.NotEmpty(t, item.CausalityToken)
|
|
if assert.Len(t, item.Values, 1) {
|
|
assert.Contains(t, item.Values[0].GoString(), "hello")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestBulkGet(t *testing.T) {
|
|
f, ctx := newFixture(t)
|
|
|
|
keys := make([]k2v.ItemKey, 500)
|
|
for i := range keys {
|
|
keys[i] = k2v.ItemKey{
|
|
PartitionKey: randomPk(),
|
|
SortKey: randomSk(),
|
|
}
|
|
require.NoError(t, f.cli.InsertItem(ctx, f.bucket, keys[i].PartitionKey, keys[i].SortKey, "", []byte("hello"+strconv.Itoa(i))))
|
|
}
|
|
|
|
rand.Shuffle(len(keys), func(i, j int) {
|
|
keys[i], keys[j] = keys[j], keys[i]
|
|
})
|
|
|
|
items, err := k2v.BulkGet(ctx, f.cli, f.bucket, keys)
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, items)
|
|
|
|
require.Equal(t, len(keys), len(items))
|
|
for i := range keys {
|
|
require.Equal(t, keys[i].SortKey, items[i].SortKey)
|
|
require.Len(t, items[i].Values, 1)
|
|
require.Contains(t, string(items[i].Values[0]), "hello")
|
|
}
|
|
}
|