Compare commits

...

3 Commits

Author SHA1 Message Date
57b0fcb55f
move authorization tests 2025-07-03 17:13:51 +03:00
baa7526df3
move account_status tests 2025-07-03 17:07:26 +03:00
f22f86a2fb
move PIN tests to pin_test.go 2025-07-03 17:02:36 +03:00
4 changed files with 609 additions and 567 deletions

View File

@ -0,0 +1,135 @@
package application
import (
"context"
"testing"
"git.defalsify.org/vise.git/resource"
"git.grassecon.net/grassrootseconomics/sarafu-api/models"
"git.grassecon.net/grassrootseconomics/sarafu-api/testutil/mocks"
storedb "git.grassecon.net/grassrootseconomics/sarafu-vise/store/db"
"github.com/alecthomas/assert/v2"
)
func TestCheckAccountStatus(t *testing.T) {
sessionId := "session123"
ctx, store := InitializeTestStore(t)
ctx = context.WithValue(ctx, "SessionId", sessionId)
fm, err := NewFlagManager(flagsPath)
if err != nil {
t.Logf(err.Error())
}
flag_account_success, _ := fm.GetFlag("flag_account_success")
flag_account_pending, _ := fm.GetFlag("flag_account_pending")
flag_api_error, _ := fm.GetFlag("flag_api_call_error")
tests := []struct {
name string
publicKey []byte
response *models.TrackStatusResult
expectedResult resource.Result
}{
{
name: "Test when account is on the Sarafu network",
publicKey: []byte("TrackingId1234"),
response: &models.TrackStatusResult{
Active: true,
},
expectedResult: resource.Result{
FlagSet: []uint32{flag_account_success},
FlagReset: []uint32{flag_api_error, flag_account_pending},
},
},
{
name: "Test when the account is not yet on the sarafu network",
publicKey: []byte("TrackingId1234"),
response: &models.TrackStatusResult{
Active: false,
},
expectedResult: resource.Result{
FlagSet: []uint32{flag_account_pending},
FlagReset: []uint32{flag_api_error, flag_account_success},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
mockAccountService := new(mocks.MockAccountService)
h := &MenuHandlers{
userdataStore: store,
accountService: mockAccountService,
flagManager: fm,
}
err = store.WriteEntry(ctx, sessionId, storedb.DATA_PUBLIC_KEY, []byte(tt.publicKey))
if err != nil {
t.Fatal(err)
}
mockAccountService.On("TrackAccountStatus", string(tt.publicKey)).Return(tt.response, nil)
// Call the method under test
res, _ := h.CheckAccountStatus(ctx, "check_account_status", []byte(""))
// Assert that no errors occurred
assert.NoError(t, err)
//Assert that the account created flag has been set to the result
assert.Equal(t, res, tt.expectedResult, "Expected result should be equal to the actual result")
})
}
}
func TestCheckBlockedStatus(t *testing.T) {
ctx, store := InitializeTestStore(t)
sessionId := "session123"
ctx = context.WithValue(ctx, "SessionId", sessionId)
fm, err := NewFlagManager(flagsPath)
if err != nil {
t.Logf(err.Error())
}
flag_account_blocked, _ := fm.GetFlag("flag_account_blocked")
flag_account_pin_reset, _ := fm.GetFlag("flag_account_pin_reset")
h := &MenuHandlers{
userdataStore: store,
flagManager: fm,
}
tests := []struct {
name string
currentWrongPinAttempts string
expectedResult resource.Result
}{
{
name: "Currently blocked account",
currentWrongPinAttempts: "4",
expectedResult: resource.Result{
FlagReset: []uint32{flag_account_pin_reset},
},
},
{
name: "Account with 0 wrong PIN attempts",
currentWrongPinAttempts: "0",
expectedResult: resource.Result{
FlagReset: []uint32{flag_account_pin_reset, flag_account_blocked},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if err := store.WriteEntry(ctx, sessionId, storedb.DATA_INCORRECT_PIN_ATTEMPTS, []byte(tt.currentWrongPinAttempts)); err != nil {
t.Fatal(err)
}
res, err := h.CheckBlockedStatus(ctx, "", []byte(""))
assert.NoError(t, err)
assert.Equal(t, tt.expectedResult, res)
})
}
}

View File

@ -0,0 +1,181 @@
package application
import (
"context"
"log"
"testing"
"git.defalsify.org/vise.git/resource"
"git.defalsify.org/vise.git/state"
"git.grassecon.net/grassrootseconomics/common/pin"
"git.grassecon.net/grassrootseconomics/sarafu-api/testutil/mocks"
storedb "git.grassecon.net/grassrootseconomics/sarafu-vise/store/db"
"github.com/alecthomas/assert/v2"
)
func TestAuthorize(t *testing.T) {
sessionId := "session123"
ctx, store := InitializeTestStore(t)
ctx = context.WithValue(ctx, "SessionId", sessionId)
fm, err := NewFlagManager(flagsPath)
if err != nil {
t.Logf(err.Error())
}
// Create required mocks
mockAccountService := new(mocks.MockAccountService)
mockState := state.NewState(16)
flag_incorrect_pin, _ := fm.GetFlag("flag_incorrect_pin")
flag_account_authorized, _ := fm.GetFlag("flag_account_authorized")
flag_allow_update, _ := fm.GetFlag("flag_allow_update")
// Set 1234 is the correct account pin
accountPIN := "1234"
h := &MenuHandlers{
userdataStore: store,
accountService: mockAccountService,
flagManager: fm,
st: mockState,
}
tests := []struct {
name string
input []byte
expectedResult resource.Result
}{
{
name: "Test with correct PIN",
input: []byte("1234"),
expectedResult: resource.Result{
FlagReset: []uint32{flag_incorrect_pin},
FlagSet: []uint32{flag_allow_update, flag_account_authorized},
},
},
{
name: "Test with incorrect PIN",
input: []byte("1235"),
expectedResult: resource.Result{
FlagReset: []uint32{flag_account_authorized, flag_allow_update},
FlagSet: []uint32{flag_incorrect_pin},
},
},
{
name: "Test with PIN that is not a 4 digit",
input: []byte("1235aqds"),
expectedResult: resource.Result{
FlagReset: []uint32{flag_account_authorized, flag_allow_update},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Hash the PIN
hashedPIN, err := pin.HashPIN(accountPIN)
if err != nil {
logg.ErrorCtxf(ctx, "failed to hash temporaryPin", "error", err)
t.Fatal(err)
}
err = store.WriteEntry(ctx, sessionId, storedb.DATA_ACCOUNT_PIN, []byte(hashedPIN))
if err != nil {
t.Fatal(err)
}
// Call the method under test
res, err := h.Authorize(ctx, "authorize", []byte(tt.input))
// Assert that no errors occurred
assert.NoError(t, err)
//Assert that the account created flag has been set to the result
assert.Equal(t, res, tt.expectedResult, "Expected result should be equal to the actual result")
})
}
}
func TestResetAllowUpdate(t *testing.T) {
fm, err := NewFlagManager(flagsPath)
if err != nil {
log.Fatal(err)
}
flag_allow_update, _ := fm.GetFlag("flag_allow_update")
// Define test cases
tests := []struct {
name string
input []byte
expectedResult resource.Result
}{
{
name: "Resets allow update",
input: []byte(""),
expectedResult: resource.Result{
FlagReset: []uint32{flag_allow_update},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Create the MenuHandlers instance with the mock flag manager
h := &MenuHandlers{
flagManager: fm,
}
// Call the method
res, err := h.ResetAllowUpdate(context.Background(), "reset_allow update", tt.input)
if err != nil {
t.Error(err)
}
// Assert that the Result FlagSet has the required flags after language switch
assert.Equal(t, res, tt.expectedResult, "Flags should be equal to account created")
})
}
}
func TestResetAccountAuthorized(t *testing.T) {
fm, err := NewFlagManager(flagsPath)
if err != nil {
log.Fatal(err)
}
flag_account_authorized, _ := fm.GetFlag("flag_account_authorized")
// Define test cases
tests := []struct {
name string
input []byte
expectedResult resource.Result
}{
{
name: "Resets account authorized",
input: []byte(""),
expectedResult: resource.Result{
FlagReset: []uint32{flag_account_authorized},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Create the MenuHandlers instance with the mock flag manager
h := &MenuHandlers{
flagManager: fm,
}
// Call the method
res, err := h.ResetAccountAuthorized(context.Background(), "reset_account_authorized", tt.input)
if err != nil {
t.Error(err)
}
// Assert that the Result FlagSet has the required flags after language switch
assert.Equal(t, res, tt.expectedResult, "Result should contain flag(s) that have been reset")
})
}
}

View File

@ -621,67 +621,6 @@ func TestSaveGender(t *testing.T) {
}
}
func TestSaveTemporaryPin(t *testing.T) {
sessionId := "session123"
ctx, userdatastore := InitializeTestStore(t)
ctx = context.WithValue(ctx, "SessionId", sessionId)
_, logdb := InitializeTestLogdbStore(t)
logDb := store.LogDb{
Db: logdb,
}
fm, err := NewFlagManager(flagsPath)
if err != nil {
log.Fatal(err)
}
flag_invalid_pin, _ := fm.GetFlag("flag_invalid_pin")
// Create the MenuHandlers instance with the mock flag manager
h := &MenuHandlers{
flagManager: fm,
userdataStore: userdatastore,
logDb: logDb,
}
// Define test cases
tests := []struct {
name string
input []byte
expectedResult resource.Result
}{
{
name: "Valid Pin entry",
input: []byte("1234"),
expectedResult: resource.Result{
FlagReset: []uint32{flag_invalid_pin},
},
},
{
name: "Invalid Pin entry",
input: []byte("12343"),
expectedResult: resource.Result{
FlagSet: []uint32{flag_invalid_pin},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Call the method
res, err := h.SaveTemporaryPin(ctx, "save_pin", tt.input)
if err != nil {
t.Error(err)
}
// Assert that the Result FlagSet has the required flags after language switch
assert.Equal(t, res, tt.expectedResult, "Result should match expected result")
})
}
}
func TestCheckIdentifier(t *testing.T) {
sessionId := "session123"
ctx, userdatastore := InitializeTestStore(t)
@ -890,90 +829,6 @@ func TestSetLanguage(t *testing.T) {
}
}
func TestResetAllowUpdate(t *testing.T) {
fm, err := NewFlagManager(flagsPath)
if err != nil {
log.Fatal(err)
}
flag_allow_update, _ := fm.GetFlag("flag_allow_update")
// Define test cases
tests := []struct {
name string
input []byte
expectedResult resource.Result
}{
{
name: "Resets allow update",
input: []byte(""),
expectedResult: resource.Result{
FlagReset: []uint32{flag_allow_update},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Create the MenuHandlers instance with the mock flag manager
h := &MenuHandlers{
flagManager: fm,
}
// Call the method
res, err := h.ResetAllowUpdate(context.Background(), "reset_allow update", tt.input)
if err != nil {
t.Error(err)
}
// Assert that the Result FlagSet has the required flags after language switch
assert.Equal(t, res, tt.expectedResult, "Flags should be equal to account created")
})
}
}
func TestResetAccountAuthorized(t *testing.T) {
fm, err := NewFlagManager(flagsPath)
if err != nil {
log.Fatal(err)
}
flag_account_authorized, _ := fm.GetFlag("flag_account_authorized")
// Define test cases
tests := []struct {
name string
input []byte
expectedResult resource.Result
}{
{
name: "Resets account authorized",
input: []byte(""),
expectedResult: resource.Result{
FlagReset: []uint32{flag_account_authorized},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Create the MenuHandlers instance with the mock flag manager
h := &MenuHandlers{
flagManager: fm,
}
// Call the method
res, err := h.ResetAccountAuthorized(context.Background(), "reset_account_authorized", tt.input)
if err != nil {
t.Error(err)
}
// Assert that the Result FlagSet has the required flags after language switch
assert.Equal(t, res, tt.expectedResult, "Result should contain flag(s) that have been reset")
})
}
}
func TestIncorrectPinReset(t *testing.T) {
sessionId := "session123"
ctx, store := InitializeTestStore(t)
@ -1100,89 +955,6 @@ func TestResetIncorrectYob(t *testing.T) {
}
}
func TestAuthorize(t *testing.T) {
sessionId := "session123"
ctx, store := InitializeTestStore(t)
ctx = context.WithValue(ctx, "SessionId", sessionId)
fm, err := NewFlagManager(flagsPath)
if err != nil {
t.Logf(err.Error())
}
// Create required mocks
mockAccountService := new(mocks.MockAccountService)
mockState := state.NewState(16)
flag_incorrect_pin, _ := fm.GetFlag("flag_incorrect_pin")
flag_account_authorized, _ := fm.GetFlag("flag_account_authorized")
flag_allow_update, _ := fm.GetFlag("flag_allow_update")
// Set 1234 is the correct account pin
accountPIN := "1234"
h := &MenuHandlers{
userdataStore: store,
accountService: mockAccountService,
flagManager: fm,
st: mockState,
}
tests := []struct {
name string
input []byte
expectedResult resource.Result
}{
{
name: "Test with correct PIN",
input: []byte("1234"),
expectedResult: resource.Result{
FlagReset: []uint32{flag_incorrect_pin},
FlagSet: []uint32{flag_allow_update, flag_account_authorized},
},
},
{
name: "Test with incorrect PIN",
input: []byte("1235"),
expectedResult: resource.Result{
FlagReset: []uint32{flag_account_authorized, flag_allow_update},
FlagSet: []uint32{flag_incorrect_pin},
},
},
{
name: "Test with PIN that is not a 4 digit",
input: []byte("1235aqds"),
expectedResult: resource.Result{
FlagReset: []uint32{flag_account_authorized, flag_allow_update},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Hash the PIN
hashedPIN, err := pin.HashPIN(accountPIN)
if err != nil {
logg.ErrorCtxf(ctx, "failed to hash temporaryPin", "error", err)
t.Fatal(err)
}
err = store.WriteEntry(ctx, sessionId, storedb.DATA_ACCOUNT_PIN, []byte(hashedPIN))
if err != nil {
t.Fatal(err)
}
// Call the method under test
res, err := h.Authorize(ctx, "authorize", []byte(tt.input))
// Assert that no errors occurred
assert.NoError(t, err)
//Assert that the account created flag has been set to the result
assert.Equal(t, res, tt.expectedResult, "Expected result should be equal to the actual result")
})
}
}
func TestVerifyYob(t *testing.T) {
fm, err := NewFlagManager(flagsPath)
if err != nil {
@ -1317,77 +1089,6 @@ func TestVerifyCreatePin(t *testing.T) {
}
}
func TestCheckAccountStatus(t *testing.T) {
sessionId := "session123"
ctx, store := InitializeTestStore(t)
ctx = context.WithValue(ctx, "SessionId", sessionId)
fm, err := NewFlagManager(flagsPath)
if err != nil {
t.Logf(err.Error())
}
flag_account_success, _ := fm.GetFlag("flag_account_success")
flag_account_pending, _ := fm.GetFlag("flag_account_pending")
flag_api_error, _ := fm.GetFlag("flag_api_call_error")
tests := []struct {
name string
publicKey []byte
response *models.TrackStatusResult
expectedResult resource.Result
}{
{
name: "Test when account is on the Sarafu network",
publicKey: []byte("TrackingId1234"),
response: &models.TrackStatusResult{
Active: true,
},
expectedResult: resource.Result{
FlagSet: []uint32{flag_account_success},
FlagReset: []uint32{flag_api_error, flag_account_pending},
},
},
{
name: "Test when the account is not yet on the sarafu network",
publicKey: []byte("TrackingId1234"),
response: &models.TrackStatusResult{
Active: false,
},
expectedResult: resource.Result{
FlagSet: []uint32{flag_account_pending},
FlagReset: []uint32{flag_api_error, flag_account_success},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
mockAccountService := new(mocks.MockAccountService)
h := &MenuHandlers{
userdataStore: store,
accountService: mockAccountService,
flagManager: fm,
}
err = store.WriteEntry(ctx, sessionId, storedb.DATA_PUBLIC_KEY, []byte(tt.publicKey))
if err != nil {
t.Fatal(err)
}
mockAccountService.On("TrackAccountStatus", string(tt.publicKey)).Return(tt.response, nil)
// Call the method under test
res, _ := h.CheckAccountStatus(ctx, "check_account_status", []byte(""))
// Assert that no errors occurred
assert.NoError(t, err)
//Assert that the account created flag has been set to the result
assert.Equal(t, res, tt.expectedResult, "Expected result should be equal to the actual result")
})
}
}
func TestTransactionReset(t *testing.T) {
sessionId := "session123"
ctx, store := InitializeTestStore(t)
@ -2001,65 +1702,6 @@ func TestGetProfile(t *testing.T) {
}
}
func TestConfirmPinChange(t *testing.T) {
sessionId := "session123"
mockState := state.NewState(16)
ctx, store := InitializeTestStore(t)
ctx = context.WithValue(ctx, "SessionId", sessionId)
fm, _ := NewFlagManager(flagsPath)
flag_pin_mismatch, _ := fm.GetFlag("flag_pin_mismatch")
flag_account_pin_reset, _ := fm.GetFlag("flag_account_pin_reset")
mockAccountService := new(mocks.MockAccountService)
h := &MenuHandlers{
userdataStore: store,
flagManager: fm,
accountService: mockAccountService,
st: mockState,
}
tests := []struct {
name string
input []byte
temporarypin string
expectedResult resource.Result
}{
{
name: "Test with correct pin confirmation",
input: []byte("1234"),
temporarypin: "1234",
expectedResult: resource.Result{
FlagReset: []uint32{flag_pin_mismatch, flag_account_pin_reset},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Hash the PIN
hashedPIN, err := pin.HashPIN(tt.temporarypin)
if err != nil {
logg.ErrorCtxf(ctx, "failed to hash temporaryPin", "error", err)
t.Fatal(err)
}
// Set up the expected behavior of the mock
err = store.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(hashedPIN))
if err != nil {
t.Fatal(err)
}
//Call the function under test
res, _ := h.ConfirmPinChange(ctx, "confirm_pin_change", tt.input)
//Assert that the result set to content is what was expected
assert.Equal(t, res, tt.expectedResult, "Result should contain flags set according to user input")
})
}
}
func TestFetchCommunityBalance(t *testing.T) {
// Define test data
@ -2371,56 +2013,6 @@ func TestGetVoucherDetails(t *testing.T) {
assert.Equal(t, expectedResult, res)
}
func TestCountIncorrectPINAttempts(t *testing.T) {
ctx, store := InitializeTestStore(t)
sessionId := "session123"
ctx = context.WithValue(ctx, "SessionId", sessionId)
attempts := uint8(2)
h := &MenuHandlers{
userdataStore: store,
}
err := store.WriteEntry(ctx, sessionId, storedb.DATA_INCORRECT_PIN_ATTEMPTS, []byte(strconv.Itoa(int(attempts))))
if err != nil {
t.Logf(err.Error())
}
err = h.incrementIncorrectPINAttempts(ctx, sessionId)
if err != nil {
t.Logf(err.Error())
}
attemptsAfterCount, err := store.ReadEntry(ctx, sessionId, storedb.DATA_INCORRECT_PIN_ATTEMPTS)
if err != nil {
t.Logf(err.Error())
}
pinAttemptsValue, _ := strconv.ParseUint(string(attemptsAfterCount), 0, 64)
pinAttemptsCount := uint8(pinAttemptsValue)
expectedAttempts := attempts + 1
assert.Equal(t, pinAttemptsCount, expectedAttempts)
}
func TestResetIncorrectPINAttempts(t *testing.T) {
ctx, store := InitializeTestStore(t)
sessionId := "session123"
ctx = context.WithValue(ctx, "SessionId", sessionId)
err := store.WriteEntry(ctx, sessionId, storedb.DATA_INCORRECT_PIN_ATTEMPTS, []byte(string("2")))
if err != nil {
t.Logf(err.Error())
}
h := &MenuHandlers{
userdataStore: store,
}
h.resetIncorrectPINAttempts(ctx, sessionId)
incorrectAttempts, err := store.ReadEntry(ctx, sessionId, storedb.DATA_INCORRECT_PIN_ATTEMPTS)
if err != nil {
t.Logf(err.Error())
}
assert.Equal(t, "0", string(incorrectAttempts))
}
func TestPersistLanguageCode(t *testing.T) {
ctx, store := InitializeTestStore(t)
@ -2460,58 +2052,6 @@ func TestPersistLanguageCode(t *testing.T) {
}
}
func TestCheckBlockedStatus(t *testing.T) {
ctx, store := InitializeTestStore(t)
sessionId := "session123"
ctx = context.WithValue(ctx, "SessionId", sessionId)
fm, err := NewFlagManager(flagsPath)
if err != nil {
t.Logf(err.Error())
}
flag_account_blocked, _ := fm.GetFlag("flag_account_blocked")
flag_account_pin_reset, _ := fm.GetFlag("flag_account_pin_reset")
h := &MenuHandlers{
userdataStore: store,
flagManager: fm,
}
tests := []struct {
name string
currentWrongPinAttempts string
expectedResult resource.Result
}{
{
name: "Currently blocked account",
currentWrongPinAttempts: "4",
expectedResult: resource.Result{
FlagReset: []uint32{flag_account_pin_reset},
},
},
{
name: "Account with 0 wrong PIN attempts",
currentWrongPinAttempts: "0",
expectedResult: resource.Result{
FlagReset: []uint32{flag_account_pin_reset, flag_account_blocked},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if err := store.WriteEntry(ctx, sessionId, storedb.DATA_INCORRECT_PIN_ATTEMPTS, []byte(tt.currentWrongPinAttempts)); err != nil {
t.Fatal(err)
}
res, err := h.CheckBlockedStatus(ctx, "", []byte(""))
assert.NoError(t, err)
assert.Equal(t, tt.expectedResult, res)
})
}
}
func TestPersistInitialLanguageCode(t *testing.T) {
ctx, store := InitializeTestStore(t)
@ -2955,80 +2495,6 @@ func TestShowBlockedAccount(t *testing.T) {
}
}
func TestValidateBlockedNumber(t *testing.T) {
sessionId := "session123"
validNumber := "+254712345678"
invalidNumber := "12343" // Invalid phone number
unregisteredNumber := "+254734567890" // Valid but unregistered number
publicKey := "0X13242618721"
mockState := state.NewState(128)
ctx, userStore := InitializeTestStore(t)
ctx = context.WithValue(ctx, "SessionId", sessionId)
fm, err := NewFlagManager(flagsPath)
if err != nil {
t.Fatal(err)
}
flag_unregistered_number, _ := fm.GetFlag("flag_unregistered_number")
h := &MenuHandlers{
userdataStore: userStore,
st: mockState,
flagManager: fm,
}
err = userStore.WriteEntry(ctx, validNumber, storedb.DATA_PUBLIC_KEY, []byte(publicKey))
if err != nil {
t.Fatal(err)
}
tests := []struct {
name string
input []byte
expectedResult resource.Result
}{
{
name: "Valid and registered number",
input: []byte(validNumber),
expectedResult: resource.Result{},
},
{
name: "Invalid Phone Number",
input: []byte(invalidNumber),
expectedResult: resource.Result{
FlagSet: []uint32{flag_unregistered_number},
},
},
{
name: "Unregistered Phone Number",
input: []byte(unregisteredNumber),
expectedResult: resource.Result{
FlagSet: []uint32{flag_unregistered_number},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
res, err := h.ValidateBlockedNumber(ctx, "validate_blocked_number", tt.input)
assert.NoError(t, err)
assert.Equal(t, tt.expectedResult, res)
if tt.name == "Valid and registered number" {
blockedNumber, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_BLOCKED_NUMBER)
if err != nil {
t.Fatal(err)
}
assert.Equal(t, validNumber, string(blockedNumber))
}
})
}
}
func TestGetCurrentProfileInfo(t *testing.T) {
sessionId := "session123"
ctx, store := InitializeTestStore(t)
@ -3152,39 +2618,6 @@ func TestGetCurrentProfileInfo(t *testing.T) {
}
}
func TestResetOthersPin(t *testing.T) {
sessionId := "session123"
blockedNumber := "+254712345678"
testPin := "1234"
ctx, userStore := InitializeTestStore(t)
ctx = context.WithValue(ctx, "SessionId", sessionId)
hashedPIN, err := pin.HashPIN(testPin)
if err != nil {
logg.ErrorCtxf(ctx, "failed to hash testPin", "error", err)
t.Fatal(err)
}
h := &MenuHandlers{
userdataStore: userStore,
}
// Write initial data to the store
err = userStore.WriteEntry(ctx, sessionId, storedb.DATA_BLOCKED_NUMBER, []byte(blockedNumber))
if err != nil {
t.Fatal(err)
}
err = userStore.WriteEntry(ctx, blockedNumber, storedb.DATA_TEMPORARY_VALUE, []byte(hashedPIN))
if err != nil {
t.Fatal(err)
}
_, err = h.ResetOthersPin(ctx, "reset_others_pin", []byte(""))
assert.NoError(t, err)
}
func TestResetUnregisteredNumber(t *testing.T) {
ctx := context.Background()

View File

@ -0,0 +1,293 @@
package application
import (
"context"
"log"
"strconv"
"testing"
"git.defalsify.org/vise.git/resource"
"git.defalsify.org/vise.git/state"
"git.grassecon.net/grassrootseconomics/common/pin"
"git.grassecon.net/grassrootseconomics/sarafu-api/testutil/mocks"
"git.grassecon.net/grassrootseconomics/sarafu-vise/store"
storedb "git.grassecon.net/grassrootseconomics/sarafu-vise/store/db"
"github.com/alecthomas/assert/v2"
)
func TestCountIncorrectPINAttempts(t *testing.T) {
ctx, store := InitializeTestStore(t)
sessionId := "session123"
ctx = context.WithValue(ctx, "SessionId", sessionId)
attempts := uint8(2)
h := &MenuHandlers{
userdataStore: store,
}
err := store.WriteEntry(ctx, sessionId, storedb.DATA_INCORRECT_PIN_ATTEMPTS, []byte(strconv.Itoa(int(attempts))))
if err != nil {
t.Logf(err.Error())
}
err = h.incrementIncorrectPINAttempts(ctx, sessionId)
if err != nil {
t.Logf(err.Error())
}
attemptsAfterCount, err := store.ReadEntry(ctx, sessionId, storedb.DATA_INCORRECT_PIN_ATTEMPTS)
if err != nil {
t.Logf(err.Error())
}
pinAttemptsValue, _ := strconv.ParseUint(string(attemptsAfterCount), 0, 64)
pinAttemptsCount := uint8(pinAttemptsValue)
expectedAttempts := attempts + 1
assert.Equal(t, pinAttemptsCount, expectedAttempts)
}
func TestResetIncorrectPINAttempts(t *testing.T) {
ctx, store := InitializeTestStore(t)
sessionId := "session123"
ctx = context.WithValue(ctx, "SessionId", sessionId)
err := store.WriteEntry(ctx, sessionId, storedb.DATA_INCORRECT_PIN_ATTEMPTS, []byte(string("2")))
if err != nil {
t.Logf(err.Error())
}
h := &MenuHandlers{
userdataStore: store,
}
h.resetIncorrectPINAttempts(ctx, sessionId)
incorrectAttempts, err := store.ReadEntry(ctx, sessionId, storedb.DATA_INCORRECT_PIN_ATTEMPTS)
if err != nil {
t.Logf(err.Error())
}
assert.Equal(t, "0", string(incorrectAttempts))
}
func TestSaveTemporaryPin(t *testing.T) {
sessionId := "session123"
ctx, userdatastore := InitializeTestStore(t)
ctx = context.WithValue(ctx, "SessionId", sessionId)
_, logdb := InitializeTestLogdbStore(t)
logDb := store.LogDb{
Db: logdb,
}
fm, err := NewFlagManager(flagsPath)
if err != nil {
log.Fatal(err)
}
flag_invalid_pin, _ := fm.GetFlag("flag_invalid_pin")
// Create the MenuHandlers instance with the mock flag manager
h := &MenuHandlers{
flagManager: fm,
userdataStore: userdatastore,
logDb: logDb,
}
// Define test cases
tests := []struct {
name string
input []byte
expectedResult resource.Result
}{
{
name: "Valid Pin entry",
input: []byte("1234"),
expectedResult: resource.Result{
FlagReset: []uint32{flag_invalid_pin},
},
},
{
name: "Invalid Pin entry",
input: []byte("12343"),
expectedResult: resource.Result{
FlagSet: []uint32{flag_invalid_pin},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Call the method
res, err := h.SaveTemporaryPin(ctx, "save_pin", tt.input)
if err != nil {
t.Error(err)
}
// Assert that the Result FlagSet has the required flags after language switch
assert.Equal(t, res, tt.expectedResult, "Result should match expected result")
})
}
}
func TestConfirmPinChange(t *testing.T) {
sessionId := "session123"
mockState := state.NewState(16)
ctx, store := InitializeTestStore(t)
ctx = context.WithValue(ctx, "SessionId", sessionId)
fm, _ := NewFlagManager(flagsPath)
flag_pin_mismatch, _ := fm.GetFlag("flag_pin_mismatch")
flag_account_pin_reset, _ := fm.GetFlag("flag_account_pin_reset")
mockAccountService := new(mocks.MockAccountService)
h := &MenuHandlers{
userdataStore: store,
flagManager: fm,
accountService: mockAccountService,
st: mockState,
}
tests := []struct {
name string
input []byte
temporarypin string
expectedResult resource.Result
}{
{
name: "Test with correct pin confirmation",
input: []byte("1234"),
temporarypin: "1234",
expectedResult: resource.Result{
FlagReset: []uint32{flag_pin_mismatch, flag_account_pin_reset},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Hash the PIN
hashedPIN, err := pin.HashPIN(tt.temporarypin)
if err != nil {
logg.ErrorCtxf(ctx, "failed to hash temporaryPin", "error", err)
t.Fatal(err)
}
// Set up the expected behavior of the mock
err = store.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(hashedPIN))
if err != nil {
t.Fatal(err)
}
//Call the function under test
res, _ := h.ConfirmPinChange(ctx, "confirm_pin_change", tt.input)
//Assert that the result set to content is what was expected
assert.Equal(t, res, tt.expectedResult, "Result should contain flags set according to user input")
})
}
}
func TestValidateBlockedNumber(t *testing.T) {
sessionId := "session123"
validNumber := "+254712345678"
invalidNumber := "12343" // Invalid phone number
unregisteredNumber := "+254734567890" // Valid but unregistered number
publicKey := "0X13242618721"
mockState := state.NewState(128)
ctx, userStore := InitializeTestStore(t)
ctx = context.WithValue(ctx, "SessionId", sessionId)
fm, err := NewFlagManager(flagsPath)
if err != nil {
t.Fatal(err)
}
flag_unregistered_number, _ := fm.GetFlag("flag_unregistered_number")
h := &MenuHandlers{
userdataStore: userStore,
st: mockState,
flagManager: fm,
}
err = userStore.WriteEntry(ctx, validNumber, storedb.DATA_PUBLIC_KEY, []byte(publicKey))
if err != nil {
t.Fatal(err)
}
tests := []struct {
name string
input []byte
expectedResult resource.Result
}{
{
name: "Valid and registered number",
input: []byte(validNumber),
expectedResult: resource.Result{},
},
{
name: "Invalid Phone Number",
input: []byte(invalidNumber),
expectedResult: resource.Result{
FlagSet: []uint32{flag_unregistered_number},
},
},
{
name: "Unregistered Phone Number",
input: []byte(unregisteredNumber),
expectedResult: resource.Result{
FlagSet: []uint32{flag_unregistered_number},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
res, err := h.ValidateBlockedNumber(ctx, "validate_blocked_number", tt.input)
assert.NoError(t, err)
assert.Equal(t, tt.expectedResult, res)
if tt.name == "Valid and registered number" {
blockedNumber, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_BLOCKED_NUMBER)
if err != nil {
t.Fatal(err)
}
assert.Equal(t, validNumber, string(blockedNumber))
}
})
}
}
func TestResetOthersPin(t *testing.T) {
sessionId := "session123"
blockedNumber := "+254712345678"
testPin := "1234"
ctx, userStore := InitializeTestStore(t)
ctx = context.WithValue(ctx, "SessionId", sessionId)
hashedPIN, err := pin.HashPIN(testPin)
if err != nil {
logg.ErrorCtxf(ctx, "failed to hash testPin", "error", err)
t.Fatal(err)
}
h := &MenuHandlers{
userdataStore: userStore,
}
// Write initial data to the store
err = userStore.WriteEntry(ctx, sessionId, storedb.DATA_BLOCKED_NUMBER, []byte(blockedNumber))
if err != nil {
t.Fatal(err)
}
err = userStore.WriteEntry(ctx, blockedNumber, storedb.DATA_TEMPORARY_VALUE, []byte(hashedPIN))
if err != nil {
t.Fatal(err)
}
_, err = h.ResetOthersPin(ctx, "reset_others_pin", []byte(""))
assert.NoError(t, err)
}