fix(rueidiscompatmock): make Cache() mockable via the expectation queue (#1023)

`rueidiscompatmock` now supports mocking client-side caching.
`Cache(ttl)` commands dispatch through the existing `Expect*`
expectation queue instead of panicking with `unexpected call to DoCache`
(issue #972). The new `DoCache` stub reuses the same ordered queue as
`Do`/`DoMulti`, so no `Expect*` API changed and the TTL argument is
deliberately not matched (documented in the README).

Design notes:
- The fix lives in `rueidiscompatmock` only; `rueidiscompat` and the
root `mock/` package are untouched. This follows the maintainer's
direction on #1021 instead of the rejected interface-ization of
`CacheCompat`.
- `DoMultiCache` is not stubbed: the `rueidiscompat` cache surface never
calls it (verified against the receiver block in
`rueidiscompat/adapter.go`).

Validated with the module's full test suite including `-race`. Eight new
`TestCacheCompat*` tests cover dispatch through both adapter entry
points, multi-command queues, `Cacheable`-wrapped commands, nil/error
results, TTL irrelevance, and unmatched-command reporting.

Fixes #972.

Related: #1021

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> **Low Risk**
> Test-helper only; no production Redis client or auth/data path
changes. Matching origin (cache vs plain) is a behavior change for
existing mock tests that mix Cache() with unmarked Expect* calls.
> 
> **Overview**
> Makes `rueidiscompat.Cache(ttl)` commands mockable in
`rueidiscompatmock` instead of panicking on `DoCache`. Cached calls
reuse the existing `Expect*` queue; TTL is not matched.
> 
> Matching is origin-aware: `ExpectGet("k").ViaCache()` only matches
`rdb.Cache(ttl).Get(...)`, and unmarked expectations only match plain
calls. Unordered matching still prefers the origin-specific entry rather
than the first same-command expectation.
> 
> `ViaCache()` is added on all expected-result types. Unmatched cache
calls report `via cache` in the error. `DoMultiCache` is not stubbed.
> 
> <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit
def365b. Bugbot is set up for automated
code reviews on this repo. Configure
[here](https://www.cursor.com/dashboard/bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

---------

Co-authored-by: SomSamantray <>
Co-authored-by: Rueian <rueiancsie@gmail.com>

Author: SomSamantray

rueidiscompatmock/README.md

@@ -46,4 +46,35 @@ p := rdb.Pipeline()
 p.Get(ctx, "k1")
 p.Set(ctx, "k2", "v2", 0)
 p.Exec(ctx)
+```
+
+### Client-side caching example
+
+Cached commands (`Cache(ttl)`) use the same `Expect*` calls as non-cached
+commands, but expectation matching is origin-aware: a call made through
+`Cache(ttl)` only matches an expectation marked `ViaCache()`, and a plain call
+only matches an expectation without it. The TTL argument itself is not
+matched against expectations.
+
+```golang
+compatmock.ExpectGet("key").ViaCache().SetVal("val")
+
+cached := rdb.Cache(100 * time.Millisecond)
+cached.Get(context.Background(), "key") // matches
+
+rdb.Get(context.Background(), "key") // would NOT match the ViaCache() expectation
+```
+
+The reverse also holds: an expectation without `ViaCache()` only matches a
+plain call and will not be satisfied by a call routed through `Cache(ttl)`.
+`ExpectationsWereMet()` reports an unmatched expectation when the two origins
+are mixed.
+
+```golang
+compatmock.ExpectGet("key").SetVal("val")
+
+rdb.Get(context.Background(), "key") // matches
+
+cached := rdb.Cache(100 * time.Millisecond)
+cached.Get(context.Background(), "key") // would NOT match the plain expectation
 ```

rueidiscompatmock/adapter.go

@@ -369,16 +369,17 @@ type clientMock struct {
 }
 
 type expectation struct {
-	matcher     gomock.Matcher
-	expected    []string
-	result      rueidis.RedisResult
-	rawResult   any
-	err         error
-	resultSet   bool
-	rawSet      bool
-	redisNil    bool
-	regexpMatch bool
-	customMatch CustomMatch
+	matcher      gomock.Matcher
+	expected     []string
+	result       rueidis.RedisResult
+	rawResult    any
+	err          error
+	resultSet    bool
+	rawSet       bool
+	redisNil     bool
+	regexpMatch  bool
+	customMatch  CustomMatch
+	requireCache bool
 }
 
 type resolvedExpectation struct {
@@ -553,25 +554,38 @@ func (m *clientMock) wire() {
 	m.raw.EXPECT().
 		Do(gomock.Any(), gomock.Any()).
 		DoAndReturn(func(_ context.Context, cmd rueidis.Completed) rueidis.RedisResult {
-			return m.consume(1, []rueidis.Completed{cmd})[0]
+			return m.consume(1, []rueidis.Completed{cmd}, false)[0]
 		}).
 		AnyTimes()
 	m.raw.EXPECT().
 		DoMulti(gomock.Any(), gomock.Any()).
 		DoAndReturn(func(_ context.Context, cmds ...rueidis.Completed) []rueidis.RedisResult {
-			return m.consume(len(cmds), cmds)
+			return m.consume(len(cmds), cmds, false)
 		}).
 		AnyTimes()
+	m.raw.EXPECT().
+		DoCache(gomock.Any(), gomock.Any(), gomock.Any()).
+		DoAndReturn(func(_ context.Context, cmd rueidis.Cacheable, _ time.Duration) rueidis.RedisResult {
+			return m.consume(1, []rueidis.Completed{rueidis.Completed(cmd)}, true)[0]
+		}).
+		AnyTimes()
+}
+
+func unmatchedErr(cmd rueidis.Completed, viaCache bool) error {
+	if viaCache {
+		return fmt.Errorf("rueidiscompatmock: no expectation for command %v via cache", cmd.Commands())
+	}
+	return fmt.Errorf("rueidiscompatmock: no expectation for command %v", cmd.Commands())
 }
 
-func (m *clientMock) consume(n int, cmds []rueidis.Completed) []rueidis.RedisResult {
+func (m *clientMock) consume(n int, cmds []rueidis.Completed, viaCache bool) []rueidis.RedisResult {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	out := make([]rueidis.RedisResult, n)
 	for i, cmd := range cmds {
-		idx, ok := m.matchLocked(cmd)
+		idx, ok := m.matchLocked(cmd, viaCache)
 		if !ok {
-			err := fmt.Errorf("rueidiscompatmock: no expectation for command %v", cmd.Commands())
+			err := unmatchedErr(cmd, viaCache)
 			m.unmatched = append(m.unmatched, err)
 			out[i] = mock.ErrorResult(err)
 			for j := i + 1; j < n; j++ {
@@ -588,9 +602,9 @@ func (m *clientMock) consume(n int, cmds []rueidis.Completed) []rueidis.RedisRes
 func (m *clientMock) consumeWithRaw(cmd rueidis.Completed) resolvedExpectation {
 	m.mu.Lock()
 	defer m.mu.Unlock()
-	idx, ok := m.matchLocked(cmd)
+	idx, ok := m.matchLocked(cmd, false)
 	if !ok {
-		err := fmt.Errorf("rueidiscompatmock: no expectation for command %v", cmd.Commands())
+		err := unmatchedErr(cmd, false)
 		m.unmatched = append(m.unmatched, err)
 		return resolvedExpectation{result: mock.ErrorResult(err)}
 	}
@@ -604,25 +618,28 @@ func (m *clientMock) consumeWithRaw(cmd rueidis.Completed) resolvedExpectation {
 	return resolved
 }
 
-func (m *clientMock) matchLocked(cmd rueidis.Completed) (int, bool) {
+func (m *clientMock) matchLocked(cmd rueidis.Completed, viaCache bool) (int, bool) {
 	if m.ordered {
 		if len(m.queue) == 0 {
 			return 0, false
 		}
-		if !m.queue[0].matches(cmd) {
+		if !m.queue[0].matches(cmd, viaCache) {
 			return 0, false
 		}
 		return 0, true
 	}
 	for i, e := range m.queue {
-		if e.matches(cmd) {
+		if e.matches(cmd, viaCache) {
 			return i, true
 		}
 	}
 	return 0, false
 }
 
-func (e *expectation) matches(cmd rueidis.Completed) bool {
+func (e *expectation) matches(cmd rueidis.Completed, viaCache bool) bool {
+	if e.requireCache != viaCache {
+		return false
+	}
 	if e.customMatch == nil && !e.regexpMatch {
 		return e.matcher.Matches(cmd)
 	}