move authorization tests

handlers/application/account_status_test.go

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

handlers/application/authorization_test.go

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

handlers/application/menuhandler_test.go

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

handlers/application/pin_test.go

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