fix: testMultipleRequestsWithMaxBatchSize

Author: ZirgVoice

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.10
+// swift-tools-version:5.9
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription

Sources/AsyncDataLoader/Channel/Channel.swift

@@ -1,8 +1,8 @@
-internal actor Channel<Success: Sendable, Failure: Error>: Sendable {
+actor Channel<Success: Sendable, Failure: Error>: Sendable {
     private var state = State<Success, Failure>()
 }
 
-internal extension Channel {
+extension Channel {
     @discardableResult
     func fulfill(_ value: Success) async -> Bool {
         if await state.result == nil {
@@ -16,7 +16,7 @@ internal extension Channel {
 
             return false
         }
-        
+
         return true
     }
 

Sources/AsyncDataLoader/DataLoader.swift

@@ -6,8 +6,12 @@ public enum DataLoaderValue<T: Sendable>: Sendable {
     case failure(Error)
 }
 
-public typealias BatchLoadFunction<Key: Hashable & Sendable, Value: Sendable> = @Sendable (_ keys: [Key]) async throws -> [DataLoaderValue<Value>]
-private typealias LoaderQueue<Key: Hashable & Sendable, Value: Sendable> = [(key: Key, channel: Channel<Value, Error>)]
+public typealias BatchLoadFunction<Key: Hashable & Sendable, Value: Sendable> =
+    @Sendable (_ keys: [Key]) async throws -> [DataLoaderValue<Value>]
+private typealias LoaderQueue<Key: Hashable & Sendable, Value: Sendable> = [(
+    key: Key,
+    channel: Channel<Value, Error>
+)]
 
 /// DataLoader creates a public API for loading data from a particular
 /// data back-end with unique keys such as the id column of a SQL table
@@ -61,7 +65,11 @@ public actor DataLoader<Key: Hashable & Sendable, Value: Sendable> {
                     let results = try await self.batchLoadFunction([key])
 
                     if results.isEmpty {
-                        await channel.fail(DataLoaderError.noValueForKey("Did not return value for key: \(key)"))
+                        await channel
+                            .fail(
+                                DataLoaderError
+                                    .noValueForKey("Did not return value for key: \(key)")
+                            )
                     } else {
                         let result = results[0]
 
@@ -190,7 +198,10 @@ public actor DataLoader<Key: Hashable & Sendable, Value: Sendable> {
             let values = try await batchLoadFunction(keys)
 
             if values.count != keys.count {
-                throw DataLoaderError.typeError("The function did not return an array of the same length as the array of keys. \nKeys count: \(keys.count)\nValues count: \(values.count)")
+                throw DataLoaderError
+                    .typeError(
+                        "The function did not return an array of the same length as the array of keys. \nKeys count: \(keys.count)\nValues count: \(values.count)"
+                    )
             }
 
             for entry in batch.enumerated() {

Tests/AsyncDataLoaderTests/DataLoaderTests.swift

@@ -21,9 +21,9 @@ actor Concurrent<T> {
 }
 
 /// Primary API
-///The `try await Task.sleep(nanoseconds: 2_000_000)` introduces a small delay to simulate asynchronous
-///behavior and ensure that concurrent requests (`value1`, `value2`...) are grouped into a single batch
-///for processing, as intended by the batching settings.
+/// The `try await Task.sleep(nanoseconds: 2_000_000)` introduces a small delay to simulate
+/// asynchronous behavior and ensure that concurrent requests (`value1`, `value2`...)
+/// are grouped into a single batch for processing, as intended by the batching settings.
 final class DataLoaderTests: XCTestCase {
     /// Builds a really really simple data loader'
     func testReallyReallySimpleDataLoader() async throws {
@@ -126,16 +126,18 @@ final class DataLoaderTests: XCTestCase {
 
         XCTAssertNil(didFailWithError)
 
-        let (result1, result2) = try await (value1, value2)
+        let result1 = try await value1
+        let result2 = try await value2
         let result3 = try await value3
 
         XCTAssertEqual(result1, 1)
         XCTAssertEqual(result2, 2)
         XCTAssertEqual(result3, 3)
 
         let calls = await loadCalls.wrappedValue
-
-        XCTAssertEqual(calls.map { $0.sorted() }, [[1, 2], [3]])
+        
+        XCTAssertEqual(calls.first?.count, 2)
+        XCTAssertEqual(calls.last?.count, 1)
     }
 
     /// Coalesces identical requests