internal/handlers/ussd/menuhandler.go

@@ -477,19 +477,21 @@ func (h *Handlers) Authorize(ctx context.Context, sym string, input []byte) (res
 	if err != nil {
 		return res, err
 	}
-	if len(input) == 4 {
-		if bytes.Equal(input, AccountPin) {
-			if h.st.MatchFlag(flag_account_authorized, false) {
-				res.FlagReset = append(res.FlagReset, flag_incorrect_pin)
-				res.FlagSet = append(res.FlagSet, flag_allow_update, flag_account_authorized)
+	if err == nil {
+		if len(input) == 4 {
+			if bytes.Equal(input, AccountPin) {
+				if h.st.MatchFlag(flag_account_authorized, false) {
+					res.FlagReset = append(res.FlagReset, flag_incorrect_pin)
+					res.FlagSet = append(res.FlagSet, flag_allow_update, flag_account_authorized)
+				} else {
+					res.FlagSet = append(res.FlagSet, flag_allow_update)
+					res.FlagReset = append(res.FlagReset, flag_account_authorized)
+				}
 			} else {
-				res.FlagSet = append(res.FlagSet, flag_allow_update)
+				res.FlagSet = append(res.FlagSet, flag_incorrect_pin)
 				res.FlagReset = append(res.FlagReset, flag_account_authorized)
+				return res, nil
 			}
-		} else {
-			res.FlagSet = append(res.FlagSet, flag_incorrect_pin)
-			res.FlagReset = append(res.FlagReset, flag_account_authorized)
-			return res, nil
 		}
 	} else {
 		return res, nil
@@ -536,6 +538,7 @@ func (h *Handlers) CheckAccountStatus(ctx context.Context, sym string, input []b
 	if err != nil {
 		return res, nil
 	}
+
 	if status == "SUCCESS" {
 		res.FlagSet = append(res.FlagSet, flag_account_success)
 		res.FlagReset = append(res.FlagReset, flag_account_pending)
@@ -750,7 +753,6 @@ func (h *Handlers) ValidateAmount(ctx context.Context, sym string, input []byte)
 	if err != nil {
 		return res, err
 	}
-
 	res.Content = balanceStr
 
 	// Parse the balance
@@ -758,7 +760,6 @@ func (h *Handlers) ValidateAmount(ctx context.Context, sym string, input []byte)
 	if len(balanceParts) != 2 {
 		return res, fmt.Errorf("unexpected balance format: %s", balanceStr)
 	}
-
 	balanceValue, err := strconv.ParseFloat(balanceParts[0], 64)
 	if err != nil {
 		return res, fmt.Errorf("failed to parse balance: %v", err)
@@ -768,7 +769,6 @@ func (h *Handlers) ValidateAmount(ctx context.Context, sym string, input []byte)
 	re := regexp.MustCompile(`^(\d+(\.\d+)?)\s*(?:CELO)?$`)
 	matches := re.FindStringSubmatch(strings.TrimSpace(amountStr))
 	if len(matches) < 2 {
-
 		res.FlagSet = append(res.FlagSet, flag_invalid_amount)
 		res.Content = amountStr
 		return res, nil
@@ -776,7 +776,6 @@ func (h *Handlers) ValidateAmount(ctx context.Context, sym string, input []byte)
 
 	inputAmount, err := strconv.ParseFloat(matches[1], 64)
 	if err != nil {
-
 		res.FlagSet = append(res.FlagSet, flag_invalid_amount)
 		res.Content = amountStr
 		return res, nil

internal/handlers/ussd/menuhandler_test.go

@@ -3,7 +3,6 @@ package ussd
 import (
 	"context"
 	"encoding/json"
-	"fmt"
 	"log"
 	"path"
 	"testing"
@@ -150,64 +149,6 @@ func TestSaveFamilyname(t *testing.T) {
 	mockStore.AssertExpectations(t)
 }
 
-func TestSavePin(t *testing.T) {
-	fm, err := NewFlagManager(flagsPath)
-	mockStore := new(mocks.MockUserDataStore)
-	if err != nil {
-		log.Fatal(err)
-	}
-	flag_incorrect_pin, _ := fm.parser.GetFlag("flag_incorrect_pin")
-
-	// Create the Handlers instance with the mock flag manager
-	h := &Handlers{
-		flagManager:   fm.parser,
-		userdataStore: mockStore,
-	}
-	sessionId := "session123"
-	ctx := context.WithValue(context.Background(), "SessionId", sessionId)
-
-	// 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_incorrect_pin},
-			},
-		},
-		{
-			name:  "Invalid Pin entry",
-			input: []byte("12343"),
-			expectedResult: resource.Result{
-				FlagSet: []uint32{flag_incorrect_pin},
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-
-			// Set up the expected behavior of the mock
-			mockStore.On("WriteEntry", ctx, sessionId, utils.DATA_ACCOUNT_PIN, []byte(tt.input)).Return(nil)
-
-			// Call the method
-			res, err := h.SavePin(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, "Flags should be equal to account created")
-
-		})
-	}
-}
-
 func TestSaveYoB(t *testing.T) {
 	// Create a new instance of MockMyDataStore
 	mockStore := new(mocks.MockUserDataStore)
@@ -802,7 +743,7 @@ func TestIncorrectPinReset(t *testing.T) {
 	}
 }
 
-func TestResetIncorrectYob(t *testing.T) {
+func TestIncorrectYob(t *testing.T) {
 	fm, err := NewFlagManager(flagsPath)
 
 	flag_incorrect_date_format, _ := fm.parser.GetFlag("flag_incorrect_date_format")
@@ -897,11 +838,6 @@ func TestAuthorize(t *testing.T) {
 				FlagSet:   []uint32{flag_incorrect_pin},
 			},
 		},
-		{
-			name:           "Test with pin that is not a 4 digit",
-			input:          []byte("1235aqds"),
-			expectedResult: resource.Result{},
-		},
 	}
 
 	for _, tt := range tests {
@@ -1048,6 +984,13 @@ func TestVerifyPin(t *testing.T) {
 				FlagSet: []uint32{flag_pin_mismatch},
 			},
 		},
+		// {
+		// 	name:  "Test with numeric but less 4 digits",
+		// 	input: []byte("123"),
+		// 	expectedResult: resource.Result{
+		// 		FlagSet: []uint32{flag_incorrect_date_format},
+		// 	},
+		// },
 	}
 
 	typ := utils.DATA_ACCOUNT_PIN
@@ -1073,646 +1016,3 @@ func TestVerifyPin(t *testing.T) {
 		})
 	}
 }
-
-func TestCheckAccountStatus(t *testing.T) {
-	fm, err := NewFlagManager(flagsPath)
-
-	if err != nil {
-		t.Logf(err.Error())
-	}
-	mockDataStore := new(mocks.MockUserDataStore)
-	mockCreateAccountService := new(mocks.MockAccountService)
-
-	sessionId := "session123"
-	flag_account_success, _ := fm.GetFlag("flag_account_success")
-	flag_account_pending, _ := fm.GetFlag("flag_account_pending")
-
-	ctx := context.WithValue(context.Background(), "SessionId", sessionId)
-
-	h := &Handlers{
-		userdataStore:  mockDataStore,
-		accountService: mockCreateAccountService,
-		flagManager:    fm.parser,
-	}
-	tests := []struct {
-		name           string
-		input          []byte
-		status         string
-		expectedResult resource.Result
-	}{
-		{
-			name:   "Test when account status is Success",
-			input:  []byte("TrackingId1234"),
-			status: "SUCCESS",
-			expectedResult: resource.Result{
-				FlagSet:   []uint32{flag_account_success},
-				FlagReset: []uint32{flag_account_pending},
-			},
-		},
-		// {
-		// 	name:   "Test when account status is not Success",
-		// 	input:  []byte("TrackingId1234"),
-		// 	status: "REVERTED",
-		// 	expectedResult: resource.Result{
-		// 		FlagReset: []uint32{flag_account_pending},
-		// 		FlagSet:   []uint32{flag_account_success},
-		// 	},
-		// },
-	}
-
-	typ := utils.DATA_TRACKING_ID
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-
-			// Define expected interactions with the mock
-			mockDataStore.On("ReadEntry", ctx, sessionId, typ).Return(tt.input, nil)
-
-			mockCreateAccountService.On("CheckAccountStatus", string(tt.input)).Return(tt.status, nil)
-			mockDataStore.On("WriteEntry", ctx, sessionId, utils.DATA_ACCOUNT_STATUS, []byte(tt.status)).Return(nil)
-
-			// Call the method under test
-			res, _ := h.CheckAccountStatus(ctx, "check_status", 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")
-
-			// Assert that expectations were met
-			mockDataStore.AssertExpectations(t)
-
-		})
-	}
-
-}
-
-func TestTransactionReset(t *testing.T) {
-	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")
-
-	mockDataStore := new(mocks.MockUserDataStore)
-	mockCreateAccountService := new(mocks.MockAccountService)
-
-	sessionId := "session123"
-
-	ctx := context.WithValue(context.Background(), "SessionId", sessionId)
-
-	h := &Handlers{
-		userdataStore:  mockDataStore,
-		accountService: mockCreateAccountService,
-		flagManager:    fm.parser,
-	}
-	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) {
-			mockDataStore.On("WriteEntry", ctx, sessionId, utils.DATA_AMOUNT, []byte("")).Return(nil)
-			mockDataStore.On("WriteEntry", ctx, sessionId, utils.DATA_RECIPIENT, []byte("")).Return(nil)
-
-			// 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")
-
-			// Assert that expectations were met
-			mockDataStore.AssertExpectations(t)
-
-		})
-	}
-}
-
-func TestResetInvalidAmount(t *testing.T) {
-	sessionId := "session123"
-
-	fm, err := NewFlagManager(flagsPath)
-
-	if err != nil {
-		t.Logf(err.Error())
-	}
-
-	flag_invalid_amount, _ := fm.parser.GetFlag("flag_invalid_amount")
-
-	ctx := context.WithValue(context.Background(), "SessionId", sessionId)
-
-	mockDataStore := new(mocks.MockUserDataStore)
-	mockCreateAccountService := new(mocks.MockAccountService)
-
-	h := &Handlers{
-		userdataStore:  mockDataStore,
-		accountService: mockCreateAccountService,
-		flagManager:    fm.parser,
-	}
-
-	tests := []struct {
-		name           string
-		input          []byte
-		status         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) {
-			mockDataStore.On("WriteEntry", ctx, sessionId, utils.DATA_AMOUNT, []byte("")).Return(nil)
-
-			// Call the method under test
-			res, _ := h.ResetTransactionAmount(ctx, "transaction_reset_amount", 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")
-
-			// Assert that expectations were met
-			mockDataStore.AssertExpectations(t)
-
-		})
-	}
-
-}
-
-func TestInitiateTransaction(t *testing.T) {
-	sessionId := "session123"
-
-	fm, err := NewFlagManager(flagsPath)
-
-	if err != nil {
-		t.Logf(err.Error())
-	}
-	account_authorized_flag, err := fm.parser.GetFlag("flag_account_authorized")
-
-	ctx := context.WithValue(context.Background(), "SessionId", sessionId)
-
-	mockDataStore := new(mocks.MockUserDataStore)
-	mockCreateAccountService := new(mocks.MockAccountService)
-
-	h := &Handlers{
-		userdataStore:  mockDataStore,
-		accountService: mockCreateAccountService,
-		flagManager:    fm.parser,
-	}
-
-	tests := []struct {
-		name           string
-		input          []byte
-		PublicKey      []byte
-		Recipient      []byte
-		Amount         []byte
-		status         string
-		expectedResult resource.Result
-	}{
-		{
-			name:      "Test amount reset",
-			PublicKey: []byte("0x1241527192"),
-			Amount:    []byte("0.002CELO"),
-			Recipient: []byte("0x12415ass27192"),
-			expectedResult: resource.Result{
-				FlagReset: []uint32{account_authorized_flag},
-				Content:   "Your request has been sent. 0x12415ass27192 will receive 0.002CELO from 0x1241527192.",
-			},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Define expected interactions with the mock
-			mockDataStore.On("ReadEntry", ctx, sessionId, utils.DATA_PUBLIC_KEY).Return(tt.PublicKey, nil)
-			mockDataStore.On("ReadEntry", ctx, sessionId, utils.DATA_AMOUNT).Return(tt.Amount, nil)
-			mockDataStore.On("ReadEntry", ctx, sessionId, utils.DATA_RECIPIENT).Return(tt.Recipient, nil)
-			//mockDataStore.On("WriteEntry", ctx, sessionId, utils.DATA_AMOUNT, []byte("")).Return(nil)
-
-			// Call the method under test
-			res, _ := h.InitiateTransaction(ctx, "transaction_reset_amount", 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")
-
-			// Assert that expectations were met
-			mockDataStore.AssertExpectations(t)
-
-		})
-	}
-
-}
-
-func TestQuit(t *testing.T) {
-	fm, err := NewFlagManager(flagsPath)
-
-	if err != nil {
-		t.Logf(err.Error())
-	}
-	flag_account_authorized, _ := fm.parser.GetFlag("flag_account_authorized")
-
-	mockDataStore := new(mocks.MockUserDataStore)
-	mockCreateAccountService := new(mocks.MockAccountService)
-
-	sessionId := "session123"
-
-	ctx := context.WithValue(context.Background(), "SessionId", sessionId)
-
-	h := &Handlers{
-		userdataStore:  mockDataStore,
-		accountService: mockCreateAccountService,
-		flagManager:    fm.parser,
-	}
-	tests := []struct {
-		name           string
-		input          []byte
-		status         string
-		expectedResult resource.Result
-	}{
-		{
-			name: "Test quit message",
-			expectedResult: resource.Result{
-				FlagReset: []uint32{flag_account_authorized},
-				Content:   "Thank you for using Sarafu. Goodbye!",
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-
-			// Call the method under test
-			res, _ := h.Quit(ctx, "test_quit", 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")
-
-			// Assert that expectations were met
-			mockDataStore.AssertExpectations(t)
-
-		})
-	}
-}
-func TestIsValidPIN(t *testing.T) {
-	tests := []struct {
-		name     string
-		pin      string
-		expected bool
-	}{
-		{
-			name:     "Valid PIN with 4 digits",
-			pin:      "1234",
-			expected: true,
-		},
-		{
-			name:     "Valid PIN with leading zeros",
-			pin:      "0001",
-			expected: true,
-		},
-		{
-			name:     "Invalid PIN with less than 4 digits",
-			pin:      "123",
-			expected: false,
-		},
-		{
-			name:     "Invalid PIN with more than 4 digits",
-			pin:      "12345",
-			expected: false,
-		},
-		{
-			name:     "Invalid PIN with letters",
-			pin:      "abcd",
-			expected: false,
-		},
-		{
-			name:     "Invalid PIN with special characters",
-			pin:      "12@#",
-			expected: false,
-		},
-		{
-			name:     "Empty PIN",
-			pin:      "",
-			expected: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			actual := isValidPIN(tt.pin)
-			if actual != tt.expected {
-				t.Errorf("isValidPIN(%q) = %v; expected %v", tt.pin, actual, tt.expected)
-			}
-		})
-	}
-}
-
-func TestQuitWithBalance(t *testing.T) {
-	fm, err := NewFlagManager(flagsPath)
-
-	if err != nil {
-		t.Logf(err.Error())
-	}
-	flag_account_authorized, _ := fm.parser.GetFlag("flag_account_authorized")
-
-	mockDataStore := new(mocks.MockUserDataStore)
-	mockCreateAccountService := new(mocks.MockAccountService)
-
-	sessionId := "session123"
-
-	ctx := context.WithValue(context.Background(), "SessionId", sessionId)
-
-	h := &Handlers{
-		userdataStore:  mockDataStore,
-		accountService: mockCreateAccountService,
-		flagManager:    fm.parser,
-	}
-	tests := []struct {
-		name           string
-		input          []byte
-		publicKey      []byte
-		balance        string
-		expectedResult resource.Result
-	}{
-		{
-			name:      "Test quit with balance",
-			balance:   "0.02CELO",
-			publicKey: []byte("0xrqeqrequuq"),
-			expectedResult: resource.Result{
-				FlagReset: []uint32{flag_account_authorized},
-				Content:   fmt.Sprintf("Your account balance is %s", "0.02CELO"),
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-
-			mockDataStore.On("ReadEntry", ctx, sessionId, utils.DATA_PUBLIC_KEY).Return(tt.publicKey, nil)
-			mockCreateAccountService.On("CheckBalance", string(tt.publicKey)).Return(tt.balance, nil)
-
-			// Call the method under test
-			res, _ := h.QuitWithBalance(ctx, "test_quit_with_balance", 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")
-
-			// Assert that expectations were met
-			mockDataStore.AssertExpectations(t)
-
-		})
-	}
-}
-
-func TestValidateAmount(t *testing.T) {
-	fm, err := NewFlagManager(flagsPath)
-
-	if err != nil {
-		t.Logf(err.Error())
-	}
-	//flag_invalid_amount, _ := fm.parser.GetFlag("flag_invalid_amount")
-	mockDataStore := new(mocks.MockUserDataStore)
-	mockCreateAccountService := new(mocks.MockAccountService)
-
-	sessionId := "session123"
-
-	ctx := context.WithValue(context.Background(), "SessionId", sessionId)
-
-	h := &Handlers{
-		userdataStore:  mockDataStore,
-		accountService: mockCreateAccountService,
-		flagManager:    fm.parser,
-	}
-	tests := []struct {
-		name           string
-		input          []byte
-		publicKey      []byte
-		balance        string
-		expectedResult resource.Result
-	}{
-		{
-			name:      "Test with valid amount",
-			input:     []byte("0.001"),
-			balance:   "0.003 CELO",
-			publicKey: []byte("0xrqeqrequuq"),
-			expectedResult: resource.Result{
-				Content: "0.001",
-			},
-		},
-		// {
-		// 	name:      "Test with amount larger than balance",
-		// 	input:     []byte("0.02"),
-		// 	balance:   "0.003 CELO",
-		// 	publicKey: []byte("0xrqeqrequuq"),
-		// 	expectedResult: resource.Result{
-		// 		FlagSet: []uint32{flag_invalid_amount},
-		// 		Content: "0.02",
-		// 	},
-		// },
-		// {
-		// 	name:      "Test with invalid amount",
-		// 	input:     []byte("0.02ms"),
-		// 	balance:   "0.003 CELO",
-		// 	publicKey: []byte("0xrqeqrequuq"),
-		// 	expectedResult: resource.Result{
-		// 		FlagSet: []uint32{flag_invalid_amount},
-		// 		Content: "0.02ms",
-		// 	},
-		// },
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-
-			mockDataStore.On("ReadEntry", ctx, sessionId, utils.DATA_PUBLIC_KEY).Return(tt.publicKey, nil)
-			mockCreateAccountService.On("CheckBalance", string(tt.publicKey)).Return(tt.balance, nil)
-			mockDataStore.On("WriteEntry", ctx, sessionId, utils.DATA_AMOUNT, tt.input).Return(nil)
-
-			// Call the method under test
-			res, _ := h.ValidateAmount(ctx, "test_validate_amount", 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")
-
-			// Assert that expectations were met
-			mockDataStore.AssertExpectations(t)
-
-		})
-	}
-}
-
-func TestValidateRecipient(t *testing.T) {
-	fm, err := NewFlagManager(flagsPath)
-
-	flag_invalid_recipient, _ := fm.parser.GetFlag("flag_invalid_recipient")
-	mockDataStore := new(mocks.MockUserDataStore)
-
-	sessionId := "session123"
-
-	ctx := context.WithValue(context.Background(), "SessionId", sessionId)
-
-	if err != nil {
-		log.Fatal(err)
-	}
-	// Define test cases
-	tests := []struct {
-		name           string
-		input          []byte
-		expectedResult resource.Result
-	}{
-		{
-			name:  "Test with invalid recepient",
-			input: []byte("000"),
-			expectedResult: resource.Result{
-				FlagSet: []uint32{flag_invalid_recipient},
-				Content: "000",
-			},
-		},
-		{
-			name:           "Test with valid recepient",
-			input:          []byte("0705X2"),
-			expectedResult: resource.Result{},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-
-			mockDataStore.On("WriteEntry", ctx, sessionId, utils.DATA_RECIPIENT, tt.input).Return(nil)
-
-			// Create the Handlers instance with the mock flag manager
-			h := &Handlers{
-				flagManager:   fm.parser,
-				userdataStore: mockDataStore,
-			}
-
-			// Call the method
-			res, err := h.ValidateRecipient(ctx, "validate_recepient", 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 TestCheckBalance(t *testing.T) {
-
-	mockDataStore := new(mocks.MockUserDataStore)
-	sessionId := "session123"
-	publicKey := "0X13242618721"
-	balance := "0.003 CELO"
-
-	expectedResult := resource.Result{
-		Content: "0.003 CELO",
-	}
-
-	mockCreateAccountService := new(mocks.MockAccountService)
-
-	ctx := context.WithValue(context.Background(), "SessionId", sessionId)
-
-	h := &Handlers{
-		userdataStore:  mockDataStore,
-		accountService: mockCreateAccountService,
-		//flagManager:    fm.parser,
-	}
-	//mock call operations
-	mockDataStore.On("ReadEntry", ctx, sessionId, utils.DATA_PUBLIC_KEY).Return([]byte(publicKey), nil)
-	mockCreateAccountService.On("CheckBalance", string(publicKey)).Return(balance, nil)
-
-	res, _ := h.CheckBalance(ctx, "check_balance", []byte("123456"))
-
-	assert.Equal(t, res, expectedResult, "Result should contain flag(s) that have been reset")
-
-}
-
-func TestGetProfile(t *testing.T) {
-
-	sessionId := "session123"
-
-	mockDataStore := new(mocks.MockUserDataStore)
-	mockCreateAccountService := new(mocks.MockAccountService)
-	h := &Handlers{
-		userdataStore:  mockDataStore,
-		accountService: mockCreateAccountService,
-	}
-	ctx := context.WithValue(context.Background(), "SessionId", sessionId)
-
-	tests := []struct {
-		name        string
-		keys        []utils.DataTyp
-		profileInfo []string
-		result      resource.Result
-	}{
-		{
-			name:        "Test with full profile information",
-			keys:        []utils.DataTyp{utils.DATA_FAMILY_NAME, utils.DATA_FIRST_NAME, utils.DATA_GENDER, utils.DATA_OFFERINGS, utils.DATA_LOCATION, utils.DATA_YOB},
-			profileInfo: []string{"Doee", "John", "Male", "Bananas", "Kilifi", "1976"},
-			result: resource.Result{
-				Content: fmt.Sprintf(
-					"Name: %s\nGender: %s\nAge: %s\nLocation: %s\nYou provide: %s\n",
-					"John Doee", "Male", "48", "Kilifi", "Bananas",
-				),
-			},
-		},
-		{
-			name:        "Test with yob not provided",
-			keys:        []utils.DataTyp{utils.DATA_FAMILY_NAME, utils.DATA_FIRST_NAME, utils.DATA_GENDER, utils.DATA_OFFERINGS, utils.DATA_LOCATION, utils.DATA_YOB},
-			profileInfo: []string{"Doee", "John", "Male", "Bananas", "Kilifi", "Not Provided"},
-			result: resource.Result{
-				Content: fmt.Sprintf(
-					"Name: %s\nGender: %s\nAge: %s\nLocation: %s\nYou provide: %s\n",
-					"John Doee", "Male", "Not Provided", "Kilifi", "Bananas",
-				),
-			},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			for index, key := range tt.keys {
-				mockDataStore.On("ReadEntry", ctx, sessionId, key).Return([]byte(tt.profileInfo[index]), nil)
-			}
-			res, _ := h.GetProfileInfo(ctx, "get_profile_info", []byte(""))
-
-			// Assert that expectations were met
-			mockDataStore.AssertExpectations(t)
-
-			//Assert that the result set to content is what was expected
-			assert.Equal(t, res, tt.result, "Result should contain profile information served back to user")
-
-		})
-	}
-}