Revert "test: improve test cases (#1099)"

This reverts commit 9ca9350.

Author: jeevatkm

circuit_breaker_test.go

@@ -46,45 +46,45 @@ func TestCircuitBreakerCountBased(t *testing.T) {
 	resp, err := c.R().Get(ts.URL + "/500")
 	assertErrorIs(t, ErrCircuitBreakerOpen, err)
 	assertNil(t, resp)
-	assertEqual(t, CircuitBreakerStateOpen, c.circuitBreaker.getState(), "expected open state after reaching failure threshold")
+	assertEqual(t, CircuitBreakerStateOpen, c.circuitBreaker.getState())
 
 	time.Sleep(resetTimeout + 50*time.Millisecond)
-	assertEqual(t, CircuitBreakerStateHalfOpen, c.circuitBreaker.getState(), "expected half-open state")
+	assertEqual(t, CircuitBreakerStateHalfOpen, c.circuitBreaker.getState())
 
 	_, err = c.R().Get(ts.URL + "/500")
 	assertError(t, err)
-	assertEqual(t, CircuitBreakerStateOpen, c.circuitBreaker.getState(), "expected open state after failure in half-open")
+	assertEqual(t, CircuitBreakerStateOpen, c.circuitBreaker.getState())
 
 	time.Sleep(resetTimeout + 50*time.Millisecond)
-	assertEqual(t, CircuitBreakerStateHalfOpen, c.circuitBreaker.getState(), "expected half-open state")
+	assertEqual(t, CircuitBreakerStateHalfOpen, c.circuitBreaker.getState())
 
 	for i := uint64(0); i < successThreshold; i++ {
 		_, err := c.R().Get(ts.URL + "/200")
 		assertNil(t, err)
 	}
-	assertEqual(t, CircuitBreakerStateClosed, c.circuitBreaker.getState(), "expected closed state after success threshold")
+	assertEqual(t, CircuitBreakerStateClosed, c.circuitBreaker.getState())
 
 	resp, err = c.R().Get(ts.URL + "/200")
 	assertNil(t, err)
 	assertEqual(t, http.StatusOK, resp.StatusCode())
 
 	_, err = c.R().Get(ts.URL + "/500")
 	assertError(t, err)
-	assertEqual(t, 1, c.circuitBreaker.sw.Get().failures, "expected failure count to be 1 after single failure in closed state")
+	assertEqual(t, 1, c.circuitBreaker.sw.Get().failures)
 
 	time.Sleep(resetTimeout)
 
 	_, err = c.R().Get(ts.URL + "/500")
 	assertError(t, err)
-	assertEqual(t, 1, c.circuitBreaker.sw.Get().failures, "expected failure count to be 1 after single failure in closed state")
+	assertEqual(t, 1, c.circuitBreaker.sw.Get().failures)
 }
 
 func TestCircuitBreaker5xxPolicy(t *testing.T) {
 	res1 := CircuitBreaker5xxPolicy(&http.Response{StatusCode: 500})
-	assertTrue(t, res1, "expected true for 5xx status code")
+	assertEqual(t, true, res1)
 
 	res2 := CircuitBreaker5xxPolicy(&http.Response{StatusCode: 200})
-	assertFalse(t, res2, "expected false for non-5xx status code")
+	assertEqual(t, false, res2)
 }
 
 func TestCircuitBreakerCountBasedOpensAndAllow(t *testing.T) {
@@ -94,30 +94,30 @@ func TestCircuitBreakerCountBasedOpensAndAllow(t *testing.T) {
 	// expected allow when state is closed
 	err1 := cb.allow()
 	assertNil(t, err1)
-	assertEqual(t, 0, cb.sw.Get().failures, "expected allow when no failures initially")
+	assertEqual(t, 0, cb.sw.Get().failures)
 
 	// expected still closed after 1 failure
 	cb.applyPolicies(fail)
 	err2 := cb.allow()
 	assertNil(t, err2)
-	assertEqual(t, 1, cb.sw.Get().failures, "expected still closed after 1 failure")
+	assertEqual(t, 1, cb.sw.Get().failures)
 
 	// expected open after reaching failure threshold
 	cb.applyPolicies(fail)
 	err3 := cb.allow()
-	assertErrorIs(t, ErrCircuitBreakerOpen, err3, "expected open after reaching failure threshold")
+	assertErrorIs(t, ErrCircuitBreakerOpen, err3)
 
 	// time.Sleep to half-open state
 	time.Sleep(25 * time.Millisecond)
-	assertEqual(t, CircuitBreakerStateHalfOpen, cb.getState(), "expected half-open state after reset timeout")
+	assertEqual(t, CircuitBreakerStateHalfOpen, cb.getState())
 
 	// expected still half-open after a failure
 	cb.applyPolicies(fail)
-	assertEqual(t, CircuitBreakerStateOpen, cb.getState(), "expected open state after failure in half-open")
+	assertEqual(t, CircuitBreakerStateOpen, cb.getState())
 
 	// expected open state on allow
 	err4 := cb.allow()
-	assertErrorIs(t, ErrCircuitBreakerOpen, err4, "expected open state on allow after failure in half-open")
+	assertErrorIs(t, ErrCircuitBreakerOpen, err4)
 }
 
 func TestCircuitBreakerCountBasedHalfOpenToClosedOnSuccess(t *testing.T) {
@@ -128,7 +128,7 @@ func TestCircuitBreakerCountBasedHalfOpenToClosedOnSuccess(t *testing.T) {
 	// expected open after failing threshold
 	cb.applyPolicies(fail)
 	err1 := cb.allow()
-	assertErrorIs(t, ErrCircuitBreakerOpen, err1, "expected open after failing threshold")
+	assertErrorIs(t, ErrCircuitBreakerOpen, err1)
 
 	// wait for resetTimeout to transition to half-open
 	deadline := time.Now().Add(200 * time.Millisecond)
@@ -139,11 +139,11 @@ func TestCircuitBreakerCountBasedHalfOpenToClosedOnSuccess(t *testing.T) {
 		time.Sleep(5 * time.Millisecond)
 	}
 	// expected half-open state after reset timeout
-	assertEqual(t, CircuitBreakerStateHalfOpen, cb.getState(), "expected half-open state after reset timeout")
+	assertEqual(t, CircuitBreakerStateHalfOpen, cb.getState())
 
 	// on success in half-open, should move to closed
 	cb.applyPolicies(ok)
-	assertEqual(t, CircuitBreakerStateClosed, cb.getState(), "expected closed state after success in half-open")
+	assertEqual(t, CircuitBreakerStateClosed, cb.getState())
 
 	// expected allow when closed
 	err := cb.allow()
@@ -166,16 +166,18 @@ func TestCircuitBreakerRatioBasedOpenToClosed(t *testing.T) {
 	// expected open after failures exceed ratio threshold
 	cb.applyPolicies(fail)
 	err2 := cb.allow()
-	assertErrorIs(t, ErrCircuitBreakerOpen, err2, "expected open after failures exceed ratio threshold")
-
+	assertErrorIs(t, ErrCircuitBreakerOpen, err2)
+	// if err := cb.allow(); err != ErrCircuitBreakerOpen {
+	// 	t.Fatalf("expected open after failures exceed ratio threshold, got %v", err)
+	// }
 	time.Sleep(25 * time.Millisecond)
 
 	// expected half-open state after reset timeout
-	assertEqual(t, CircuitBreakerStateHalfOpen, cb.getState(), "expected half-open state after reset timeout")
+	assertEqual(t, CircuitBreakerStateHalfOpen, cb.getState())
 
 	// on success in half-open, should move to closed
 	cb.applyPolicies(ok)
-	assertEqual(t, CircuitBreakerStateClosed, cb.getState(), "expected closed state after success in half-open")
+	assertEqual(t, CircuitBreakerStateClosed, cb.getState())
 }
 
 func TestCircuitBreakerNewStateAndPolicies(t *testing.T) {
@@ -205,10 +207,10 @@ func TestCircuitBreakerAllowDuringHalfOpen(t *testing.T) {
 	fail := &http.Response{StatusCode: 500}
 
 	cb.applyPolicies(fail) // opens
-	assertErrorIs(t, ErrCircuitBreakerOpen, cb.allow(), "expected open state")
+	assertErrorIs(t, ErrCircuitBreakerOpen, cb.allow())
 
 	time.Sleep(25 * time.Millisecond) // wait to transition to half-open
-	assertEqual(t, CircuitBreakerStateHalfOpen, cb.getState(), "expected half-open state")
+	assertEqual(t, CircuitBreakerStateHalfOpen, cb.getState())
 	assertNil(t, cb.allow())
 }
 
@@ -224,8 +226,8 @@ func TestCircuitBreakerOnTriggerHooks(t *testing.T) {
 
 	cb.onTriggerHooks(nil, ErrCircuitBreakerOpen)
 
-	assertTrue(t, called, "expected onTrigger hook to be called")
-	assertEqual(t, ErrCircuitBreakerOpen, gotErr, "expected error to be passed to onTrigger hook")
+	assertEqual(t, true, called)
+	assertEqual(t, ErrCircuitBreakerOpen, gotErr)
 }
 
 func TestCircuitBreakerOnStateChangeHooks(t *testing.T) {
@@ -241,9 +243,9 @@ func TestCircuitBreakerOnStateChangeHooks(t *testing.T) {
 
 	cb.onStateChangeHooks(CircuitBreakerStateClosed, CircuitBreakerStateOpen)
 
-	assertTrue(t, called)
-	assertEqual(t, CircuitBreakerStateClosed, oldState, "expected old state to be passed to onStateChange hook")
-	assertEqual(t, CircuitBreakerStateOpen, newState, "expected new state to be passed to onStateChange hook")
+	assertEqual(t, true, called)
+	assertEqual(t, CircuitBreakerStateClosed, oldState)
+	assertEqual(t, CircuitBreakerStateOpen, newState)
 }
 
 func TestCircuitBreakerMultipleHooksAreCalled(t *testing.T) {
@@ -254,14 +256,14 @@ func TestCircuitBreakerMultipleHooksAreCalled(t *testing.T) {
 	cb.OnTrigger(func(_ *Request, _ error) { triggerCount++ })
 
 	cb.onTriggerHooks(nil, ErrCircuitBreakerOpen)
-	assertEqual(t, 2, triggerCount, "expected both trigger hooks to be called")
+	assertEqual(t, 2, triggerCount)
 
 	stateCount := 0
 	cb.OnStateChange(func(_, _ CircuitBreakerState) { stateCount++ })
 	cb.OnStateChange(func(_, _ CircuitBreakerState) { stateCount++ })
 
 	cb.onStateChangeHooks(CircuitBreakerStateClosed, CircuitBreakerStateHalfOpen)
-	assertEqual(t, 2, stateCount, "expected both state change hooks to be called")
+	assertEqual(t, 2, stateCount)
 }
 
 func TestCircuitBreakerConcurrentOnTriggerRegistration(t *testing.T) {
@@ -283,7 +285,7 @@ func TestCircuitBreakerConcurrentOnTriggerRegistration(t *testing.T) {
 
 	cb.onTriggerHooks(nil, ErrCircuitBreakerOpen)
 	got := atomic.LoadInt32(&cnt)
-	assertEqual(t, int32(n), got, "expected N hooks executed")
+	assertEqual(t, int32(n), got) // expected N hooks executed
 }
 
 func TestCircuitBreakerConcurrentOnStateChangeRegistration(t *testing.T) {
@@ -305,82 +307,18 @@ func TestCircuitBreakerConcurrentOnStateChangeRegistration(t *testing.T) {
 
 	cb.onStateChangeHooks(CircuitBreakerStateClosed, CircuitBreakerStateOpen)
 	got := atomic.LoadInt32(&cnt)
-	assertEqual(t, int32(n), got, "expected N state change hooks executed")
+	assertEqual(t, int32(n), got) // expected N state change hooks executed
 }
 
-func TestCircuitBreakerSlidingWindow1SetInterval(t *testing.T) {
+func TestCircuitBreakerSlidingWindowSetInterval(t *testing.T) {
 	cb := NewCircuitBreakerWithCount(2, 1, 100*time.Millisecond)
 
 	// Verify initial interval
-	assertEqual(t, 100*time.Millisecond, cb.sw.interval, "initial interval mismatch")
+	assertEqual(t, 100*time.Millisecond, cb.sw.interval)
 
 	// Change interval to a longer duration
 	cb.sw.SetInterval(200 * time.Millisecond)
 
 	// Verify interval was changed
-	assertEqual(t, 200*time.Millisecond, cb.sw.interval, "interval not updated correctly")
-}
-
-func TestCircuitBreakerSlidingWindow2SetInterval(t *testing.T) {
-	sw := newSlidingWindow(func() totalAndFailures { return totalAndFailures{} }, 100*time.Millisecond, 5)
-	assertEqual(t, 100*time.Millisecond, sw.interval, "initial interval mismatch")
-
-	sw.SetInterval(250 * time.Millisecond)
-	assertEqual(t, 250*time.Millisecond, sw.interval, "interval not updated correctly")
-}
-
-func TestCircuitBreakerSlidingWindowConcurrentAddGet(t *testing.T) {
-	sw := newSlidingWindow(func() totalAndFailures { return totalAndFailures{} }, 200*time.Millisecond, 10)
-
-	var wg sync.WaitGroup
-	n := 200
-	wg.Add(n)
-	for i := 0; i < n; i++ {
-		go func() {
-			sw.Add(totalAndFailures{total: 1, failures: 0})
-			wg.Done()
-		}()
-	}
-	wg.Wait()
-
-	got := sw.Get()
-	assertEqual(t, n, got.total, "concurrent adds: expected total count mismatch")
-}
-
-func TestCircuitBreakerTotalAndFailuresOperations(t *testing.T) {
-	a := totalAndFailures{total: 2, failures: 1}
-	b := totalAndFailures{total: 3, failures: 2}
-
-	c := a.op(b)
-	assertEqual(t, 5, c.total, "op result incorrect, want total 5")
-	assertEqual(t, 3, c.failures, "op result incorrect, want failures 3")
-
-	inv := c.inverse()
-	assertEqual(t, -5, inv.total, "inverse result incorrect, want total -5")
-	assertEqual(t, -3, inv.failures, "inverse result incorrect, want failures -3")
-
-	empty := c.empty()
-	assertEqual(t, 0, empty.total, "empty result incorrect, want total 0")
-	assertEqual(t, 0, empty.failures, "empty result incorrect, want failures 0")
-}
-
-func TestCircuitBreakerSlidingWindowResetWhenElapsedExceedsBuckets(t *testing.T) {
-	interval := 100 * time.Millisecond
-	sw := newSlidingWindow(func() totalAndFailures { return totalAndFailures{} }, interval, 4)
-
-	// Pre-populate total and buckets to non-zero values
-	sw.values[0] = totalAndFailures{total: 5, failures: 2}
-	sw.values[1] = totalAndFailures{total: 3, failures: 1}
-	sw.total = sw.values[0].op(sw.values[1]).op(sw.total)
-
-	// Force lastStart far in the past so bucketsToAdvance >= len(values) path is taken
-	sw.lastStart = sw.lastStart.Add(-time.Duration(10) * interval)
-
-	// Add a new value; should reset buckets and only this value remains
-	sw.Add(totalAndFailures{total: 1, failures: 1})
-
-	got := sw.Get()
-	assertEqual(t, 1, got.total, "after reset expected total=1")
-	assertEqual(t, 1, got.failures, "after reset expected failures=1")
-	assertEqual(t, 0, sw.idx, "expected idx reset to 0")
+	assertEqual(t, 200*time.Millisecond, cb.sw.interval)
 }