Fade transition still occurs when cache is used with downsampling enabled

[bohdany-cricut]

Check List

• I have read the wiki page and cheat sheet, but there is no information I need.
• I have searched in existing issues, but did not find a same one.
• I want to report a problem instead of asking a question. It'd better to use kingfisher tag in Stack Overflow to ask a question.

Issue Description

What

The documentation for the fade transition says that

The transition will not happen when the image is retrieved from either memory or disk cache by default

But in one particular case it seems to still being applied - when it's used with downsampling.
I noticed that my snapshot tests started to fail after I added downsampling to the KFImage I use. Upon closer look, it turned out to be that images now don't appear instantly but with a slight delay and a fade transition animation.
Here's the image setup:

KFImage
  .url(url)
  .downsampling(size: customSize)
  .fade(duration: 0.2)

And here is the cache setup:

func setup() {
    let cache = ImageCache(name: name)

    imagesToCache.forEach { (image, url) in
        let data = image.loadFromResources(.png)
        cache.store(.init(data: data)!, forKey: url, options: .init(nil))
    }

    KingfisherManager.shared.defaultOptions = [
        .onlyFromCache,
        .targetCache(cache),
    ]
}

Reproduce

Use KFImage with fade and downsampling applied along with cache being set up.
Upon retrieval images from the cache fade transition is still being applied.

Other Comment

I did try using .cacheOriginalImage but it did not make any difference.

[CraigSiemens]

I just ran into this as well.

It appears to be caused in KingfisherManager.retrieveImageFromCache

• looks for a cached processed image and fails
• then looks for the original image and succeeds
• then processes the image
• stores the processed image in the cache
• returns the cacheType as .none since the processed image was missing from the cache

It fails to find the processed image since kingfisher appends the processor identifier to the cache key when saving and restoring.

This is probably expected behaviour since the final image wasn't found in the cache so retrieving it could take long enough that the fade is needed.

---

My current workaround is to make a MockImageCache for use in the tests, which always discards the options when retrieving an image since the options are used to modify the cache key.

The one downside with this approach is it'll bypass running any processor on the image, so your snapshots wont accurately test whether the correct processor is being used.

private final class MockImageCache: ImageCache {
    override func imageCachedType(
        forKey key: String,
        processorIdentifier identifier: String = DefaultImageProcessor.default.identifier
    ) -> CacheType {
        .memory
    }
    
    override func retrieveImage(
        forKey key: String,
        options: KingfisherParsedOptionsInfo,
        callbackQueue: CallbackQueue = .mainCurrentOrAsync,
        completionHandler: ((Result<ImageCacheResult, KingfisherError>) -> Void)?
    ) {
        var options = options
        options.processor = DefaultImageProcessor.default

        super.retrieveImage(
            forKey: key,
            options: options,
            callbackQueue: callbackQueue,
            completionHandler: completionHandler
        )
    }
}