go-vise

Constrained Size Output Virtual Machine
Info | Log | Files | Refs | README | LICENSE

persist_test.go (2604B)

      1 package engine
      2 
      3 import (
      4 	"bytes"
      5 	"context"
      6 	"testing"
      7 
      8 	"git.defalsify.org/vise.git/cache"
      9 	memdb "git.defalsify.org/vise.git/db/mem"
     10 	"git.defalsify.org/vise.git/persist"
     11 	"git.defalsify.org/vise.git/state"
     12 )
     13 
     14 func TestPersistNewAcrossEngine(t *testing.T) {
     15 	var err error
     16 	var cfg Config
     17 	generateTestData(t)
     18 	st := state.NewState(1)
     19 	ca := cache.NewCache()
     20 	rs := newTestWrapper(dataDir, st)
     21 	ctx := context.Background()
     22 	store := memdb.NewMemDb()
     23 	store.Connect(ctx, "")
     24 	pe := persist.NewPersister(store)
     25 	en := NewEngine(cfg, rs)
     26 	en = en.WithState(st)
     27 	en = en.WithMemory(ca)
     28 	en = en.WithPersister(pe)
     29 	cont, err := en.Exec(ctx, []byte{})
     30 	if err != nil {
     31 		t.Fatal(err)
     32 	}
     33 	if !cont {
     34 		t.Errorf("expected cont")
     35 	}
     36 
     37 	r := bytes.NewBuffer(nil)
     38 	_, err = en.Flush(ctx, r)
     39 	if err != nil {
     40 		t.Fatal(err)
     41 	}
     42 
     43 	cont, err = en.Exec(ctx, []byte("1"))
     44 	if err != nil {
     45 		t.Fatal(err)
     46 	}
     47 	if !cont {
     48 		t.Errorf("expected cont")
     49 	}
     50 	r = bytes.NewBuffer(nil)
     51 	_, err = en.Flush(ctx, r)
     52 	if err != nil {
     53 		t.Fatal(err)
     54 	}
     55 
     56 	err = en.Finish(ctx)
     57 	if err != nil {
     58 		t.Fatal(err)
     59 	}
     60 
     61 	cfg.FlagCount = 1
     62 	pe = persist.NewPersister(store)
     63 	en = NewEngine(cfg, rs)
     64 	en = en.WithPersister(pe)
     65 	cont, err = en.Exec(ctx, []byte{})
     66 	if err != nil {
     67 		t.Fatal(err)
     68 	}
     69 	if !cont {
     70 		t.Errorf("expected cont")
     71 	}
     72 	location, _ := st.Where()
     73 	if location != "foo" {
     74 		t.Errorf("expected location 'foo', got '%s", location)
     75 	}
     76 }
     77 
     78 func TestPersistSameAcrossEngine(t *testing.T) {
     79 	var err error
     80 	var cfg Config
     81 	generateTestData(t)
     82 	st := state.NewState(1)
     83 	ca := cache.NewCache()
     84 	rs := newTestWrapper(dataDir, st)
     85 	ctx := context.Background()
     86 	store := memdb.NewMemDb()
     87 	store.Connect(ctx, "")
     88 	pe := persist.NewPersister(store)
     89 	pe = pe.WithFlush()
     90 	en := NewEngine(cfg, rs)
     91 	en = en.WithState(st)
     92 	en = en.WithMemory(ca)
     93 	en = en.WithPersister(pe)
     94 	cont, err := en.Exec(ctx, []byte{})
     95 	if err != nil {
     96 		t.Fatal(err)
     97 	}
     98 	if !cont {
     99 		t.Errorf("expected cont")
    100 	}
    101 
    102 	r := bytes.NewBuffer(nil)
    103 	_, err = en.Flush(ctx, r)
    104 	if err != nil {
    105 		t.Fatal(err)
    106 	}
    107 
    108 	cont, err = en.Exec(ctx, []byte("1"))
    109 	if err != nil {
    110 		t.Fatal(err)
    111 	}
    112 	if !cont {
    113 		t.Errorf("expected cont")
    114 	}
    115 	r = bytes.NewBuffer(nil)
    116 	_, err = en.Flush(ctx, r)
    117 	if err != nil {
    118 		t.Fatal(err)
    119 	}
    120 
    121 	err = en.Finish(ctx)
    122 	if err != nil {
    123 		t.Fatal(err)
    124 	}
    125 
    126 	cfg.FlagCount = 1
    127 	en = NewEngine(cfg, rs)
    128 	en = en.WithPersister(pe)
    129 	cont, err = en.Exec(ctx, []byte{})
    130 	if err != nil {
    131 		t.Fatal(err)
    132 	}
    133 	if !cont {
    134 		t.Errorf("expected cont")
    135 	}
    136 	location, _ := st.Where()
    137 	if location != "foo" {
    138 		t.Errorf("expected location 'foo', got '%s", location)
    139 	}
    140 }