CacheStore

import CacheStore
import SwiftUI

struct Post: Codable, Hashable {
    var id: Int
    var userId: Int
    var title: String
    var body: String
}

enum StoreKey {
    case url
    case posts
    case isLoading
}

enum Action {
    case fetchPosts
    case postsResponse(Result<[Post], Error>)
}

extension String: Error { }

struct Dependency {
    var fetchPosts: (URL) async -> Result<[Post], Error>
}

extension Dependency {
    static var mock: Dependency {
        Dependency(
            fetchPosts: { _ in
                sleep(1)
                return .success([Post(id: 1, userId: 1, title: "Mock", body: "Post")])
            }
        )
    }
    
    static var live: Dependency {
        Dependency { url in
            do {
                let (data, _) = try await URLSession.shared.data(from: url)
                return .success(try JSONDecoder().decode([Post].self, from: data))
            } catch {
                return .failure(error)
            }
        }
    }
}

let actionHandler = StoreActionHandler<StoreKey, Action, Dependency> { cacheStore, action, dependency in
    switch action {
    case .fetchPosts:
        struct FetchPostsID: Hashable { }
        
        guard let url = cacheStore.get(.url, as: URL.self) else {
            return ActionEffect(.postsResponse(.failure("Key `.url` was not a URL")))
        }
        
        cacheStore.set(value: true, forKey: .isLoading)
        
        return ActionEffect(id: FetchPostsID()) {
            .postsResponse(await dependency.fetchPosts(url))
        }
        
    case let .postsResponse(.success(posts)):
        cacheStore.set(value: false, forKey: .isLoading)
        cacheStore.set(value: posts, forKey: .posts)
        
    case let .postsResponse(.failure(error)):
        cacheStore.set(value: false, forKey: .isLoading)
    }
    
    return .none
}

struct ContentView: View {
    @ObservedObject var store: Store<StoreKey, Action, Dependency> = .init(
        initialValues: [
            .url: URL(string: "https://jsonplaceholder.typicode.com/posts")!
        ],
        actionHandler: actionHandler,
        dependency: .live
    )
        .debug
    
    private var isLoading: Bool {
        store.get(.isLoading, as: Bool.self) ?? true
    }
    
    var body: some View {
        if
            !isLoading,
            let posts = store.get(.posts, as: [Post].self)
        {
            List(posts, id: \.self) { post in
                Text(post.title)
            }
        } else {
            ProgressView()
                .onAppear {
                    store.handle(action: .fetchPosts)
                }
        }
    }
}

import CacheStore
import XCTest
@testable import CacheStoreDemo

class CacheStoreDemoTests: XCTestCase {
    func testExample_success() throws {
        let store = TestStore(
            initialValues: [
                .url: URL(string: "https://jsonplaceholder.typicode.com/posts") as Any
            ],
            actionHandler: actionHandler,
            dependency: .mock
        )
        
        store.send(.fetchPosts) { cacheStore in
            cacheStore.set(value: true, forKey: .isLoading)
        }
        store.send(.fetchPosts) { cacheStore in
            cacheStore.set(value: true, forKey: .isLoading)
        }
        
        let expectedPosts: [Post] = [Post(id: 1, userId: 1, title: "Mock", body: "Post")]
        
        store.receive(.postsResponse(.success(expectedPosts))) { cacheStore in
            cacheStore.set(value: false, forKey: .isLoading)
            cacheStore.set(value: expectedPosts, forKey: .posts)
        }
    }
    
    func testExample_failure() throws {
        let store = TestStore(
            initialValues: [
                :
            ],
            actionHandler: actionHandler,
            dependency: .mock
        )
        
        store.send(.fetchPosts, expecting: { _ in })
        
        store.receive(.postsResponse(.failure("Key `.url` was not a URL"))) { cacheStore in
            cacheStore.set(value: false, forKey: .isLoading)
        }
    }
}