diff --git a/proxy/helpers_env_test.go b/proxy/helpers_env_test.go
new file mode 100644
index 0000000..9974c9c
--- /dev/null
+++ b/proxy/helpers_env_test.go
@@ -0,0 +1,262 @@
+package main
+
+import (
+	"os"
+	"strconv"
+	"testing"
+)
+
+// TestIsTestMode verifies that IsTestMode correctly detects test mode
+func TestIsTestMode(t *testing.T) {
+	t.Run("returns true during test execution via testing.Testing", func(t *testing.T) {
+		// When called from a test, testing.Testing() returns true
+		if !IsTestMode() {
+			t.Error("IsTestMode should return true during test execution via testing.Testing()")
+		}
+	})
+
+	t.Run("returns true when ZAI_PROXY_TEST_MODE is true", func(t *testing.T) {
+		// Save original value
+		orig := os.Getenv(TestModeEnv)
+
+		// Set env var and verify
+		t.Setenv(TestModeEnv, "true")
+		if !IsTestMode() {
+			t.Error("IsTestMode should return true when ZAI_PROXY_TEST_MODE=true")
+		}
+
+		// Restore
+		if orig != "" {
+			t.Setenv(TestModeEnv, orig)
+		} else {
+			os.Unsetenv(TestModeEnv)
+		}
+	})
+
+	t.Run("returns false when neither condition is met", func(t *testing.T) {
+		// This test verifies the logic, though we can't truly test
+		// the "non-test" case since we're always in a test context.
+		// The key point is that during tests, it should return true.
+		if !IsTestMode() {
+			t.Error("IsTestMode should return true in test context")
+		}
+	})
+}
+
+// TestGetTestMaxRetries verifies that GetTestMaxRetries returns the correct value
+func TestGetTestMaxRetries(t *testing.T) {
+	t.Run("returns DefaultTestMaxRetries (1) when MAX_RETRIES not set", func(t *testing.T) {
+		// Save original value
+		orig := os.Getenv(TestMaxRetriesEnv)
+
+		// Ensure env var is unset
+		os.Unsetenv(TestMaxRetriesEnv)
+
+		retries := GetTestMaxRetries()
+		if retries != DefaultTestMaxRetries {
+			t.Errorf("Expected DefaultTestMaxRetries=%d, got %d", DefaultTestMaxRetries, retries)
+		}
+
+		// Restore
+		if orig != "" {
+			t.Setenv(TestMaxRetriesEnv, orig)
+		}
+	})
+
+	t.Run("returns DefaultTestMaxRetries (1) when MAX_RETRIES is empty string", func(t *testing.T) {
+		// Save original value
+		orig := os.Getenv(TestMaxRetriesEnv)
+
+		t.Setenv(TestMaxRetriesEnv, "")
+
+		retries := GetTestMaxRetries()
+		if retries != DefaultTestMaxRetries {
+			t.Errorf("Expected DefaultTestMaxRetries=%d when env is empty, got %d", DefaultTestMaxRetries, retries)
+		}
+
+		// Restore
+		if orig != "" {
+			t.Setenv(TestMaxRetriesEnv, orig)
+		}
+	})
+
+	t.Run("returns value from MAX_RETRIES when set to valid positive integer", func(t *testing.T) {
+		// Save original value
+		orig := os.Getenv(TestMaxRetriesEnv)
+
+		testCases := []struct {
+			name     string
+			envValue string
+			expected int
+		}{
+			{"zero", "0", 0},
+			{"one", "1", 1},
+			{"two", "2", 2},
+			{"five", "5", 5},
+			{"ten", "10", 10},
+			{"large", "100", 100},
+		}
+
+		for _, tc := range testCases {
+			t.Run(tc.name, func(t *testing.T) {
+				t.Setenv(TestMaxRetriesEnv, tc.envValue)
+				retries := GetTestMaxRetries()
+				if retries != tc.expected {
+					t.Errorf("Expected %d, got %d", tc.expected, retries)
+				}
+			})
+		}
+
+		// Restore
+		if orig != "" {
+			t.Setenv(TestMaxRetriesEnv, orig)
+		}
+	})
+
+	t.Run("returns DefaultTestMaxRetries when MAX_RETRIES is invalid", func(t *testing.T) {
+		// Save original value
+		orig := os.Getenv(TestMaxRetriesEnv)
+
+		invalidValues := []string{
+			"not-a-number",
+			"-1",  // negative
+			"-5",  // negative
+			"1.5", // not an integer
+			"abc",
+		}
+
+		for _, val := range invalidValues {
+			t.Run("value_"+val, func(t *testing.T) {
+				t.Setenv(TestMaxRetriesEnv, val)
+				retries := GetTestMaxRetries()
+				if retries != DefaultTestMaxRetries {
+					t.Errorf("Expected DefaultTestMaxRetries=%d for invalid value %q, got %d",
+						DefaultTestMaxRetries, val, retries)
+				}
+			})
+		}
+
+		// Restore
+		if orig != "" {
+			t.Setenv(TestMaxRetriesEnv, orig)
+		}
+	})
+}
+
+// TestConfigureTestEnv verifies that ConfigureTestEnv sets all required environment variables
+func TestConfigureTestEnv(t *testing.T) {
+	// Save original values
+	origTestMode := os.Getenv(TestModeEnv)
+	origMaxRetries := os.Getenv(TestMaxRetriesEnv)
+	origDeploymentVariant := os.Getenv("DEPLOYMENT_VARIANT")
+	origTokenCounting := os.Getenv("TOKEN_COUNTING_ENABLED")
+	origRateLimitInitial := os.Getenv("RATE_LIMIT_INITIAL")
+	origRateLimitMin := os.Getenv("RATE_LIMIT_MIN")
+	origRateLimitMax := os.Getenv("RATE_LIMIT_MAX")
+
+	// Clear all env vars to ensure clean state
+	os.Unsetenv(TestModeEnv)
+	os.Unsetenv(TestMaxRetriesEnv)
+	os.Unsetenv("DEPLOYMENT_VARIANT")
+	os.Unsetenv("TOKEN_COUNTING_ENABLED")
+	os.Unsetenv("RATE_LIMIT_INITIAL")
+	os.Unsetenv("RATE_LIMIT_MIN")
+	os.Unsetenv("RATE_LIMIT_MAX")
+
+	// Call ConfigureTestEnv
+	ConfigureTestEnv(t)
+
+	// Verify TestMaxRetriesEnv is set to DefaultTestMaxRetries
+	t.Run("sets TestMaxRetriesEnv (MAX_RETRIES) to DefaultTestMaxRetries", func(t *testing.T) {
+		expected := strconv.Itoa(DefaultTestMaxRetries)
+		actual := os.Getenv(TestMaxRetriesEnv)
+		if actual != expected {
+			t.Errorf("Expected MAX_RETRIES=%s, got %s", expected, actual)
+		}
+	})
+
+	// Verify TestModeEnv is set to "true"
+	t.Run("sets TestModeEnv (ZAI_PROXY_TEST_MODE) to true", func(t *testing.T) {
+		actual := os.Getenv(TestModeEnv)
+		if actual != "true" {
+			t.Errorf("Expected ZAI_PROXY_TEST_MODE=true, got %s", actual)
+		}
+	})
+
+	// Verify DEPLOYMENT_VARIANT is set to "test"
+	t.Run("sets DEPLOYMENT_VARIANT to test", func(t *testing.T) {
+		actual := os.Getenv("DEPLOYMENT_VARIANT")
+		if actual != "test" {
+			t.Errorf("Expected DEPLOYMENT_VARIANT=test, got %s", actual)
+		}
+	})
+
+	// Verify TOKEN_COUNTING_ENABLED is set to "false"
+	t.Run("sets TOKEN_COUNTING_ENABLED to false", func(t *testing.T) {
+		actual := os.Getenv("TOKEN_COUNTING_ENABLED")
+		if actual != "false" {
+			t.Errorf("Expected TOKEN_COUNTING_ENABLED=false, got %s", actual)
+		}
+	})
+
+	// Verify RATE_LIMIT_INITIAL is set to "1000"
+	t.Run("sets RATE_LIMIT_INITIAL to 1000", func(t *testing.T) {
+		actual := os.Getenv("RATE_LIMIT_INITIAL")
+		if actual != "1000" {
+			t.Errorf("Expected RATE_LIMIT_INITIAL=1000, got %s", actual)
+		}
+	})
+
+	// Verify RATE_LIMIT_MIN is set to "1000"
+	t.Run("sets RATE_LIMIT_MIN to 1000", func(t *testing.T) {
+		actual := os.Getenv("RATE_LIMIT_MIN")
+		if actual != "1000" {
+			t.Errorf("Expected RATE_LIMIT_MIN=1000, got %s", actual)
+		}
+	})
+
+	// Verify RATE_LIMIT_MAX is set to "1000"
+	t.Run("sets RATE_LIMIT_MAX to 1000", func(t *testing.T) {
+		actual := os.Getenv("RATE_LIMIT_MAX")
+		if actual != "1000" {
+			t.Errorf("Expected RATE_LIMIT_MAX=1000, got %s", actual)
+		}
+	})
+
+	// Restore original values
+	if origTestMode != "" {
+		os.Setenv(TestModeEnv, origTestMode)
+	} else {
+		os.Unsetenv(TestModeEnv)
+	}
+	if origMaxRetries != "" {
+		os.Setenv(TestMaxRetriesEnv, origMaxRetries)
+	} else {
+		os.Unsetenv(TestMaxRetriesEnv)
+	}
+	if origDeploymentVariant != "" {
+		os.Setenv("DEPLOYMENT_VARIANT", origDeploymentVariant)
+	} else {
+		os.Unsetenv("DEPLOYMENT_VARIANT")
+	}
+	if origTokenCounting != "" {
+		os.Setenv("TOKEN_COUNTING_ENABLED", origTokenCounting)
+	} else {
+		os.Unsetenv("TOKEN_COUNTING_ENABLED")
+	}
+	if origRateLimitInitial != "" {
+		os.Setenv("RATE_LIMIT_INITIAL", origRateLimitInitial)
+	} else {
+		os.Unsetenv("RATE_LIMIT_INITIAL")
+	}
+	if origRateLimitMin != "" {
+		os.Setenv("RATE_LIMIT_MIN", origRateLimitMin)
+	} else {
+		os.Unsetenv("RATE_LIMIT_MIN")
+	}
+	if origRateLimitMax != "" {
+		os.Setenv("RATE_LIMIT_MAX", origRateLimitMax)
+	} else {
+		os.Unsetenv("RATE_LIMIT_MAX")
+	}
+}