github.com/safing/portbase@v0.19.5/database/storage/hashmap/map_test.go (about)

     1  package hashmap
     2  
     3  import (
     4  	"reflect"
     5  	"sync"
     6  	"testing"
     7  
     8  	"github.com/safing/portbase/database/query"
     9  	"github.com/safing/portbase/database/record"
    10  	"github.com/safing/portbase/database/storage"
    11  )
    12  
    13  var (
    14  	// Compile time interface checks.
    15  	_ storage.Interface = &HashMap{}
    16  	_ storage.Batcher   = &HashMap{}
    17  )
    18  
    19  type TestRecord struct { //nolint:maligned
    20  	record.Base
    21  	sync.Mutex
    22  	S    string
    23  	I    int
    24  	I8   int8
    25  	I16  int16
    26  	I32  int32
    27  	I64  int64
    28  	UI   uint
    29  	UI8  uint8
    30  	UI16 uint16
    31  	UI32 uint32
    32  	UI64 uint64
    33  	F32  float32
    34  	F64  float64
    35  	B    bool
    36  }
    37  
    38  func TestHashMap(t *testing.T) {
    39  	t.Parallel()
    40  
    41  	// start
    42  	db, err := NewHashMap("test", "")
    43  	if err != nil {
    44  		t.Fatal(err)
    45  	}
    46  
    47  	a := &TestRecord{
    48  		S:    "banana",
    49  		I:    42,
    50  		I8:   42,
    51  		I16:  42,
    52  		I32:  42,
    53  		I64:  42,
    54  		UI:   42,
    55  		UI8:  42,
    56  		UI16: 42,
    57  		UI32: 42,
    58  		UI64: 42,
    59  		F32:  42.42,
    60  		F64:  42.42,
    61  		B:    true,
    62  	}
    63  	a.SetMeta(&record.Meta{})
    64  	a.Meta().Update()
    65  	a.SetKey("test:A")
    66  
    67  	// put record
    68  	_, err = db.Put(a)
    69  	if err != nil {
    70  		t.Fatal(err)
    71  	}
    72  
    73  	// get and compare
    74  	a1, err := db.Get("A")
    75  	if err != nil {
    76  		t.Fatal(err)
    77  	}
    78  
    79  	if !reflect.DeepEqual(a, a1) {
    80  		t.Fatalf("mismatch, got %v", a1)
    81  	}
    82  
    83  	// setup query test records
    84  	qA := &TestRecord{}
    85  	qA.SetKey("test:path/to/A")
    86  	qA.CreateMeta()
    87  	qB := &TestRecord{}
    88  	qB.SetKey("test:path/to/B")
    89  	qB.CreateMeta()
    90  	qC := &TestRecord{}
    91  	qC.SetKey("test:path/to/C")
    92  	qC.CreateMeta()
    93  	qZ := &TestRecord{}
    94  	qZ.SetKey("test:z")
    95  	qZ.CreateMeta()
    96  	// put
    97  	_, err = db.Put(qA)
    98  	if err == nil {
    99  		_, err = db.Put(qB)
   100  	}
   101  	if err == nil {
   102  		_, err = db.Put(qC)
   103  	}
   104  	if err == nil {
   105  		_, err = db.Put(qZ)
   106  	}
   107  	if err != nil {
   108  		t.Fatal(err)
   109  	}
   110  
   111  	// test query
   112  	q := query.New("test:path/to/").MustBeValid()
   113  	it, err := db.Query(q, true, true)
   114  	if err != nil {
   115  		t.Fatal(err)
   116  	}
   117  	cnt := 0
   118  	for range it.Next {
   119  		cnt++
   120  	}
   121  	if it.Err() != nil {
   122  		t.Fatal(it.Err())
   123  	}
   124  	if cnt != 3 {
   125  		t.Fatalf("unexpected query result count: %d", cnt)
   126  	}
   127  
   128  	// delete
   129  	err = db.Delete("A")
   130  	if err != nil {
   131  		t.Fatal(err)
   132  	}
   133  
   134  	// check if its gone
   135  	_, err = db.Get("A")
   136  	if err == nil {
   137  		t.Fatal("should fail")
   138  	}
   139  
   140  	// shutdown
   141  	err = db.Shutdown()
   142  	if err != nil {
   143  		t.Fatal(err)
   144  	}
   145  }