driver/testdata.go

@@ -0,0 +1,55 @@
+package driver
+
+import (
+	"encoding/json"
+	"log"
+	"os"
+)
+
+type Step struct {
+	Input           string `json:"input"`
+	ExpectedContent string `json:"expectedContent"`
+}
+
+type Group struct {
+	Name  string `json:"name"`
+	Steps []Step `json:"steps"`
+}
+
+type Session struct {
+	Name   string  `json:"name"`
+	Groups []Group `json:"groups"`
+}
+
+func ReadData() []Session {
+	data, err := os.ReadFile("test_data_two.json")
+	if err != nil {
+		log.Fatalf("Failed to read file: %v", err)
+	}
+	// Unmarshal JSON data
+	var sessions []Session
+	err = json.Unmarshal(data, &sessions)
+	if err != nil {
+		log.Fatalf("Failed to unmarshal JSON: %v", err)
+	}
+
+	return sessions
+}
+
+func FilterGroupsByName(groups []Group, name string) []Group {
+	var filteredGroups []Group
+	for _, group := range groups {
+		if group.Name == name {
+			filteredGroups = append(filteredGroups, group)
+		}
+	}
+	return filteredGroups
+}
+
+func Map[T any, U any](input []T, fn func(T) U) []U {
+	result := make([]U, len(input))
+	for i, v := range input {
+		result[i] = fn(v)
+	}
+	return result
+}

enginetest/engine.go

@@ -27,7 +27,7 @@ func TestEngine(sessionId string) (engine.Engine,*persist.Persister){
 		Root:       "root",
 		SessionId:  sessionId,
 		OutputSize: uint32(160),
-		//FlagCount:  uint32(16),
+		FlagCount:  uint32(16),
 	}
 
 	dbDir := ".test_state"

menu_traversal_test.go

@@ -1,58 +1,70 @@
 package main
 
 import (
-	"bufio"
+	"bytes"
 	"context"
-	"encoding/json"
-	"fmt"
-	"os"
-	"strings"
 	"testing"
 
-	"git.defalsify.org/vise.git/engine"
-
+	"git.grassecon.net/urdt/ussd/driver"
 	"git.grassecon.net/urdt/ussd/enginetest"
 )
 
-type TestCase struct {
-	Input    []string `json:"input"`
-	Expected string   `json:"expected"`
-}
-
-type UserRegistration struct {
-	UserRegistration []TestCase `json:"user_registration"`
-}
-
-type TestData struct {
-	UserRegistration []TestCase `json:"user_registration"`
-	PinCheck         []TestCase `json:"pincheck"`
-}
+var (
+	testData = driver.ReadData()
+)
 
 func TestUserRegistration(t *testing.T) {
-	en, pe := enginetest.TestEngine("session12341122")
-	//w := bytes.NewBuffer(nil)
-	file, err := os.Open("test_data.json")
+	en, _ := enginetest.TestEngine("session1234112")
+	var err error
+	ctx := context.Background()
+	sessions := testData
+	for _, session := range sessions {
+		groups := driver.FilterGroupsByName(session.Groups, "account_creation_successful")
+		for _, group := range groups {
+			for _, step := range group.Steps {
+				cont, _ := en.Exec(ctx, []byte(step.Input))
+				if cont {
+					w := bytes.NewBuffer(nil)
+					_, err = en.Flush(ctx, w)
 					if err != nil {
-		fmt.Println("Error opening file:", err)
-		return
+						t.Fatal(err)
 					}
-	defer file.Close()
-
-	var testData TestData
-	decoder := json.NewDecoder(file)
-	if err := decoder.Decode(&testData); err != nil {
-		fmt.Println("Error decoding JSON:", err)
-		return
+					b := w.Bytes()
+					if !bytes.Equal(b, []byte(step.ExpectedContent)) {
+						t.Fatalf("expected:\n\t%s\ngot:\n\t%s\n", step.ExpectedContent, b)
 					}
 
-	var inputBuilder strings.Builder
-	for _, testCase := range testData.UserRegistration {
-		inputBuilder.WriteString(strings.Join(testCase.Input, "\n") + "\n")
 				}
-	readers := bufio.NewReader(strings.NewReader(inputBuilder.String()))
-	engine.Loop(context.Background(), en, readers, os.Stdout, nil)
-	st := pe.GetState()
-	sym, _ := st.Where()
-	fmt.Println("Rendering symbol:", sym)
+			}
+		}
+	}
+}
+
+func TestAcceptTerms(t *testing.T) {
+	en, _ := enginetest.TestEngine("session12341123")
+	var err error
+	ctx := context.Background()
+	sessions := testData
+
+	for _, session := range sessions {
+		groups := driver.FilterGroupsByName(session.Groups, "account_creation_accept_terms")
+		for _, group := range groups {
+			for _, step := range group.Steps {
+				cont, _ := en.Exec(ctx, []byte(step.Input))
+				if cont {
+					w := bytes.NewBuffer(nil)
+					_, err = en.Flush(ctx, w)
+					if err != nil {
+						t.Fatal(err)
+					}
+					b := w.Bytes()
+					if !bytes.Equal(b, []byte(step.ExpectedContent)) {
+						t.Fatalf("expected:\n\t%s\ngot:\n\t%s\n", step.ExpectedContent, b)
+					}
 
 				}
+
+			}
+		}
+	}
+}