add tests

internal/handlers/ussd/menuhandler.go

@@ -477,7 +477,6 @@ func (h *Handlers) Authorize(ctx context.Context, sym string, input []byte) (res
 	if err != nil {
 		return res, err
 	}
-	if err == nil {
 	if len(input) == 4 {
 		if bytes.Equal(input, AccountPin) {
 			if h.st.MatchFlag(flag_account_authorized, false) {
@@ -492,7 +491,6 @@ func (h *Handlers) Authorize(ctx context.Context, sym string, input []byte) (res
 			res.FlagReset = append(res.FlagReset, flag_account_authorized)
 			return res, nil
 		}
-		}
 	} else {
 		return res, nil
 	}
@@ -538,7 +536,6 @@ 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)
@@ -753,6 +750,7 @@ func (h *Handlers) ValidateAmount(ctx context.Context, sym string, input []byte)
 	if err != nil {
 		return res, err
 	}
+
 	res.Content = balanceStr
 
 	// Parse the balance
@@ -760,6 +758,7 @@ 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)
@@ -769,6 +768,7 @@ 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,6 +776,7 @@ 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,6 +3,7 @@ package ussd
 import (
 	"context"
 	"encoding/json"
+	"fmt"
 	"log"
 	"path"
 	"testing"
@@ -149,6 +150,64 @@ 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)
@@ -743,7 +802,7 @@ func TestIncorrectPinReset(t *testing.T) {
 	}
 }
 
-func TestIncorrectYob(t *testing.T) {
+func TestResetIncorrectYob(t *testing.T) {
 	fm, err := NewFlagManager(flagsPath)
 
 	flag_incorrect_date_format, _ := fm.parser.GetFlag("flag_incorrect_date_format")
@@ -838,6 +897,11 @@ 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 {
@@ -984,13 +1048,6 @@ 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
@@ -1016,3 +1073,646 @@ 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")
+
+		})
+	}
+}