面向协议不是银弹
先明白几个测试的概念
double 可以理解为置换，它是所有模拟测试对象的统称，我们也可以称它为替身。一般来说，当你创建任意一种测试置换对象时，它将被用来替代某个指定类的对象。
stub 可以理解为测试桩，它能实现当特定的方法被调用时，返回一个指定的模拟值。如果你的测试用例需要一个伴生对象来提供一些数据，可以使用 stub 来取代数据源，在测试设置时可以指定返回每次一致的模拟数据。
spy 可以理解为侦查，它负责汇报情况，持续追踪什么方法被调用了，以及调用过程中传递了哪些参数。你能用它来实现测试断言，比如一个特定的方法是否被调用或者是否使用正确的参数调用。当你需要测试两个对象间的某些协议或者关系时会非常有用。
mock 与 spy 类似，但在使用上有些许不同。spy 追踪所有的方法调用，并在事后让你写断言，而 mock 通常需要你事先设定期望。你告诉它你期望发生什么，然后执行测试代码并验证最后的结果与事先定义的期望是否一致。
fake 是一个具备完整功能实现和行为的对象，行为上来说它和这个类型的真实对象上一样，但不同于它所模拟的类，它使测试变得更加容易。一个典型的例子是使用内存中的数据库来生成一个数据持久化对象，而不是去访问一个真正的生产环境的数据库。
实践中，这些术语常常用起来不同于它们的定义，甚至可以互换。稍后我们在这篇文章中会看到一些库，它们自认为自己是 "mock 对象框架"，但是其实它们也提供 stub 的功能，而且验证行为的方式也类似于我描述的 "spy" 而不是 "mock"。所以不要太过于陷入这些词汇的细节；我下这些定义更多的是因为要在高层次上区分这些概念，并且它对考虑不同类型测试对象的行为会有帮助。
如果你对不同类型的模拟测试对象更多的细节讨论感兴趣，Martin Fowler 的文章 "Mocks Aren't Stubs" 被认为是关于这个问题的权威讨论。
开始
class Webservice {
func loadUser() -> User? {
let json = self.load(URL(string: "/users/current")!)
return User(json: json)
}
func loadEpisode() -> Episode? {
let json = self.load(URL(string: "/episodes/latest")!)
return Episode(json: json)
}
private func load(_ url: URL) -> [AnyHashable:Any] {
URLSession.shared.dataTask(with: url)
// etc.
return [:] // should come from the server
}
}
- load -- afnetworking 或者你封装的通用网络调用接口
- loaduser -- networkapimanager
- user -- model
- episode -- model
- Webservice -- datasource or datacenter
目前为止还不错。但是如果你要测试apimanager
-
你要用一个东西替换网络请求。
-
or pass in a mock URLSession using dependency injection.
(这句话没理解 ？？？ 给URLSession 写断言？)
总结起来就是 为了验证 a 的功能， a调用了b 。
- 那么通过替换b的实现 ，交付给a一个仿真的数据。我们能够得到进一步测试a的正确性。
- 或者是直接在b里面写断言，判断b的输入结果和输出结果是否符合预期。
We could also define a protocol that URLSession conforms to and then pass in a test instance.
其实就是临时给b添加了一个检验方法而已。还是和mock方法。这个还算优雅吧。
稍微好测试点的改动
struct Resource<A> {
let url: URL
let parse: ([AnyHashable:Any]) -> A
}
class Webservice {
let user = Resource<User>(url: URL(string: "/users/current")!, parse: User.init)
let episode = Resource<Episode>(url: URL(string: "/episodes/latest")!, parse: Episode.init)
private func load<A>(resource: Resource<A>) -> A {
URLSession.shared.dataTask(with: resource.url)
// load asynchronously, parse the JSON, etc. For the sake of the example, we directly return an empty result.
let json: [AnyHashable:Any] = [:] // should come from the server
return resource.parse(json)
}
}
这是对资源的封装 ，通过泛型，定义了一组输入和输出。
- 输入资源：url
- 输出资源：对象A
现在我们测试对象user 和 episode 就不用想着mock 什么东西啦。
虽然感觉是这样子的，但是本质还是没理解： 因为输入输出都有了，就是一个结构而已，没什么好测的。 那么问题来了， 什么东西要测，什么东西不测呢？结构本省没有什么过程调用。
load 函数我们还是要测的
protocol FromJSON {
init(json: [AnyHashable:Any])
}
struct Resource<A: FromJSON> {
let url: URL
}
class Webservice {
let user = Resource<User>(url: URL(string: "/users/current")!)
let episode = Resource<Episode>(url: URL(string: "/episodes/latest")!)
private func load<A>(resource: Resource<A>) -> A {
URLSession.shared.dataTask(with: resource.url)
// load asynchronously, parse the JSON, etc. For the sake of the example, we directly return an empty result.
let json: [AnyHashable:Any] = [:] // should come from the server
return A(json: json)
}
}
上面看上去简单，但是缺少灵活性（上面是一种高内聚的改动）
上面的代码，怎么定义一个resource 包含 User数组呢。
The protocol makes things simpler, but I think it doesn’t pay for itself, because it dramatically decreases the ways in which we can create a Resource
struct Resource<A> {
let url: URL
let parse: ([AnyHashable:Any]) -> A
}
protocol FromJSON {
init(json: [AnyHashable:Any])
}
struct Resource<A: FromJSON> {
let url: URL
}
灵活性丧失在哪里？
