Add ExpressionTests

Author: jberkel

Sources/SQLite/Typed/Expression.swift

@@ -64,31 +64,31 @@ public struct Expression<Datatype>: ExpressionType {
 
 }
 
-public protocol Expressible {
+public protocol Expressible: CustomStringConvertible {
 
     var expression: Expression<Void> { get }
 
 }
 
 extension Expressible {
+    public var description: String {
+        asSQL()
+    }
 
     // naïve compiler for statements that can’t be bound, e.g., CREATE TABLE
     func asSQL() -> String {
         let expressed = expression
-        var idx = 0
-        return expressed.template.reduce("") { template, character in
-            let transcoded: String
+        return expressed.template.reduce(("", 0)) { memo, character in
+            let (template, index) = memo
 
             if character == "?" {
-                transcoded = transcode(expressed.bindings[idx])
-                idx += 1
+                precondition(index < expressed.bindings.count, "not enough bindings for expression")
+                return (template + transcode(expressed.bindings[index]), index + 1)
             } else {
-                transcoded = String(character)
+                return (template + String(character), index)
             }
-            return template + transcoded
-        }
+        }.0
     }
-
 }
 
 extension ExpressionType {

Tests/SQLiteTests/TestHelpers.swift

@@ -12,7 +12,7 @@ class SQLiteTestCase: XCTestCase {
         trace = [String: Int]()
 
         db.trace { SQL in
-            print(SQL)
+            // print("SQL: \(SQL)")
             self.trace[SQL, default: 0] += 1
         }
     }

Tests/SQLiteTests/Typed/ExpressionTests.swift

@@ -1,5 +1,30 @@
 import XCTest
-import SQLite
+@testable import SQLite
 
 class ExpressionTests: XCTestCase {
+
+    func test_asSQL_expression_bindings() {
+        let expression = Expression<String>("foo ? bar", ["baz"])
+        XCTAssertEqual(expression.asSQL(), "foo 'baz' bar")
+    }
+
+    func test_asSQL_expression_bindings_quoting() {
+        let expression = Expression<String>("foo ? bar", ["'baz'"])
+        XCTAssertEqual(expression.asSQL(), "foo '''baz''' bar")
+    }
+
+    func test_expression_custom_string_convertible() {
+        let expression = Expression<String>("foo ? bar", ["baz"])
+        XCTAssertEqual(expression.asSQL(), expression.description)
+    }
+
+    func test_init_literal() {
+        let expression = Expression<String>(literal: "literal")
+        XCTAssertEqual(expression.template, "literal")
+    }
+
+    func test_init_identifier() {
+        let expression = Expression<String>("identifier")
+        XCTAssertEqual(expression.template, "\"identifier\"")
+    }
 }

Tests/SQLiteTests/Typed/QueryIntegrationTests.swift

@@ -192,7 +192,12 @@ class QueryIntegrationTests: SQLiteTestCase {
         let query3 = users.select(users[*], Expression<Int>(literal: "1 AS weight")).filter(email == "sally@example.com")
         let query4 = users.select(users[*], Expression<Int>(literal: "2 AS weight")).filter(email == "alice@example.com")
 
-        print(query3.union(query4).order(Expression<Int>(literal: "weight")).asSQL())
+        let sql = query3.union(query4).order(Expression<Int>(literal: "weight")).asSQL()
+        XCTAssertEqual(sql,
+        """
+        SELECT "users".*, 1 AS weight FROM "users" WHERE ("email" = 'sally@example.com') UNION \
+        SELECT "users".*, 2 AS weight FROM "users" WHERE ("email" = 'alice@example.com') ORDER BY weight
+        """)
 
         let orderedIDs = try db.prepare(query3.union(query4).order(Expression<Int>(literal: "weight"), email)).map { $0[id] }
         XCTAssertEqual(Array(expectedIDs.reversed()), orderedIDs)