From 92af428af46fb34866da6fb8fe0c5210da970122 Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Thu, 3 Jul 2025 17:44:55 +0300 Subject: [PATCH] move send node related tests --- handlers/application/menuhandler_test.go | 535 ---------------------- handlers/application/send_test.go | 550 +++++++++++++++++++++++ 2 files changed, 550 insertions(+), 535 deletions(-) create mode 100644 handlers/application/send_test.go diff --git a/handlers/application/menuhandler_test.go b/handlers/application/menuhandler_test.go index b87cfc5..fbd504a 100644 --- a/handlers/application/menuhandler_test.go +++ b/handlers/application/menuhandler_test.go @@ -277,77 +277,6 @@ func TestCheckIdentifier(t *testing.T) { } } -func TestGetSender(t *testing.T) { - sessionId := "session123" - ctx, _ := InitializeTestStore(t) - ctx = context.WithValue(ctx, "SessionId", sessionId) - - // Create the MenuHandlers instance - h := &MenuHandlers{} - - // Call the method - res, _ := h.GetSender(ctx, "get_sender", []byte("")) - - //Assert that the sessionId is what was set as the result content. - assert.Equal(t, sessionId, res.Content) -} - -func TestGetAmount(t *testing.T) { - sessionId := "session123" - ctx, store := InitializeTestStore(t) - ctx = context.WithValue(ctx, "SessionId", sessionId) - - // Define test data - amount := "0.03" - activeSym := "SRF" - - err := store.WriteEntry(ctx, sessionId, storedb.DATA_AMOUNT, []byte(amount)) - if err != nil { - t.Fatal(err) - } - - err = store.WriteEntry(ctx, sessionId, storedb.DATA_ACTIVE_SYM, []byte(activeSym)) - if err != nil { - t.Fatal(err) - } - - // Create the MenuHandlers instance with the mock store - h := &MenuHandlers{ - userdataStore: store, - } - - // Call the method - res, _ := h.GetAmount(ctx, "get_amount", []byte("")) - - formattedAmount := fmt.Sprintf("%s %s", amount, activeSym) - - //Assert that the retrieved amount is what was set as the content - assert.Equal(t, formattedAmount, res.Content) -} - -func TestGetRecipient(t *testing.T) { - sessionId := "session123" - ctx, store := InitializeTestStore(t) - ctx = context.WithValue(ctx, "SessionId", sessionId) - - recepient := "0712345678" - - err := store.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(recepient)) - if err != nil { - t.Fatal(err) - } - - // Create the MenuHandlers instance with the mock store - h := &MenuHandlers{ - userdataStore: store, - } - - // Call the method - res, _ := h.GetRecipient(ctx, "get_recipient", []byte("")) - - //Assert that the retrieved recepient is what was set as the content - assert.Equal(t, recepient, res.Content) -} func TestGetFlag(t *testing.T) { fm, err := NewFlagManager(flagsPath) @@ -520,196 +449,6 @@ func TestVerifyCreatePin(t *testing.T) { } } -func TestTransactionReset(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_invalid_recipient, _ := fm.GetFlag("flag_invalid_recipient") - flag_invalid_recipient_with_invite, _ := fm.GetFlag("flag_invalid_recipient_with_invite") - - mockAccountService := new(mocks.MockAccountService) - - h := &MenuHandlers{ - userdataStore: store, - accountService: mockAccountService, - flagManager: fm, - } - tests := []struct { - name string - input []byte - status string - expectedResult resource.Result - }{ - { - name: "Test transaction reset for amount and recipient", - expectedResult: resource.Result{ - FlagReset: []uint32{flag_invalid_recipient, flag_invalid_recipient_with_invite}, - }, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - // Call the method under test - res, _ := h.TransactionReset(ctx, "transaction_reset", 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 TestResetTransactionAmount(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_invalid_amount, _ := fm.GetFlag("flag_invalid_amount") - - mockAccountService := new(mocks.MockAccountService) - - h := &MenuHandlers{ - userdataStore: store, - accountService: mockAccountService, - flagManager: fm, - } - - tests := []struct { - name string - expectedResult resource.Result - }{ - { - name: "Test amount reset", - expectedResult: resource.Result{ - FlagReset: []uint32{flag_invalid_amount}, - }, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - // Call the method under test - res, _ := h.ResetTransactionAmount(ctx, "transaction_reset_amount", []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 TestInitiateTransaction(t *testing.T) { - sessionId := "254712345678" - ctx, store := InitializeTestStore(t) - ctx = context.WithValue(ctx, "SessionId", sessionId) - - fm, err := NewFlagManager(flagsPath) - if err != nil { - t.Logf(err.Error()) - } - account_authorized_flag, _ := fm.GetFlag("flag_account_authorized") - - mockAccountService := new(mocks.MockAccountService) - - h := &MenuHandlers{ - userdataStore: store, - accountService: mockAccountService, - flagManager: fm, - } - - tests := []struct { - name string - TemporaryValue []byte - ActiveSym []byte - StoredAmount []byte - TransferAmount string - PublicKey []byte - Recipient []byte - ActiveDecimal []byte - ActiveAddress []byte - TransferResponse *models.TokenTransferResponse - expectedResult resource.Result - }{ - { - name: "Test initiate transaction", - TemporaryValue: []byte("0711223344"), - ActiveSym: []byte("SRF"), - StoredAmount: []byte("1.00"), - TransferAmount: "1000000", - PublicKey: []byte("0X13242618721"), - Recipient: []byte("0x12415ass27192"), - ActiveDecimal: []byte("6"), - ActiveAddress: []byte("0xd4c288865Ce"), - TransferResponse: &models.TokenTransferResponse{ - TrackingId: "1234567890", - }, - expectedResult: resource.Result{ - FlagReset: []uint32{account_authorized_flag}, - Content: "Your request has been sent. 0711223344 will receive 1.00 SRF from 254712345678.", - }, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - err := store.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(tt.TemporaryValue)) - if err != nil { - t.Fatal(err) - } - err = store.WriteEntry(ctx, sessionId, storedb.DATA_ACTIVE_SYM, []byte(tt.ActiveSym)) - if err != nil { - t.Fatal(err) - } - err = store.WriteEntry(ctx, sessionId, storedb.DATA_AMOUNT, []byte(tt.StoredAmount)) - if err != nil { - t.Fatal(err) - } - err = store.WriteEntry(ctx, sessionId, storedb.DATA_PUBLIC_KEY, []byte(tt.PublicKey)) - if err != nil { - t.Fatal(err) - } - err = store.WriteEntry(ctx, sessionId, storedb.DATA_RECIPIENT, []byte(tt.Recipient)) - if err != nil { - t.Fatal(err) - } - err = store.WriteEntry(ctx, sessionId, storedb.DATA_ACTIVE_DECIMAL, []byte(tt.ActiveDecimal)) - if err != nil { - t.Fatal(err) - } - err = store.WriteEntry(ctx, sessionId, storedb.DATA_ACTIVE_ADDRESS, []byte(tt.ActiveAddress)) - if err != nil { - t.Fatal(err) - } - - mockAccountService.On("TokenTransfer").Return(tt.TransferResponse, nil) - - // Call the method under test - res, _ := h.InitiateTransaction(ctx, "transaction_reset_amount", []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 TestQuit(t *testing.T) { fm, err := NewFlagManager(flagsPath) if err != nil { @@ -757,214 +496,6 @@ func TestQuit(t *testing.T) { } } -func TestValidateAmount(t *testing.T) { - fm, err := NewFlagManager(flagsPath) - if err != nil { - t.Logf(err.Error()) - } - - sessionId := "session123" - - ctx, store := InitializeTestStore(t) - ctx = context.WithValue(ctx, "SessionId", sessionId) - - flag_invalid_amount, _ := fm.GetFlag("flag_invalid_amount") - - mockAccountService := new(mocks.MockAccountService) - - h := &MenuHandlers{ - userdataStore: store, - accountService: mockAccountService, - flagManager: fm, - } - tests := []struct { - name string - input []byte - activeBal []byte - balance string - expectedResult resource.Result - }{ - { - name: "Test with valid amount", - input: []byte("4.10"), - activeBal: []byte("5"), - expectedResult: resource.Result{ - Content: "4.10", - }, - }, - { - name: "Test with amount larger than active balance", - input: []byte("5.02"), - activeBal: []byte("5"), - expectedResult: resource.Result{ - FlagSet: []uint32{flag_invalid_amount}, - Content: "5.02", - }, - }, - { - name: "Test with invalid amount format", - input: []byte("0.02ms"), - activeBal: []byte("5"), - expectedResult: resource.Result{ - FlagSet: []uint32{flag_invalid_amount}, - Content: "0.02ms", - }, - }, - { - name: "Test with valid decimal amount", - input: []byte("0.149"), - activeBal: []byte("5"), - expectedResult: resource.Result{ - Content: "0.14", - }, - }, - { - name: "Test with valid large decimal amount", - input: []byte("1.8599999999"), - activeBal: []byte("5"), - expectedResult: resource.Result{ - Content: "1.85", - }, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - err := store.WriteEntry(ctx, sessionId, storedb.DATA_ACTIVE_BAL, []byte(tt.activeBal)) - if err != nil { - t.Fatal(err) - } - - // Call the method under test - res, _ := h.ValidateAmount(ctx, "test_validate_amount", tt.input) - - // Assert no errors occurred - assert.NoError(t, err) - - // Assert the result matches the expected result - assert.Equal(t, tt.expectedResult, res, "Expected result should match actual result") - }) - } -} - -func TestValidateRecipient(t *testing.T) { - fm, err := NewFlagManager(flagsPath) - if err != nil { - log.Fatal(err) - } - - sessionId := "session123" - publicKey := "0X13242618721" - ctx, store := InitializeTestStore(t) - ctx = context.WithValue(ctx, "SessionId", sessionId) - - flag_invalid_recipient, _ := fm.GetFlag("flag_invalid_recipient") - flag_invalid_recipient_with_invite, _ := fm.GetFlag("flag_invalid_recipient_with_invite") - - // Define test cases - tests := []struct { - name string - input []byte - expectError bool - expectedRecipient []byte - expectedResult resource.Result - }{ - { - name: "Test with invalid recepient", - input: []byte("7?1234"), - expectError: true, - expectedResult: resource.Result{ - FlagSet: []uint32{flag_invalid_recipient}, - Content: "7?1234", - }, - }, - { - name: "Test with valid unregistered recepient", - input: []byte("0712345678"), - expectError: true, - expectedResult: resource.Result{ - FlagSet: []uint32{flag_invalid_recipient_with_invite}, - Content: "0712345678", - }, - }, - { - name: "Test with valid registered recepient", - input: []byte("0711223344"), - expectError: false, - expectedRecipient: []byte(publicKey), - expectedResult: resource.Result{}, - }, - { - name: "Test with address", - input: []byte("0xd4c288865Ce0985a481Eef3be02443dF5E2e4Ea9"), - expectError: false, - expectedRecipient: []byte("0xd4c288865Ce0985a481Eef3be02443dF5E2e4Ea9"), - expectedResult: resource.Result{}, - }, - { - name: "Test with alias recepient", - input: []byte("alias123.sarafu.local"), - expectError: false, - expectedRecipient: []byte("0xd4c288865Ce0985a481Eef3be02443dF5E2e4Ea9"), - expectedResult: resource.Result{}, - }, - { - name: "Test for checksummed address", - input: []byte("0x5523058cdffe5f3c1eadadd5015e55c6e00fb439"), - expectError: false, - expectedRecipient: []byte("0x5523058cdFfe5F3c1EaDADD5015E55C6E00fb439"), - expectedResult: resource.Result{}, - }, - { - name: "Test with valid registered recepient that has white spaces", - input: []byte("0711 22 33 44"), - expectError: false, - expectedRecipient: []byte(publicKey), - expectedResult: resource.Result{}, - }, - } - - // store a public key for the valid recipient - err = store.WriteEntry(ctx, "+254711223344", storedb.DATA_PUBLIC_KEY, []byte(publicKey)) - if err != nil { - t.Fatal(err) - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - mockAccountService := new(mocks.MockAccountService) - // Create the MenuHandlers instance - h := &MenuHandlers{ - flagManager: fm, - userdataStore: store, - accountService: mockAccountService, - } - - aliasResponse := &models.AliasAddress{ - Address: "0xd4c288865Ce0985a481Eef3be02443dF5E2e4Ea9", - } - - mockAccountService.On("CheckAliasAddress", string(tt.input)).Return(aliasResponse, nil) - - // Call the method - res, err := h.ValidateRecipient(ctx, "validate_recepient", tt.input) - - if err != nil { - t.Error(err) - } - - if !tt.expectError { - storedRecipientAddress, err := store.ReadEntry(ctx, sessionId, storedb.DATA_RECIPIENT) - assert.NoError(t, err) - assert.Equal(t, tt.expectedRecipient, storedRecipientAddress) - } - - // 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 TestManageVouchers(t *testing.T) { sessionId := "session123" publicKey := "0X13242618721" @@ -1505,72 +1036,6 @@ 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) - }) - } -} - func TestQuitWithHelp(t *testing.T) { fm, err := NewFlagManager(flagsPath) if err != nil { diff --git a/handlers/application/send_test.go b/handlers/application/send_test.go new file mode 100644 index 0000000..cde3598 --- /dev/null +++ b/handlers/application/send_test.go @@ -0,0 +1,550 @@ +package application + +import ( + "context" + "fmt" + "log" + "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 TestValidateRecipient(t *testing.T) { + fm, err := NewFlagManager(flagsPath) + if err != nil { + log.Fatal(err) + } + + sessionId := "session123" + publicKey := "0X13242618721" + ctx, store := InitializeTestStore(t) + ctx = context.WithValue(ctx, "SessionId", sessionId) + + flag_invalid_recipient, _ := fm.GetFlag("flag_invalid_recipient") + flag_invalid_recipient_with_invite, _ := fm.GetFlag("flag_invalid_recipient_with_invite") + + // Define test cases + tests := []struct { + name string + input []byte + expectError bool + expectedRecipient []byte + expectedResult resource.Result + }{ + { + name: "Test with invalid recepient", + input: []byte("7?1234"), + expectError: true, + expectedResult: resource.Result{ + FlagSet: []uint32{flag_invalid_recipient}, + Content: "7?1234", + }, + }, + { + name: "Test with valid unregistered recepient", + input: []byte("0712345678"), + expectError: true, + expectedResult: resource.Result{ + FlagSet: []uint32{flag_invalid_recipient_with_invite}, + Content: "0712345678", + }, + }, + { + name: "Test with valid registered recepient", + input: []byte("0711223344"), + expectError: false, + expectedRecipient: []byte(publicKey), + expectedResult: resource.Result{}, + }, + { + name: "Test with address", + input: []byte("0xd4c288865Ce0985a481Eef3be02443dF5E2e4Ea9"), + expectError: false, + expectedRecipient: []byte("0xd4c288865Ce0985a481Eef3be02443dF5E2e4Ea9"), + expectedResult: resource.Result{}, + }, + { + name: "Test with alias recepient", + input: []byte("alias123.sarafu.local"), + expectError: false, + expectedRecipient: []byte("0xd4c288865Ce0985a481Eef3be02443dF5E2e4Ea9"), + expectedResult: resource.Result{}, + }, + { + name: "Test for checksummed address", + input: []byte("0x5523058cdffe5f3c1eadadd5015e55c6e00fb439"), + expectError: false, + expectedRecipient: []byte("0x5523058cdFfe5F3c1EaDADD5015E55C6E00fb439"), + expectedResult: resource.Result{}, + }, + { + name: "Test with valid registered recepient that has white spaces", + input: []byte("0711 22 33 44"), + expectError: false, + expectedRecipient: []byte(publicKey), + expectedResult: resource.Result{}, + }, + } + + // store a public key for the valid recipient + err = store.WriteEntry(ctx, "+254711223344", storedb.DATA_PUBLIC_KEY, []byte(publicKey)) + if err != nil { + t.Fatal(err) + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + mockAccountService := new(mocks.MockAccountService) + // Create the MenuHandlers instance + h := &MenuHandlers{ + flagManager: fm, + userdataStore: store, + accountService: mockAccountService, + } + + aliasResponse := &models.AliasAddress{ + Address: "0xd4c288865Ce0985a481Eef3be02443dF5E2e4Ea9", + } + + mockAccountService.On("CheckAliasAddress", string(tt.input)).Return(aliasResponse, nil) + + // Call the method + res, err := h.ValidateRecipient(ctx, "validate_recepient", tt.input) + + if err != nil { + t.Error(err) + } + + if !tt.expectError { + storedRecipientAddress, err := store.ReadEntry(ctx, sessionId, storedb.DATA_RECIPIENT) + assert.NoError(t, err) + assert.Equal(t, tt.expectedRecipient, storedRecipientAddress) + } + + // 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 TestTransactionReset(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_invalid_recipient, _ := fm.GetFlag("flag_invalid_recipient") + flag_invalid_recipient_with_invite, _ := fm.GetFlag("flag_invalid_recipient_with_invite") + + mockAccountService := new(mocks.MockAccountService) + + h := &MenuHandlers{ + userdataStore: store, + accountService: mockAccountService, + flagManager: fm, + } + tests := []struct { + name string + input []byte + status string + expectedResult resource.Result + }{ + { + name: "Test transaction reset for amount and recipient", + expectedResult: resource.Result{ + FlagReset: []uint32{flag_invalid_recipient, flag_invalid_recipient_with_invite}, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // Call the method under test + res, _ := h.TransactionReset(ctx, "transaction_reset", 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 TestResetTransactionAmount(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_invalid_amount, _ := fm.GetFlag("flag_invalid_amount") + + mockAccountService := new(mocks.MockAccountService) + + h := &MenuHandlers{ + userdataStore: store, + accountService: mockAccountService, + flagManager: fm, + } + + tests := []struct { + name string + expectedResult resource.Result + }{ + { + name: "Test amount reset", + expectedResult: resource.Result{ + FlagReset: []uint32{flag_invalid_amount}, + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // Call the method under test + res, _ := h.ResetTransactionAmount(ctx, "transaction_reset_amount", []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 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) + }) + } +} + +func TestValidateAmount(t *testing.T) { + fm, err := NewFlagManager(flagsPath) + if err != nil { + t.Logf(err.Error()) + } + + sessionId := "session123" + + ctx, store := InitializeTestStore(t) + ctx = context.WithValue(ctx, "SessionId", sessionId) + + flag_invalid_amount, _ := fm.GetFlag("flag_invalid_amount") + + mockAccountService := new(mocks.MockAccountService) + + h := &MenuHandlers{ + userdataStore: store, + accountService: mockAccountService, + flagManager: fm, + } + tests := []struct { + name string + input []byte + activeBal []byte + balance string + expectedResult resource.Result + }{ + { + name: "Test with valid amount", + input: []byte("4.10"), + activeBal: []byte("5"), + expectedResult: resource.Result{ + Content: "4.10", + }, + }, + { + name: "Test with amount larger than active balance", + input: []byte("5.02"), + activeBal: []byte("5"), + expectedResult: resource.Result{ + FlagSet: []uint32{flag_invalid_amount}, + Content: "5.02", + }, + }, + { + name: "Test with invalid amount format", + input: []byte("0.02ms"), + activeBal: []byte("5"), + expectedResult: resource.Result{ + FlagSet: []uint32{flag_invalid_amount}, + Content: "0.02ms", + }, + }, + { + name: "Test with valid decimal amount", + input: []byte("0.149"), + activeBal: []byte("5"), + expectedResult: resource.Result{ + Content: "0.14", + }, + }, + { + name: "Test with valid large decimal amount", + input: []byte("1.8599999999"), + activeBal: []byte("5"), + expectedResult: resource.Result{ + Content: "1.85", + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := store.WriteEntry(ctx, sessionId, storedb.DATA_ACTIVE_BAL, []byte(tt.activeBal)) + if err != nil { + t.Fatal(err) + } + + // Call the method under test + res, _ := h.ValidateAmount(ctx, "test_validate_amount", tt.input) + + // Assert no errors occurred + assert.NoError(t, err) + + // Assert the result matches the expected result + assert.Equal(t, tt.expectedResult, res, "Expected result should match actual result") + }) + } +} + +func TestGetRecipient(t *testing.T) { + sessionId := "session123" + ctx, store := InitializeTestStore(t) + ctx = context.WithValue(ctx, "SessionId", sessionId) + + recepient := "0712345678" + + err := store.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(recepient)) + if err != nil { + t.Fatal(err) + } + + // Create the MenuHandlers instance with the mock store + h := &MenuHandlers{ + userdataStore: store, + } + + // Call the method + res, _ := h.GetRecipient(ctx, "get_recipient", []byte("")) + + //Assert that the retrieved recepient is what was set as the content + assert.Equal(t, recepient, res.Content) +} + +func TestGetSender(t *testing.T) { + sessionId := "session123" + ctx, _ := InitializeTestStore(t) + ctx = context.WithValue(ctx, "SessionId", sessionId) + + // Create the MenuHandlers instance + h := &MenuHandlers{} + + // Call the method + res, _ := h.GetSender(ctx, "get_sender", []byte("")) + + //Assert that the sessionId is what was set as the result content. + assert.Equal(t, sessionId, res.Content) +} + +func TestGetAmount(t *testing.T) { + sessionId := "session123" + ctx, store := InitializeTestStore(t) + ctx = context.WithValue(ctx, "SessionId", sessionId) + + // Define test data + amount := "0.03" + activeSym := "SRF" + + err := store.WriteEntry(ctx, sessionId, storedb.DATA_AMOUNT, []byte(amount)) + if err != nil { + t.Fatal(err) + } + + err = store.WriteEntry(ctx, sessionId, storedb.DATA_ACTIVE_SYM, []byte(activeSym)) + if err != nil { + t.Fatal(err) + } + + // Create the MenuHandlers instance with the mock store + h := &MenuHandlers{ + userdataStore: store, + } + + // Call the method + res, _ := h.GetAmount(ctx, "get_amount", []byte("")) + + formattedAmount := fmt.Sprintf("%s %s", amount, activeSym) + + //Assert that the retrieved amount is what was set as the content + assert.Equal(t, formattedAmount, res.Content) +} + +func TestInitiateTransaction(t *testing.T) { + sessionId := "254712345678" + ctx, store := InitializeTestStore(t) + ctx = context.WithValue(ctx, "SessionId", sessionId) + + fm, err := NewFlagManager(flagsPath) + if err != nil { + t.Logf(err.Error()) + } + account_authorized_flag, _ := fm.GetFlag("flag_account_authorized") + + mockAccountService := new(mocks.MockAccountService) + + h := &MenuHandlers{ + userdataStore: store, + accountService: mockAccountService, + flagManager: fm, + } + + tests := []struct { + name string + TemporaryValue []byte + ActiveSym []byte + StoredAmount []byte + TransferAmount string + PublicKey []byte + Recipient []byte + ActiveDecimal []byte + ActiveAddress []byte + TransferResponse *models.TokenTransferResponse + expectedResult resource.Result + }{ + { + name: "Test initiate transaction", + TemporaryValue: []byte("0711223344"), + ActiveSym: []byte("SRF"), + StoredAmount: []byte("1.00"), + TransferAmount: "1000000", + PublicKey: []byte("0X13242618721"), + Recipient: []byte("0x12415ass27192"), + ActiveDecimal: []byte("6"), + ActiveAddress: []byte("0xd4c288865Ce"), + TransferResponse: &models.TokenTransferResponse{ + TrackingId: "1234567890", + }, + expectedResult: resource.Result{ + FlagReset: []uint32{account_authorized_flag}, + Content: "Your request has been sent. 0711223344 will receive 1.00 SRF from 254712345678.", + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := store.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(tt.TemporaryValue)) + if err != nil { + t.Fatal(err) + } + err = store.WriteEntry(ctx, sessionId, storedb.DATA_ACTIVE_SYM, []byte(tt.ActiveSym)) + if err != nil { + t.Fatal(err) + } + err = store.WriteEntry(ctx, sessionId, storedb.DATA_AMOUNT, []byte(tt.StoredAmount)) + if err != nil { + t.Fatal(err) + } + err = store.WriteEntry(ctx, sessionId, storedb.DATA_PUBLIC_KEY, []byte(tt.PublicKey)) + if err != nil { + t.Fatal(err) + } + err = store.WriteEntry(ctx, sessionId, storedb.DATA_RECIPIENT, []byte(tt.Recipient)) + if err != nil { + t.Fatal(err) + } + err = store.WriteEntry(ctx, sessionId, storedb.DATA_ACTIVE_DECIMAL, []byte(tt.ActiveDecimal)) + if err != nil { + t.Fatal(err) + } + err = store.WriteEntry(ctx, sessionId, storedb.DATA_ACTIVE_ADDRESS, []byte(tt.ActiveAddress)) + if err != nil { + t.Fatal(err) + } + + mockAccountService.On("TokenTransfer").Return(tt.TransferResponse, nil) + + // Call the method under test + res, _ := h.InitiateTransaction(ctx, "transaction_reset_amount", []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") + }) + } +}