142 lines
2.8 KiB
Go
142 lines
2.8 KiB
Go
package ussd
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"path"
|
|
"testing"
|
|
|
|
"git.defalsify.org/vise.git/db"
|
|
fsdb "git.defalsify.org/vise.git/db/fs"
|
|
"git.defalsify.org/vise.git/engine"
|
|
"git.defalsify.org/vise.git/persist"
|
|
"git.defalsify.org/vise.git/resource"
|
|
"git.grassecon.net/urdt/ussd/internal/storage"
|
|
"git.grassecon.net/urdt/ussd/testdata"
|
|
testdataloader "github.com/peteole/testdata-loader"
|
|
)
|
|
|
|
var (
|
|
dataGenerated bool = false
|
|
dataDir string = testdata.DataDir
|
|
BaseDir = testdataloader.GetBasePath()
|
|
)
|
|
|
|
type testWrapper struct {
|
|
resource.Resource
|
|
db db.Db
|
|
}
|
|
|
|
func generateTestData(t *testing.T) {
|
|
if dataGenerated {
|
|
return
|
|
}
|
|
var err error
|
|
dataDir, err = testdata.Generate()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func newTestWrapper(path string) testWrapper {
|
|
ctx := context.Background()
|
|
store := fsdb.NewFsDb()
|
|
store.Connect(ctx, path)
|
|
rs := resource.NewDbResource(store)
|
|
rs.With(db.DATATYPE_STATICLOAD)
|
|
wr := testWrapper{
|
|
rs,
|
|
store,
|
|
}
|
|
rs.AddLocalFunc("quit", quit)
|
|
|
|
return wr
|
|
}
|
|
|
|
func quit(ctx context.Context, sym string, input []byte) (resource.Result, error) {
|
|
return resource.Result{
|
|
Content: "Thank you for using Sarafu network",
|
|
}, nil
|
|
}
|
|
|
|
func TestTerms(t *testing.T) {
|
|
generateTestData(t)
|
|
ctx := context.Background()
|
|
rs := newTestWrapper(dataDir)
|
|
cfg := engine.Config{
|
|
Root: "terms",
|
|
FlagCount: uint32(9),
|
|
}
|
|
store := storage.NewThreadGdbmDb()
|
|
storeFile := path.Join(baseDir, "state.gdbm")
|
|
err := store.Connect(ctx, storeFile)
|
|
if err != nil {
|
|
t.Fail()
|
|
}
|
|
|
|
pr := persist.NewPersister(store)
|
|
en := engine.NewEngine(cfg, &rs)
|
|
en.WithPersister(pr)
|
|
if pr.GetState() == nil || pr.GetMemory() == nil {
|
|
t.Fail()
|
|
}
|
|
_, err = en.Exec(ctx, []byte{})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
w := bytes.NewBuffer(nil)
|
|
_, err = en.Flush(ctx, w)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
b := w.Bytes()
|
|
|
|
expect_str := `Do you agree to terms and conditions?
|
|
1:yes
|
|
2:no`
|
|
|
|
if !bytes.Equal(b, []byte(expect_str)) {
|
|
t.Fatalf("expected:\n\t%s\ngot:\n\t%s\n", expect_str, b)
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
expectedSymbol string
|
|
input []byte
|
|
}{
|
|
{
|
|
name: "Test accept terms option(yes)",
|
|
expectedSymbol: "create_pin",
|
|
input: []byte("1"),
|
|
},
|
|
// {
|
|
// name: "Test reject terms option(no)",
|
|
// input: []byte("2"),
|
|
// expectedSymbol: "quit",
|
|
// },
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
_, err = en.Exec(ctx, tt.input)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
w := bytes.NewBuffer(nil)
|
|
_, err = en.Flush(ctx, w)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
b = w.Bytes()
|
|
fmt.Println("result", string(b))
|
|
symbol, _ := pr.State.Where()
|
|
|
|
if symbol != tt.expectedSymbol {
|
|
t.Fatalf("expected symbol to be 'create_pin', got %s", symbol)
|
|
}
|
|
})
|
|
}
|
|
}
|