How do you unit-test the purchase and entitlement logic when Product and Transaction cannot be created in a test?

Predict first

Do three tests of the store logic against a fake backend pass in a real Swift package?

// === Package.swift ===
// swift-tools-version: 6.0
import PackageDescription
let package = Package(name: "StoreCore", targets: [
    .target(name: "StoreCore"),
    .testTarget(name: "StoreCoreTests", dependencies: ["StoreCore"]),
])
// === Sources/StoreCore/StoreCore.swift ===
public struct Offer: Equatable, Sendable { public let id: String; public let price: Int
    public init(id: String, price: Int) { self.id = id; self.price = price } }
public protocol StoreBackend: Sendable {
    func offers(for ids: [String]) async throws -> [Offer]
    func entitled() async -> Set<String>
}
public struct StoreFailure: Error, Equatable { public init() {} }
public actor StoreModel {
    public private(set) var offers: [Offer] = []
    public private(set) var missing: [String] = []
    public private(set) var entitled: Set<String> = []
    public private(set) var loadFailed = false
    private let ids: [String]; private let backend: StoreBackend
    public init(ids: [String], backend: StoreBackend) { self.ids = ids; self.backend = backend }
    public func load() async {
        do {
            let found = try await backend.offers(for: ids)
            offers = found.sorted { $0.price < $1.price }
            missing = ids.filter { id in !found.contains { $0.id == id } }
            loadFailed = false
        } catch { offers = []; missing = ids; loadFailed = true }
        entitled = await backend.entitled()
    }
    public func isUnlocked(_ id: String) -> Bool { entitled.contains(id) }
}
// === Tests/StoreCoreTests/StoreCoreTests.swift ===
import Testing
@testable import StoreCore

struct Fake: StoreBackend {
    var found: [Offer] = []; var owned: Set<String> = []; var fail = false
    func offers(for ids: [String]) async throws -> [Offer] { if fail { throw StoreFailure() }; return found }
    func entitled() async -> Set<String> { owned }
}
@Test func sortsAndReportsMissingIDs() async {
    let model = StoreModel(ids: ["a", "b", "c"], backend: Fake(found: [Offer(id: "b", price: 9), Offer(id: "a", price: 3)]))
    await model.load()
    #expect(await model.offers.map(\.id) == ["a", "b"])
    #expect(await model.missing == ["c"])
}
@Test func unlocksOnlyOwnedProducts() async {
    let model = StoreModel(ids: ["pro"], backend: Fake(found: [Offer(id: "pro", price: 5)], owned: ["pro"]))
    await model.load()
    #expect(await model.isUnlocked("pro"))
    #expect(await model.isUnlocked("other") == false)
}
@Test func aFailedLoadIsVisibleNotSilent() async {
    let model = StoreModel(ids: ["pro"], backend: Fake(fail: true))
    await model.load()
    #expect(await model.loadFailed)
    #expect(await model.offers.isEmpty)
}

• Yes: all three tests pass
• No: actors cannot be tested
• The missing-id test fails