565 lines
16 KiB
Go
565 lines
16 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"regexp"
|
|
"testing"
|
|
|
|
"git.grassecon.net/urdt/ussd/driver"
|
|
enginetest "git.grassecon.net/urdt/ussd/engine"
|
|
)
|
|
|
|
var (
|
|
testData = driver.ReadData()
|
|
)
|
|
|
|
// Extract the public key from the engine response
|
|
func extractPublicKey(response []byte) string {
|
|
// Regex pattern to match the public key starting with 0x and 40 characters
|
|
re := regexp.MustCompile(`0x[a-fA-F0-9]{40}`)
|
|
match := re.Find(response)
|
|
if match != nil {
|
|
return string(match)
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func TestAccountCreationSuccessful(t *testing.T) {
|
|
en, fn := enginetest.TestEngine("session1234112")
|
|
defer fn()
|
|
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, err := en.Exec(ctx, []byte(step.Input))
|
|
if err != nil {
|
|
t.Fatalf("Test case '%s' failed at input '%s': %v", group.Name, step.Input, err)
|
|
}
|
|
if !cont {
|
|
break
|
|
}
|
|
w := bytes.NewBuffer(nil)
|
|
_, err = en.Flush(ctx, w)
|
|
if err != nil {
|
|
t.Fatalf("Test case '%s' failed during Flush: %v", group.Name, 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)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestAccountRegistrationRejectTerms(t *testing.T) {
|
|
en, fn := enginetest.TestEngine("session1234112_b")
|
|
defer fn()
|
|
ctx := context.Background()
|
|
sessions := testData
|
|
for _, session := range sessions {
|
|
groups := driver.FilterGroupsByName(session.Groups, "account_creation_reject_terms")
|
|
for _, group := range groups {
|
|
for _, step := range group.Steps {
|
|
cont, err := en.Exec(ctx, []byte(step.Input))
|
|
if err != nil {
|
|
t.Fatalf("Test case '%s' failed at input '%s': %v", group.Name, step.Input, err)
|
|
return
|
|
}
|
|
if !cont {
|
|
break
|
|
}
|
|
w := bytes.NewBuffer(nil)
|
|
if _, err := en.Flush(ctx, w); err != nil {
|
|
t.Fatalf("Test case '%s' failed during Flush: %v", group.Name, 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)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSendWithInvalidInputs(t *testing.T) {
|
|
en, fn := enginetest.TestEngine("session1234112")
|
|
defer fn()
|
|
ctx := context.Background()
|
|
sessions := testData
|
|
for _, session := range sessions {
|
|
groups := driver.FilterGroupsByName(session.Groups, "send_with_invalid_inputs")
|
|
for _, group := range groups {
|
|
for _, step := range group.Steps {
|
|
cont, err := en.Exec(ctx, []byte(step.Input))
|
|
if err != nil {
|
|
t.Fatalf("Test case '%s' failed at input '%s': %v", group.Name, step.Input, err)
|
|
return
|
|
}
|
|
if !cont {
|
|
break
|
|
}
|
|
w := bytes.NewBuffer(nil)
|
|
if _, err := en.Flush(ctx, w); err != nil {
|
|
t.Fatalf("Test case '%s' failed during Flush: %v", group.Name, err)
|
|
}
|
|
|
|
b := w.Bytes()
|
|
|
|
// Extract the dynamic public key from the output
|
|
publicKey := extractPublicKey(b)
|
|
|
|
// Replace placeholder {public_key} with the actual dynamic public key
|
|
expectedContent := bytes.Replace([]byte(step.ExpectedContent), []byte("{public_key}"), []byte(publicKey), -1)
|
|
|
|
if !bytes.Equal(b, expectedContent) {
|
|
t.Fatalf("expected:\n\t%s\ngot:\n\t%s\n", expectedContent, b)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMainMenuHelp(t *testing.T) {
|
|
en, fn := enginetest.TestEngine("session1234112")
|
|
defer fn()
|
|
ctx := context.Background()
|
|
sessions := testData
|
|
for _, session := range sessions {
|
|
groups := driver.FilterGroupsByName(session.Groups, "main_menu_help")
|
|
for _, group := range groups {
|
|
for _, step := range group.Steps {
|
|
cont, err := en.Exec(ctx, []byte(step.Input))
|
|
if err != nil {
|
|
t.Fatalf("Test case '%s' failed at input '%s': %v", group.Name, step.Input, err)
|
|
return
|
|
}
|
|
if !cont {
|
|
break
|
|
}
|
|
w := bytes.NewBuffer(nil)
|
|
if _, err := en.Flush(ctx, w); err != nil {
|
|
t.Fatalf("Test case '%s' failed during Flush: %v", group.Name, 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)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMainMenuQuit(t *testing.T) {
|
|
en, fn := enginetest.TestEngine("session1234112")
|
|
defer fn()
|
|
ctx := context.Background()
|
|
sessions := testData
|
|
for _, session := range sessions {
|
|
groups := driver.FilterGroupsByName(session.Groups, "main_menu_quit")
|
|
for _, group := range groups {
|
|
for _, step := range group.Steps {
|
|
cont, err := en.Exec(ctx, []byte(step.Input))
|
|
if err != nil {
|
|
t.Fatalf("Test case '%s' failed at input '%s': %v", group.Name, step.Input, err)
|
|
return
|
|
}
|
|
if !cont {
|
|
break
|
|
}
|
|
w := bytes.NewBuffer(nil)
|
|
if _, err := en.Flush(ctx, w); err != nil {
|
|
t.Fatalf("Test case '%s' failed during Flush: %v", group.Name, 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)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMyAccountChangePin(t *testing.T) {
|
|
en, fn := enginetest.TestEngine("session1234112")
|
|
defer fn()
|
|
ctx := context.Background()
|
|
sessions := testData
|
|
for _, session := range sessions {
|
|
groups := driver.FilterGroupsByName(session.Groups, "my_account_change_pin")
|
|
for _, group := range groups {
|
|
for _, step := range group.Steps {
|
|
cont, err := en.Exec(ctx, []byte(step.Input))
|
|
if err != nil {
|
|
t.Fatalf("Test case '%s' failed at input '%s': %v", group.Name, step.Input, err)
|
|
return
|
|
}
|
|
if !cont {
|
|
break
|
|
}
|
|
w := bytes.NewBuffer(nil)
|
|
if _, err := en.Flush(ctx, w); err != nil {
|
|
t.Fatalf("Test case '%s' failed during Flush: %v", group.Name, 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)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMyAccount_Change_Language(t *testing.T) {
|
|
en, fn := enginetest.TestEngine("session1234112")
|
|
defer fn()
|
|
ctx := context.Background()
|
|
sessions := testData
|
|
for _, session := range sessions {
|
|
groups := driver.FilterGroupsByName(session.Groups, "menu_my_account_language_change")
|
|
for _, group := range groups {
|
|
for index, step := range group.Steps {
|
|
t.Logf("step %v with input %v", index, step.Input)
|
|
cont, err := en.Exec(ctx, []byte(step.Input))
|
|
if err != nil {
|
|
t.Errorf("Test case '%s' failed at input '%s': %v", group.Name, step.Input, err)
|
|
return
|
|
}
|
|
if !cont {
|
|
break
|
|
}
|
|
w := bytes.NewBuffer(nil)
|
|
if _, err := en.Flush(ctx, w); err != nil {
|
|
t.Errorf("Test case '%s' failed during Flush: %v", group.Name, 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)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMyAccount_Edit_firstname(t *testing.T) {
|
|
en, fn := enginetest.TestEngine("session1234112")
|
|
defer fn()
|
|
ctx := context.Background()
|
|
sessions := testData
|
|
for _, session := range sessions {
|
|
groups := driver.FilterGroupsByName(session.Groups, "menu_my_account_edit_firstname")
|
|
for _, group := range groups {
|
|
for index, step := range group.Steps {
|
|
t.Logf("step %v with input %v", index, step.Input)
|
|
cont, err := en.Exec(ctx, []byte(step.Input))
|
|
if err != nil {
|
|
t.Errorf("Test case '%s' failed at input '%s': %v", group.Name, step.Input, err)
|
|
return
|
|
}
|
|
if !cont {
|
|
break
|
|
}
|
|
w := bytes.NewBuffer(nil)
|
|
if _, err := en.Flush(ctx, w); err != nil {
|
|
t.Errorf("Test case '%s' failed during Flush: %v", group.Name, 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)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMyAccount_Edit_familyname(t *testing.T) {
|
|
en, fn := enginetest.TestEngine("session1234112")
|
|
defer fn()
|
|
ctx := context.Background()
|
|
sessions := testData
|
|
for _, session := range sessions {
|
|
groups := driver.FilterGroupsByName(session.Groups, "menu_my_account_edit_familyname")
|
|
for _, group := range groups {
|
|
for index, step := range group.Steps {
|
|
t.Logf("step %v with input %v", index, step.Input)
|
|
cont, err := en.Exec(ctx, []byte(step.Input))
|
|
if err != nil {
|
|
t.Errorf("Test case '%s' failed at input '%s': %v", group.Name, step.Input, err)
|
|
return
|
|
}
|
|
if !cont {
|
|
break
|
|
}
|
|
w := bytes.NewBuffer(nil)
|
|
if _, err := en.Flush(ctx, w); err != nil {
|
|
t.Errorf("Test case '%s' failed during Flush: %v", group.Name, 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)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMyAccount_Edit_gender(t *testing.T) {
|
|
en, fn := enginetest.TestEngine("session1234112")
|
|
defer fn()
|
|
ctx := context.Background()
|
|
sessions := testData
|
|
for _, session := range sessions {
|
|
groups := driver.FilterGroupsByName(session.Groups, "menu_my_account_edit_gender")
|
|
for _, group := range groups {
|
|
for index, step := range group.Steps {
|
|
t.Logf("step %v with input %v", index, step.Input)
|
|
cont, err := en.Exec(ctx, []byte(step.Input))
|
|
if err != nil {
|
|
t.Errorf("Test case '%s' failed at input '%s': %v", group.Name, step.Input, err)
|
|
return
|
|
}
|
|
if !cont {
|
|
break
|
|
}
|
|
w := bytes.NewBuffer(nil)
|
|
if _, err := en.Flush(ctx, w); err != nil {
|
|
t.Errorf("Test case '%s' failed during Flush: %v", group.Name, 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)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMyAccount_Edit_yob(t *testing.T) {
|
|
en, fn := enginetest.TestEngine("session1234112")
|
|
defer fn()
|
|
ctx := context.Background()
|
|
sessions := testData
|
|
for _, session := range sessions {
|
|
groups := driver.FilterGroupsByName(session.Groups, "menu_my_account_edit_yob")
|
|
for _, group := range groups {
|
|
for index, step := range group.Steps {
|
|
t.Logf("step %v with input %v", index, step.Input)
|
|
cont, err := en.Exec(ctx, []byte(step.Input))
|
|
if err != nil {
|
|
t.Errorf("Test case '%s' failed at input '%s': %v", group.Name, step.Input, err)
|
|
return
|
|
}
|
|
if !cont {
|
|
break
|
|
}
|
|
w := bytes.NewBuffer(nil)
|
|
if _, err := en.Flush(ctx, w); err != nil {
|
|
t.Errorf("Test case '%s' failed during Flush: %v", group.Name, 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)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMyAccount_Edit_location(t *testing.T) {
|
|
en, fn := enginetest.TestEngine("session1234112")
|
|
defer fn()
|
|
ctx := context.Background()
|
|
sessions := testData
|
|
for _, session := range sessions {
|
|
groups := driver.FilterGroupsByName(session.Groups, "menu_my_account_edit_location")
|
|
for _, group := range groups {
|
|
for index, step := range group.Steps {
|
|
t.Logf("step %v with input %v", index, step.Input)
|
|
cont, err := en.Exec(ctx, []byte(step.Input))
|
|
if err != nil {
|
|
t.Errorf("Test case '%s' failed at input '%s': %v", group.Name, step.Input, err)
|
|
return
|
|
}
|
|
if !cont {
|
|
break
|
|
}
|
|
w := bytes.NewBuffer(nil)
|
|
if _, err := en.Flush(ctx, w); err != nil {
|
|
t.Errorf("Test case '%s' failed during Flush: %v", group.Name, 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)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMyAccount_Edit_offerings(t *testing.T) {
|
|
en, fn := enginetest.TestEngine("session1234112")
|
|
defer fn()
|
|
ctx := context.Background()
|
|
sessions := testData
|
|
for _, session := range sessions {
|
|
groups := driver.FilterGroupsByName(session.Groups, "menu_my_account_edit_offerings")
|
|
for _, group := range groups {
|
|
for index, step := range group.Steps {
|
|
t.Logf("step %v with input %v", index, step.Input)
|
|
cont, err := en.Exec(ctx, []byte(step.Input))
|
|
if err != nil {
|
|
t.Errorf("Test case '%s' failed at input '%s': %v", group.Name, step.Input, err)
|
|
return
|
|
}
|
|
if !cont {
|
|
break
|
|
}
|
|
w := bytes.NewBuffer(nil)
|
|
if _, err := en.Flush(ctx, w); err != nil {
|
|
t.Errorf("Test case '%s' failed during Flush: %v", group.Name, 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)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMyAccount_View_Profile(t *testing.T) {
|
|
en, fn := enginetest.TestEngine("session1234112")
|
|
defer fn()
|
|
ctx := context.Background()
|
|
sessions := testData
|
|
for _, session := range sessions {
|
|
groups := driver.FilterGroupsByName(session.Groups, "menu_my_account_view_profile")
|
|
for _, group := range groups {
|
|
for index, step := range group.Steps {
|
|
t.Logf("step %v with input %v", index, step.Input)
|
|
cont, err := en.Exec(ctx, []byte(step.Input))
|
|
if err != nil {
|
|
t.Errorf("Test case '%s' failed at input '%s': %v", group.Name, step.Input, err)
|
|
return
|
|
}
|
|
if !cont {
|
|
break
|
|
}
|
|
w := bytes.NewBuffer(nil)
|
|
if _, err := en.Flush(ctx, w); err != nil {
|
|
t.Errorf("Test case '%s' failed during Flush: %v", group.Name, 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)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMyAccount_Check_My_Balance(t *testing.T) {
|
|
en, fn := enginetest.TestEngine("session1234112")
|
|
defer fn()
|
|
ctx := context.Background()
|
|
sessions := testData
|
|
for _, session := range sessions {
|
|
groups := driver.FilterGroupsByName(session.Groups, "menu_my_account_check_my_balance")
|
|
for _, group := range groups {
|
|
for index, step := range group.Steps {
|
|
t.Logf("step %v with input %v", index, step.Input)
|
|
cont, err := en.Exec(ctx, []byte(step.Input))
|
|
if err != nil {
|
|
t.Errorf("Test case '%s' failed at input '%s': %v", group.Name, step.Input, err)
|
|
return
|
|
}
|
|
if !cont {
|
|
break
|
|
}
|
|
w := bytes.NewBuffer(nil)
|
|
if _, err := en.Flush(ctx, w); err != nil {
|
|
t.Errorf("Test case '%s' failed during Flush: %v", group.Name, 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)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMyAccount_Check_Community_Balance(t *testing.T) {
|
|
en, fn := enginetest.TestEngine("session1234112")
|
|
defer fn()
|
|
ctx := context.Background()
|
|
sessions := testData
|
|
for _, session := range sessions {
|
|
groups := driver.FilterGroupsByName(session.Groups, "menu_my_account_check_community_balance")
|
|
for _, group := range groups {
|
|
for index, step := range group.Steps {
|
|
t.Logf("step %v with input %v", index, step.Input)
|
|
cont, err := en.Exec(ctx, []byte(step.Input))
|
|
if err != nil {
|
|
t.Errorf("Test case '%s' failed at input '%s': %v", group.Name, step.Input, err)
|
|
return
|
|
}
|
|
if !cont {
|
|
break
|
|
}
|
|
w := bytes.NewBuffer(nil)
|
|
if _, err := en.Flush(ctx, w); err != nil {
|
|
t.Errorf("Test case '%s' failed during Flush: %v", group.Name, 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)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMyAccount_MyAddress(t *testing.T) {
|
|
en, fn := enginetest.TestEngine("session1234112")
|
|
defer fn()
|
|
ctx := context.Background()
|
|
sessions := testData
|
|
for _, session := range sessions {
|
|
groups := driver.FilterGroupsByName(session.Groups, "menu_my_account_my_address")
|
|
for _, group := range groups {
|
|
for index, step := range group.Steps {
|
|
t.Logf("step %v with input %v", index, step.Input)
|
|
cont, err := en.Exec(ctx, []byte(step.Input))
|
|
if err != nil {
|
|
t.Errorf("Test case '%s' failed at input '%s': %v", group.Name, step.Input, err)
|
|
return
|
|
}
|
|
if !cont {
|
|
break
|
|
}
|
|
w := bytes.NewBuffer(nil)
|
|
if _, err := en.Flush(ctx, w); err != nil {
|
|
t.Errorf("Test case '%s' failed during Flush: %v", group.Name, err)
|
|
}
|
|
b := w.Bytes()
|
|
|
|
publicKey := extractPublicKey(b)
|
|
|
|
expectedContent := bytes.Replace([]byte(step.ExpectedContent), []byte("{public_key}"), []byte(publicKey), -1)
|
|
|
|
if !bytes.Equal(b, expectedContent) {
|
|
t.Fatalf("expected:\n\t%s\ngot:\n\t%s\n", expectedContent, b)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|