fix: resolve CI lint errors and unify code style with project conventions

Author: Eraxyso

traq/traq_test.go

@@ -12,7 +12,6 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-// roundTripFunc is a helper to create http.RoundTripper from a function.
 type roundTripFunc func(*http.Request) (*http.Response, error)
 
 func (f roundTripFunc) RoundTrip(r *http.Request) (*http.Response, error) {
@@ -31,7 +30,6 @@ func makeResponse(statusCode int, body string, headers map[string]string) *http.
 	return resp
 }
 
-// TestIsETagTargetPath verifies which URL paths are considered ETag-cache targets.
 func TestIsETagTargetPath(t *testing.T) {
 	t.Parallel()
 
@@ -126,7 +124,6 @@ func TestIsETagTargetPath(t *testing.T) {
 	}
 }
 
-// TestNewETagCacheTransport verifies the constructor.
 func TestNewETagCacheTransport(t *testing.T) {
 	t.Parallel()
 
@@ -138,20 +135,19 @@ func TestNewETagCacheTransport(t *testing.T) {
 
 	t.Run("non-nil base is used", func(t *testing.T) {
 		t.Parallel()
-		base := roundTripFunc(func(r *http.Request) (*http.Response, error) {
+		base := roundTripFunc(func(_ *http.Request) (*http.Response, error) {
 			return nil, nil
 		})
 		transport := newETagCacheTransport(base)
 		require.NotNil(t, transport)
 	})
 }
 
-// TestETagCacheTransport_RoundTrip_NonGET verifies that non-GET requests bypass caching entirely.
 func TestETagCacheTransport_RoundTrip_NonGET(t *testing.T) {
 	t.Parallel()
 
 	called := 0
-	base := roundTripFunc(func(r *http.Request) (*http.Response, error) {
+	base := roundTripFunc(func(_ *http.Request) (*http.Response, error) {
 		called++
 		return makeResponse(http.StatusOK, "ok", nil), nil
 	})
@@ -170,14 +166,12 @@ func TestETagCacheTransport_RoundTrip_NonGET(t *testing.T) {
 	assert.Equal(t, len(methods), called, "base should be called once per non-GET method")
 }
 
-// TestETagCacheTransport_RoundTrip_NonCacheablePath verifies requests to non-ETag paths are not cached.
 func TestETagCacheTransport_RoundTrip_NonCacheablePath(t *testing.T) {
 	t.Parallel()
 
 	callCount := 0
-	base := roundTripFunc(func(r *http.Request) (*http.Response, error) {
+	base := roundTripFunc(func(_ *http.Request) (*http.Response, error) {
 		callCount++
-		// Never returns ETag header
 		return makeResponse(http.StatusOK, "data", nil), nil
 	})
 
@@ -188,16 +182,13 @@ func TestETagCacheTransport_RoundTrip_NonCacheablePath(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, http.StatusOK, resp.StatusCode)
 
-	// Second call: path not cacheable so no If-None-Match is sent
 	req2 := httptest.NewRequest(http.MethodGet, "http://example.com/api/v3/messages", nil)
 	resp2, err := transport.RoundTrip(req2)
 	require.NoError(t, err)
 	assert.Equal(t, http.StatusOK, resp2.StatusCode)
 	assert.Equal(t, 2, callCount)
 }
 
-// TestETagCacheTransport_RoundTrip_FirstRequestCachesETag verifies that a 200 response
-// with an ETag header is stored in the cache.
 func TestETagCacheTransport_RoundTrip_FirstRequestCachesETag(t *testing.T) {
 	t.Parallel()
 
@@ -221,29 +212,24 @@ func TestETagCacheTransport_RoundTrip_FirstRequestCachesETag(t *testing.T) {
 	assert.Equal(t, 1, callCount)
 	assert.Empty(t, receivedIfNoneMatch, "first request must not send If-None-Match")
 
-	// Second request must send If-None-Match with the stored ETag
 	req2 := httptest.NewRequest(http.MethodGet, "http://example.com/api/v3/users", nil)
 	_, err = transport.RoundTrip(req2)
 	require.NoError(t, err)
 	assert.Equal(t, etag, receivedIfNoneMatch, "second request must send stored ETag as If-None-Match")
 }
 
-// TestETagCacheTransport_RoundTrip_304UsesCachedBody verifies that a 304 Not Modified response
-// causes the transport to return the previously cached body as 200.
 func TestETagCacheTransport_RoundTrip_304UsesCachedBody(t *testing.T) {
 	t.Parallel()
 
 	const etag = `"v1"`
 	const cachedBody = `["user1","user2"]`
 
 	callNum := 0
-	base := roundTripFunc(func(r *http.Request) (*http.Response, error) {
+	base := roundTripFunc(func(_ *http.Request) (*http.Response, error) {
 		callNum++
 		if callNum == 1 {
-			// First call: return 200 with ETag
 			return makeResponse(http.StatusOK, cachedBody, map[string]string{"ETag": etag}), nil
 		}
-		// Second call: return 304 Not Modified (empty body)
 		return makeResponse(http.StatusNotModified, "", nil), nil
 	})
 
@@ -264,33 +250,28 @@ func TestETagCacheTransport_RoundTrip_304UsesCachedBody(t *testing.T) {
 	assert.Equal(t, cachedBody, string(bodyBytes))
 }
 
-// TestETagCacheTransport_RoundTrip_304NoCacheFallthrough verifies that a 304 without a cached entry
-// is returned as-is (edge/error case).
 func TestETagCacheTransport_RoundTrip_304NoCacheFallthrough(t *testing.T) {
 	t.Parallel()
 
-	base := roundTripFunc(func(r *http.Request) (*http.Response, error) {
+	base := roundTripFunc(func(_ *http.Request) (*http.Response, error) {
 		return makeResponse(http.StatusNotModified, "", nil), nil
 	})
 
 	transport := newETagCacheTransport(base).(*etagCacheTransport)
 	req := httptest.NewRequest(http.MethodGet, "http://example.com/api/v3/users", nil)
 	resp, err := transport.RoundTrip(req)
 	require.NoError(t, err)
-	// No cached entry, so the raw 304 is returned
 	assert.Equal(t, http.StatusNotModified, resp.StatusCode)
 }
 
-// TestETagCacheTransport_RoundTrip_5xxFallback verifies that a 5xx response falls back to
-// cached data if available.
 func TestETagCacheTransport_RoundTrip_5xxFallback(t *testing.T) {
 	t.Parallel()
 
 	const etag = `"v2"`
 	const cachedBody = `["stamp1"]`
 
 	callNum := 0
-	base := roundTripFunc(func(r *http.Request) (*http.Response, error) {
+	base := roundTripFunc(func(_ *http.Request) (*http.Response, error) {
 		callNum++
 		if callNum == 1 {
 			return makeResponse(http.StatusOK, cachedBody, map[string]string{"ETag": etag}), nil
@@ -315,12 +296,10 @@ func TestETagCacheTransport_RoundTrip_5xxFallback(t *testing.T) {
 	assert.Equal(t, cachedBody, string(bodyBytes))
 }
 
-// TestETagCacheTransport_RoundTrip_5xxNoCacheFallthrough verifies that a 5xx without a cached
-// entry is returned as-is.
 func TestETagCacheTransport_RoundTrip_5xxNoCacheFallthrough(t *testing.T) {
 	t.Parallel()
 
-	base := roundTripFunc(func(r *http.Request) (*http.Response, error) {
+	base := roundTripFunc(func(_ *http.Request) (*http.Response, error) {
 		return makeResponse(http.StatusServiceUnavailable, "unavailable", nil), nil
 	})
 
@@ -331,8 +310,6 @@ func TestETagCacheTransport_RoundTrip_5xxNoCacheFallthrough(t *testing.T) {
 	assert.Equal(t, http.StatusServiceUnavailable, resp.StatusCode)
 }
 
-// TestETagCacheTransport_RoundTrip_NetworkErrorWithCache verifies that a network error falls back
-// to cached data if available.
 func TestETagCacheTransport_RoundTrip_NetworkErrorWithCache(t *testing.T) {
 	t.Parallel()
 
@@ -341,7 +318,7 @@ func TestETagCacheTransport_RoundTrip_NetworkErrorWithCache(t *testing.T) {
 	networkErr := errors.New("connection refused")
 
 	callNum := 0
-	base := roundTripFunc(func(r *http.Request) (*http.Response, error) {
+	base := roundTripFunc(func(_ *http.Request) (*http.Response, error) {
 		callNum++
 		if callNum == 1 {
 			return makeResponse(http.StatusOK, cachedBody, map[string]string{"ETag": etag}), nil
@@ -366,13 +343,11 @@ func TestETagCacheTransport_RoundTrip_NetworkErrorWithCache(t *testing.T) {
 	assert.Equal(t, cachedBody, string(bodyBytes))
 }
 
-// TestETagCacheTransport_RoundTrip_NetworkErrorNoCache verifies that a network error without
-// cached data propagates the error.
 func TestETagCacheTransport_RoundTrip_NetworkErrorNoCache(t *testing.T) {
 	t.Parallel()
 
 	networkErr := errors.New("connection refused")
-	base := roundTripFunc(func(r *http.Request) (*http.Response, error) {
+	base := roundTripFunc(func(_ *http.Request) (*http.Response, error) {
 		return nil, networkErr
 	})
 
@@ -383,12 +358,10 @@ func TestETagCacheTransport_RoundTrip_NetworkErrorNoCache(t *testing.T) {
 	assert.ErrorIs(t, err, networkErr)
 }
 
-// TestETagCacheTransport_RoundTrip_NonOKNonSpecialStatus verifies that non-200/304/5xx status
-// codes (e.g. 401, 404) are returned as-is without caching.
 func TestETagCacheTransport_RoundTrip_NonOKNonSpecialStatus(t *testing.T) {
 	t.Parallel()
 
-	base := roundTripFunc(func(r *http.Request) (*http.Response, error) {
+	base := roundTripFunc(func(_ *http.Request) (*http.Response, error) {
 		return makeResponse(http.StatusUnauthorized, "unauthorized", nil), nil
 	})
 
@@ -399,8 +372,6 @@ func TestETagCacheTransport_RoundTrip_NonOKNonSpecialStatus(t *testing.T) {
 	assert.Equal(t, http.StatusUnauthorized, resp.StatusCode)
 }
 
-// TestETagCacheTransport_RoundTrip_200WithoutETagNotCached verifies that 200 responses without
-// an ETag header are not cached (no If-None-Match on subsequent calls).
 func TestETagCacheTransport_RoundTrip_200WithoutETagNotCached(t *testing.T) {
 	t.Parallel()
 
@@ -409,7 +380,6 @@ func TestETagCacheTransport_RoundTrip_200WithoutETagNotCached(t *testing.T) {
 	base := roundTripFunc(func(r *http.Request) (*http.Response, error) {
 		callCount++
 		receivedIfNoneMatch = r.Header.Get("If-None-Match")
-		// No ETag in response
 		return makeResponse(http.StatusOK, "data", nil), nil
 	})
 
@@ -425,15 +395,13 @@ func TestETagCacheTransport_RoundTrip_200WithoutETagNotCached(t *testing.T) {
 	assert.Equal(t, 2, callCount)
 }
 
-// TestETagCacheTransport_RoundTrip_CacheHitHeader verifies that responses served from cache
-// include the X-AnkeTo-Cache: hit header.
 func TestETagCacheTransport_RoundTrip_CacheHitHeader(t *testing.T) {
 	t.Parallel()
 
 	const etag = `"hdr-test"`
 
 	callNum := 0
-	base := roundTripFunc(func(r *http.Request) (*http.Response, error) {
+	base := roundTripFunc(func(_ *http.Request) (*http.Response, error) {
 		callNum++
 		if callNum == 1 {
 			return makeResponse(http.StatusOK, "body", map[string]string{"ETag": etag}), nil
@@ -452,16 +420,13 @@ func TestETagCacheTransport_RoundTrip_CacheHitHeader(t *testing.T) {
 	assert.Equal(t, "hit", resp.Header.Get("X-AnkeTo-Cache"))
 }
 
-// TestETagCacheTransport_ConcurrentAccess verifies that the transport is safe under concurrent load.
 func TestETagCacheTransport_ConcurrentAccess(t *testing.T) {
 	t.Parallel()
 
 	const etag = `"concurrent"`
 	const body = `["a","b"]`
 
-	callNum := 0
-	base := roundTripFunc(func(r *http.Request) (*http.Response, error) {
-		callNum++
+	base := roundTripFunc(func(_ *http.Request) (*http.Response, error) {
 		return makeResponse(http.StatusOK, body, map[string]string{"ETag": etag}), nil
 	})
 
@@ -482,5 +447,4 @@ func TestETagCacheTransport_ConcurrentAccess(t *testing.T) {
 	for i := 0; i < goroutines; i++ {
 		<-done
 	}
-	// No race detector failure is the assertion here.
-}
+}