kern/v4/d2/lsi/kstore_kv/kstore_kv_test.go

package kstore_kv

import (
	"os"
	"testing"
	"time"

	"gitp78su.ipnodns.ru/svi/kern/v4/d0"
	"gitp78su.ipnodns.ru/svi/kern/v4/d1/mock_env"
	"gitp78su.ipnodns.ru/svi/kern/v4/d2/kern_ctx"
	"gitp78su.ipnodns.ru/svi/kern/v4/d2/kern_ent/stream_name"
	"gitp78su.ipnodns.ru/svi/kern/v4/d2/kspec"
	"gitp78su.ipnodns.ru/svi/kern/v4/d2/lsi/store_ent"
	"gitp78su.ipnodns.ru/svi/kern/v4/d2/lsi/store_ent/rec_key"
)

type tester struct {
	t     *testing.T
	me    *mock_env.MockEnv
	ctx   *kern_ctx.KernCtx
	wg    kspec.IKernelWg
	owner *d0.LOwner
	streamName *stream_name.AStreamName
}

func TestKernelStore(t *testing.T) {
	kCtx := kern_ctx.GetKernCtx()
	owner := d0.LetOwner(1, "test_isol_kern_store")
	sf := &tester{
		t:     t,
		me:    mock_env.MakeEnv(owner),
		ctx:   kCtx,
		wg:    kCtx.Wg(),
		owner: owner,
		streamName: stream_name.NewAStreamName(owner, "123"),
	}
	_ = os.Unsetenv("LOCAL_STORE_PATH")
	_ = os.Setenv("LOCAL_STORE_PATH", "/store/store_kernel")
	fnClear := func() {
		pwd := sf.me.Pwd().String() + "/store/store_kernel"
		_ = os.RemoveAll(pwd)
	}
	fnClear()
	sf.new()
	sf.set()
	sf.get()
	sf.byPrefix()
	sf.del()
	sf.close()
	sf.workBad1()
	time.Sleep(time.Second * 2)
}

// Установка ключа после закрытия хранилища.
func (sf *tester) workBad1() {
	sf.t.Log("workBad1")
	key := store_ent.NewStoreKeyFix("test_key")
	recVal := store_ent.NewRecValFix([]byte("test_val"))
	rec := store_ent.NewRecKvFix(sf.owner, key, recVal)
	res := kernStore.Set(rec)
	if res.IsOk() {
		sf.t.Fatalf("workBad1(): set, err==nil")
	}
	strKey := store_ent.NewStoreKeyFix("test_key")
	opt := kernStore.Get(strKey)
	if opt.IsOk() {
		sf.t.Fatalf("workBad1(): get, val==nil")
	}
	res = kernStore.Delete(strKey)
	if res.IsOk() {
		sf.t.Fatalf("workBad1(): del, err==nil")
	}
}

// Удаляет значение.
func (sf *tester) del() {
	sf.t.Log("del")
	key := store_ent.NewStoreKeyFix("test_key")
	res := kernStore.Delete(key)
	if res.IsErr() {
		sf.t.Fatalf("del(): err=%v", res.Err())
	}
	opt := kernStore.Get(key)
	if opt.IsOk() {
		sf.t.Fatalf("del(): val!=nil")
	}
}

// Поиск по префиксу.
func (sf *tester) byPrefix() {
	sf.t.Log("byPrefix")
	key := rec_key.NewRecKey("test_key2")
	val := store_ent.NewRecValFix([]byte("test_val"))
	rec := store_ent.NewRecKvFix(sf.owner, key, val)
	res0 := kernStore.Set(rec)
	if res0.IsErr() {
		sf.t.Fatalf("byPrefix(): err=%v", res0.Err())
	}
	key = rec_key.NewRecKey("test")
	res := kernStore.ByPrefix(key)
	res.Hassert("byPrefix(): val == nil")
	lstKey := res.Ok()
	if len(lstKey) != 2 {
		sf.t.Fatalf("byPrefix(): len(%v)!=2", len(lstKey))
	}
}

// Получение значения по ключу.
func (sf *tester) get() {
	sf.t.Log("get")
	key := rec_key.NewRecKey("test_key")
	res := kernStore.Get(key)
	res.Hassert("get(): val==nil")
	strVal := d0.Txt(res.Ok())
	if strVal != "test_val" {
		sf.t.Fatalf("get(): strVal(%v)!='test_val'", strVal)
	}
}

// Добавление ключа в хранилище.
func (sf *tester) set() {
	sf.t.Log("set")
	key := rec_key.NewRecKey("test_key")
	val := store_ent.NewRecValFix([]byte("test_val"))
	rec := store_ent.NewRecKvFix(sf.owner, key, val)
	res := kernStore.Set(rec)
	if res.IsErr() {
		sf.t.Fatalf("set(): err=%v", res.Err())
	}
}

// Закрытие хранилища.
func (sf *tester) close() {
	sf.t.Log("close")
	sf.wg.Add(sf.streamName)
	sf.ctx.Cancel()
	time.Sleep(time.Millisecond * 20)
	go sf.wg.Done(sf.streamName)
	sf.wg.Wait()
	kernStore.close()
	prefix := store_ent.NewStoreKeyFix("test")
	res1 := kernStore.ByPrefix(prefix)
	if res1.IsOk() {
		sf.t.Fatalf("close(): val!=nil")
	}
}

// Создаёт новое хранилище ядра.
func (sf *tester) new() {
	sf.t.Log("new")
	sf.newGood1()
}

func (sf *tester) newGood1() {
	sf.t.Log("newGood1")
	defer func() {
		if _panic := recover(); _panic != nil {
			sf.t.Fatalf("newGood1(): panic=%v", _panic)
		}
	}()
	_ = GetKernelStore()
	store := GetKernelStore()
	if log := store.Log(); log == nil {
		sf.t.Fatalf("newGood1(): log==nil")
	}
}