Redesign subscription catalog and transaction runtime

.github/workflows/ci.yml

@@ -92,7 +92,7 @@ jobs:
             -destination 'generic/platform=macOS' \
             -derivedDataPath .build/docc-ci
 
-      - name: Build external consumer fixture
+      - name: Build and test external consumer fixture
         working-directory: Fixtures/ExternalConsumer
         run: |
           swift package resolve
@@ -101,7 +101,7 @@ jobs:
             echo "External consumer resolved an app-only dependency." >&2
             exit 1
           fi
-          swift build --build-system swiftbuild
+          swift test --build-system swiftbuild
 
   supported-platform-builds:
     name: Test Build (${{ matrix.name }})
@@ -154,7 +154,7 @@ jobs:
             CODE_SIGNING_REQUIRED=NO
 
   ios-tests:
-    name: Package Tests (iOS Simulator)
+    name: Package and StoreKit Tests (iOS Simulator)
     runs-on: macos-26
     timeout-minutes: 10
     env:
@@ -195,8 +195,9 @@ jobs:
       - name: Run iOS Simulator tests
         run: |
           xcodebuild test \
-            -scheme StoreTransactionKit \
+            -scheme StoreTransactionKit-Package \
             -destination "platform=iOS Simulator,id=${SIMULATOR_ID}" \
+            -parallel-testing-enabled NO \
             CODE_SIGNING_ALLOWED=NO \
             CODE_SIGNING_REQUIRED=NO
 

Fixtures/ExternalConsumer/Package.swift

@@ -29,6 +29,25 @@ let package = Package(
                 .defaultIsolation(nil),
                 .strictMemorySafety(),
             ]
-        )
+        ),
+        .testTarget(
+            name: "ConsumerTests",
+            dependencies: [
+                "Consumer",
+                .product(
+                    name: "StoreTransactionKit",
+                    package: "StoreTransactionKit"
+                ),
+                .product(
+                    name: "StoreTransactionKitTesting",
+                    package: "StoreTransactionKit"
+                ),
+            ],
+            swiftSettings: [
+                .swiftLanguageMode(.v6),
+                .defaultIsolation(nil),
+                .strictMemorySafety(),
+            ]
+        ),
     ]
 )

Fixtures/ExternalConsumer/Sources/Consumer/Consumer.swift

@@ -1,27 +1,72 @@
 import StoreTransactionKit
 
-private enum EntitlementID: String, Hashable, Sendable {
-    case premium = "com.example.premium"
+public enum SubscriptionEntitlement: Hashable, Sendable {
+    case tier1
+    case tier2
+}
+
+public enum Plans: AutoRenewableSubscriptionGroup<SubscriptionEntitlement> {
+    public static let id = SubscriptionGroupID(
+        rawValue: "external-consumer.subscription-group"
+    )
+
+    public enum ProductID: String, Hashable, Sendable {
+        case tier1_Monthly = "external-consumer.subscription.tier1.monthly"
+        case tier1_Yearly = "external-consumer.subscription.tier1.yearly"
+        case tier2_Monthly = "external-consumer.subscription.tier2.monthly"
+        case tier2_Yearly = "external-consumer.subscription.tier2.yearly"
+    }
+
+    public static var subscriptions: StoreSubscriptions {
+        StoreSubscription(.tier1_Monthly, entitlement: .tier1)
+        StoreSubscription(.tier1_Yearly, entitlement: .tier1)
+        StoreSubscription(.tier2_Monthly, entitlement: .tier2)
+        StoreSubscription(.tier2_Yearly, entitlement: .tier2)
+    }
+}
+
+public let subscriptionCatalog = AutoRenewableSubscriptionCatalog(Plans.self)
+
+@MainActor
+public final class NotesViewModel {
+    private let store: TransactionStore<SubscriptionEntitlement>
+
+    public var canExportPDF: Bool {
+        store.isEntitled(to: .tier1)
+    }
+
+    public init(store: TransactionStore<SubscriptionEntitlement>) {
+        self.store = store
+    }
+}
+
+public actor AppTransactionDelegate: TransactionStoreDelegate {
+    public init() {}
+
+    public func decidePolicy(
+        for transaction: StoreTransactionSnapshot
+    ) async throws -> StoreTransactionHandlingPolicy {
+        .automatic
+    }
+
+    public func didFail(
+        with failure: StoreTransactionBackgroundFailure
+    ) async {
+        print("Background failure from \(failure.source)")
+    }
 }
 
 @main
 @MainActor
 struct Consumer {
     static func main() async throws {
-        let store = TransactionStore<EntitlementID>(
-            handleTransaction: { transaction in
-                print("Handle transaction \(transaction.id)")
-            },
-            reportFailure: { failure in
-                print("Background failure from \(failure.source)")
-            }
+        let delegate = AppTransactionDelegate()
+        let store = TransactionStore(
+            subscriptionCatalog: subscriptionCatalog,
+            delegate: delegate
         )
-
-        if let activeEntitlements = store.activeEntitlements {
-            print("Active entitlements: \(activeEntitlements)")
-        } else {
-            print("Active entitlements are unresolved")
-        }
+        let viewModel = NotesViewModel(store: store)
+        print("Can export PDF: \(viewModel.canExportPDF)")
         try await store.close()
     }
 }

Fixtures/ExternalConsumer/Tests/ConsumerTests/SubscriptionAccessTests.swift

@@ -0,0 +1,24 @@
+import Consumer
+import StoreTransactionKit
+import StoreTransactionKitTesting
+import Testing
+
+@Test
+@MainActor
+func subscriptionUpdatesViewModel() async throws {
+    try await withTransactionStoreTestHarness(
+        subscriptionCatalog: subscriptionCatalog
+    ) { harness in
+        let viewModel = NotesViewModel(store: harness.store)
+
+        #expect(!viewModel.canExportPDF)
+
+        let transaction = try await harness.purchase(
+            .tier1_Monthly,
+            in: Plans.self
+        )
+
+        #expect(transaction.productID == Plans.ProductID.tier1_Monthly.rawValue)
+        #expect(viewModel.canExportPDF)
+    }
+}

Package.swift

@@ -22,17 +22,31 @@ let package = Package(
         .library(
             name: "StoreTransactionKit",
             targets: ["StoreTransactionKit"]
-        )
+        ),
+        .library(
+            name: "StoreTransactionKitTesting",
+            targets: ["StoreTransactionKitTesting"]
+        ),
     ],
     targets: [
         .target(
             name: "StoreTransactionKit",
             swiftSettings: strictSwiftSettings
         ),
+        .target(
+            name: "StoreTransactionKitTesting",
+            dependencies: ["StoreTransactionKit"],
+            swiftSettings: strictSwiftSettings
+        ),
         .testTarget(
             name: "StoreTransactionKitTests",
             dependencies: ["StoreTransactionKit"],
             swiftSettings: strictSwiftSettings
         ),
+        .testTarget(
+            name: "StoreTransactionKitTestingTests",
+            dependencies: ["StoreTransactionKitTesting"],
+            swiftSettings: strictSwiftSettings
+        ),
     ]
 )