716 lines
33 KiB
Swift
716 lines
33 KiB
Swift
// Copyright © 2022 Rangeproof Pty Ltd. All rights reserved.
|
|
|
|
import Foundation
|
|
import GRDB
|
|
|
|
import Quick
|
|
import Nimble
|
|
|
|
@testable import SessionUtilitiesKit
|
|
|
|
class PersistableRecordUtilitiesSpec: QuickSpec {
|
|
override class func spec() {
|
|
// MARK: Configuration
|
|
|
|
@TestState var customWriter: DatabaseQueue! = try! DatabaseQueue()
|
|
@TestState var mockStorage: Storage! = SynchronousStorage(
|
|
customWriter: customWriter,
|
|
migrationTargets: [
|
|
TestTarget.self
|
|
]
|
|
)
|
|
|
|
// MARK: - a PersistableRecord
|
|
describe("a PersistableRecord") {
|
|
// MARK: -- before running the add column migration
|
|
context("before running the add column migration") {
|
|
// MARK: ---- fails when using the standard insert
|
|
it("fails when using the standard insert") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
try TestType(columnA: "Test1", columnB: "Test1B").insert(db)
|
|
}
|
|
.to(throwError())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- fails when using the standard inserted
|
|
it("fails when using the standard inserted") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
try MutableTestType(columnA: "Test2", columnB: "Test2B").inserted(db)
|
|
}
|
|
.to(throwError())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- fails when using the standard save and the item does not already exist
|
|
it("fails when using the standard save and the item does not already exist") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
try TestType(columnA: "Test3", columnB: "Test3B").save(db)
|
|
}
|
|
.to(throwError())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- fails when using the standard saved and the item does not already exist
|
|
it("fails when using the standard saved and the item does not already exist") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
try MutableTestType(columnA: "Test4", columnB: "Test4B").saved(db)
|
|
}
|
|
.to(throwError())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- fails when using the standard upsert and the item does not already exist
|
|
it("fails when using the standard upsert and the item does not already exist") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
try TestType(columnA: "Test5", columnB: "Test5B").upsert(db)
|
|
}
|
|
.to(throwError())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- fails when using the standard mutable upsert and the item does not already exist
|
|
it("fails when using the standard mutable upsert and the item does not already exist") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
var result = MutableTestType(columnA: "Test6", columnB: "Test6B")
|
|
try result.upsert(db)
|
|
return result
|
|
}
|
|
.to(throwError())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- fails when using the standard upsert and the item already exists
|
|
it("fails when using the standard upsert and the item already exists") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
try db.execute(
|
|
sql: "INSERT INTO TestType (columnA) VALUES (?)",
|
|
arguments: StatementArguments(["Test19"])
|
|
)
|
|
try TestType(columnA: "Test19", columnB: "Test19B").upsert(db)
|
|
}
|
|
.to(throwError())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- fails when using the standard mutable upsert and the item already exists
|
|
it("fails when using the standard mutable upsert and the item already exists") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
try db.execute(
|
|
sql: "INSERT INTO MutableTestType (columnA) VALUES (?)",
|
|
arguments: StatementArguments(["Test20"])
|
|
)
|
|
var result = MutableTestType(id: 1, columnA: "Test20", columnB: "Test20B")
|
|
try result.upsert(db)
|
|
return result
|
|
}
|
|
.to(throwError())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the migration safe insert
|
|
it("succeeds when using the migration safe insert") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
try TestType(columnA: "Test7", columnB: "Test7B").migrationSafeInsert(db)
|
|
}
|
|
.toNot(throwError())
|
|
}
|
|
|
|
mockStorage.read { db in
|
|
expect(try TestType.fetchAll(db))
|
|
.toNot(beNil())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the migration safe inserted
|
|
it("succeeds when using the migration safe inserted") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
try MutableTestType(columnA: "Test8", columnB: "Test8B").migrationSafeInserted(db)
|
|
}
|
|
.toNot(throwError())
|
|
|
|
expect {
|
|
try MutableTestType(columnA: "Test9", columnB: "Test9B")
|
|
.migrationSafeInserted(db)
|
|
.id
|
|
}
|
|
.toNot(beNil())
|
|
}
|
|
|
|
mockStorage.read { db in
|
|
expect(try MutableTestType.fetchAll(db))
|
|
.toNot(beNil())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the migration safe save and the item does not already exist
|
|
it("succeeds when using the migration safe save and the item does not already exist") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
try TestType(columnA: "Test10", columnB: "Test10B").migrationSafeSave(db)
|
|
}
|
|
.toNot(throwError())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the migration safe saved and the item does not already exist
|
|
it("succeeds when using the migration safe saved and the item does not already exist") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
try MutableTestType(columnA: "Test11", columnB: "Test11B").migrationSafeSaved(db)
|
|
}
|
|
.toNot(throwError())
|
|
|
|
expect {
|
|
try MutableTestType(columnA: "Test12", columnB: "Test12B")
|
|
.migrationSafeSaved(db)
|
|
.id
|
|
}
|
|
.toNot(beNil())
|
|
}
|
|
|
|
mockStorage.read { db in
|
|
expect(try MutableTestType.fetchAll(db))
|
|
.toNot(beNil())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the migration safe upsert and the item does not already exist
|
|
it("succeeds when using the migration safe upsert and the item does not already exist") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
try TestType(columnA: "Test13", columnB: "Test13B").migrationSafeUpsert(db)
|
|
}
|
|
.toNot(throwError())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the migration safe mutable upsert and the item does not already exist
|
|
it("succeeds when using the migration safe mutable upsert and the item does not already exist") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
let result = MutableTestType(columnA: "Test14", columnB: "Test14B")
|
|
try result.migrationSafeUpsert(db)
|
|
return result
|
|
}
|
|
.toNot(throwError())
|
|
}
|
|
|
|
mockStorage.read { db in
|
|
expect(try MutableTestType.fetchAll(db))
|
|
.toNot(beNil())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the standard save and the item already exists
|
|
it("succeeds when using the standard save and the item already exists") {
|
|
/// **Note:** The built-in 'update' method only updates existing columns so this shouldn't fail
|
|
mockStorage.write { db in
|
|
expect {
|
|
try db.execute(
|
|
sql: "INSERT INTO TestType (columnA) VALUES (?)",
|
|
arguments: StatementArguments(["Test16"])
|
|
)
|
|
try TestType(columnA: "Test16", columnB: "Test16B").save(db)
|
|
}
|
|
.toNot(throwError())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the standard saved and the item already exists
|
|
it("succeeds when using the standard saved and the item already exists") {
|
|
/// **Note:** The built-in 'update' method only updates existing columns so this won't fail
|
|
/// due to the structure discrepancy but won't update the id as that only happens on insert
|
|
mockStorage.write { db in
|
|
expect {
|
|
try db.execute(
|
|
sql: "INSERT INTO MutableTestType (columnA) VALUES (?)",
|
|
arguments: StatementArguments(["Test17"])
|
|
)
|
|
_ = try MutableTestType(id: 1, columnA: "Test17", columnB: "Test17B").saved(db)
|
|
}
|
|
.toNot(throwError())
|
|
|
|
expect {
|
|
try db.execute(
|
|
sql: "INSERT INTO MutableTestType (columnA) VALUES (?)",
|
|
arguments: StatementArguments(["Test18"])
|
|
)
|
|
return try MutableTestType(id: 2, columnA: "Test18", columnB: "Test18B")
|
|
.saved(db)
|
|
.id
|
|
}
|
|
.toNot(beNil())
|
|
}
|
|
|
|
mockStorage.read { db in
|
|
let types: [MutableTestType]? = try MutableTestType.fetchAll(db)
|
|
|
|
expect(types).toNot(beNil())
|
|
expect(types?.compactMap { $0.id }.count).to(equal(types?.count))
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: -- after running the add column migration
|
|
context("after running the add column migration") {
|
|
beforeEach {
|
|
var migrator: DatabaseMigrator = DatabaseMigrator()
|
|
migrator.registerMigration(
|
|
mockStorage,
|
|
targetIdentifier: TestAddColumnMigration.target,
|
|
migration: TestAddColumnMigration.self
|
|
)
|
|
|
|
expect { try migrator.migrate(customWriter) }
|
|
.toNot(throwError())
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the standard insert
|
|
it("succeeds when using the standard insert") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
try TestType(columnA: "Test1", columnB: "Test1B").insert(db)
|
|
}
|
|
.toNot(throwError())
|
|
}
|
|
|
|
mockStorage.read { db in
|
|
expect(try TestType.fetchAll(db))
|
|
.toNot(beNil())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the standard inserted
|
|
it("succeeds when using the standard inserted") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
try MutableTestType(columnA: "Test2", columnB: "Test2B").inserted(db)
|
|
}
|
|
.toNot(throwError())
|
|
}
|
|
|
|
mockStorage.read { db in
|
|
expect(try MutableTestType.fetchAll(db))
|
|
.toNot(beNil())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the standard save and the item does not already exist
|
|
it("succeeds when using the standard save and the item does not already exist") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
try TestType(columnA: "Test3", columnB: "Test3B").save(db)
|
|
}
|
|
.toNot(throwError())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the standard saved and the item does not already exist
|
|
it("succeeds when using the standard saved and the item does not already exist") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
try MutableTestType(columnA: "Test3", columnB: "Test3B").saved(db)
|
|
}
|
|
.toNot(throwError())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the standard save and the item already exists
|
|
it("succeeds when using the standard save and the item already exists") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
try db.execute(
|
|
sql: "INSERT INTO TestType (columnA) VALUES (?)",
|
|
arguments: StatementArguments(["Test4"])
|
|
)
|
|
try TestType(columnA: "Test4", columnB: "Test4B").save(db)
|
|
}
|
|
.toNot(throwError())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the standard saved and the item already exists
|
|
it("succeeds when using the standard saved and the item already exists") {
|
|
/// **Note:** The built-in 'update' method won't update the id as that only happens on insert
|
|
mockStorage.write { db in
|
|
expect {
|
|
try db.execute(
|
|
sql: "INSERT INTO MutableTestType (columnA) VALUES (?)",
|
|
arguments: StatementArguments(["Test5"])
|
|
)
|
|
_ = try MutableTestType(id: 1, columnA: "Test5", columnB: "Test5B").saved(db)
|
|
}
|
|
.toNot(throwError())
|
|
|
|
expect {
|
|
try db.execute(
|
|
sql: "INSERT INTO MutableTestType (columnA) VALUES (?)",
|
|
arguments: StatementArguments(["Test6"])
|
|
)
|
|
return try MutableTestType(id: 2, columnA: "Test6", columnB: "Test6B")
|
|
.saved(db)
|
|
.id
|
|
}
|
|
.toNot(beNil())
|
|
}
|
|
|
|
mockStorage.read { db in
|
|
let types: [MutableTestType]? = try MutableTestType.fetchAll(db)
|
|
|
|
expect(types).toNot(beNil())
|
|
expect(types?.compactMap { $0.id }.count).to(equal(types?.count))
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the standard upsert and the item does not already exist
|
|
it("succeeds when using the standard upsert and the item does not already exist") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
try TestType(columnA: "Test7", columnB: "Test7B").upsert(db)
|
|
}
|
|
.toNot(throwError())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the standard mutable upsert and the item does not already exist
|
|
it("succeeds when using the standard mutable upsert and the item does not already exist") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
var result = MutableTestType(columnA: "Test8", columnB: "Test8B")
|
|
try result.upsert(db)
|
|
return result
|
|
}
|
|
.toNot(throwError())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the standard upsert and the item already exists
|
|
it("succeeds when using the standard upsert and the item already exists") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
try db.execute(
|
|
sql: "INSERT INTO TestType (columnA) VALUES (?)",
|
|
arguments: StatementArguments(["Test9"])
|
|
)
|
|
try TestType(columnA: "Test9", columnB: "Test9B").upsert(db)
|
|
}
|
|
.toNot(throwError())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the standard mutable upsert and the item already exists
|
|
it("succeeds when using the standard mutable upsert and the item already exists") {
|
|
/// **Note:** The built-in 'update' method won't update the id as that only happens on insert
|
|
mockStorage.write { db in
|
|
expect {
|
|
try db.execute(
|
|
sql: "INSERT INTO MutableTestType (columnA) VALUES (?)",
|
|
arguments: StatementArguments(["Test10"])
|
|
)
|
|
var result = MutableTestType(id: 1, columnA: "Test10", columnB: "Test10B")
|
|
try result.upsert(db)
|
|
return result
|
|
}
|
|
.toNot(throwError())
|
|
|
|
expect {
|
|
try db.execute(
|
|
sql: "INSERT INTO MutableTestType (columnA) VALUES (?)",
|
|
arguments: StatementArguments(["Test11"])
|
|
)
|
|
var result = MutableTestType(id: 2, columnA: "Test11", columnB: "Test11B")
|
|
try result.upsert(db)
|
|
return result.id
|
|
}
|
|
.toNot(beNil())
|
|
}
|
|
|
|
mockStorage.read { db in
|
|
let types: [MutableTestType]? = try MutableTestType.fetchAll(db)
|
|
|
|
expect(types).toNot(beNil())
|
|
expect(types?.compactMap { $0.id }.count).to(equal(types?.count))
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the migration safe insert
|
|
it("succeeds when using the migration safe insert") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
try TestType(columnA: "Test12", columnB: "Test12B").migrationSafeInsert(db)
|
|
}
|
|
.toNot(throwError())
|
|
}
|
|
|
|
mockStorage.read { db in
|
|
expect(try TestType.fetchAll(db))
|
|
.toNot(beNil())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the migration safe inserted
|
|
it("succeeds when using the migration safe inserted") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
try MutableTestType(columnA: "Test13", columnB: "Test13B").migrationSafeInserted(db)
|
|
}
|
|
.toNot(throwError())
|
|
|
|
expect {
|
|
try MutableTestType(columnA: "Test14", columnB: "Test14B")
|
|
.migrationSafeInserted(db)
|
|
.id
|
|
}
|
|
.toNot(beNil())
|
|
}
|
|
|
|
mockStorage.read { db in
|
|
expect(try MutableTestType.fetchAll(db))
|
|
.toNot(beNil())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the migration safe save and the item does not already exist
|
|
it("succeeds when using the migration safe save and the item does not already exist") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
try TestType(columnA: "Test15", columnB: "Test15B").migrationSafeSave(db)
|
|
}
|
|
.toNot(throwError())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the migration safe saved and the item does not already exist
|
|
it("succeeds when using the migration safe saved and the item does not already exist") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
try MutableTestType(columnA: "Test16", columnB: "Test16B").migrationSafeSaved(db)
|
|
}
|
|
.toNot(throwError())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the migration safe save and the item already exists
|
|
it("succeeds when using the migration safe save and the item already exists") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
try db.execute(
|
|
sql: "INSERT INTO TestType (columnA) VALUES (?)",
|
|
arguments: StatementArguments(["Test17"])
|
|
)
|
|
try TestType(columnA: "Test17", columnB: "Test17B").migrationSafeSave(db)
|
|
}
|
|
.toNot(throwError())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the migration safe saved and the item already exists
|
|
it("succeeds when using the migration safe saved and the item already exists") {
|
|
/// **Note:** The built-in 'update' method won't update the id as that only happens on insert
|
|
mockStorage.write { db in
|
|
expect {
|
|
try db.execute(
|
|
sql: "INSERT INTO MutableTestType (columnA) VALUES (?)",
|
|
arguments: StatementArguments(["Test18"])
|
|
)
|
|
_ = try MutableTestType(id: 1, columnA: "Test18", columnB: "Test18B")
|
|
.migrationSafeSaved(db)
|
|
}
|
|
.toNot(throwError())
|
|
|
|
expect {
|
|
try db.execute(
|
|
sql: "INSERT INTO MutableTestType (columnA) VALUES (?)",
|
|
arguments: StatementArguments(["Test19"])
|
|
)
|
|
return try MutableTestType(id: 2, columnA: "Test19", columnB: "Test19B")
|
|
.migrationSafeSaved(db)
|
|
.id
|
|
}
|
|
.toNot(beNil())
|
|
}
|
|
|
|
mockStorage.read { db in
|
|
let types: [MutableTestType]? = try MutableTestType.fetchAll(db)
|
|
|
|
expect(types).toNot(beNil())
|
|
expect(types?.compactMap { $0.id }.count).to(equal(types?.count))
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the migration safe upsert and the item does not already exist
|
|
it("succeeds when using the migration safe upsert and the item does not already exist") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
try TestType(columnA: "Test20", columnB: "Test20B").migrationSafeUpsert(db)
|
|
}
|
|
.toNot(throwError())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the migration safe mutable upsert and the item does not already exist
|
|
it("succeeds when using the migration safe mutable upsert and the item does not already exist") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
let result = MutableTestType(columnA: "Test21", columnB: "Test21B")
|
|
try result.migrationSafeUpsert(db)
|
|
return result
|
|
}
|
|
.toNot(throwError())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the migration safe upsert and the item already exists
|
|
it("succeeds when using the migration safe upsert and the item already exists") {
|
|
mockStorage.write { db in
|
|
expect {
|
|
try db.execute(
|
|
sql: "INSERT INTO TestType (columnA) VALUES (?)",
|
|
arguments: StatementArguments(["Test22"])
|
|
)
|
|
try TestType(columnA: "Test22", columnB: "Test22B").migrationSafeUpsert(db)
|
|
}
|
|
.toNot(throwError())
|
|
}
|
|
}
|
|
|
|
// MARK: ---- succeeds when using the migration safe mutable upsert and the item already exists
|
|
it("succeeds when using the migration safe mutable upsert and the item already exists") {
|
|
/// **Note:** The built-in 'update' method won't update the id as that only happens on insert
|
|
mockStorage.write { db in
|
|
expect {
|
|
try db.execute(
|
|
sql: "INSERT INTO MutableTestType (columnA) VALUES (?)",
|
|
arguments: StatementArguments(["Test23"])
|
|
)
|
|
let result = MutableTestType(id: 1, columnA: "Test23", columnB: "Test23B")
|
|
try result.migrationSafeUpsert(db)
|
|
return result
|
|
}
|
|
.toNot(throwError())
|
|
|
|
expect {
|
|
try db.execute(
|
|
sql: "INSERT INTO MutableTestType (columnA) VALUES (?)",
|
|
arguments: StatementArguments(["Test24"])
|
|
)
|
|
let result = MutableTestType(id: 2, columnA: "Test24", columnB: "Test24B")
|
|
try result.migrationSafeUpsert(db)
|
|
return result.id
|
|
}
|
|
.toNot(beNil())
|
|
}
|
|
|
|
mockStorage.read { db in
|
|
let types: [MutableTestType]? = try MutableTestType.fetchAll(db)
|
|
|
|
expect(types).toNot(beNil())
|
|
expect(types?.compactMap { $0.id }.count).to(equal(types?.count))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Test Types
|
|
|
|
fileprivate struct TestType: Codable, FetchableRecord, PersistableRecord, TableRecord, ColumnExpressible {
|
|
public static var databaseTableName: String { "TestType" }
|
|
|
|
public typealias Columns = CodingKeys
|
|
public enum CodingKeys: String, CodingKey, ColumnExpression {
|
|
case columnA
|
|
case columnB
|
|
}
|
|
|
|
public let columnA: String
|
|
public let columnB: String?
|
|
}
|
|
|
|
fileprivate struct MutableTestType: Codable, FetchableRecord, MutablePersistableRecord, TableRecord, ColumnExpressible {
|
|
public static var databaseTableName: String { "MutableTestType" }
|
|
|
|
public typealias Columns = CodingKeys
|
|
public enum CodingKeys: String, CodingKey, ColumnExpression {
|
|
case id
|
|
case columnA
|
|
case columnB
|
|
}
|
|
|
|
public var id: Int64?
|
|
public let columnA: String
|
|
public let columnB: String?
|
|
|
|
init(id: Int64? = nil, columnA: String, columnB: String?) {
|
|
self.id = id
|
|
self.columnA = columnA
|
|
self.columnB = columnB
|
|
}
|
|
|
|
mutating func didInsert(_ inserted: InsertionSuccess) {
|
|
self.id = inserted.rowID
|
|
}
|
|
}
|
|
|
|
fileprivate enum TestInsertTestTypeMigration: Migration {
|
|
static let target: TargetMigrations.Identifier = .test
|
|
static let identifier: String = "TestInsertTestType"
|
|
static let needsConfigSync: Bool = false
|
|
static let minExpectedRunDuration: TimeInterval = 0
|
|
static let fetchedTables: [(TableRecord & FetchableRecord).Type] = []
|
|
static let createdOrAlteredTables: [(FetchableRecord & TableRecord).Type] = [TestType.self, MutableTestType.self]
|
|
|
|
static func migrate(_ db: Database) throws {
|
|
try db.create(table: TestType.self) { t in
|
|
t.column(.columnA, .text).primaryKey()
|
|
}
|
|
|
|
try db.create(table: MutableTestType.self) { t in
|
|
t.column(.id, .integer).primaryKey(autoincrement: true)
|
|
t.column(.columnA, .text).unique()
|
|
}
|
|
}
|
|
}
|
|
|
|
fileprivate enum TestAddColumnMigration: Migration {
|
|
static let target: TargetMigrations.Identifier = .test
|
|
static let identifier: String = "TestAddColumn"
|
|
static let needsConfigSync: Bool = false
|
|
static let minExpectedRunDuration: TimeInterval = 0
|
|
static let fetchedTables: [(TableRecord & FetchableRecord).Type] = []
|
|
static let createdOrAlteredTables: [(FetchableRecord & TableRecord).Type] = [TestType.self, MutableTestType.self]
|
|
|
|
static func migrate(_ db: Database) throws {
|
|
try db.alter(table: TestType.self) { t in
|
|
t.add(.columnB, .text)
|
|
}
|
|
|
|
try db.alter(table: MutableTestType.self) { t in
|
|
t.add(.columnB, .text)
|
|
}
|
|
}
|
|
}
|
|
|
|
fileprivate struct TestTarget: MigratableTarget {
|
|
static func migrations() -> TargetMigrations {
|
|
return TargetMigrations(
|
|
identifier: .test,
|
|
migrations: (0..<100)
|
|
.map { _ in [] }
|
|
.appending([TestInsertTestTypeMigration.self])
|
|
)
|
|
}
|
|
}
|