Move tests into separate directories

Author: jberkel

SQLite.xcodeproj/project.pbxproj

@@ -63,16 +63,6 @@ extension Connection {
         }
     }
 
-    func tableInfo() throws -> [String] {
-        try run("SELECT tbl_name FROM sqlite_master WHERE type = 'table'").compactMap { row in
-            if let name = row[0] as? String, !name.starts(with: "sqlite_") {
-                return name
-            } else {
-                return nil
-            }
-        }
-    }
-
     func foreignKeyInfo(table: String) throws -> [ColumnDefinition.ForeignKey] {
         try run("PRAGMA foreign_key_list(\(table.quote()))").compactMap { row in
             if let table = row[2] as? String,      // table

Sources/SQLite/Schema/Connection+Schema.swift

@@ -0,0 +1,62 @@
+import XCTest
+import Foundation
+@testable import SQLite
+
+#if SQLITE_SWIFT_STANDALONE
+import sqlite3
+#elseif SQLITE_SWIFT_SQLCIPHER
+import SQLCipher
+#elseif os(Linux)
+import CSQLite
+#else
+import SQLite3
+#endif
+
+class ConnectionAttachTests: SQLiteTestCase {
+    func test_attach_detach_memory_database() throws {
+        let schemaName = "test"
+
+        try db.attach(.inMemory, as: schemaName)
+
+        let table = Table("attached_users", database: schemaName)
+        let name = Expression<String>("string")
+
+        // create a table, insert some data
+        try db.run(table.create { builder in
+            builder.column(name)
+        })
+        _ = try db.run(table.insert(name <- "test"))
+
+        // query data
+        let rows = try db.prepare(table.select(name)).map { $0[name] }
+        XCTAssertEqual(["test"], rows)
+
+        try db.detach(schemaName)
+    }
+
+    func test_attach_detach_file_database() throws {
+        let schemaName = "test"
+        let testDb = fixture("test", withExtension: "sqlite")
+
+        try db.attach(.uri(testDb, parameters: [.mode(.readOnly)]), as: schemaName)
+
+        let table = Table("tests", database: schemaName)
+        let email = Expression<String>("email")
+
+        let rows = try db.prepare(table.select(email)).map { $0[email] }
+        XCTAssertEqual(["[email protected]"], rows)
+
+        try db.detach(schemaName)
+    }
+
+    func test_detach_invalid_schema_name_errors_with_no_such_database() throws {
+        XCTAssertThrowsError(try db.detach("no-exist")) { error in
+            if case let Result.error(message, code, _) = error {
+                XCTAssertEqual(code, SQLITE_ERROR)
+                XCTAssertEqual("no such database: no-exist", message)
+            } else {
+                XCTFail("unexpected error: \(error)")
+            }
+        }
+    }
+}

Tests/SQLiteTests/BlobTests.swift renamed to Tests/SQLiteTests/Core/BlobTests.swift

@@ -0,0 +1,42 @@
+import XCTest
+import Foundation
+@testable import SQLite
+
+#if SQLITE_SWIFT_STANDALONE
+import sqlite3
+#elseif SQLITE_SWIFT_SQLCIPHER
+import SQLCipher
+#elseif os(Linux)
+import CSQLite
+#else
+import SQLite3
+#endif
+
+class ConnectionPragmaTests: SQLiteTestCase {
+    func test_userVersion() {
+        db.userVersion = 2
+        XCTAssertEqual(2, db.userVersion!)
+    }
+
+    func test_sqlite_version() {
+        XCTAssertTrue(db.sqliteVersion >= (3, 0, 0))
+    }
+
+    func test_foreignKeys_defaults_to_false() {
+        XCTAssertFalse(db.foreignKeys)
+    }
+
+    func test_foreignKeys_sets_value() {
+        db.foreignKeys = true
+        XCTAssertTrue(db.foreignKeys)
+    }
+
+    func test_defer_foreignKeys_defaults_to_false() {
+        XCTAssertFalse(db.deferForeignKeys)
+    }
+
+    func test_defer_foreignKeys_sets_value() {
+        db.deferForeignKeys = true
+        XCTAssertTrue(db.deferForeignKeys)
+    }
+}

Tests/SQLiteTests/Core/Connection+AttachTests.swift

@@ -111,11 +111,6 @@ class ConnectionTests: SQLiteTestCase {
         XCTAssertEqual(2, db.totalChanges)
     }
 
-    func test_userVersion() {
-        db.userVersion = 2
-        XCTAssertEqual(2, db.userVersion!)
-    }
-
     func test_prepare_preparesAndReturnsStatements() throws {
         _ = try db.prepare("SELECT * FROM users WHERE admin = 0")
         _ = try db.prepare("SELECT * FROM users WHERE admin = ?", 0)
@@ -445,51 +440,4 @@ class ConnectionTests: SQLiteTestCase {
         }
         semaphores.forEach { $0.wait() }
     }
-
-    func test_attach_detach_memory_database() throws {
-        let schemaName = "test"
-
-        try db.attach(.inMemory, as: schemaName)
-
-        let table = Table("attached_users", database: schemaName)
-        let name = Expression<String>("string")
-
-        // create a table, insert some data
-        try db.run(table.create { builder in
-            builder.column(name)
-        })
-        _ = try db.run(table.insert(name <- "test"))
-
-        // query data
-        let rows = try db.prepare(table.select(name)).map { $0[name] }
-        XCTAssertEqual(["test"], rows)
-
-        try db.detach(schemaName)
-    }
-
-    func test_attach_detach_file_database() throws {
-        let schemaName = "test"
-        let testDb = fixture("test", withExtension: "sqlite")
-
-        try db.attach(.uri(testDb, parameters: [.mode(.readOnly)]), as: schemaName)
-
-        let table = Table("tests", database: schemaName)
-        let email = Expression<String>("email")
-
-        let rows = try db.prepare(table.select(email)).map { $0[email] }
-        XCTAssertEqual(["[email protected]"], rows)
-
-        try db.detach(schemaName)
-    }
-
-    func test_detach_invalid_schema_name_errors_with_no_such_database() throws {
-        XCTAssertThrowsError(try db.detach("no-exist")) { error in
-            if case let Result.error(message, code, _) = error {
-                XCTAssertEqual(code, SQLITE_ERROR)
-                XCTAssertEqual("no such database: no-exist", message)
-            } else {
-                XCTFail("unexpected error: \(error)")
-            }
-        }
-    }
 }

Tests/SQLiteTests/Core/Connection+PragmaTests.swift

@@ -108,11 +108,6 @@ class ConnectionSchemaTests: SQLiteTestCase {
         ])
     }
 
-    func test_table_info_returns_list_of_tables() throws {
-        let tables = try db.tableInfo()
-        XCTAssertEqual(tables, ["users"])
-    }
-
     func test_foreign_key_info_empty() throws {
         try db.run("CREATE TABLE t (\"id\" INTEGER PRIMARY KEY)")
 
@@ -136,8 +131,4 @@ class ConnectionSchemaTests: SQLiteTestCase {
             .init(table: "users", column: "test_id", primaryKey: "id", onUpdate: nil, onDelete: nil)
         ])
     }
-
-    func test_sqlite_version() {
-        XCTAssertTrue(db.sqliteVersion >= (3, 0, 0))
-    }
 }

Tests/SQLiteTests/ConnectionTests.swift renamed to Tests/SQLiteTests/Core/ConnectionTests.swift

@@ -102,8 +102,12 @@ class SchemaChangerTests: SQLiteTestCase {
 
     func test_drop_table() throws {
         try schemaChanger.drop(table: "users")
-
-        let tables = try db.tableInfo()
-        XCTAssertFalse(tables.contains("users"))
+        XCTAssertThrowsError(try db.scalar(users.count)) { error in
+            if case Result.error(let message, _, _) =  error {
+                XCTAssertEqual(message, "no such table: users")
+            } else {
+                XCTFail("unexpected error \(error)")
+            }
+        }
     }
 }