Swift单元测试Quick+Nimble

文章目录

- 使用Quick+Nimble
- - 1、苹果官方测试框架XCTest的优缺点
  - 2、选择Quick+Nimble的原因：
  - 3、Quick+Nimble使用介绍
  - - 集成：
    - Quick关键字说明：
    - Nimble中的匹配函数
    - - 等值判断：使用equal函数
      - 是否是同一个对象：使用beIdenticalTo函数
      - 比较：
      - 比较浮点数
      - 类型检查
      - 是否为真
      - 是否有异常
      - 集合关系
      - 字符串
      - 检查集合中的所有元素是否符合条件
      - 检查集合个数
      - 匹配任意一种检查
  - 4、Quick使用总结

使用Quick+Nimble

github地址

1、苹果官方测试框架XCTest的优缺点

优点：与 Xcode 深度集成，有专门的Test 导航栏。

缺点：
1）因为受限于官方测试API，因此功能不是很丰富。
2）在书写性和可读性上都不太好。在测试用例太多的时候，由于各个测试方法是割裂的，想在某个很长的测试文件中找到特定的某个测试并搞明白这个测试是在做什么并不是很容易的事情。
3）所有的测试都是由断言完成的，而很多时候断言的意义并不是特别的明确，对于项目交付或者新的开发人员加入时，往往要花上很大成本来进行理解或者转换。另外，每一个测试的描述都被写在断言之后，夹杂在代码之中，难以寻找。
4）使用XCTest测试另外一个问题是难以进行mock或者stub

2、选择Quick+Nimble的原因：

主要是由于苹果官方框架的测试方法及断言不明确，可读性不好，难以分辨，交接项目需要花费的时间很多，所以建议采用三方测试框架
目前主流的三方测试框架主要有：
oc中：kiwi 、specta、cedar
swift：quick+nimble、Sleipnir
由于项目是使用的swift语言，所以主要采用quick+nimble，用于单元测试和断言。
如果你的项目是OC的，推荐使用kiwi，目前是start最多的三方框架。

3、Quick+Nimble使用介绍

Quick 是一个建立在XCTest 上，为Swift 和Objective-C 设计的测试框架. 对测试使用Swift编写的App非常友好，对Swift使用者来说，Quick是最佳选择
它通过DSL 去编写非常类似于RSpec 的测试用例。
Nimble 就像是Quick 的搭档，它提供了匹配器作为断言，用于编写匹配模式。

集成：

使用pod集成方便快捷：

pod ‘Quick’
pod ‘Nimble’

新建一个测试类，继承于QuickSpec父类，然后重写spec( )方法
示例代码：

finalfinal class BindDeviceTests: QuickSpec {

    override func spec() {
        //所有测试放在这里
        
        describe("test BindDeviceDB") {
            let findMac = "34:94:54:C2:E3:C6"
            let bindedMacs = ["34:94:54:C2:E3:C6",
                              "D8:0B:CB:62:08:5F",
                              "FF:F2:00:08:21:9C"]
            
            it("test saveBindDevice") {
                let bindDevice = BindDevice()
                bindDevice.scaleName = "test"
                bindDevice.userId = testLoginUserId
                bindDevice.mac = testMac
                expect(bindDevice.save()).to(beTrue())
            }
            
            it("test findBindDeviceList") {
                let list = BindDevice.findBindDeviceList()
                printLog(message: "test findBindDeviceWithMac: \(String(describing: list?.count))")
                expect(list?.count) == 6
            }
			
            ......
			
            xit("test findNotUploadBindDevices") {
                let list = BindDevice.findNotUploadBindDevices()
                printLog(message: "test findNotUploadBindDevices: \(String(describing: list?.count))")
                expect(list).to(beNil())
            }

        }
    }

}

Quick关键字说明：

在这里插入图片描述

Nimble中的匹配函数

等值判断：使用equal函数

expect(actual).to(equal(expected))
expect(actual) == expected
expect(actual) != expected

是否是同一个对象：使用beIdenticalTo函数

expect(actual).to(beIdenticalTo(expected))
expect(actual) === expected
expect(actual) !== expected

比较：

expect(actual).to(beLessThan(expected))
expect(actual) < expected
expect(actual).to(beLessThanOrEqualTo(expected))
expect(actual) <= expected
expect(actual).to(beGreaterThan(expected))
expect(actual) > expected
expect(actual).to(beGreaterThanOrEqualTo(expected))
expect(actual) >= expected

比较浮点数

expect(10.01).to(beCloseTo(10, within: 0.1))

类型检查

expect(instance).to(beAnInstanceOf(aClass))
expect(instance).to(beAKindOf(aClass))

是否为真

expect(actual).to(beTruthy())
expect(actual).to(beTrue())
expect(actual).to(beFalsy())
expect(actual).to(beFalse())
expect(actual).to(beNil())

是否有异常

// Passes if actual, when evaluated, raises an exception:
expect(actual).to(raiseException())
// Passes if actual raises an exception with the given name:
expect(actual).to(raiseException(named: name))
// Passes if actual raises an exception with the given name and reason:
expect(actual).to(raiseException(named: name, reason: reason))
// Passes if actual raises an exception and it passes expectations in the block
// (in this case, if name begins with ‘a r’)
expect { exception.raise() }.to(raiseException { (exception: NSException) in
- expect(exception.name).to(beginWith(“a r”))
})

集合关系

// Passes if all of the expected values are members of actual:
expect(actual).to(contain(expected…))
expect([“whale”, “dolphin”, “starfish”]).to(contain(“dolphin”, “starfish”))
// Passes if actual is an empty collection (it contains no elements):
expect(actual).to(beEmpty())

字符串

// Passes if actual contains substring expected:
expect(actual).to(contain(expected))
// Passes if actual begins with substring:
expect(actual).to(beginWith(expected))
// Passes if actual ends with substring:
expect(actual).to(endWith(expected))
// Passes if actual is an empty string, “”:
expect(actual).to(beEmpty())
// Passes if actual matches the regular expression defined in expected:
expect(actual).to(match(expected))

检查集合中的所有元素是否符合条件

// with a custom function:
expect([1,2,3,4]).to(allPass({$0 < 5}))
// with another matcher:
expect([1,2,3,4]).to(allPass(beLessThan(5)))

检查集合个数

expect(actual).to(haveCount(expected))

匹配任意一种检查

// passes if actual is either less than 10 or greater than 20
expect(actual).to(satisfyAnyOf(beLessThan(10), beGreaterThan(20)))
// can include any number of matchers – the following will pass
expect(6).to(satisfyAnyOf(equal(2), equal(3), equal(4), equal(5), equal(6), equal(7)))
// in Swift you also have the option to use the || operator to achieve a similar function
expect(82).to(beLessThan(50) || beGreaterThan(80))