Test iterable dict methods with multiple cache instances: ``iter, keys, values, items``

Accessing or deleting a deleted item should raise a KeyError

If we add a big file, we should delete everything.

With match_headers, requests with different headers should have different cache keys

match_headers can optionally be a list of specific headers to include

With match_headers, the same headers (in any order) should have the same cache key

Vary should be used to validate headers, if available. It should also override `match_headers` for the secondary cache key, if both are provided.

Alternating between two Accept values should not cause endless cache misses. After the first round of requests, each variant should be cached unde

Secondary Vary lookup should work correctly through redirect chains. Each Accept-Language variant should be cached under its own Vary-qualified ke

When Vary headers overlaps with ignored_parameters and the header is present on the request, it's always a cache miss (prevents cross-user cache l

With Vary + redirects, Vary should match against the last request in the redirect chain. * 1st response has `Vary: Accept` (shouldn't be matched)

Test that the mock_session fixture is working as expected

Test that the mock_session fixture is working as expected

Test that the mock_session fixture is working as expected

Multiple cache instances should see the same files.

Expect a custom error message if a parent path already exists but isn't a directory

Test normalization with different combinations of data fields

Test normalization with different dict-like classes

For serialized request body content that isn't in JSON format, no normalization is expected

Test normalization for serialized request body content

Test URL variations that should all result in the same key

Test a request body with a file-like class that doesn't support seek()

stale_if_error is aliased to old_data_on_error for backwards-compatibility

Test both instantiating directly and wrapping a `requests.Response`

`requests.Response` modifies pickling behavior. If plain `pickle` is used as a serializer, serializing `CachedResponse` should still work as expec

Test settings that make additional PRAGMA statements

POST and PUT requests with different data (raw) should be cached under different keys

read() with decode_content=False is not supported

In read-only mode, cached responses should be returned, but no new responses should be cached

In read-only mode, expired responses trigger re-fetch but don't update cache

force_refresh skips cache read, but read_only still prevents write

Test that redact_response() handles urlescaped request parameters

Test redirect caching (in separate `redirects` cache) with all types of redirect endpoints, using different numbers of consecutive redirects

Test redirect caching (in main `responses` cache) with all types of redirect endpoints

Test session and cache string representations

Just ensure that a subset of relevant attrs get included in the response repr

Test that regular __repr__ excludes default values

A per-session expiration is set, but then disabled for a single request

No per-session expiration is set, but then overridden for a single request

Pre-request expiration should also work for PreparedRequests with CachedSession.send()

The force_refresh option should send and cache a new request. Any expire_after value provided should overwrite the previous value.

The force_refresh option should also work for PreparedRequests with CachedSession.send()

only_if_cached has no effect if the response is already cached

By default, only_if_cached will not return an expired response

The only_if_cached option should also work for PreparedRequests with CachedSession.send()

only_if_cached should skip other revalidation conditions if the response isn't expired. This includes taking precedence over refresh=True.

only_if_cached *will* return an expired response if stale_if_error is also set

only_if_cached should return a 504 response if it is not already cached

The refresh option should send a conditional request, if possible

The refresh option should result in a new (unconditional) request if the cached response has no validator

The refresh option should also work for PreparedRequests with CachedSession.send()

Within this test function, requests will be mocked and not cached

Both cached and new responses should always have the following attributes

When a request results in redirects: * An alias for the redirect should be added to 'redirects' table/collection * Both the original and targe

Ensure that response data is read only once per request, whether it's cached or not

Keys can be reused and can be removed.

After a revalidation request, the response should not be updated in the cache if expiration and headers are unchanged.

After a revalidation request, the response should be updated in the cache with new expiration and/or headers (if either changed).

Test that RichMixin.__rich_repr__ informs rich about all public attributes, current values, and defaults

This test from base class doesn't apply here