TouchInstinct
/
TIDAORealm
312
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Произведен рефакторинг тестов Dao/Realm

This commit is contained in:
Jon Fir 2018-06-15 16:08:13 +03:00
parent 8aa0b5089f
commit 4cb5e976d5
4 changed files with 99 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
Example/RealmDAOTests/RealmDAOBookTests.swift
View File

@ -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<Book, DBBook>!
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")
}
}

117
Example/RealmDAOTests/RealmDAOEntityTests.swift
View File

@ -12,23 +12,28 @@ import DAO
final class RealmDAOEntityTests: XCTestCase {
let dao = RealmDAO(RLMEntityTranslator())
private var dao: RealmDAO<Entity, DBEntity>!
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)
}
}

39
Example/RealmDAOTests/RealmDAOFolderTests.swift
View File

@ -13,33 +13,34 @@ import DAO
final class RealmDAOFolderTests: XCTestCase {
let messageDAO = RealmDAO(RLMMessageTranslator())
private var messageDAO: RealmDAO<Message, DBMessage>!
private var folderDAO: RealmDAO<Folder, DBFolder>!
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"))
}
}

49
Example/RealmDAOTests/RealmDAOMessagesTests.swift
View File

@ -13,48 +13,40 @@ import DAO
final class RealmDAOMessagesTests: XCTestCase {
let dao = RealmDAO(RLMMessageTranslator())
private var dao: RealmDAO<Message, DBMessage>!
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()