Some tests

Author: wickwirew

Sources/Feather/Queries/Fail.swift

@@ -13,6 +13,12 @@ extension Queries {
         /// The error to throw on execution
         let error: any Error
 
+        /// Initializes a query that always fails with an error.
+        /// This is useful for unit tests and previews to test
+        /// how a part of an application behaives when an error
+        /// is thrown.
+        ///
+        /// - Parameter error: The error to throw
         public init(_ error: any Error) {
             self.error = error
         }
@@ -34,9 +40,9 @@ extension Queries {
 
             func start(
                 onChange: @escaping (Output) -> Void,
-                onError: @escaping (any Error) -> Void
+                onComplete: @escaping (Error?) -> Void
             ) {
-                onError(error)
+                onComplete(error)
             }
 
             func cancel() {}

Sources/Feather/Queries/Just.swift

@@ -56,9 +56,11 @@ extension Queries {
 
             func start(
                 onChange: @escaping (Output) -> Void,
-                onError: @escaping (any Error) -> Void
+                onComplete: @escaping (Error?) -> Void
             ) {
                 onChange(output)
+                // Complete instantly
+                onComplete(nil)
             }
 
             func cancel() {}

Sources/Feather/Queries/Map.swift

@@ -13,33 +13,34 @@ extension Queries {
         /// The upstream query to transform
         let base: Base
         /// The transform to apply to the output
-        let transform: @Sendable (Base.Output) throws -> Output
+        let transform: @Sendable (Base.Input, Base.Output) throws -> Output
 
         public func execute(with input: Base.Input) async throws -> Output {
-            try await transform(base.execute(with: input))
+            try await transform(input, base.execute(with: input))
         }
 
         public func observe(with input: Base.Input) -> any QueryObservation<Output> {
-            return Observation(base: base.observe(with: input), transform: transform)
+            return Observation(base: base.observe(with: input), input: input, transform: transform)
         }
 
         struct Observation: QueryObservation {
             let base: any QueryObservation<Base.Output>
+            let input: Base.Input
             /// The transform to apply to the output
-            let transform: @Sendable (Base.Output) throws -> Output
+            let transform: @Sendable (Base.Input, Base.Output) throws -> Output
 
             func start(
                 onChange: @escaping @Sendable (Output) -> Void,
-                onError: @escaping @Sendable (any Error) -> Void
+                onComplete: @escaping @Sendable (Error?) -> Void
             ) {
                 base.start { upstream in
                     do {
-                        try onChange(transform(upstream))
+                        try onChange(transform(input, upstream))
                     } catch {
-                        onError(error)
+                        onComplete(error)
                     }
-                } onError: { error in
-                    onError(error)
+                } onComplete: { error in
+                    onComplete(error)
                 }
             }
 
@@ -67,7 +68,7 @@ extension Queries.Map: DatabaseQuery where Base: DatabaseQuery {
         with input: Base.Input,
         tx: borrowing Transaction
     ) throws -> Output {
-        return try transform(base.execute(with: input, tx: tx))
+        return try transform(input, base.execute(with: input, tx: tx))
     }
 }
 
@@ -79,20 +80,43 @@ public extension Query {
     func map<NewOutput>(
         _ transform: @Sendable @escaping (Output) throws -> NewOutput
     ) -> Queries.Map<Self, NewOutput> {
-        return Queries.Map(base: self, transform: transform)
+        return Queries.Map(base: self) { _, entity in try transform(entity) }
     }
 
 
-    /// If a `nil` value is returned from the query, then a `FeatherError.entityWasNotFound`
-    /// will be thrown instead.
+    /// If a `nil` value is returned from the query, then an will throw an error.
     ///
+    /// The input closure for the error takes the `input` as a parameter.
+    /// This allows for less ambiguous erros to be thrown by passing an id
+    /// or any other identifying information.
+    ///
+    /// ```swift
+    /// query.throwIfNotFound { id in NotFound(id: id) }
+    /// ```
+    ///
+    /// If the `error` is `nil` then it will default to a `entityNotFound` erro
+    /// to be thrown.
+    ///
+    /// - Parameter error: A closure to construct the error to be thrown.
     /// - Returns: A query with a non optional result type, that will throw in case of an error.
-    func throwIfNotFound<Wrapped>() -> Queries.Map<Self, Wrapped> where Output == Wrapped? {
-        return Queries.Map(base: self) { entity in
-            guard let entity else {
-                throw FeatherError.entityWasNotFound
-            }
-            
+    func throwIfNotFound<Wrapped>(
+        _ error: (@Sendable (Input) -> Error)? = nil
+    ) -> Queries.Map<Self, Wrapped> where Output == Wrapped? {
+        return Queries.Map(base: self) { input, entity in
+            guard let entity else { throw error?(input) ?? FeatherError.entityWasNotFound }
+            return entity
+        }
+    }
+    
+    /// If a `nil` value is returned from the query, then an will throw an error.
+    ///
+    /// - Parameter error: The error to throw if `nil`
+    /// - Returns: A query with a non optional result type, that will throw in case of an error.
+    func throwIfNotFound<Wrapped>(
+        _ error: @Sendable @autoclosure @escaping () -> Error
+    ) -> Queries.Map<Self, Wrapped> where Output == Wrapped? {
+        return Queries.Map(base: self) { input, entity in
+            guard let entity else { throw error() }
             return entity
         }
     }
@@ -107,7 +131,7 @@ public extension Query {
     func replaceNil<Wrapped>(
         with value: @Sendable @autoclosure @escaping () -> Wrapped
     ) -> Queries.Map<Self, Wrapped> where Output == Wrapped? {
-        return Queries.Map(base: self) { entity in
+        return Queries.Map(base: self) { _, entity in
             return entity ?? value()
         }
     }

Sources/Feather/Queries/MapInput.swift

@@ -47,6 +47,8 @@ extension Queries.MapInput: DatabaseQuery where Base: DatabaseQuery {
 
 public extension Query {
     /// Transforms the input value before passing it to the query.
+    /// Allows you to change the input type of a query. Useful if
+    /// merging multiple queries together using `then`.
     ///
     /// - Parameter transform: The closure to transform the input
     /// - Returns: A query with a input type of the resulting closure.

Sources/Feather/Queries/Test.swift

@@ -35,7 +35,7 @@ extension Queries {
         public private(set) var cancelObservationCallCount = 0
         private let lock = NSLock()
 
-        public init(execute:@escaping  @Sendable (Input) throws -> Output) {
+        public init(execute: @escaping @Sendable (Input) throws -> Output) {
             self.execute = execute
         }
 
@@ -75,14 +75,15 @@ extension Queries {
 
             func start(
                 onChange: @escaping (Output) -> Void,
-                onError: @escaping (any Error) -> Void
+                onComplete: @escaping (Error?) -> Void
             ) {
                 query.incrementStartObservationCallCount()
 
                 do {
                     try onChange(query.execute(input))
+                    onComplete(nil)
                 } catch {
-                    onError(error)
+                    onComplete(error)
                 }
             }
 

Sources/Feather/QueryObservation.swift

@@ -16,7 +16,7 @@ public final class DatabaseQueryObservation<Query>: DatabaseSubscriber, QueryObs
     private let queue = Queue()
 
     private var onChange: (@Sendable (Query.Output) -> Void)?
-    private var onError: (@Sendable (Error) -> Void)?
+    private var onComplete: (@Sendable (Error?) -> Void)?
 
     init(
         query: Query,
@@ -35,7 +35,7 @@ public final class DatabaseQueryObservation<Query>: DatabaseSubscriber, QueryObs
     public func cancel() {
         lock.withLock {
             onChange = nil
-            onError = nil
+            onComplete = nil
         }
 
         query.connection.cancel(subscriber: self)
@@ -44,11 +44,11 @@ public final class DatabaseQueryObservation<Query>: DatabaseSubscriber, QueryObs
 
     public func start(
         onChange: @escaping @Sendable (Query.Output) -> Void,
-        onError: @escaping @Sendable (Error) -> Void
+        onComplete: @escaping @Sendable (Error?) -> Void
     ) {
         lock.withLock {
             self.onChange = onChange
-            self.onError = onError
+            self.onComplete = onComplete
         }
 
         query.connection.observe(subscriber: self)
@@ -68,7 +68,7 @@ public final class DatabaseQueryObservation<Query>: DatabaseSubscriber, QueryObs
             let output = try await query.execute(with: input)
             onChange(output)
         } catch {
-            onError?(error)
+            onComplete?(error)
             cancel()
         }
     }
@@ -85,7 +85,7 @@ public protocol QueryObservation<Output>: Sendable, AsyncSequence {
 
     func start(
         onChange: @escaping @Sendable (Output) -> Void,
-        onError: @escaping @Sendable (Error) -> Void
+        onComplete: @escaping @Sendable (Error?) -> Void
     )
 
     func cancel()
@@ -100,7 +100,7 @@ extension QueryObservation {
         AsyncThrowingStream<Output, Error> { continuation in
             start { output in
                 continuation.yield(output)
-            } onError: { error in
+            } onComplete: { error in
                 continuation.finish(throwing: error)
             }
 

Tests/FeatherTests/ConnectionPoolTests.swift

@@ -42,4 +42,17 @@ struct ConnectionPoolTests {
             }
         }
     }
+    
+    @Test func modificationsAreRolledBackOnError() async throws {
+        let db = try TestDB.inMemory()
+        struct Err: Error {}
+        
+        try? await db.connection.begin(.write) { tx in
+            try db.insertFoo.execute(with: 1, tx: tx)
+            throw Err()
+        }
+        
+        let foos = try await db.selectFoos.execute()
+        #expect(foos.isEmpty)
+    }
 }

Tests/FeatherTests/FailTests.swift

@@ -0,0 +1,30 @@
+//
+//  FailTests.swift
+//  Feather
+//
+//  Created by Wes Wickwire on 6/16/25.
+//
+
+import Testing
+@testable import Feather
+
+@Suite
+struct FailTests {
+    struct ExpectedError: Equatable, Error {}
+    
+    @Test func executeThrowsInputError() async {
+        let query = Queries.Fail<(), ()>(ExpectedError())
+        
+        await #expect(throws: ExpectedError.self) {
+            try await query.execute()
+        }
+    }
+    
+    @Test func observeThrowsInputError() async {
+        let query = Queries.Fail<(), ()>(ExpectedError())
+        
+        await #expect(throws: ExpectedError.self) {
+            for try await _ in query.observe() {}
+        }
+    }
+}

Tests/FeatherTests/JustTests.swift

@@ -0,0 +1,46 @@
+//
+//  JustTests.swift
+//  Feather
+//
+//  Created by Wes Wickwire on 6/16/25.
+//
+
+import Testing
+@testable import Feather
+
+@Suite
+struct JustTests {
+    @Test func executeReturnsDefinedOutput() async throws {
+        let output = try await Queries.Just<Int, String>("foo").execute(with: 1)
+        #expect(output == "foo")
+    }
+    
+    @Test func observeReturnsOutputOnceAndFinishes() async throws {
+        let query = Queries.Just<Int, String>("foo")
+        var count = 0
+        
+        for try await value in query.observe(with: 1) {
+            count += 1
+            #expect(value == "foo")
+        }
+        
+        #expect(count == 1)
+    }
+    
+    @Test func arrayOutputDefaultInitIsEmpty() async throws {
+        let query = Queries.Just<(), [String]>()
+        let output = try await query.execute()
+        #expect(output == [])
+    }
+    
+    @Test func optionalOutputDefaultInitIsNil() async throws {
+        let query = Queries.Just<(), String?>()
+        let output = try await query.execute()
+        #expect(output == nil)
+    }
+    
+    @Test func voidOutputDefaultInitIsVoid() async throws {
+        // Silly test but i dont want to delete it on accident
+        let _ = Queries.Just<(), ()>()
+    }
+}

Tests/FeatherTests/MapInputTests.swift

@@ -0,0 +1,20 @@
+//
+//  MapInputTests.swift
+//  Feather
+//
+//  Created by Wes Wickwire on 6/16/25.
+//
+
+import Testing
+@testable import Feather
+
+@Suite
+struct MapInputTests {
+    @Test func mapInputMapsInput() async throws {
+        let query = Queries.Just<String, Int>(100)
+        let newInput: any Query<Int, Int> = query.mapInput(to: Int.self) { $0.description }
+        let output = try await newInput.execute(with: 1)
+        #expect(output == 100)
+    }
+}
+