From f884b19012d8c01440e08a1799830845d0bc4ff8 Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Thu, 23 Jan 2025 11:29:57 +0300 Subject: [PATCH 01/28] added TestCheckBlockedStatus --- handlers/application/menuhandler_test.go | 53 +++++++++++++++++++++++- 1 file changed, 52 insertions(+), 1 deletion(-) diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index 0d3b9ef..e0a78d3 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -2336,5 +2336,56 @@ func TestPersistLanguageCode(t *testing.T) { assert.Equal(t, test.expectedLanguageCode, string(code)) } - +} + +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, err := fm.GetFlag("flag_account_blocked") + if err != nil { + t.Logf(err.Error()) + } + + h := &MenuHandlers{ + userdataStore: store, + flagManager: fm, + } + + tests := []struct { + name string + currentWrongPinAttempts string + expectedResult resource.Result + }{ + { + name: "Currently blocked account", + currentWrongPinAttempts: "4", + expectedResult: resource.Result{}, + }, + { + name: "Account with 0 wrong PIN attempts", + currentWrongPinAttempts: "0", + expectedResult: resource.Result{ + FlagReset: []uint32{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) + }) + } } From caabf4f8af14d313bb5970ccaa69fb1b4cd70406 Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Thu, 23 Jan 2025 11:30:25 +0300 Subject: [PATCH 02/28] updated the structure of TestPersistLanguageCode --- handlers/application/menuhandler_test.go | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index e0a78d3..2bd42e0 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -2328,13 +2328,15 @@ func TestPersistLanguageCode(t *testing.T) { } for _, test := range tests { - err := h.persistLanguageCode(ctx, test.code) - if err != nil { - t.Logf(err.Error()) - } - code, err := store.ReadEntry(ctx, sessionId, storedb.DATA_SELECTED_LANGUAGE_CODE) + t.Run(test.name, func(t *testing.T) { + err := h.persistLanguageCode(ctx, test.code) + if err != nil { + t.Logf(err.Error()) + } + code, err := store.ReadEntry(ctx, sessionId, storedb.DATA_SELECTED_LANGUAGE_CODE) - assert.Equal(t, test.expectedLanguageCode, string(code)) + assert.Equal(t, test.expectedLanguageCode, string(code)) + }) } } From c9257ba0d69ca24166383f3995ad9549edce8bb1 Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Thu, 23 Jan 2025 11:47:12 +0300 Subject: [PATCH 03/28] added TestPersistInitialLanguageCode --- handlers/application/menuhandler_test.go | 37 ++++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index 2bd42e0..c04c60f 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -2391,3 +2391,40 @@ func TestCheckBlockedStatus(t *testing.T) { }) } } + +func TestPersistInitialLanguageCode(t *testing.T) { + ctx, store := InitializeTestStore(t) + + h := &MenuHandlers{ + userdataStore: store, + } + + tests := []struct { + name string + code string + sessionId string + }{ + { + name: "Persist initial Language (English)", + code: "eng", + sessionId: "session123", + }, + { + name: "Persist initial Language (Swahili)", + code: "swa", + sessionId: "session456", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := h.persistInitialLanguageCode(ctx, tt.sessionId, tt.code) + if err != nil { + t.Logf(err.Error()) + } + code, err := store.ReadEntry(ctx, tt.sessionId, storedb.DATA_INITIAL_LANGUAGE_CODE) + + assert.Equal(t, tt.code, string(code)) + }) + } +} From 93723616f66ff76b81500f9f3c7b5bbbaf054489 Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Thu, 23 Jan 2025 13:42:17 +0300 Subject: [PATCH 04/28] added TestCheckTransactions --- handlers/application/menuhandler_test.go | 65 ++++++++++++++++++++++++ 1 file changed, 65 insertions(+) diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index c04c60f..599ea8f 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -8,6 +8,7 @@ import ( "strconv" "strings" "testing" + "time" "git.defalsify.org/vise.git/cache" "git.defalsify.org/vise.git/lang" @@ -2428,3 +2429,67 @@ func TestPersistInitialLanguageCode(t *testing.T) { }) } } + +func TestCheckTransactions(t *testing.T) { + mockAccountService := new(mocks.MockAccountService) + sessionId := "session123" + publicKey := "0X13242618721" + + ctx, store := InitializeTestStore(t) + ctx = context.WithValue(ctx, "SessionId", sessionId) + spdb := InitializeTestSubPrefixDb(t, ctx) + + fm, err := NewFlagManager(flagsPath) + if err != nil { + t.Logf(err.Error()) + } + + h := &MenuHandlers{ + userdataStore: store, + accountService: mockAccountService, + prefixDb: spdb, + flagManager: fm, + } + + err = store.WriteEntry(ctx, sessionId, storedb.DATA_PUBLIC_KEY, []byte(publicKey)) + if err != nil { + t.Fatal(err) + } + + mockTXResponse := []dataserviceapi.Last10TxResponse{ + { + Sender: "0X13242618721", Recipient: "0x41c188d63Qa", TransferValue: "100", ContractAddress: "0X1324262343rfdGW23", + TxHash: "0x123wefsf34rf", DateBlock: time.Now(), TokenSymbol: "SRF", TokenDecimals: "6", + }, + { + Sender: "0x41c188d63Qa", Recipient: "0X13242618721", TransferValue: "200", ContractAddress: "0X1324262343rfdGW23", + TxHash: "0xq34wresfdb44", DateBlock: time.Now(), TokenSymbol: "SRF", TokenDecimals: "6", + }, + } + + expectedSenders := []byte("0X13242618721\n0x41c188d63Qa") + + mockAccountService.On("FetchTransactions", string(publicKey)).Return(mockTXResponse, nil) + + _, err = h.CheckTransactions(ctx, "check_transactions", []byte("")) + assert.NoError(t, err) + + // Read tranfers senders data from the store + senderData, err := spdb.Get(ctx, storedb.ToBytes(storedb.DATA_TX_SENDERS)) + if err != nil { + t.Fatal(err) + } + + // assert that the data is stored correctly + assert.Equal(t, expectedSenders, senderData) + + mockAccountService.AssertExpectations(t) +} + +func TestGetTransactionsList(t *testing.T) { + +} + +func TestViewTransactionStatement(t *testing.T) { + +} From be5bd16616d6c88db60e867f572f52df5a0ceed5 Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Thu, 23 Jan 2025 15:06:12 +0300 Subject: [PATCH 05/28] added TestGetTransactionsList --- handlers/application/menuhandler_test.go | 56 ++++++++++++++++++++++++ 1 file changed, 56 insertions(+) diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index 599ea8f..093b600 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -2487,7 +2487,63 @@ func TestCheckTransactions(t *testing.T) { } func TestGetTransactionsList(t *testing.T) { + sessionId := "session123" + publicKey := "0X13242618721" + ctx, userStore := InitializeTestStore(t) + ctx = context.WithValue(ctx, "SessionId", sessionId) + + spdb := InitializeTestSubPrefixDb(t, ctx) + + // Initialize MenuHandlers + h := &MenuHandlers{ + userdataStore: userStore, + prefixDb: spdb, + ReplaceSeparatorFunc: mockReplaceSeparator, + } + + err := userStore.WriteEntry(ctx, sessionId, storedb.DATA_PUBLIC_KEY, []byte(publicKey)) + if err != nil { + t.Fatal(err) + } + + mockTXResponse := []dataserviceapi.Last10TxResponse{ + { + Sender: "0X13242618721", Recipient: "0x41c188d63Qa", TransferValue: "1000", ContractAddress: "0X1324262343rfdGW23", + TxHash: "0x123wefsf34rf", DateBlock: time.Now(), TokenSymbol: "SRF", TokenDecimals: "2", + }, + { + Sender: "0x41c188d63Qa", Recipient: "0X13242618721", TransferValue: "2000", ContractAddress: "0X1324262343rfdGW23", + TxHash: "0xq34wresfdb44", DateBlock: time.Now(), TokenSymbol: "SRF", TokenDecimals: "2", + }, + } + + data := store.ProcessTransfers(mockTXResponse) + + // Store all transaction data + dataMap := map[storedb.DataTyp]string{ + storedb.DATA_TX_SENDERS: data.Senders, + storedb.DATA_TX_RECIPIENTS: data.Recipients, + storedb.DATA_TX_VALUES: data.TransferValues, + storedb.DATA_TX_ADDRESSES: data.Addresses, + storedb.DATA_TX_HASHES: data.TxHashes, + storedb.DATA_TX_DATES: data.Dates, + storedb.DATA_TX_SYMBOLS: data.Symbols, + storedb.DATA_TX_DECIMALS: data.Decimals, + } + + for key, value := range dataMap { + if err := h.prefixDb.Put(ctx, []byte(storedb.ToBytes(key)), []byte(value)); err != nil { + t.Fatal(err) + } + } + + expectedTransactionList := []byte("1: Sent 10 SRF " + time.Now().Format("2006-01-02") + "\n2: Received 20 SRF " + time.Now().Format("2006-01-02")) + + res, err := h.GetTransactionsList(ctx, "", []byte("")) + + assert.NoError(t, err) + assert.Equal(t, res.Content, string(expectedTransactionList)) } func TestViewTransactionStatement(t *testing.T) { From ffea1a0b9666c73074eb1b0a2cbd664365acb6e2 Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Thu, 23 Jan 2025 15:54:50 +0300 Subject: [PATCH 06/28] added TestViewTransactionStatement --- handlers/application/menuhandler_test.go | 75 +++++++++++++++++++++++- 1 file changed, 72 insertions(+), 3 deletions(-) diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index 093b600..7e9952d 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -2507,14 +2507,19 @@ func TestGetTransactionsList(t *testing.T) { t.Fatal(err) } + dateBlock, err := time.Parse(time.RFC3339, "2024-10-03T07:23:12Z") + if err != nil { + t.Fatal(err) + } + mockTXResponse := []dataserviceapi.Last10TxResponse{ { Sender: "0X13242618721", Recipient: "0x41c188d63Qa", TransferValue: "1000", ContractAddress: "0X1324262343rfdGW23", - TxHash: "0x123wefsf34rf", DateBlock: time.Now(), TokenSymbol: "SRF", TokenDecimals: "2", + TxHash: "0x123wefsf34rf", DateBlock: dateBlock, TokenSymbol: "SRF", TokenDecimals: "2", }, { Sender: "0x41c188d63Qa", Recipient: "0X13242618721", TransferValue: "2000", ContractAddress: "0X1324262343rfdGW23", - TxHash: "0xq34wresfdb44", DateBlock: time.Now(), TokenSymbol: "SRF", TokenDecimals: "2", + TxHash: "0xq34wresfdb44", DateBlock: dateBlock, TokenSymbol: "SRF", TokenDecimals: "2", }, } @@ -2538,7 +2543,7 @@ func TestGetTransactionsList(t *testing.T) { } } - expectedTransactionList := []byte("1: Sent 10 SRF " + time.Now().Format("2006-01-02") + "\n2: Received 20 SRF " + time.Now().Format("2006-01-02")) + expectedTransactionList := []byte("1: Sent 10 SRF 2024-10-03\n2: Received 20 SRF 2024-10-03") res, err := h.GetTransactionsList(ctx, "", []byte("")) @@ -2547,5 +2552,69 @@ func TestGetTransactionsList(t *testing.T) { } func TestViewTransactionStatement(t *testing.T) { + ctx, userStore := InitializeTestStore(t) + sessionId := "session123" + publicKey := "0X13242618721" + ctx = context.WithValue(ctx, "SessionId", sessionId) + spdb := InitializeTestSubPrefixDb(t, ctx) + + fm, err := NewFlagManager(flagsPath) + if err != nil { + t.Logf(err.Error()) + } + + h := &MenuHandlers{ + userdataStore: userStore, + prefixDb: spdb, + flagManager: fm, + } + + err = userStore.WriteEntry(ctx, sessionId, storedb.DATA_PUBLIC_KEY, []byte(publicKey)) + if err != nil { + t.Fatal(err) + } + + dateBlock, err := time.Parse(time.RFC3339, "2024-10-03T07:23:12Z") + if err != nil { + t.Fatal(err) + } + + mockTXResponse := []dataserviceapi.Last10TxResponse{ + { + Sender: "0X13242618721", Recipient: "0x41c188d63Qa", TransferValue: "1000", ContractAddress: "0X1324262343rfdGW23", + TxHash: "0x123wefsf34rf", DateBlock: dateBlock, TokenSymbol: "SRF", TokenDecimals: "2", + }, + { + Sender: "0x41c188d63Qa", Recipient: "0X13242618721", TransferValue: "2000", ContractAddress: "0X1324262343rfdGW23", + TxHash: "0xq34wresfdb44", DateBlock: dateBlock, TokenSymbol: "SRF", TokenDecimals: "2", + }, + } + + data := store.ProcessTransfers(mockTXResponse) + + // Store all transaction data + dataMap := map[storedb.DataTyp]string{ + storedb.DATA_TX_SENDERS: data.Senders, + storedb.DATA_TX_RECIPIENTS: data.Recipients, + storedb.DATA_TX_VALUES: data.TransferValues, + storedb.DATA_TX_ADDRESSES: data.Addresses, + storedb.DATA_TX_HASHES: data.TxHashes, + storedb.DATA_TX_DATES: data.Dates, + storedb.DATA_TX_SYMBOLS: data.Symbols, + storedb.DATA_TX_DECIMALS: data.Decimals, + } + + for key, value := range dataMap { + if err := h.prefixDb.Put(ctx, []byte(storedb.ToBytes(key)), []byte(value)); err != nil { + t.Fatal(err) + } + } + + expectedTransactionData := []byte("Sent 10 SRF\nTo: 0x41c188d63Qa\nContract address: 0X1324262343rfdGW23\nTxhash: 0x123wefsf34rf\nDate: 2024-10-03 07:23:12 AM") + + res, err := h.ViewTransactionStatement(ctx, "view_transaction_statement", []byte("1")) + + assert.NoError(t, err) + assert.Equal(t, res.Content, string(expectedTransactionData)) } From 0e480e3d551e1fef338258e36a0831c99eb2225b Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Thu, 23 Jan 2025 16:08:04 +0300 Subject: [PATCH 07/28] enhanced the TestViewTransactionStatement --- handlers/application/menuhandler_test.go | 62 ++++++++++++++++++++++-- 1 file changed, 58 insertions(+), 4 deletions(-) diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index 7e9952d..fa9fdd8 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -2563,6 +2563,7 @@ func TestViewTransactionStatement(t *testing.T) { if err != nil { t.Logf(err.Error()) } + flag_incorrect_statement, _ := fm.GetFlag("flag_incorrect_statement") h := &MenuHandlers{ userdataStore: userStore, @@ -2611,10 +2612,63 @@ func TestViewTransactionStatement(t *testing.T) { } } - expectedTransactionData := []byte("Sent 10 SRF\nTo: 0x41c188d63Qa\nContract address: 0X1324262343rfdGW23\nTxhash: 0x123wefsf34rf\nDate: 2024-10-03 07:23:12 AM") + tests := []struct { + name string + input []byte + expectedError error + expectedResult resource.Result + }{ + { + name: "Valid input - index 1", + input: []byte("1"), + expectedError: nil, + expectedResult: resource.Result{ + Content: "Sent 10 SRF\nTo: 0x41c188d63Qa\nContract address: 0X1324262343rfdGW23\nTxhash: 0x123wefsf34rf\nDate: 2024-10-03 07:23:12 AM", + FlagReset: []uint32{flag_incorrect_statement}, + }, + }, + { + name: "Valid input - index 2", + input: []byte("2"), + expectedError: nil, + expectedResult: resource.Result{ + Content: "Received 20 SRF\nFrom: 0x41c188d63Qa\nContract address: 0X1324262343rfdGW23\nTxhash: 0xq34wresfdb44\nDate: 2024-10-03 07:23:12 AM", + FlagReset: []uint32{flag_incorrect_statement}, + }, + }, + { + name: "Invalid input - index 0", + input: []byte("0"), + expectedError: nil, + expectedResult: resource.Result{ + FlagReset: []uint32{flag_incorrect_statement}, + }, + }, + { + name: "Invalid input - index 12", + input: []byte("12"), + expectedError: fmt.Errorf("invalid input: index must be between 1 and 10"), + expectedResult: resource.Result{}, + }, + { + name: "Invalid input - non-numeric", + input: []byte("abc"), + expectedError: fmt.Errorf("invalid input: must be a number between 1 and 10"), + expectedResult: resource.Result{}, + }, + } - res, err := h.ViewTransactionStatement(ctx, "view_transaction_statement", []byte("1")) + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + res, err := h.ViewTransactionStatement(ctx, "view_transaction_statement", tt.input) - assert.NoError(t, err) - assert.Equal(t, res.Content, string(expectedTransactionData)) + if tt.expectedError != nil { + assert.EqualError(t, err, tt.expectedError.Error()) + } else { + assert.NoError(t, err) + } + + assert.Equal(t, tt.expectedResult, res) + }) + } } From 64a87231ca55f1d732309181d49f9684baddc71b Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Fri, 24 Jan 2025 15:43:42 +0300 Subject: [PATCH 08/28] removed redundant type from array --- handlers/application/menuhandler_test.go | 26 +++++++++++------------- 1 file changed, 12 insertions(+), 14 deletions(-) diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index fa9fdd8..f0edf2b 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -2028,7 +2028,7 @@ func TestSetDefaultVoucher(t *testing.T) { { name: "Test set default voucher when no active voucher is set", vouchersResp: []dataserviceapi.TokenHoldings{ - dataserviceapi.TokenHoldings{ + { ContractAddress: "0x123", TokenSymbol: "TOKEN1", TokenDecimals: "18", @@ -2276,7 +2276,6 @@ func TestCountIncorrectPINAttempts(t *testing.T) { pinAttemptsCount := uint8(pinAttemptsValue) expectedAttempts := attempts + 1 assert.Equal(t, pinAttemptsCount, expectedAttempts) - } func TestResetIncorrectPINAttempts(t *testing.T) { @@ -2299,7 +2298,6 @@ func TestResetIncorrectPINAttempts(t *testing.T) { t.Logf(err.Error()) } assert.Equal(t, "0", string(incorrectAttempts)) - } func TestPersistLanguageCode(t *testing.T) { @@ -2619,27 +2617,27 @@ func TestViewTransactionStatement(t *testing.T) { expectedResult resource.Result }{ { - name: "Valid input - index 1", - input: []byte("1"), - expectedError: nil, + name: "Valid input - index 1", + input: []byte("1"), + expectedError: nil, expectedResult: resource.Result{ - Content: "Sent 10 SRF\nTo: 0x41c188d63Qa\nContract address: 0X1324262343rfdGW23\nTxhash: 0x123wefsf34rf\nDate: 2024-10-03 07:23:12 AM", + Content: "Sent 10 SRF\nTo: 0x41c188d63Qa\nContract address: 0X1324262343rfdGW23\nTxhash: 0x123wefsf34rf\nDate: 2024-10-03 07:23:12 AM", FlagReset: []uint32{flag_incorrect_statement}, }, }, { - name: "Valid input - index 2", - input: []byte("2"), - expectedError: nil, + name: "Valid input - index 2", + input: []byte("2"), + expectedError: nil, expectedResult: resource.Result{ - Content: "Received 20 SRF\nFrom: 0x41c188d63Qa\nContract address: 0X1324262343rfdGW23\nTxhash: 0xq34wresfdb44\nDate: 2024-10-03 07:23:12 AM", + Content: "Received 20 SRF\nFrom: 0x41c188d63Qa\nContract address: 0X1324262343rfdGW23\nTxhash: 0xq34wresfdb44\nDate: 2024-10-03 07:23:12 AM", FlagReset: []uint32{flag_incorrect_statement}, }, }, { - name: "Invalid input - index 0", - input: []byte("0"), - expectedError: nil, + name: "Invalid input - index 0", + input: []byte("0"), + expectedError: nil, expectedResult: resource.Result{ FlagReset: []uint32{flag_incorrect_statement}, }, From 28185fc2c51bb757c40e35185562367274ef4b5b Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Mon, 27 Jan 2025 01:05:32 +0300 Subject: [PATCH 09/28] added TestRetrieveBlockedNumber --- handlers/application/menuhandler_test.go | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index f0edf2b..3bd0e92 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -2670,3 +2670,26 @@ func TestViewTransactionStatement(t *testing.T) { }) } } + +func TestRetrieveBlockedNumber(t *testing.T) { + sessionId := "session123" + blockedNumber := "0712345678" + + ctx, userStore := InitializeTestStore(t) + ctx = context.WithValue(ctx, "SessionId", sessionId) + + h := &MenuHandlers{ + userdataStore: userStore, + } + + err := userStore.WriteEntry(ctx, sessionId, storedb.DATA_BLOCKED_NUMBER, []byte(blockedNumber)) + if err != nil { + t.Fatal(err) + } + + res, err := h.RetrieveBlockedNumber(ctx, "retrieve_blocked_number", []byte("")) + + assert.NoError(t, err) + + assert.Equal(t, blockedNumber, res.Content) +} From d66fd894bc6e21fceef021e43a241d756a6291b3 Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Mon, 27 Jan 2025 01:17:44 +0300 Subject: [PATCH 10/28] added TestMaxAmount --- handlers/application/menuhandler_test.go | 66 ++++++++++++++++++++++++ 1 file changed, 66 insertions(+) diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index 3bd0e92..918900b 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -2693,3 +2693,69 @@ func TestRetrieveBlockedNumber(t *testing.T) { assert.Equal(t, blockedNumber, res.Content) } + +func TestMaxAmount(t *testing.T) { + sessionId := "session123" + activeBal := "500" + + tests := []struct { + name string + sessionId string + activeBal string + expectedError bool + expectedResult resource.Result + }{ + { + name: "Valid session ID and active balance", + sessionId: sessionId, + activeBal: activeBal, + expectedError: false, + expectedResult: resource.Result{Content: activeBal}, + }, + { + name: "Missing Session ID", + sessionId: "", + activeBal: activeBal, + expectedError: true, + expectedResult: resource.Result{}, + }, + { + name: "Failed to Read Active Balance", + sessionId: sessionId, + activeBal: "", // failure to read active balance + expectedError: true, + expectedResult: resource.Result{}, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + ctx, userStore := InitializeTestStore(t) + if tt.sessionId != "" { + ctx = context.WithValue(ctx, "SessionId", tt.sessionId) + } + + h := &MenuHandlers{ + userdataStore: userStore, + } + + // Write active balance to the store only if it's not empty + if tt.activeBal != "" { + err := userStore.WriteEntry(ctx, tt.sessionId, storedb.DATA_ACTIVE_BAL, []byte(tt.activeBal)) + if err != nil { + t.Fatal(err) + } + } + + res, err := h.MaxAmount(ctx, "max_amount", []byte("")) + + if tt.expectedError { + assert.Error(t, err) + } else { + assert.NoError(t, err) + } + + assert.Equal(t, tt.expectedResult, res) + }) + } +} From df0c1b3429f18aebdc15aebd070774eb9ccb5a41 Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Mon, 27 Jan 2025 01:25:01 +0300 Subject: [PATCH 11/28] added TestQuitWithHelp and TestShowBlockedAccount --- handlers/application/menuhandler_test.go | 67 ++++++++++++++++++++++++ 1 file changed, 67 insertions(+) diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index 918900b..7b4ea42 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -2759,3 +2759,70 @@ func TestMaxAmount(t *testing.T) { }) } } + +func TestQuitWithHelp(t *testing.T) { + fm, err := NewFlagManager(flagsPath) + if err != nil { + t.Logf(err.Error()) + } + flag_account_authorized, _ := fm.GetFlag("flag_account_authorized") + + sessionId := "session123" + + ctx := context.WithValue(context.Background(), "SessionId", sessionId) + + h := &MenuHandlers{ + flagManager: fm, + } + tests := []struct { + name string + input []byte + status string + expectedResult resource.Result + }{ + { + name: "Test quit with help message", + expectedResult: resource.Result{ + FlagReset: []uint32{flag_account_authorized}, + Content: "For more help, please call: 0757628885", + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + res, _ := h.QuitWithHelp(ctx, "quit_with_help", tt.input) + //Assert that the aflag_account_authorized has been reset to the result + assert.Equal(t, res, tt.expectedResult, "Expected result should be equal to the actual result") + }) + } +} + +func TestShowBlockedAccount(t *testing.T) { + sessionId := "session123" + ctx := context.WithValue(context.Background(), "SessionId", sessionId) + + h := &MenuHandlers{} + + tests := []struct { + name string + input []byte + status string + expectedResult resource.Result + }{ + { + name: "Test quit with Show Blocked Account", + expectedResult: resource.Result{ + Content: "Your account has been locked. For help on how to unblock your account, contact support at: 0757628885", + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + res, _ := h.ShowBlockedAccount(ctx, "show_blocked_account", tt.input) + //Assert that the result is as expected + assert.Equal(t, res, tt.expectedResult, "Expected result should be equal to the actual result") + }) + } +} From ebe94c705f5b9ee5cd93c40101b9f96beef99c56 Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Mon, 27 Jan 2025 01:46:14 +0300 Subject: [PATCH 12/28] added TestValidateBlockedNumber --- handlers/application/menuhandler_test.go | 72 ++++++++++++++++++++++++ 1 file changed, 72 insertions(+) diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index 7b4ea42..b1d7df3 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -2826,3 +2826,75 @@ 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" + + 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, + 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)) + } + }) + } +} From 128c0162d2732257cc9965657053a3555e77e5fd Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Mon, 27 Jan 2025 02:13:53 +0300 Subject: [PATCH 13/28] added TestSaveOthersTemporaryPin --- handlers/application/menuhandler_test.go | 31 ++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index b1d7df3..0954e2e 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -2898,3 +2898,34 @@ func TestValidateBlockedNumber(t *testing.T) { }) } } + +func TestSaveOthersTemporaryPin(t *testing.T) { + sessionId := "session123" + blockedNumber := "+254712345678" + testPin := "1234" + + ctx, userStore := InitializeTestStore(t) + ctx = context.WithValue(ctx, "SessionId", sessionId) + + h := &MenuHandlers{ + userdataStore: userStore, + } + + err := userStore.WriteEntry(ctx, sessionId, storedb.DATA_BLOCKED_NUMBER, []byte(blockedNumber)) + if err != nil { + t.Fatal(err) + } + + _, err = h.SaveOthersTemporaryPin(ctx, "save_others_temporary_pin", []byte(testPin)) + + assert.NoError(t, err) + + othersHashedPin, err := userStore.ReadEntry(ctx, blockedNumber, storedb.DATA_TEMPORARY_VALUE) + if err != nil { + t.Fatal(err) + } + + if !pin.VerifyPIN(string(othersHashedPin), string(testPin)) { + t.Fatal(err) + } +} From b4924218518af68858e1d37b81430aa65f8bd24a Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Mon, 27 Jan 2025 10:40:35 +0300 Subject: [PATCH 14/28] enhanced the TestSaveOthersTemporaryPin --- handlers/application/menuhandler_test.go | 90 +++++++++++++++++++++--- 1 file changed, 79 insertions(+), 11 deletions(-) diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index 0954e2e..a8faa95 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -2911,21 +2911,89 @@ func TestSaveOthersTemporaryPin(t *testing.T) { userdataStore: userStore, } - err := userStore.WriteEntry(ctx, sessionId, storedb.DATA_BLOCKED_NUMBER, []byte(blockedNumber)) - if err != nil { - t.Fatal(err) + tests := []struct { + name string + sessionId string + blockedNumber string + testPin string + setup func() error // Setup function for each test case + expectedError bool + verifyResult func(t *testing.T) // Function to verify the result + }{ + { + name: "Missing Session ID", + sessionId: "", // Empty session ID + blockedNumber: blockedNumber, + testPin: testPin, + setup: nil, + expectedError: true, + verifyResult: nil, + }, + { + name: "Failed to Read Blocked Number", + sessionId: sessionId, + blockedNumber: blockedNumber, + testPin: testPin, + setup: func() error { + // Do not write the blocked number to simulate a read failure + return nil + }, + expectedError: true, + verifyResult: nil, + }, + + { + name: "Successfully save hashed PIN", + sessionId: sessionId, + blockedNumber: blockedNumber, + testPin: testPin, + setup: func() error { + // Write the blocked number to the store + return userStore.WriteEntry(ctx, sessionId, storedb.DATA_BLOCKED_NUMBER, []byte(blockedNumber)) + }, + expectedError: false, + verifyResult: func(t *testing.T) { + // Read the stored hashed PIN + othersHashedPin, err := userStore.ReadEntry(ctx, blockedNumber, storedb.DATA_TEMPORARY_VALUE) + if err != nil { + t.Fatal(err) + } + + // Verify that the stored hashed PIN matches the original PIN + if !pin.VerifyPIN(string(othersHashedPin), testPin) { + t.Fatal("stored hashed PIN does not match the original PIN") + } + }, + }, } - _, err = h.SaveOthersTemporaryPin(ctx, "save_others_temporary_pin", []byte(testPin)) + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // Set up the context with the session ID + ctx := context.WithValue(context.Background(), "SessionId", tt.sessionId) - assert.NoError(t, err) + // Run the setup function if provided + if tt.setup != nil { + err := tt.setup() + if err != nil { + t.Fatal(err) + } + } - othersHashedPin, err := userStore.ReadEntry(ctx, blockedNumber, storedb.DATA_TEMPORARY_VALUE) - if err != nil { - t.Fatal(err) - } + // Call the function under test + _, err := h.SaveOthersTemporaryPin(ctx, "save_others_temporary_pin", []byte(tt.testPin)) - if !pin.VerifyPIN(string(othersHashedPin), string(testPin)) { - t.Fatal(err) + // Assert the error + if tt.expectedError { + assert.Error(t, err) + } else { + assert.NoError(t, err) + } + + // Verify the result if a verification function is provided + if tt.verifyResult != nil { + tt.verifyResult(t) + } + }) } } From 6fdf3735d0dc36d0d7b3ed94fe440a557a8188da Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Mon, 27 Jan 2025 10:52:43 +0300 Subject: [PATCH 15/28] added TestCheckBlockedNumPinMisMatch --- handlers/application/menuhandler_test.go | 67 ++++++++++++++++++++++++ 1 file changed, 67 insertions(+) diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index a8faa95..09ee40f 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -2997,3 +2997,70 @@ func TestSaveOthersTemporaryPin(t *testing.T) { }) } } + +func TestCheckBlockedNumPinMisMatch(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) + } + + fm, err := NewFlagManager(flagsPath) + if err != nil { + t.Fatal(err) + } + flag_pin_mismatch, _ := fm.GetFlag("flag_pin_mismatch") + + h := &MenuHandlers{ + userdataStore: userStore, + flagManager: fm, + } + + // 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) + } + + tests := []struct { + name string + input []byte + expectedResult resource.Result + }{ + { + name: "Successful PIN match", + input: []byte(testPin), + expectedResult: resource.Result{ + FlagReset: []uint32{flag_pin_mismatch}, + }, + }, + { + name: "PIN mismatch", + input: []byte("1345"), + expectedResult: resource.Result{ + FlagSet: []uint32{flag_pin_mismatch}, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + res, err := h.CheckBlockedNumPinMisMatch(ctx, "sym", tt.input) + + assert.NoError(t, err) + assert.Equal(t, tt.expectedResult, res) + }) + } +} From dd55906e70eb161d8d88328001d0cc8ebae4b671 Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Mon, 27 Jan 2025 11:35:05 +0300 Subject: [PATCH 16/28] added TestGetCurrentProfileInfo --- handlers/application/menuhandler_test.go | 124 ++++++++++++++++++++++- 1 file changed, 123 insertions(+), 1 deletion(-) diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index 09ee40f..ac5ecfd 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -3006,7 +3006,6 @@ func TestCheckBlockedNumPinMisMatch(t *testing.T) { 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) @@ -3064,3 +3063,126 @@ func TestCheckBlockedNumPinMisMatch(t *testing.T) { }) } } + +func TestGetCurrentProfileInfo(t *testing.T) { + sessionId := "session123" + ctx, store := InitializeTestStore(t) + + fm, err := NewFlagManager(flagsPath) + if err != nil { + t.Fatal(err) + } + flag_firstname_set, _ := fm.GetFlag("flag_firstname_set") + flag_familyname_set, _ := fm.GetFlag("flag_familyname_set") + flag_yob_set, _ := fm.GetFlag("flag_yob_set") + flag_gender_set, _ := fm.GetFlag("flag_gender_set") + flag_location_set, _ := fm.GetFlag("flag_location_set") + flag_offerings_set, _ := fm.GetFlag("flag_offerings_set") + flag_back_set, _ := fm.GetFlag("flag_back_set") + + h := &MenuHandlers{ + userdataStore: store, + flagManager: fm, + st: state.NewState(16), + } + + tests := []struct { + name string + execPath string + dbKey storedb.DataTyp + value string + expected resource.Result + }{ + { + name: "Test fetching first name", + execPath: "edit_first_name", + dbKey: storedb.DATA_FIRST_NAME, + value: "John", + expected: resource.Result{ + FlagReset: []uint32{flag_back_set}, + FlagSet: []uint32{flag_firstname_set}, + Content: "John", + }, + }, + { + name: "Test fetching family name", + execPath: "edit_family_name", + dbKey: storedb.DATA_FAMILY_NAME, + value: "Doe", + expected: resource.Result{ + FlagReset: []uint32{flag_back_set}, + FlagSet: []uint32{flag_familyname_set}, + Content: "Doe", + }, + }, + { + name: "Test fetching year of birth", + execPath: "edit_yob", + dbKey: storedb.DATA_YOB, + value: "1980", + expected: resource.Result{ + FlagReset: []uint32{flag_back_set}, + FlagSet: []uint32{flag_yob_set}, + Content: "1980", + }, + }, + { + name: "Test fetching gender", + execPath: "edit_gender", + dbKey: storedb.DATA_GENDER, + value: "Male", + expected: resource.Result{ + FlagReset: []uint32{flag_back_set}, + FlagSet: []uint32{flag_gender_set}, + Content: "Male", + }, + }, + { + name: "Test fetching location", + execPath: "edit_location", + dbKey: storedb.DATA_LOCATION, + value: "Nairobi", + expected: resource.Result{ + FlagReset: []uint32{flag_back_set}, + FlagSet: []uint32{flag_location_set}, + Content: "Nairobi", + }, + }, + { + name: "Test fetching offerings", + execPath: "edit_offerings", + dbKey: storedb.DATA_OFFERINGS, + value: "Fruits", + expected: resource.Result{ + FlagReset: []uint32{flag_back_set}, + FlagSet: []uint32{flag_offerings_set}, + Content: "Fruits", + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + ctx = context.WithValue(ctx, "SessionId", sessionId) + ctx = context.WithValue(ctx, "Language", lang.Language{ + Code: "eng", + }) + // Set ExecPath to include tt.execPath + h.st.ExecPath = []string{tt.execPath} + + if tt.value != "" { + err := store.WriteEntry(ctx, sessionId, tt.dbKey, []byte(tt.value)) + if err != nil { + t.Fatal(err) + } + } + + res, err := h.GetCurrentProfileInfo(ctx, tt.execPath, []byte("")) + if err != nil { + t.Fatal(err) + } + + assert.Equal(t, tt.expected, res, "Result should match the expected output") + }) + } +} From a6cd4b5fcae9f1790d1f3c9cc2805a41c834e0cc Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Mon, 27 Jan 2025 12:36:04 +0300 Subject: [PATCH 17/28] added TestResetOthersPin --- handlers/application/menuhandler_test.go | 33 ++++++++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index b76f538..7321738 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -3186,3 +3186,36 @@ 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) +} From 73b501c8aa806019d1a7a31446511770332ce1b5 Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Mon, 27 Jan 2025 12:42:48 +0300 Subject: [PATCH 18/28] removed left over commented code --- handlers/application/menuhandler.go | 4 +--- handlers/application/menuhandler_test.go | 1 - handlers/local.go | 1 - 3 files changed, 1 insertion(+), 5 deletions(-) diff --git a/handlers/application/menuhandler.go b/handlers/application/menuhandler.go index 53ada39..40b91d9 100644 --- a/handlers/application/menuhandler.go +++ b/handlers/application/menuhandler.go @@ -102,14 +102,12 @@ func NewMenuHandlers(appFlags *FlagManager, userdataStore db.Db, accountService return h, nil } -// WithPersister sets persister instance to the handlers. -// func (h *MenuHandlers) WithPersister(pe *persist.Persister) *MenuHandlers { +// SetPersister sets persister instance to the handlers. func (h *MenuHandlers) SetPersister(pe *persist.Persister) { if h.pe != nil { panic("persister already set") } h.pe = pe - //return h } // Init initializes the handler for a new session. diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index 7321738..f9f654d 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -266,7 +266,6 @@ func TestWithPersister(t *testing.T) { h.SetPersister(p) assert.Equal(t, p, h.pe, "The persister should be set correctly.") - //assert.Equal(t, h, result, "The returned handler should be the same instance.") } func TestWithPersister_PanicWhenAlreadySet(t *testing.T) { diff --git a/handlers/local.go b/handlers/local.go index 77e3980..fcdfa76 100644 --- a/handlers/local.go +++ b/handlers/local.go @@ -60,7 +60,6 @@ func (ls *LocalHandlerService) GetHandler(accountService remote.AccountService) if err != nil { return nil, err } - //appHandlers = appHandlers.WithPersister(ls.Pe) appHandlers.SetPersister(ls.Pe) ls.DbRs.AddLocalFunc("check_blocked_status", appHandlers.CheckBlockedStatus) ls.DbRs.AddLocalFunc("set_language", appHandlers.SetLanguage) From 39f8c86e8ba27eb018f34b07035333817547ee48 Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Mon, 27 Jan 2025 12:50:46 +0300 Subject: [PATCH 19/28] added TestResetValidPin --- handlers/application/menuhandler_test.go | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index f9f654d..ae8da15 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -3218,3 +3218,27 @@ func TestResetOthersPin(t *testing.T) { assert.NoError(t, err) } + +func TestResetValidPin(t *testing.T) { + ctx := context.Background() + + fm, err := NewFlagManager(flagsPath) + if err != nil { + t.Fatal(err) + } + flag_valid_pin, _ := fm.GetFlag("flag_valid_pin") + + expectedResult := resource.Result{ + FlagReset: []uint32{flag_valid_pin}, + } + + h := &MenuHandlers{ + flagManager: fm, + } + + res, err := h.ResetValidPin(ctx, "reset_valid_pin", []byte("")) + + assert.NoError(t, err) + + assert.Equal(t, expectedResult, res) +} From 6a945f8f203fca5b148654d8e1fa99e3f94f2acd Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Mon, 27 Jan 2025 12:53:02 +0300 Subject: [PATCH 20/28] added TestResetUnregisteredNumber --- handlers/application/menuhandler_test.go | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index ae8da15..25a51a6 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -3242,3 +3242,27 @@ func TestResetValidPin(t *testing.T) { assert.Equal(t, expectedResult, res) } + +func TestResetUnregisteredNumber(t *testing.T) { + ctx := context.Background() + + fm, err := NewFlagManager(flagsPath) + if err != nil { + t.Fatal(err) + } + flag_unregistered_number, _ := fm.GetFlag("flag_unregistered_number") + + expectedResult := resource.Result{ + FlagReset: []uint32{flag_unregistered_number}, + } + + h := &MenuHandlers{ + flagManager: fm, + } + + res, err := h.ResetUnregisteredNumber(ctx, "reset_unregistered_number", []byte("")) + + assert.NoError(t, err) + + assert.Equal(t, expectedResult, res) +} From 5a586eb67a676aa57e3c5019f147ff8e098b9282 Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Mon, 27 Jan 2025 13:31:00 +0300 Subject: [PATCH 21/28] added TestConstructAccountAlias --- handlers/application/menuhandler_test.go | 91 ++++++++++++++++++++++++ 1 file changed, 91 insertions(+) diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index 25a51a6..292ef8e 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -3266,3 +3266,94 @@ func TestResetUnregisteredNumber(t *testing.T) { assert.Equal(t, expectedResult, res) } + +func TestConstructAccountAlias(t *testing.T) { + ctx, store := InitializeTestStore(t) + sessionId := "session123" + mockAccountService := new(mocks.MockAccountService) + + ctx = context.WithValue(ctx, "SessionId", sessionId) + + h := &MenuHandlers{ + userdataStore: store, + accountService: mockAccountService, + } + + tests := []struct { + name string + firstName string + familyName string + publicKey string + expectedAlias string + aliasResponse *models.RequestAliasResult + aliasError error + expectedError error + }{ + { + name: "Valid alias construction", + firstName: "John", + familyName: "Doe", + publicKey: "pubkey123", + expectedAlias: "JohnDoeAlias", + aliasResponse: &models.RequestAliasResult{Alias: "JohnDoeAlias"}, + aliasError: nil, + expectedError: nil, + }, + { + name: "Account service fails to return alias", + firstName: "Jane", + familyName: "Smith", + publicKey: "pubkey456", + expectedAlias: "", + aliasResponse: nil, + aliasError: fmt.Errorf("service unavailable"), + expectedError: fmt.Errorf("Failed to retrieve alias: service unavailable"), + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if tt.firstName != "" { + err := store.WriteEntry(ctx, sessionId, storedb.DATA_FIRST_NAME, []byte(tt.firstName)) + require.NoError(t, err) + } + + if tt.familyName != "" { + err := store.WriteEntry(ctx, sessionId, storedb.DATA_FAMILY_NAME, []byte(tt.familyName)) + require.NoError(t, err) + } + + if tt.publicKey != "" { + err := store.WriteEntry(ctx, sessionId, storedb.DATA_PUBLIC_KEY, []byte(tt.publicKey)) + require.NoError(t, err) + } + + aliasInput := fmt.Sprintf("%s%s", tt.firstName, tt.familyName) + + // Mock service behavior + mockAccountService.On( + "RequestAlias", + tt.publicKey, + aliasInput, + ).Return(tt.aliasResponse, tt.aliasError) + + // Call the function under test + err := h.constructAccountAlias(ctx) + + // Assertions + if tt.expectedError != nil { + assert.EqualError(t, err, tt.expectedError.Error()) + } else { + assert.NoError(t, err) + if tt.expectedAlias != "" { + storedAlias, err := store.ReadEntry(ctx, sessionId, storedb.DATA_ACCOUNT_ALIAS) + require.NoError(t, err) + assert.Equal(t, tt.expectedAlias, string(storedAlias)) + } + } + + // Ensure mock expectations were met + mockAccountService.AssertExpectations(t) + }) + } +} From 09c5f3a14c211600c44c265738105b66bb976c83 Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Tue, 4 Feb 2025 10:30:39 +0300 Subject: [PATCH 22/28] added TestInsertProfileItems --- handlers/application/menuhandler_test.go | 44 ++++++++++++++++++++++++ 1 file changed, 44 insertions(+) diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index 292ef8e..43efc3e 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -19,6 +19,7 @@ import ( "git.grassecon.net/grassrootseconomics/sarafu-api/models" "git.grassecon.net/grassrootseconomics/sarafu-api/testutil/mocks" "git.grassecon.net/grassrootseconomics/sarafu-api/testutil/testservice" + "git.grassecon.net/grassrootseconomics/sarafu-vise/profile" "git.grassecon.net/grassrootseconomics/sarafu-vise/store" storedb "git.grassecon.net/grassrootseconomics/sarafu-vise/store/db" @@ -3357,3 +3358,46 @@ func TestConstructAccountAlias(t *testing.T) { }) } } + +func TestInsertProfileItems(t *testing.T) { + ctx, store := InitializeTestStore(t) + sessionId := "session123" + mockState := state.NewState(128) + + fm, err := NewFlagManager(flagsPath) + if err != nil { + t.Fatal(err) + } + + profileDataKeys := []storedb.DataTyp{ + storedb.DATA_FIRST_NAME, + storedb.DATA_FAMILY_NAME, + storedb.DATA_GENDER, + storedb.DATA_YOB, + storedb.DATA_LOCATION, + storedb.DATA_OFFERINGS, + } + + profileItems := []string{"John", "Doe", "Male", "1990", "Nairobi", "Software"} + + h := &MenuHandlers{ + userdataStore: store, + flagManager: fm, + st: mockState, + profile: &profile.Profile{ + ProfileItems: profileItems, + Max: 6, + }, + } + + res := &resource.Result{} + err = h.insertProfileItems(ctx, sessionId, res) + require.NoError(t, err) + + // Loop through profileDataKeys to validate stored values + for i, key := range profileDataKeys { + storedValue, err := store.ReadEntry(ctx, sessionId, key) + require.NoError(t, err) + assert.Equal(t, profileItems[i], string(storedValue)) + } +} From ff3c597158b3c879e6c8dbc39537cf9ba9d64874 Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Tue, 4 Feb 2025 11:03:23 +0300 Subject: [PATCH 23/28] added TestUpdateAllProfileItems --- handlers/application/menuhandler_test.go | 85 ++++++++++++++++++++++++ 1 file changed, 85 insertions(+) diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index 43efc3e..bc41c9f 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -3401,3 +3401,88 @@ func TestInsertProfileItems(t *testing.T) { assert.Equal(t, profileItems[i], string(storedValue)) } } + +func TestUpdateAllProfileItems(t *testing.T) { + ctx, store := InitializeTestStore(t) + sessionId := "session123" + publicKey := "0X13242618721" + + ctx = context.WithValue(ctx, "SessionId", sessionId) + + mockState := state.NewState(128) + mockAccountService := new(mocks.MockAccountService) + + fm, err := NewFlagManager(flagsPath) + if err != nil { + t.Fatal(err) + } + + flag_firstname_set, _ := fm.GetFlag("flag_firstname_set") + flag_familyname_set, _ := fm.GetFlag("flag_familyname_set") + flag_yob_set, _ := fm.GetFlag("flag_yob_set") + flag_gender_set, _ := fm.GetFlag("flag_gender_set") + flag_location_set, _ := fm.GetFlag("flag_location_set") + flag_offerings_set, _ := fm.GetFlag("flag_offerings_set") + + profileDataKeys := []storedb.DataTyp{ + storedb.DATA_FIRST_NAME, + storedb.DATA_FAMILY_NAME, + storedb.DATA_GENDER, + storedb.DATA_YOB, + storedb.DATA_LOCATION, + storedb.DATA_OFFERINGS, + } + + profileItems := []string{"John", "Doe", "Male", "1990", "Nairobi", "Software"} + + expectedResult := resource.Result{ + FlagSet: []uint32{ + flag_firstname_set, + flag_familyname_set, + flag_yob_set, + flag_gender_set, + flag_location_set, + flag_offerings_set, + }, + } + + h := &MenuHandlers{ + userdataStore: store, + flagManager: fm, + st: mockState, + accountService: mockAccountService, + profile: &profile.Profile{ + ProfileItems: profileItems, + Max: 6, + }, + } + + err = store.WriteEntry(ctx, sessionId, storedb.DATA_PUBLIC_KEY, []byte(publicKey)) + require.NoError(t, err) + + aliasInput := fmt.Sprintf("%s%s", profileItems[0], profileItems[1]) + + // Mock the account alias response + mockAccountService.On( + "RequestAlias", + publicKey, + aliasInput, + ).Return(&models.RequestAliasResult{Alias: "JohnDoe"}, nil) + + // Call the function under test + res, err := h.UpdateAllProfileItems(ctx, "symbol", nil) + assert.NoError(t, err) + + // Loop through profileDataKeys to validate stored values + for i, key := range profileDataKeys { + storedValue, err := store.ReadEntry(ctx, sessionId, key) + require.NoError(t, err) + assert.Equal(t, profileItems[i], string(storedValue)) + } + + // Validate alias storage + storedAlias, err := store.ReadEntry(ctx, sessionId, storedb.DATA_ACCOUNT_ALIAS) + assert.NoError(t, err) + assert.Equal(t, "JohnDoe", string(storedAlias)) + assert.Equal(t, expectedResult, res) +} From c78081fb841628d0252275d4306d160bc99fb000 Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Tue, 4 Feb 2025 11:42:14 +0300 Subject: [PATCH 24/28] added TestInsertOrShift --- profile/profile_test.go | 42 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) create mode 100644 profile/profile_test.go diff --git a/profile/profile_test.go b/profile/profile_test.go new file mode 100644 index 0000000..a210646 --- /dev/null +++ b/profile/profile_test.go @@ -0,0 +1,42 @@ +package profile + +import ( + "testing" + + "github.com/alecthomas/assert/v2" + "github.com/stretchr/testify/require" +) + +func TestInsertOrShift(t *testing.T) { + tests := []struct { + name string + profile Profile + index int + value string + expected []string + }{ + { + name: "Insert within range", + profile: Profile{ProfileItems: []string{"A", "B", "C"}, Max: 5}, + index: 1, + value: "X", + expected: []string{"A", "X"}, + }, + { + name: "Insert beyond range", + profile: Profile{ProfileItems: []string{"A"}, Max: 5}, + index: 3, + value: "Y", + expected: []string{"A", "0", "0", "Y"}, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + p := tt.profile + p.InsertOrShift(tt.index, tt.value) + require.NotNil(t, p.ProfileItems) + assert.Equal(t, tt.expected, p.ProfileItems) + }) + } +} From 14df16098cee333fb646c463d430f9744b1f0bd4 Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Thu, 6 Feb 2025 15:10:15 +0300 Subject: [PATCH 25/28] Updated tests to include the mockState --- handlers/application/menuhandler_test.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index e3019bd..3400dba 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -2823,6 +2823,7 @@ func TestValidateBlockedNumber(t *testing.T) { 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) @@ -2835,6 +2836,7 @@ func TestValidateBlockedNumber(t *testing.T) { h := &MenuHandlers{ userdataStore: userStore, + st: mockState, flagManager: fm, } @@ -2992,6 +2994,7 @@ func TestCheckBlockedNumPinMisMatch(t *testing.T) { sessionId := "session123" blockedNumber := "+254712345678" testPin := "1234" + mockState := state.NewState(128) ctx, userStore := InitializeTestStore(t) ctx = context.WithValue(ctx, "SessionId", sessionId) @@ -3010,6 +3013,7 @@ func TestCheckBlockedNumPinMisMatch(t *testing.T) { h := &MenuHandlers{ userdataStore: userStore, + st: mockState, flagManager: fm, } From c324e29aea37c39e6313bc7c1a17b3fb4747cbb0 Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Tue, 11 Feb 2025 13:00:23 +0300 Subject: [PATCH 26/28] added test case to the TestCheckVouchers --- handlers/application/menuhandler_test.go | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index 3400dba..b52e7f1 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -2082,7 +2082,18 @@ func TestCheckVouchers(t *testing.T) { {ContractAddress: "0x41c188d63Qa", TokenSymbol: "MILO", TokenDecimals: "4", Balance: "200"}, } + // store the default voucher data + err = store.WriteEntry(ctx, sessionId, storedb.DATA_ACTIVE_SYM, []byte("SRF")) + if err != nil { + t.Fatal(err) + } + err = store.WriteEntry(ctx, sessionId, storedb.DATA_ACTIVE_ADDRESS, []byte("0x41c188D45rfg6ds")) + if err != nil { + t.Fatal(err) + } + expectedSym := []byte("1:SRF\n2:MILO") + expectedUpdatedAddress := []byte("0xd4c288865Ce") mockAccountService.On("FetchVouchers", string(publicKey)).Return(mockVouchersResponse, nil) @@ -2095,8 +2106,16 @@ func TestCheckVouchers(t *testing.T) { t.Fatal(err) } + // Read active contract address from the store + updatedAddress, err := store.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_ADDRESS) + if err != nil { + t.Fatal(err) + } + // assert that the data is stored correctly assert.Equal(t, expectedSym, voucherData) + // assert that the address is updated + assert.Equal(t, expectedUpdatedAddress, updatedAddress) mockAccountService.AssertExpectations(t) } From 2f1dbb914797641c6a8ae5a7498d8a6a9942b502 Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Tue, 11 Feb 2025 13:10:56 +0300 Subject: [PATCH 27/28] added TestClearTemporaryValue --- handlers/application/menuhandler_test.go | 29 ++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index b52e7f1..f008085 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -3499,3 +3499,32 @@ func TestUpdateAllProfileItems(t *testing.T) { assert.Equal(t, "JohnDoe", string(storedAlias)) assert.Equal(t, expectedResult, res) } + +func TestClearTemporaryValue(t *testing.T) { + ctx, store := InitializeTestStore(t) + sessionId := "session123" + + ctx = context.WithValue(ctx, "SessionId", sessionId) + + h := &MenuHandlers{ + userdataStore: store, + } + + // Write initial data to the store + err := store.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte("SomePreviousDATA34$")) + if err != nil { + t.Fatal(err) + } + + _, err = h.ClearTemporaryValue(ctx, "clear_temporary_value", []byte("")) + + assert.NoError(t, err) + // Read current temp value from the store + currentTempValue, err := store.ReadEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE) + if err != nil { + t.Fatal(err) + } + + // assert that the temp value is empty + assert.Equal(t, currentTempValue, []byte("")) +} From 07fd1110eddade8abc45216f173479ba2197b8f9 Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Tue, 11 Feb 2025 13:22:32 +0300 Subject: [PATCH 28/28] added documentation lines --- handlers/application/menuhandler.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/handlers/application/menuhandler.go b/handlers/application/menuhandler.go index 38dcad9..6012818 100644 --- a/handlers/application/menuhandler.go +++ b/handlers/application/menuhandler.go @@ -2305,6 +2305,7 @@ func (h *MenuHandlers) ViewTransactionStatement(ctx context.Context, sym string, return res, nil } +// persistInitialLanguageCode receives an initial language code and persists it to the store func (h *MenuHandlers) persistInitialLanguageCode(ctx context.Context, sessionId string, code string) error { store := h.userdataStore _, err := store.ReadEntry(ctx, sessionId, storedb.DATA_INITIAL_LANGUAGE_CODE) @@ -2337,6 +2338,8 @@ func (h *MenuHandlers) persistLanguageCode(ctx context.Context, code string) err return h.persistInitialLanguageCode(ctx, sessionId, code) } +// constructAccountAlias retrieves and alias based on the first and family name +// and writes the result in DATA_ACCOUNT_ALIAS func (h *MenuHandlers) constructAccountAlias(ctx context.Context) error { var alias string store := h.userdataStore @@ -2381,6 +2384,8 @@ func (h *MenuHandlers) constructAccountAlias(ctx context.Context) error { return nil } +// ClearTemporaryValue empties the DATA_TEMPORARY_VALUE at the main menu to prevent +// previously stored data from being accessed func (h *MenuHandlers) ClearTemporaryValue(ctx context.Context, sym string, input []byte) (resource.Result, error) { var res resource.Result sessionId, ok := ctx.Value("SessionId").(string)