Unit testing in AppCode

1. Open the existing Podfile by clicking Tools | CocoaPods | Edit Podfile in the main menu.

2. Add the Quick and Nimble pods under the iOSConferencesTests target:

   target 'iOSConferences' do
     use_frameworks!
     pod 'Yams'
     target 'iOSConferencesTests' do
       inherit! :search_paths
       pod 'Quick'
       pod 'Nimble'
     end
   end

3. Click the Install pods link that appears in the top-right corner of the editor and wait until the two new pods are installed.

   

1. In the Project tool window ⌥ 1, right-click the iOSConferencesTests folder and select New | File from Xcode Template.

2. In the dialog that opens, select iOS | Source | Unit Test Case Class and click Next.

3. On the next page, specify the following:

   • File name: ApiTests

   • Language: Swift

   • Subclass of: QuickSpec

   • Targets: iOSConferencesTests

   

4. In the newly created Swift file, add the Yams, Quick, and Nimble import statements and delete all the default methods in the ApiTests class:

   import XCTest
   import Yams
   import Quick
   import Nimble
   
   class ApiTests: QuickSpec {
   
   }

5. Make the application code available for the tests by adding the following line right after the import statements:

   @testable import iOSConferences

1. Override the spec() method of the QuickSpec class: with the caret placed inside the ApiTests class, press ⌃ O and select spec() in the dialog that opens:

   

2. Inside the spec() method, add the describe block and create the decoder and loader variables there:

   override func spec() {
        describe("Application") {
            let decoder = YAMLDecoder()
            let loader = ConferencesLoader()
        }
   }

3. Inside the describe block, add the following test methods in the it blocks:

   it("should load conferences") {
       waitUntil(timeout: 5) { done in
           loader.loadConferences { conferences in
               done()
           }
       }
   }
   
   it("should parse conference") {
       let yaml = try! decoder.decode([Conference].self, from:
       """
       - name: mDevCamp
         link: https://mdevcamp.eu/
         start: 2019-05-30
         end: 2019-05-30
         location: 🇨🇿 Prague, Czech Republic
       """
       )
       let conference: Conference = yaml[0]
       expect(conference.end).toNot(beNil())
       expect(conference.name).to(equal("mDevCamp"))
       expect(conference.start).toNot(beNil())
       expect(conference.location).to(equal("🇨🇿 Prague, Czech Republic"))
       expect(conference.link).to(equal("https://mdevcamp.eu/"))
   }
   
   it("should ignore unused fields") {
       let yaml = try! decoder.decode([Conference].self, from:
       """
       - name: mDevCamp
         link: https://mdevcamp.eu/
         start: 2019-05-30
         end: 2019-05-30
         location: 🇨🇿 Prague, Czech Republic
         cocoa-only: true
         cfp:
           link: https://www.papercall.io/swift-to-2020
           deadline: 2020-06-16
       """
       )
       let conference: Conference = yaml[0]
       expect(conference.end).toNot(beNil())
       expect(conference.name).to(equal("mDevCamp"))
       expect(conference.start).toNot(beNil())
       expect(conference.location).to(equal("🇨🇿 Prague, Czech Republic"))
       expect(conference.link).to(equal("https://mdevcamp.eu/"))
   }

   These methods test the following:

   • it("should load conferences"): the network request performed in the loadConferences() method doesn't return an empty response.

   • it("should parse conference"): the conference data is parsed correctly.

   • it("should ignore unused fields"): the conferences with fields not handled by the application (such as cocoa-only or cfp) are parsed correctly.

To run all test classes in the test target, you need to create a special run/debug configuration.

1. In the run/debug configuration selector, click Edit Configurations:

   

2. In the dialog that opens, click and select XCTest:

   

   tip

   The XCTest run/debug configuration template is used for all XCTest-based frameworks, including Quick and Kiwi.

3. By default, AppCode creates a run/debug configuration for all classes in the test target:

   

   Save this configuration by clicking OK. Now it is pre-selected in the run/debug configuration selector:

   

4. Press ⇧ F10 to run all test classes. The Run tool window displays the results for all test classes available in the project, and you can see that there are two tests failed:

   

   tip

   To show/hide passed tests in the tree, click on the toolbar.

1. Click the DateTests node in the tree. In the right-hand pane, you can see the stack trace with error messages helping you understand why the tests have failed. In our case, the expected values don't match the actual ones returned by the textDate() method:

   

2. Click the testEndEarlierThanStartReplaced test in the tree to navigate to its code in the editor.

   tip

   If the navigation with a single click doesn't work, double-click the test node or click and select Navigate with Single Click.

   You can also navigate to the methods' code by clicking the links in the stack trace.

3. Set a breakpoint ⌃ F8 at the following line:

   

4. With the caret placed inside the testEndEarlierThanStartReplaced() method, press ⌃ ⇧ D to run the test in debug mode. The program execution stops at the breakpoint and the Debug tool window opens.

   tip

   For more information on how to examine a suspended program in debug mode, refer to Examine suspended program.

5. Press F7 or click to go to the textDate() method implementation and step over its code lines pressing F8 or clicking . On the Variables tab of the Debug tool window as well as in the editor, you will see the value this method returns:

   

   As far as you can see, there's no code for swapping the end and start dates in case they are mixed up in the source file. Replace the textDates() method's code with the following:

   func textDates() -> String {
       var result = start.dateToString()
       if let end = self.end {
           if start < end {
               result = "\(result) - \(end.dateToString())"
           } else if start > end {
               result = "\(end.dateToString()) - \(result)"
           }
       }
       return result
   }

6. In the Debug tool window, press to rerun the failed tests and go to the Console tab:

   

   The execution is paused at the breakpoint at the moment. Press F9 or click to resume the program. All the tests are successfully passed now:

   

Finally, let's check how much of the application code is covered by the unit tests:

1. Make sure the All Tests run/debug configuration is selected.

2. Click on the toolbar.

The Coverage tool window opens:

Double-click a folder to go to its contents or click the button to navigate to the upper level.

Moreover, you can see the percentage of files and lines covered by the tests in the Project tool window:

In the editor, the colored stripes appear in the gutter. Green means the line is fully covered by the tests, yellow — partially covered, red — uncovered:

tip

You can set up other colors for coverage indication: in the Preferences ⌃ ⌥ S dialog, go to Preferences | Editor | Color Scheme | General and select Line Coverage from the list.

If you click the coverage indicator, the popup appears:

Here you can see how many times the line was executed during testing and hide the coverage data by clicking Hide coverage. To show it again, press ⌃ ⌥ F6 and select the necessary coverage suite from the dialog that opens.

For more information on test coverage in AppCode, refer to Running with coverage.