Testing for all types of iOS Applications using XCTest

import UIKit
import CoreData
 
class MasterViewController: UITableViewController, NSFetchedResultsControllerDelegate {
 
    var detailViewController: DetailViewController? = nil
    var managedObjectContext: NSManagedObjectContext? = nil
 
    override func viewDidLoad() {
        ...
        // Adds a button to the navigation bar and calls back to the insertNewObject when tapped
        let addButton = UIBarButtonItem(barButtonSystemItem: .add, target: self, action: #selector(insertNewObject(_:)))
        self.navigationItem.rightBarButtonItem = addButton
        ...
    }
 
    ...
 
    // Inserts a new event into CoreData and triggers an event to reload the UITableView
    func insertNewObject(_ sender: Any) {
        let context = self.fetchedResultsController.managedObjectContext
        let newEvent = Event(context: context)
 
        // If appropriate, configure the new managed object.
        newEvent.timestamp = NSDate()
        // Getting an random string as the title.
        // This is an opportunity for a test!
        newEvent.title = self.getRandomString(stringLength:10)
 
        // Save the context.
        do {
            // Saving the managedObjectContext triggers the following functions:
            // func controllerWillChangeContent(_ controller: NSFetchedResultsController<NSFetchRequestResult>)
            // func controller(_ controller: NSFetchedResultsController<NSFetchRequestResult>, didChange anObject: Any, at indexPath: IndexPath?, for type: NSFetchedResultsChangeType, newIndexPath: IndexPath?)
            try context.save()
        } catch {
            let nserror = error as NSError
            fatalError("Unresolved error \(nserror), \(nserror.userInfo)")
        }
    }
 
    // Called by insertNewObject to generate a random string based upon a set length
    func getRandomString(stringLength:Int) -> String {
 
        let letters:String = "abcdefghijklmnopqrstuvwxyz1234567890"
        // The character array
        let characterArray = [Character](letters.characters)
        // Random string about to be generated
        var randomString: String = ""
 
        // For loop to generate a string based upon the passed in size
        // The string is generated at random based off the letters string
        for _ in (0..<stringLength) {
            let rand = Int(arc4random_uniform(UInt32(characterArray.count)))
            randomString += String(characterArray[rand])
        }
        // Return the new string
        return randomString
    }
 
    ...
 
    // Triggered when the NSManagedObjectContext is updated in any way
    func controllerWillChangeContent(_ controller: NSFetchedResultsController<NSFetchRequestResult>) {
        self.tableView.beginUpdates()
    }
 
    // Triggered when the NSManagedObjectContext is updated in any way
    func controller(_ controller: NSFetchedResultsController<NSFetchRequestResult>, didChange anObject: Any, at indexPath: IndexPath?, for type: NSFetchedResultsChangeType, newIndexPath: IndexPath?) {
        switch type {
            case .insert:
                tableView.insertRows(at: [newIndexPath!], with: .fade)
            case .delete:
                tableView.deleteRows(at: [indexPath!], with: .fade)
            case .update:
                self.configureCell(tableView.cellForRow(at: indexPath!)! as! CustomTableCell, withEvent: anObject as! Event)
            case .move:
                tableView.moveRow(at: indexPath!, to: newIndexPath!)
        }
    }
 
    ...
 
    // Triggered as a result of the update to the NSManagedObject context and creates a CustomTableCell, sets data to this cell and returns it
    override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let customCell: CustomTableCell = tableView.dequeueReusableCell(withIdentifier: "Cell") as! CustomTableCell
        customCell.layoutMargins = UIEdgeInsets.zero
        customCell.preservesSuperviewLayoutMargins = false
 
        let event = self.fetchedResultsController.object(at: indexPath)
        self.configureCell(customCell, withEvent: event)
 
        return customCell
    }
 
    // Call from the above function to set the properties of the CustomTableCell
    func configureCell(_ cell: CustomTableCell, withEvent event: Event) {
        cell.titleLabel!.text = event.title
        cell.dateLabel!.text = event.timestamp!.description
        cell.rowImage!.image = UIImage(named: "swift-bird")!
    }
 
    ...
}
 
 
//
//  CustomTableCell.swift
//  Custom UITableViewCell called CustomTableCell
//
import UIKit
 
class CustomTableCell: UITableViewCell {
 
    @IBOutlet weak var rowImage: UIImageView?
    @IBOutlet weak var titleLabel: UILabel?
    @IBOutlet weak var dateLabel: UILabel?
 
    override func awakeFromNib() {
        super.awakeFromNib()
    }
 
    override func setSelected(_ selected: Bool, animated: Bool) {
        super.setSelected(selected, animated: animated)
    }
}

//
//  CoreDataTestClass.swift
//  XCTestExample
//
//  Created by Matt Eaton on 10/8/16.
//  Copyright © 2016 AgnosticDev. All rights reserved.
//
import XCTest
import CoreData
 
class CoreDataTestClass: XCTestCase {
 
    // Create a local NSManagedObjectContext
    var managedObjectContext: NSManagedObjectContext? = nil
 
    // In iOS 10 and Swift 3 this is all I need to create my core data stack
    lazy var persistentContainer: NSPersistentContainer = {
        let container = NSPersistentContainer(name: "XCTestExample")
        container.loadPersistentStores(completionHandler: { (storeDescription, error) in
            if let error = error as NSError? {
                fatalError("Unresolved error \(error), \(error.userInfo)")
            }
        })
        return container
    }()
 
    override func tearDown() {
        super.tearDown()
        managedObjectContext = nil
    }
 
    override func setUp() {
        super.setUp()
        // Set the NSManagedObjectContext with the view Context
        managedObjectContext = self.persistentContainer.viewContext
    }
 
    func testExample() {
        // This is an example of a functional test case.
        // Use XCTAssert and related functions to verify your tests produce the correct results.
    }
 
    func testPerformanceExample() {
        // This is an example of a performance test case.
        self.measure {
            // Put the code you want to measure the time of here.
        }
    }
}
 
//
//  TestEventCreation.swift
//  XCTestExample
//
//  Created by Matt Eaton on 10/8/16.
//  Copyright © 2016 AgnosticDev. All rights reserved.
//
 
import XCTest
import CoreData
@testable import XCTestExample
 
class TestEventCreation: CoreDataTestClass {
 
    var newEvent:Event?
 
    override func setUp() {
        super.setUp()
        let newEventEntity = NSEntityDescription.entity(forEntityName: "Event", in: managedObjectContext!)
        newEvent = Event(entity: newEventEntity!, insertInto: managedObjectContext)
    }
 
    override func tearDown() {
        super.tearDown()
    }
 
    func testNewEvent() {
        XCTAssertNotNil(self.newEvent, "Cannot create a new event!")
    }
 
    override func testPerformanceExample() {
        // This is an example of a performance test case.
        self.measure {
            // Put the code you want to measure the time of here.
        }
    }
 
}

//
//  TestTitleGeneration.swift
//  XCTestExample
//
//  Created by Matt Eaton on 10/8/16.
//  Copyright © 2016 AgnosticDev. All rights reserved.
//
 
import UIKit
import XCTest
@testable import XCTestExample
 
class TestTitleGeneration: XCTestCase {
 
    let master = MasterViewController()
 
    override func setUp() {
        super.setUp()
        // Put setup code here. This method is called before the invocation of each test method in the class.
    }
 
    override func tearDown() {
        // Put teardown code here. This method is called after the invocation of each test method in the class.
        super.tearDown()
    }
 
    func testRandomTitle() {
 
        // Declare two constant lengths for random string generation length
        let firstTestLength = 10
        let secondTestLength = 15
 
        // Get the first string
        let firstString = master.getRandomString(stringLength: firstTestLength)
        XCTAssertEqual(firstString.characters.count, firstTestLength, "First string characters should equal \(firstTestLength)")
        // Get the second string
        let secondString = master.getRandomString(stringLength: secondTestLength)
        XCTAssertEqual(secondString.characters.count, secondTestLength, "Second string characters should equal \(secondTestLength)")
 
    }
 
    func testPerformanceExample() {
        // This is an example of a performance test case.
        self.measure {
            // Put the code you want to measure the time of here.
        }
    }
}

//
//  TestCustomCell.swift
//  XCTestExample
//
//  Created by Matt Eaton on 10/8/16.
//  Copyright © 2016 AgnosticDev. All rights reserved.
//
 
import UIKit
import XCTest
@testable import XCTestExample
 
class TestCustomCell: XCTestCase {
 
    var testTable = UITableView()
 
    override func setUp() {
        super.setUp()
        // Put setup code here. This method is called before the invocation of each test method in the class.
        testTable.register(CustomTableCell.self, forCellReuseIdentifier: "Cell")
    }
 
    override func tearDown() {
        // Put teardown code here. This method is called after the invocation of each test method in the class.
        super.tearDown()
    }
 
    func testCustomCell() {
        let customCell: CustomTableCell = testTable.dequeueReusableCell(withIdentifier: "Cell") as! CustomTableCell
        XCTAssertNotNil(customCell, "No Custom Cell Available")
    }
 
    func testPerformanceExample() {
        // This is an example of a performance test case.
        self.measure {
            // Put the code you want to measure the time of here.
        }
    }
}