diff --git a/Example/RealmDAOTests/RealmDAOBookTests.swift b/Example/RealmDAOTests/RealmDAOBookTests.swift index 83bdb6f..6ce2b11 100644 --- a/Example/RealmDAOTests/RealmDAOBookTests.swift +++ b/Example/RealmDAOTests/RealmDAOBookTests.swift @@ -11,33 +11,41 @@ import DAO @testable import DAO_Example -class RealmDAOBookTests: XCTestCase { +final class RealmDAOBookTests: XCTestCase { - let dao = RealmDAO(RLMBookTranslator()) + private var dao: RealmDAO! + override func setUp() { + super.setUp() + + dao = RealmDAO(RLMBookTranslator()) + } + + override func tearDown() { + super.tearDown() + + try! dao.erase() + dao = nil + } func testPersist() { - let book = Book(entityId: "book1", name: "Swift", authors: ["Chris Lattner"], - dates: [Date(timeIntervalSince1970: 1000000)], - pages: [100, 200], attachments: [Data()]) + let book = Book( + entityId: "book1", + name: "Swift", + authors: ["Chris Lattner"], + dates: [Date(timeIntervalSince1970: 1000000)], + pages: [100, 200], + attachments: [Data()] + ) - do { - try dao.persist(book) - } catch { - XCTFail("Persist is failed") - } - - if let savedBook = dao.read(book.entityId) { - XCTAssertEqual(book, savedBook) - XCTAssertFalse(savedBook.authors.isEmpty) - XCTAssertEqual(savedBook.authors.first, "Chris Lattner") - XCTAssertFalse(savedBook.dates.isEmpty) - XCTAssertFalse(savedBook.pages.isEmpty) - XCTAssertEqual(savedBook.pages.count, 2) - XCTAssertFalse(savedBook.attachments.isEmpty) - } else { - XCTFail("Persist is failed") - } + XCTAssertNoThrow(try dao.persist(book), "Persist is failed") + XCTAssertEqual(book, dao.read(book.entityId), "Persist is failed") + XCTAssertFalse((dao.read(book.entityId)?.authors.isEmpty) == true, "Persist is failed") + XCTAssertEqual(dao.read(book.entityId)?.authors.first, "Chris Lattner", "Persist is failed") + XCTAssertFalse((dao.read(book.entityId)?.dates.isEmpty) == true, "Persist is failed") + XCTAssertFalse((dao.read(book.entityId)?.pages.isEmpty) == true, "Persist is failed") + XCTAssertEqual(dao.read(book.entityId)?.pages.count, 2, "Persist is failed") + XCTAssertFalse((dao.read(book.entityId)?.attachments.isEmpty) == true, "Persist is failed") } } diff --git a/Example/RealmDAOTests/RealmDAOEntityTests.swift b/Example/RealmDAOTests/RealmDAOEntityTests.swift index c6b9f54..188e1ea 100644 --- a/Example/RealmDAOTests/RealmDAOEntityTests.swift +++ b/Example/RealmDAOTests/RealmDAOEntityTests.swift @@ -12,23 +12,28 @@ import DAO final class RealmDAOEntityTests: XCTestCase { - - let dao = RealmDAO(RLMEntityTranslator()) + + private var dao: RealmDAO! + + override func setUp() { + super.setUp() + + dao = RealmDAO(RLMEntityTranslator()) + } + + override func tearDown() { + super.tearDown() + + try! dao.erase() + dao = nil + } func testReadById() { let entity = Entity(entityId: "2") - do { - try dao.persist(entity) - } catch { - XCTFail("Persist is failed") - } - - if let savedEntity = dao.read("2") { - XCTAssertEqual(entity, savedEntity) - } else { - XCTFail("Read is failed") - } + + XCTAssertNoThrow(try dao.persist(entity), "Persist is failed") + XCTAssertEqual(entity, dao.read("2"), "Read is failed") } @@ -37,120 +42,64 @@ final class RealmDAOEntityTests: XCTestCase { let exp = expectation(description: "") DispatchQueue.global().async { - do { - try self.dao.persist(entity) - } catch { - XCTFail("Async read by id is failed") - } + XCTAssertNotNil(try? self.dao.persist(entity), "Async read by id is failed") - DispatchQueue.main.async { - if let savedEntity = self.dao.read("2_back") { - XCTAssertEqual(savedEntity.entityId, entity.entityId) - } else { - XCTFail("Async read by id is failed") - } + DispatchQueue.global().async { + XCTAssertEqual(self.dao.read("2_back")?.entityId, entity.entityId, "Async read by id is failed") exp.fulfill() } } - waitForExpectations(timeout: 5) { error in - if error != nil { - XCTFail("Async read by id is failed") - } - XCTAssert(true) - } + waitForExpectations(timeout: 5) } - func testPersist() { let entity = Entity(entityId: "1") - do { - try dao.persist(entity) - } catch { - XCTFail("Saving entity is failed") - } + XCTAssertNoThrow(try dao.persist(entity), "Saving entity is failed") XCTAssert(true) } - func testPersistAll() { let firstEntity = Entity(entityId: "2") let secondEntity = Entity(entityId: "3") - do { - try dao.persist([firstEntity, secondEntity]) - } catch { - XCTFail("Saving entities is failed") - } - - XCTAssert(true) + XCTAssertNoThrow(try dao.persist([firstEntity, secondEntity]), "Saving entities is failed") } - func testAsyncPersist() { + let entity = Entity(entityId: "1_back") let exp = expectation(description: "") DispatchQueue.global().async { - let entity = Entity(entityId: "1_back") - do { - try self.dao.persist(entity) - } catch { - XCTFail("Saving entity in background is failed") - } - + XCTAssertNotNil(try? self.dao.persist(entity), "Saving entity in background is failed") exp.fulfill() } - waitForExpectations(timeout: 5) { error in - if error != nil { - XCTFail("Saving entity in background is failed") - } - XCTAssert(true) - } + waitForExpectations(timeout: 5) } - func testEraseById() { let entity = Entity(entityId: "3") - do { - try dao.persist(entity) - try dao.erase("3") - } catch { - XCTFail("Erase is failed") - } - + + XCTAssertNoThrow(try dao.persist(entity), "Erase is failed") + XCTAssertNoThrow(try dao.erase("3"), "Erase is failed") XCTAssertNil(dao.read("3")) } - func testAsyncEraseById() { let entity = Entity(entityId: "2_back") - do { - try dao.persist(entity) - } catch { - XCTFail("Async erase by id is failed") - } + XCTAssertNoThrow(try dao.persist(entity), "Async erase by id is failed") let exp = expectation(description: "") DispatchQueue.global().async { - do { - try self.dao.erase("2_back") - } catch { - XCTFail("Async erase by id is failed") - } - + XCTAssertNotNil(try? self.dao.erase("2_back"), "Async erase by id is failed") exp.fulfill() } - waitForExpectations(timeout: 5) { error in - if error != nil { - XCTFail("Async erase by id is failed") - } - XCTAssert(true) - } + waitForExpectations(timeout: 5) } } diff --git a/Example/RealmDAOTests/RealmDAOFolderTests.swift b/Example/RealmDAOTests/RealmDAOFolderTests.swift index 3721445..d691c1e 100644 --- a/Example/RealmDAOTests/RealmDAOFolderTests.swift +++ b/Example/RealmDAOTests/RealmDAOFolderTests.swift @@ -13,33 +13,34 @@ import DAO final class RealmDAOFolderTests: XCTestCase { - let messageDAO = RealmDAO(RLMMessageTranslator()) + private var messageDAO: RealmDAO! + private var folderDAO: RealmDAO! - let folderDAO = RealmDAO(RLMFolderTranslator()) + override func setUp() { + super.setUp() + + messageDAO = RealmDAO(RLMMessageTranslator()) + folderDAO = RealmDAO(RLMFolderTranslator()) + } + override func tearDown() { + super.tearDown() + + try! messageDAO.erase() + try! folderDAO.erase() + + messageDAO = nil + folderDAO = nil + } func testCascadeErase() { let message = Message(entityId: "V.message", text: "V.message.text") let folder = Folder(entityId: "V", name: "Delete", messages: [message]) - do { - try folderDAO.persist(folder) - } catch { - XCTFail("Persist folder is failed") - } - - let savedMessage = messageDAO.read("V.message") - - XCTAssertNotNil(savedMessage) - - do { - try folderDAO.erase("V") - } catch { - XCTFail("Erase folder is failed") - } - + XCTAssertNoThrow(try folderDAO.persist(folder), "Persist folder is failed") + XCTAssertNotNil(messageDAO.read("V.message")) + XCTAssertNoThrow(try folderDAO.erase("V"), "Erase folder is failed") XCTAssertNil(messageDAO.read("V.message")) } - } diff --git a/Example/RealmDAOTests/RealmDAOMessagesTests.swift b/Example/RealmDAOTests/RealmDAOMessagesTests.swift index f69eeea..cd268f4 100644 --- a/Example/RealmDAOTests/RealmDAOMessagesTests.swift +++ b/Example/RealmDAOTests/RealmDAOMessagesTests.swift @@ -13,48 +13,40 @@ import DAO final class RealmDAOMessagesTests: XCTestCase { - let dao = RealmDAO(RLMMessageTranslator()) - + private var dao: RealmDAO! override func setUp() { - try? dao.erase() + super.setUp() + + dao = RealmDAO(RLMMessageTranslator()) } + override func tearDown() { + super.tearDown() + + try! dao.erase() + dao = nil + } func testPersistMessage() { let message = Message(entityId: "abc", text: "text") - do { - try dao.persist(message) - } catch { - XCTFail("Persist is failed") - } - + XCTAssertNoThrow(try dao.persist(message), "Persist is failed") XCTAssertEqual(message, dao.read(message.entityId)) } - func testReadMessage() { let message = Message(entityId: "def", text: "text 2") - do { - try dao.persist(message) - } catch { - XCTFail("Persist is failed") - } + XCTAssertNoThrow(try dao.persist(message), "Persist is failed") XCTAssertEqual(message, dao.read("def")) } - func testEraseMessage() { let message = Message(entityId: "ghi", text: "text 2") - do { - try dao.persist(message) - try dao.erase("ghi") - } catch { - XCTFail("Persist or erase is failed") - } + XCTAssertNoThrow(try dao.persist(message), "Persist or erase is failed") + XCTAssertNoThrow(try dao.erase("ghi"), "Persist or erase is failed") XCTAssertNil(dao.read("ghi")) } @@ -65,12 +57,7 @@ final class RealmDAOMessagesTests: XCTestCase { let message2 = Message(entityId: "2", text: "2") let message3 = Message(entityId: "3", text: "3") - do { - try dao.persist([message1, message2, message3]) - } catch { - XCTFail("Persist is failed") - } - + XCTAssertNoThrow(try dao.persist([message1, message2, message3]), "Persist is failed") let threeMessages = dao.read() XCTAssertEqual(threeMessages.count, 3) @@ -81,11 +68,7 @@ final class RealmDAOMessagesTests: XCTestCase { let message55 = Message(entityId: "55", text: "55") let message66 = Message(entityId: "66", text: "66") - do { - try dao.persist([message1, message2, message3, message55, message66]) - } catch { - XCTFail("Persist is failed") - } + XCTAssertNoThrow(try dao.persist([message1, message2, message3, message55, message66]), "Persist is failed") let fiveMessages = dao.read()