From 7403a75d8ed319cb99666a38efea88380a6bc2f7 Mon Sep 17 00:00:00 2001
From: Kharec <sandro@cazzaniga.fr>
Date: Sat, 29 Nov 2025 14:46:26 +0100
Subject: [PATCH] refactor: clean variable naming

---
 .../page_handler_forms_integration_test.go    | 166 +++++++++---------
 .../page_handler_integration_test.go          | 105 ++++++-----
 2 files changed, 135 insertions(+), 136 deletions(-)

diff --git a/internal/integration/page_handler_forms_integration_test.go b/internal/integration/page_handler_forms_integration_test.go
index f18387b..7e9c79a 100644
--- a/internal/integration/page_handler_forms_integration_test.go
+++ b/internal/integration/page_handler_forms_integration_test.go
@@ -22,26 +22,26 @@ func TestIntegration_PageHandlerFormWorkflows(t *testing.T) {
 		ctx.Suite.EmailSender.Reset()
 		user := createAuthenticatedUser(t, authService, ctx.Suite.UserRepo, "settings_email_user", "settings_email@example.com")
 
-		getReq := httptest.NewRequest("GET", "/settings", nil)
-		getReq.AddCookie(&http.Cookie{Name: "auth_token", Value: user.Token})
-		getRec := httptest.NewRecorder()
-		router.ServeHTTP(getRec, getReq)
+		getRequest := httptest.NewRequest("GET", "/settings", nil)
+		getRequest.AddCookie(&http.Cookie{Name: "auth_token", Value: user.Token})
+		getRecorder := httptest.NewRecorder()
+		router.ServeHTTP(getRecorder, getRequest)
 
 		csrfToken := getCSRFToken(t, router, "/settings", &http.Cookie{Name: "auth_token", Value: user.Token})
 
-		reqBody := url.Values{}
-		reqBody.Set("email", "newemail@example.com")
-		reqBody.Set("csrf_token", csrfToken)
+		requestBody := url.Values{}
+		requestBody.Set("email", "newemail@example.com")
+		requestBody.Set("csrf_token", csrfToken)
 
-		req := httptest.NewRequest("POST", "/settings/email", strings.NewReader(reqBody.Encode()))
-		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-		req.AddCookie(&http.Cookie{Name: "auth_token", Value: user.Token})
-		req.AddCookie(&http.Cookie{Name: "csrf_token", Value: csrfToken})
-		rec := httptest.NewRecorder()
+		request := httptest.NewRequest("POST", "/settings/email", strings.NewReader(requestBody.Encode()))
+		request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+		request.AddCookie(&http.Cookie{Name: "auth_token", Value: user.Token})
+		request.AddCookie(&http.Cookie{Name: "csrf_token", Value: csrfToken})
+		recorder := httptest.NewRecorder()
 
-		router.ServeHTTP(rec, req)
+		router.ServeHTTP(recorder, request)
 
-		assertStatusRange(t, rec, http.StatusOK, http.StatusSeeOther)
+		assertStatusRange(t, recorder, http.StatusOK, http.StatusSeeOther)
 	})
 
 	t.Run("Settings_Username_Update_Form", func(t *testing.T) {
@@ -51,19 +51,19 @@ func TestIntegration_PageHandlerFormWorkflows(t *testing.T) {
 
 		csrfToken := getCSRFToken(t, router, "/settings", &http.Cookie{Name: "auth_token", Value: user.Token})
 
-		reqBody := url.Values{}
-		reqBody.Set("username", "new_username")
-		reqBody.Set("csrf_token", csrfToken)
+		requestBody := url.Values{}
+		requestBody.Set("username", "new_username")
+		requestBody.Set("csrf_token", csrfToken)
 
-		req := httptest.NewRequest("POST", "/settings/username", strings.NewReader(reqBody.Encode()))
-		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-		req.AddCookie(&http.Cookie{Name: "auth_token", Value: user.Token})
-		req.AddCookie(&http.Cookie{Name: "csrf_token", Value: csrfToken})
-		rec := httptest.NewRecorder()
+		request := httptest.NewRequest("POST", "/settings/username", strings.NewReader(requestBody.Encode()))
+		request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+		request.AddCookie(&http.Cookie{Name: "auth_token", Value: user.Token})
+		request.AddCookie(&http.Cookie{Name: "csrf_token", Value: csrfToken})
+		recorder := httptest.NewRecorder()
 
-		router.ServeHTTP(rec, req)
+		router.ServeHTTP(recorder, request)
 
-		assertStatusRange(t, rec, http.StatusOK, http.StatusSeeOther)
+		assertStatusRange(t, recorder, http.StatusOK, http.StatusSeeOther)
 	})
 
 	t.Run("Settings_Password_Update_Form", func(t *testing.T) {
@@ -74,20 +74,20 @@ func TestIntegration_PageHandlerFormWorkflows(t *testing.T) {
 
 		csrfToken := getCSRFToken(t, freshCtx.Router, "/settings", &http.Cookie{Name: "auth_token", Value: user.Token})
 
-		reqBody := url.Values{}
-		reqBody.Set("current_password", "SecurePass123!")
-		reqBody.Set("new_password", "NewSecurePass123!")
-		reqBody.Set("csrf_token", csrfToken)
+		requestBody := url.Values{}
+		requestBody.Set("current_password", "SecurePass123!")
+		requestBody.Set("new_password", "NewSecurePass123!")
+		requestBody.Set("csrf_token", csrfToken)
 
-		req := httptest.NewRequest("POST", "/settings/password", strings.NewReader(reqBody.Encode()))
-		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-		req.AddCookie(&http.Cookie{Name: "auth_token", Value: user.Token})
-		req.AddCookie(&http.Cookie{Name: "csrf_token", Value: csrfToken})
-		rec := httptest.NewRecorder()
+		request := httptest.NewRequest("POST", "/settings/password", strings.NewReader(requestBody.Encode()))
+		request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+		request.AddCookie(&http.Cookie{Name: "auth_token", Value: user.Token})
+		request.AddCookie(&http.Cookie{Name: "csrf_token", Value: csrfToken})
+		recorder := httptest.NewRecorder()
 
-		freshCtx.Router.ServeHTTP(rec, req)
+		freshCtx.Router.ServeHTTP(recorder, request)
 
-		assertStatusRange(t, rec, http.StatusOK, http.StatusSeeOther)
+		assertStatusRange(t, recorder, http.StatusOK, http.StatusSeeOther)
 	})
 
 	t.Run("Logout_Page_Handler", func(t *testing.T) {
@@ -98,19 +98,19 @@ func TestIntegration_PageHandlerFormWorkflows(t *testing.T) {
 
 		csrfToken := getCSRFToken(t, freshCtx.Router, "/settings", &http.Cookie{Name: "auth_token", Value: user.Token})
 
-		reqBody := url.Values{}
-		reqBody.Set("csrf_token", csrfToken)
+		requestBody := url.Values{}
+		requestBody.Set("csrf_token", csrfToken)
 
-		req := httptest.NewRequest("POST", "/logout", strings.NewReader(reqBody.Encode()))
-		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-		req.AddCookie(&http.Cookie{Name: "auth_token", Value: user.Token})
-		req.AddCookie(&http.Cookie{Name: "csrf_token", Value: csrfToken})
-		rec := httptest.NewRecorder()
+		request := httptest.NewRequest("POST", "/logout", strings.NewReader(requestBody.Encode()))
+		request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+		request.AddCookie(&http.Cookie{Name: "auth_token", Value: user.Token})
+		request.AddCookie(&http.Cookie{Name: "csrf_token", Value: csrfToken})
+		recorder := httptest.NewRecorder()
 
-		freshCtx.Router.ServeHTTP(rec, req)
+		freshCtx.Router.ServeHTTP(recorder, request)
 
-		assertStatus(t, rec, http.StatusSeeOther)
-		assertCookieCleared(t, rec, "auth_token")
+		assertStatus(t, recorder, http.StatusSeeOther)
+		assertCookieCleared(t, recorder, "auth_token")
 	})
 
 	t.Run("Resend_Verification_Page_Handler", func(t *testing.T) {
@@ -120,18 +120,18 @@ func TestIntegration_PageHandlerFormWorkflows(t *testing.T) {
 
 		csrfToken := getCSRFToken(t, freshCtx.Router, "/resend-verification")
 
-		reqBody := url.Values{}
-		reqBody.Set("email", "resend_page@example.com")
-		reqBody.Set("csrf_token", csrfToken)
+		requestBody := url.Values{}
+		requestBody.Set("email", "resend_page@example.com")
+		requestBody.Set("csrf_token", csrfToken)
 
-		req := httptest.NewRequest("POST", "/resend-verification", strings.NewReader(reqBody.Encode()))
-		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-		req.AddCookie(&http.Cookie{Name: "csrf_token", Value: csrfToken})
-		rec := httptest.NewRecorder()
+		request := httptest.NewRequest("POST", "/resend-verification", strings.NewReader(requestBody.Encode()))
+		request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+		request.AddCookie(&http.Cookie{Name: "csrf_token", Value: csrfToken})
+		recorder := httptest.NewRecorder()
 
-		freshCtx.Router.ServeHTTP(rec, req)
+		freshCtx.Router.ServeHTTP(recorder, request)
 
-		assertStatusRange(t, rec, http.StatusOK, http.StatusSeeOther)
+		assertStatusRange(t, recorder, http.StatusOK, http.StatusSeeOther)
 	})
 
 	t.Run("Post_Vote_Page_Handler", func(t *testing.T) {
@@ -142,26 +142,26 @@ func TestIntegration_PageHandlerFormWorkflows(t *testing.T) {
 
 		post := testutils.CreatePostWithRepo(t, freshCtx.Suite.PostRepo, user.User.ID, "Vote Page Test", "https://example.com/vote-page")
 
-		getReq := httptest.NewRequest("GET", fmt.Sprintf("/posts/%d", post.ID), nil)
-		getRec := httptest.NewRecorder()
-		freshCtx.Router.ServeHTTP(getRec, getReq)
+		getRequest := httptest.NewRequest("GET", fmt.Sprintf("/posts/%d", post.ID), nil)
+		getRecorder := httptest.NewRecorder()
+		freshCtx.Router.ServeHTTP(getRecorder, getRequest)
 
 		csrfToken := getCSRFToken(t, freshCtx.Router, fmt.Sprintf("/posts/%d", post.ID))
 
-		reqBody := url.Values{}
-		reqBody.Set("action", "up")
-		reqBody.Set("csrf_token", csrfToken)
+		requestBody := url.Values{}
+		requestBody.Set("action", "up")
+		requestBody.Set("csrf_token", csrfToken)
 
-		req := httptest.NewRequest("POST", fmt.Sprintf("/posts/%d/vote", post.ID), strings.NewReader(reqBody.Encode()))
-		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-		req.AddCookie(&http.Cookie{Name: "auth_token", Value: user.Token})
-		req.AddCookie(&http.Cookie{Name: "csrf_token", Value: csrfToken})
-		req = testutils.WithURLParams(req, map[string]string{"id": fmt.Sprintf("%d", post.ID)})
-		rec := httptest.NewRecorder()
+		request := httptest.NewRequest("POST", fmt.Sprintf("/posts/%d/vote", post.ID), strings.NewReader(requestBody.Encode()))
+		request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+		request.AddCookie(&http.Cookie{Name: "auth_token", Value: user.Token})
+		request.AddCookie(&http.Cookie{Name: "csrf_token", Value: csrfToken})
+		request = testutils.WithURLParams(request, map[string]string{"id": fmt.Sprintf("%d", post.ID)})
+		recorder := httptest.NewRecorder()
 
-		freshCtx.Router.ServeHTTP(rec, req)
+		freshCtx.Router.ServeHTTP(recorder, request)
 
-		assertStatusRange(t, rec, http.StatusOK, http.StatusSeeOther)
+		assertStatusRange(t, recorder, http.StatusOK, http.StatusSeeOther)
 	})
 
 	t.Run("Login_Page_Handler_Workflow", func(t *testing.T) {
@@ -172,20 +172,20 @@ func TestIntegration_PageHandlerFormWorkflows(t *testing.T) {
 
 		csrfToken := getCSRFToken(t, freshCtx.Router, "/login")
 
-		reqBody := url.Values{}
-		reqBody.Set("username", "login_page_user")
-		reqBody.Set("password", "SecurePass123!")
-		reqBody.Set("csrf_token", csrfToken)
+		requestBody := url.Values{}
+		requestBody.Set("username", "login_page_user")
+		requestBody.Set("password", "SecurePass123!")
+		requestBody.Set("csrf_token", csrfToken)
 
-		req := httptest.NewRequest("POST", "/login", strings.NewReader(reqBody.Encode()))
-		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-		req.AddCookie(&http.Cookie{Name: "csrf_token", Value: csrfToken})
-		rec := httptest.NewRecorder()
+		request := httptest.NewRequest("POST", "/login", strings.NewReader(requestBody.Encode()))
+		request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+		request.AddCookie(&http.Cookie{Name: "csrf_token", Value: csrfToken})
+		recorder := httptest.NewRecorder()
 
-		freshCtx.Router.ServeHTTP(rec, req)
+		freshCtx.Router.ServeHTTP(recorder, request)
 
-		assertStatus(t, rec, http.StatusSeeOther)
-		assertCookie(t, rec, "auth_token", "")
+		assertStatus(t, recorder, http.StatusSeeOther)
+		assertCookie(t, recorder, "auth_token", "")
 	})
 
 	t.Run("Email_Confirmation_Page_Handler", func(t *testing.T) {
@@ -198,11 +198,11 @@ func TestIntegration_PageHandlerFormWorkflows(t *testing.T) {
 			token = "test-token"
 		}
 
-		req := httptest.NewRequest("GET", "/confirm?token="+url.QueryEscape(token), nil)
-		rec := httptest.NewRecorder()
+		request := httptest.NewRequest("GET", "/confirm?token="+url.QueryEscape(token), nil)
+		recorder := httptest.NewRecorder()
 
-		router.ServeHTTP(rec, req)
+		router.ServeHTTP(recorder, request)
 
-		assertStatusRange(t, rec, http.StatusOK, http.StatusSeeOther)
+		assertStatusRange(t, recorder, http.StatusOK, http.StatusSeeOther)
 	})
 }
diff --git a/internal/integration/page_handler_integration_test.go b/internal/integration/page_handler_integration_test.go
index 788a6a7..f631e37 100644
--- a/internal/integration/page_handler_integration_test.go
+++ b/internal/integration/page_handler_integration_test.go
@@ -16,63 +16,62 @@ func TestIntegration_PageHandler(t *testing.T) {
 	router := ctx.Router
 
 	t.Run("Home_Page_Renders", func(t *testing.T) {
-		req := httptest.NewRequest("GET", "/", nil)
-		rec := httptest.NewRecorder()
+		request := httptest.NewRequest("GET", "/", nil)
+		recorder := httptest.NewRecorder()
 
-		router.ServeHTTP(rec, req)
+		router.ServeHTTP(recorder, request)
 
-		assertStatus(t, rec, http.StatusOK)
+		assertStatus(t, recorder, http.StatusOK)
 
-		if !strings.Contains(rec.Body.String(), "<html") {
+		if !strings.Contains(recorder.Body.String(), "<html") {
 			t.Error("Expected HTML content")
 		}
 	})
 
 	t.Run("Login_Form_Renders", func(t *testing.T) {
-		req := httptest.NewRequest("GET", "/login", nil)
-		rec := httptest.NewRecorder()
+		request := httptest.NewRequest("GET", "/login", nil)
+		recorder := httptest.NewRecorder()
 
-		router.ServeHTTP(rec, req)
+		router.ServeHTTP(recorder, request)
 
-		assertStatus(t, rec, http.StatusOK)
+		assertStatus(t, recorder, http.StatusOK)
 
-		body := rec.Body.String()
+		body := recorder.Body.String()
 		if !strings.Contains(body, "login") && !strings.Contains(body, "Login") {
 			t.Error("Expected login form content")
 		}
 	})
 
 	t.Run("Register_Form_Renders", func(t *testing.T) {
-		req := httptest.NewRequest("GET", "/register", nil)
-		rec := httptest.NewRecorder()
+		request := httptest.NewRequest("GET", "/register", nil)
+		recorder := httptest.NewRecorder()
 
-		router.ServeHTTP(rec, req)
+		router.ServeHTTP(recorder, request)
+		assertStatus(t, recorder, http.StatusOK)
 
-		assertStatus(t, rec, http.StatusOK)
-
-		body := rec.Body.String()
+		body := recorder.Body.String()
 		if !strings.Contains(body, "register") && !strings.Contains(body, "Register") {
 			t.Error("Expected register form content")
 		}
 	})
 
 	t.Run("PageHandler_With_CSRF_Token", func(t *testing.T) {
-		req := httptest.NewRequest("GET", "/register", nil)
-		rec := httptest.NewRecorder()
+		request := httptest.NewRequest("GET", "/register", nil)
+		recorder := httptest.NewRecorder()
 
-		router.ServeHTTP(rec, req)
+		router.ServeHTTP(recorder, request)
 
-		assertCookie(t, rec, "csrf_token", "")
+		assertCookie(t, recorder, "csrf_token", "")
 	})
 
 	t.Run("PageHandler_Form_Submission", func(t *testing.T) {
 		ctx.Suite.EmailSender.Reset()
 
-		getReq := httptest.NewRequest("GET", "/register", nil)
-		getRec := httptest.NewRecorder()
-		router.ServeHTTP(getRec, getReq)
+		getRequest := httptest.NewRequest("GET", "/register", nil)
+		getRecorder := httptest.NewRecorder()
+		router.ServeHTTP(getRecorder, getRequest)
 
-		cookies := getRec.Result().Cookies()
+		cookies := getRecorder.Result().Cookies()
 		var csrfCookie *http.Cookie
 		for _, cookie := range cookies {
 			if cookie.Name == "csrf_token" {
@@ -85,33 +84,33 @@ func TestIntegration_PageHandler(t *testing.T) {
 			t.Fatal("Expected CSRF cookie")
 		}
 
-		reqBody := url.Values{}
-		reqBody.Set("username", "page_form_user")
-		reqBody.Set("email", "page_form@example.com")
-		reqBody.Set("password", "SecurePass123!")
-		reqBody.Set("csrf_token", csrfCookie.Value)
+		requestBody := url.Values{}
+		requestBody.Set("username", "page_form_user")
+		requestBody.Set("email", "page_form@example.com")
+		requestBody.Set("password", "SecurePass123!")
+		requestBody.Set("csrf_token", csrfCookie.Value)
 
-		req := httptest.NewRequest("POST", "/register", strings.NewReader(reqBody.Encode()))
-		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-		req.AddCookie(csrfCookie)
-		rec := httptest.NewRecorder()
+		request := httptest.NewRequest("POST", "/register", strings.NewReader(requestBody.Encode()))
+		request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+		request.AddCookie(csrfCookie)
+		recorder := httptest.NewRecorder()
 
-		router.ServeHTTP(rec, req)
+		router.ServeHTTP(recorder, request)
 
-		assertStatusRange(t, rec, http.StatusOK, http.StatusSeeOther)
+		assertStatusRange(t, recorder, http.StatusOK, http.StatusSeeOther)
 	})
 
 	t.Run("PageHandler_Authenticated_Access", func(t *testing.T) {
 		ctx.Suite.EmailSender.Reset()
 		user := createUserWithCleanup(t, ctx, "page_auth_user", "page_auth@example.com")
 
-		req := httptest.NewRequest("GET", "/settings", nil)
-		req.AddCookie(&http.Cookie{Name: "auth_token", Value: user.Token})
-		rec := httptest.NewRecorder()
+		request := httptest.NewRequest("GET", "/settings", nil)
+		request.AddCookie(&http.Cookie{Name: "auth_token", Value: user.Token})
+		recorder := httptest.NewRecorder()
 
-		router.ServeHTTP(rec, req)
+		router.ServeHTTP(recorder, request)
 
-		assertStatus(t, rec, http.StatusOK)
+		assertStatus(t, recorder, http.StatusOK)
 	})
 
 	t.Run("PageHandler_Post_Display", func(t *testing.T) {
@@ -120,34 +119,34 @@ func TestIntegration_PageHandler(t *testing.T) {
 
 		post := testutils.CreatePostWithRepo(t, ctx.Suite.PostRepo, user.User.ID, "Page Test Post", "https://example.com/page-test")
 
-		req := httptest.NewRequest("GET", "/posts/"+fmt.Sprintf("%d", post.ID), nil)
-		rec := httptest.NewRecorder()
+		request := httptest.NewRequest("GET", "/posts/"+fmt.Sprintf("%d", post.ID), nil)
+		recorder := httptest.NewRecorder()
 
-		router.ServeHTTP(rec, req)
+		router.ServeHTTP(recorder, request)
 
-		assertStatus(t, rec, http.StatusOK)
+		assertStatus(t, recorder, http.StatusOK)
 
-		body := rec.Body.String()
+		body := recorder.Body.String()
 		if !strings.Contains(body, "Page Test Post") {
 			t.Error("Expected post title in page")
 		}
 	})
 
 	t.Run("PageHandler_Search_Page", func(t *testing.T) {
-		req := httptest.NewRequest("GET", "/search?q=test", nil)
-		rec := httptest.NewRecorder()
+		request := httptest.NewRequest("GET", "/search?q=test", nil)
+		recorder := httptest.NewRecorder()
 
-		router.ServeHTTP(rec, req)
+		router.ServeHTTP(recorder, request)
 
-		assertStatus(t, rec, http.StatusOK)
+		assertStatus(t, recorder, http.StatusOK)
 	})
 
 	t.Run("PageHandler_Error_Handling", func(t *testing.T) {
-		req := httptest.NewRequest("GET", "/nonexistent", nil)
-		rec := httptest.NewRecorder()
+		request := httptest.NewRequest("GET", "/nonexistent", nil)
+		recorder := httptest.NewRecorder()
 
-		router.ServeHTTP(rec, req)
+		router.ServeHTTP(recorder, request)
 
-		assertStatus(t, rec, http.StatusNotFound)
+		assertStatus(t, recorder, http.StatusNotFound)
 	})
 }