milvus/internal/kv/mem/mem_kv_test.go
Letian Jiang 442e791128
Add ByteSlice Method for memkv (#15774)
Signed-off-by: Letian Jiang <letian.jiang@zilliz.com>
2022-03-02 17:29:56 +08:00

261 lines
6.5 KiB
Go

// Licensed to the LF AI & Data foundation under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package memkv
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestMemoryKV_SaveAndLoadBytes(t *testing.T) {
mem := NewMemoryKV()
key := "key"
value := []byte("value")
err := mem.SaveBytes(key, value)
assert.NoError(t, err)
_value, err := mem.LoadBytes(key)
assert.NoError(t, err)
assert.Equal(t, value, _value)
noKey := "no_key"
_value, err = mem.LoadBytes(noKey)
assert.NoError(t, err)
assert.Empty(t, _value)
}
func TestMemoryKV_LoadBytesRange(t *testing.T) {
saveAndLoadBytesTests := []struct {
key string
value []byte
}{
{"test1", []byte("value1")},
{"test2", []byte("value2")},
{"test1/a", []byte("value_a")},
{"test1/b", []byte("value_b")},
}
mem := NewMemoryKV()
for _, kv := range saveAndLoadBytesTests {
err := mem.SaveBytes(kv.key, kv.value)
assert.NoError(t, err)
}
keys, values, err := mem.LoadBytesRange("test1", "test1/b", 0)
assert.Equal(t, len(keys), 2)
assert.Equal(t, len(values), 2)
assert.NoError(t, err)
keys, values, err = mem.LoadBytesRange("test1", "test1/a", 2)
assert.Equal(t, len(keys), 1)
assert.Equal(t, len(values), 1)
assert.NoError(t, err)
}
func TestMemoryKV_LoadBytesWithDefault(t *testing.T) {
mem := NewMemoryKV()
key := "key"
value := []byte("value")
err := mem.SaveBytes(key, value)
assert.NoError(t, err)
_default := []byte("default")
_value := mem.LoadBytesWithDefault(key, _default)
assert.Equal(t, value, _value)
noKey := "no_key"
_value = mem.LoadBytesWithDefault(noKey, _default)
assert.Equal(t, _value, _default)
}
func TestMemoryKV_LoadBytesWithPrefix(t *testing.T) {
saveAndLoadBytesTests := []struct {
key string
value []byte
}{
{"test1", []byte("value1")},
{"test2", []byte("value2")},
{"test1/a", []byte("value_a")},
{"test1/b", []byte("value_b")},
}
mem := NewMemoryKV()
for _, kv := range saveAndLoadBytesTests {
err := mem.SaveBytes(kv.key, kv.value)
assert.NoError(t, err)
}
keys, values, err := mem.LoadBytesWithPrefix("test1")
assert.Equal(t, len(keys), 3)
assert.Equal(t, len(values), 3)
assert.NoError(t, err)
keys, values, err = mem.LoadBytesWithPrefix("test")
assert.Equal(t, len(keys), 4)
assert.Equal(t, len(values), 4)
assert.NoError(t, err)
keys, values, err = mem.LoadBytesWithPrefix("a")
assert.Equal(t, len(keys), 0)
assert.Equal(t, len(values), 0)
assert.NoError(t, err)
}
func TestMemoryKV_MultiSaveBytes(t *testing.T) {
saveAndLoadBytesTests := map[string][]byte{
"test1": []byte("value1"),
"test2": []byte("value2"),
"test1/a": []byte("value_a"),
"test1/b": []byte("value_b"),
}
var keys []string
var values [][]byte
for k, v := range saveAndLoadBytesTests {
keys = append(keys, k)
values = append(values, v)
}
mem := NewMemoryKV()
err := mem.MultiSaveBytes(saveAndLoadBytesTests)
assert.NoError(t, err)
_values, err := mem.MultiLoadBytes(keys)
assert.Equal(t, values, _values)
assert.NoError(t, err)
_values, err = mem.MultiLoadBytes([]string{})
assert.Empty(t, _values)
assert.NoError(t, err)
}
func TestMemoryKV_MultiSaveBytesAndRemove(t *testing.T) {
saveAndLoadBytesTests := map[string][]byte{
"test1": []byte("value1"),
"test2": []byte("value2"),
"test1/a": []byte("value_a"),
"test1/b": []byte("value_b"),
}
var keys []string
var values [][]byte
for k, v := range saveAndLoadBytesTests {
keys = append(keys, k)
values = append(values, v)
}
mem := NewMemoryKV()
err := mem.MultiSaveBytesAndRemove(saveAndLoadBytesTests, []string{keys[0]})
assert.NoError(t, err)
_value, err := mem.LoadBytes(keys[0])
assert.Empty(t, _value)
assert.NoError(t, err)
_values, err := mem.MultiLoadBytes(keys[1:])
assert.Equal(t, values[1:], _values)
assert.NoError(t, err)
}
func TestMemoryKV_MultiSaveBytesAndRemoveWithPrefix(t *testing.T) {
saveAndLoadBytesTests := map[string][]byte{
"test1": []byte("value1"),
"test2": []byte("value2"),
"test1/a": []byte("value_a"),
"test1/b": []byte("value_b"),
}
var keys []string
var values [][]byte
for k, v := range saveAndLoadBytesTests {
keys = append(keys, k)
values = append(values, v)
}
mem := NewMemoryKV()
err := mem.MultiSaveBytesAndRemoveWithPrefix(saveAndLoadBytesTests, []string{"test1"})
assert.NoError(t, err)
_keys, _values, err := mem.LoadBytesWithPrefix("test")
assert.ElementsMatch(t, keys, _keys)
assert.ElementsMatch(t, values, _values)
assert.NoError(t, err)
}
func TestMemoryKV_LoadPartial(t *testing.T) {
memKV := NewMemoryKV()
key := "TestMemoryKV_LoadPartial_key"
value := "TestMemoryKV_LoadPartial_value"
err := memKV.Save(key, value)
assert.NoError(t, err)
var start, end int64
var partial []byte
// case 0 <= start && start = end && end <= int64(len(value))
start, end = 1, 2
partial, err = memKV.LoadPartial(key, start, end)
assert.NoError(t, err)
assert.ElementsMatch(t, partial, []byte(value[start:end]))
start, end = int64(len(value)-2), int64(len(value)-1)
partial, err = memKV.LoadPartial(key, start, end)
assert.NoError(t, err)
assert.ElementsMatch(t, partial, []byte(value[start:end]))
// error case
start, end = 5, 3
_, err = memKV.LoadPartial(key, start, end)
assert.Error(t, err)
start, end = 1, 1
_, err = memKV.LoadPartial(key, start, end)
assert.Error(t, err)
err = memKV.Remove(key)
assert.NoError(t, err)
start, end = 1, 2
_, err = memKV.LoadPartial(key, start, end)
assert.Error(t, err)
}
func TestMemoryKV_GetSize(t *testing.T) {
memKV := NewMemoryKV()
key := "TestMemoryKV_GetSize_key"
value := "TestMemoryKV_GetSize_value"
err := memKV.Save(key, value)
assert.NoError(t, err)
size, err := memKV.GetSize(key)
assert.NoError(t, err)
assert.Equal(t, size, int64(len(value)))
key2 := "TestMemoryKV_GetSize_key2"
size, err = memKV.GetSize(key2)
assert.NoError(t, err)
assert.Equal(t, int64(0), size)
}