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

package kstore_kv

import (
	"os"
	"testing"
	"time"

	"gitp78su.ipnodns.ru/svi/kern/v4/lev0/defs/stream_name"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev1/mock_env"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev2/kctx"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev2/kspec"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev2/lsi/store_ent"
	"gitp78su.ipnodns.ru/svi/kern/v4/lev2/lsi/store_ent/rec_key"
)

type tester struct {
	t   *testing.T
	me  *mock_env.MockEnv
	ctx kspec.IKernelCtx
	wg  kspec.IKernelWg
}

func TestKernelStore(t *testing.T) {
	kCtx := kctx.GetKernelCtx()
	sf := &tester{
		t:   t,
		me:  mock_env.MakeEnv(),
		ctx: kCtx,
		wg:  kCtx.Wg(),
	}
	_ = os.Unsetenv("LOCAL_STORE_PATH")
	_ = os.Setenv("LOCAL_STORE_PATH", "/store/store_kernel")
	fnClear := func() {
		pwd := sf.me.Pwd() + "/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(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(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 := string(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(key, val)
	res := kernStore.Set(rec)
	if res.IsErr() {
		sf.t.Fatalf("set(): err=%v", res.Err())
	}
}

var (
	qName = stream_name.NewAStreamName("123")
)

// Закрытие хранилища.
func (sf *tester) close() {
	sf.t.Log("close")
	sf.wg.Add(qName)
	sf.ctx.Cancel()
	time.Sleep(time.Millisecond * 20)
	go sf.wg.Done(qName)
	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")
	}
}