Updated unit tests

Author: colemancda

Tests/CoreModelTests/CoreDataTests.swift

@@ -18,84 +18,35 @@ final class CoreDataTests: XCTestCase {
 
     func testCoreData() async throws {
 
-        let model = Model(entities: [
-            EntityDescription(entity: Person.self),
-            EntityDescription(entity: Event.self)
-        ])
+        let model = Model(entities: Person.self, Event.self)
 
         let store = NSPersistentContainer(
             name: "Test\(UUID())",
             managedObjectModel: NSManagedObjectModel(model: model)
         )
 
+        for try await store in store.loadPersistentStores() {
+            print("Loaded store", store.type, store.url?.absoluteString ?? "")
+        }
+        
         var person1 = Person(
             name: "John Appleseed",
             age: 22
         )
 
-        //store.insert(person1)
+        try await store.insert(person1)
 
         var event1 = Event(
             name: "WWDC",
-            date: Date(timeIntervalSinceNow: 60 * 60 * 24 * 10)
+            date: Date(timeIntervalSinceNow: 60 * 60 * 24 * 10),
+            people: [person1.id]
         )
 
-        //store.insert(event1)
-        
-        /*
-        do {
-            let event1 = ModelInstance(
-                entity: "Event",
-                id: "1",
-                attributes: [:],
-                relationships: [:]
-            )
-            store.insert()
-            let event = try store("Event")
-            event.setAttribute(.string("Event 1"), for: "name")
-            event.setAttribute(.date(Date()), for: "date")
-            
-            let person1 = try store.create("Person")
-            person1.setAttribute(.string("Person1"), for: "name")
-            
-            let person2 = try store.create("Person")
-            person2.setAttribute(.string("Person2"), for: "name")
-            
-            person1.setRelationship(.toMany([event]), for: "events")
-            XCTAssertEqual(event.relationship(for: "people"), .toMany([person1]))
-            XCTAssertEqual(person1.relationship(for: "events"), .toMany([event]))
-            XCTAssertEqual(person2.relationship(for: "events"), .null)
-            XCTAssertNotEqual(person2.relationship(for: "events"), .toMany([]))
-            
-            event.setRelationship(.toMany([person1, person2]), for: "people")
-            XCTAssertEqual(event.relationship(for: "people"), .toMany([person1, person2]))
-            XCTAssertEqual(person1.relationship(for: "events"), .toMany([event]))
-            XCTAssertEqual(person2.relationship(for: "events"), .toMany([event]))
-            
-            event.setRelationship(.toMany([]), for: "people")
-            XCTAssertEqual(event.relationship(for: "people"), .toMany([]))
-            XCTAssertEqual(person1.relationship(for: "events"), .toMany([]))
-            XCTAssertEqual(person2.relationship(for: "events"), .toMany([]))
-            
-            event.setRelationship(.toMany([person1]), for: "people")
-            XCTAssertEqual(event.relationship(for: "people"), .toMany([person1]))
-            XCTAssertEqual(person1.relationship(for: "events"), .toMany([event]))
-            XCTAssertEqual(person2.relationship(for: "events"), .toMany([]))
-            
-            event.setRelationship(.toMany([person1, person2]), for: "people")
-            XCTAssertEqual(person1.relationship(for: "events"), .toMany([event]))
-            XCTAssertEqual(person2.relationship(for: "events"), .toMany([event]))
-            store.delete(event)
-            
-            XCTAssert(event.isDeleted)
-            XCTAssertFalse(person1.isDeleted)
-            XCTAssertFalse(person2.isDeleted)
-            XCTAssertEqual(person1.relationship(for: "events"), .toMany([]))
-            XCTAssertEqual(person2.relationship(for: "events"), .toMany([]))
-            
-            XCTAssertEqual(try store.fetch(FetchRequest(entity: "Person")), [person1, person2])
-            XCTAssertEqual(try store.fetch(FetchRequest(entity: "Event")), [event])
-        }*/
+        try await store.insert(event1)
+        person1 = try await store.fetch(Person.self, for: person1.id)!
+        XCTAssertEqual(person1.events, [event1.id])
+        event1 = try await store.fetch(Event.self, for: event1.id)!
+        XCTAssertEqual(event1.people, [person1.id])
     }
 }
 

Tests/CoreModelTests/TestModel.swift

@@ -80,6 +80,33 @@ extension Person: Entity {
             )
         ]
     }
+    
+    init(from container: ModelData) throws {
+        guard container.entity == Self.entityName else {
+            throw DecodingError.typeMismatch(Self.self, DecodingError.Context(codingPath: [], debugDescription: "Cannot decode \(String(describing: Self.self)) from \(container.entity)"))
+        }
+        guard let id = UUID(uuidString: container.id.rawValue) else {
+            throw DecodingError.dataCorrupted(DecodingError.Context(codingPath: [], debugDescription: "Cannot decode identifier from \(container.id)"))
+        }
+        self.id = id
+        self.name = try container.decode(String.self, forKey: Person.CodingKeys.name)
+        self.created = try container.decode(Date.self, forKey: Person.CodingKeys.created)
+        self.age = try container.decode(UInt.self, forKey: Person.CodingKeys.age)
+        self.events = try container.decodeRelationship([Event.ID].self, forKey: Person.CodingKeys.events)
+    }
+    
+    func encode() -> ModelData {
+        
+        var container = ModelData(
+            entity: Self.entityName,
+            id: ObjectID(rawValue: self.id.description)
+        )
+        container.encode(self.name, forKey: Person.CodingKeys.name)
+        container.encode(self.created, forKey: Person.CodingKeys.created)
+        container.encode(self.age, forKey: Person.CodingKeys.age)
+        container.encodeRelationship(self.events, forKey: Person.CodingKeys.events)
+        return container
+    }
 }
 
 struct Event: Equatable, Hashable, Codable, Identifiable {
@@ -92,6 +119,10 @@ struct Event: Equatable, Hashable, Codable, Identifiable {
 
     var people: [Person.ID]
 
+    //var speaker: Person.ID?
+    
+    //var notes: String?
+    
     init(id: UUID = UUID(), name: String, date: Date, people: [Person.ID] = []) {
         self.id = id
         self.name = name
@@ -146,4 +177,29 @@ extension Event: Entity {
                 inverseRelationship: PropertyKey(Person.CodingKeys.events))
         ]
     }
+    
+    init(from container: ModelData) throws {
+        guard container.entity == Self.entityName else {
+            throw DecodingError.typeMismatch(Self.self, DecodingError.Context(codingPath: [], debugDescription: "Cannot decode \(String(describing: Self.self)) from \(container.entity)"))
+        }
+        guard let id = UUID(uuidString: container.id.rawValue) else {
+            throw DecodingError.dataCorrupted(DecodingError.Context(codingPath: [], debugDescription: "Cannot decode identifier from \(container.id)"))
+        }
+        self.id = id
+        self.name = try container.decode(String.self, forKey: Event.CodingKeys.name)
+        self.date = try container.decode(Date.self, forKey: Event.CodingKeys.date)
+        self.people = try container.decodeRelationship([Person.ID].self, forKey: Event.CodingKeys.people)
+    }
+    
+    func encode() -> ModelData {
+        
+        var container = ModelData(
+            entity: Self.entityName,
+            id: ObjectID(rawValue: self.id.description)
+        )
+        container.encode(self.name, forKey: Event.CodingKeys.name)
+        container.encode(self.date, forKey: Event.CodingKeys.date)
+        container.encodeRelationship(self.people, forKey: Event.CodingKeys.people)
+        return container
+    }
 }