不可测的代码
假设我们需要记录一些日志，而日志的容器有一定的容量，如果日志满了就无法记录了，我们可能会写出如下的代码
// MyLogger.m
- (void)writeLog:(NSString *)log {
MyLoggerService *service = [[MyLoggerService alloc] init];
if ([service isLogFull]) {
// Do something else
}
else {
[service writeLog:log];
}
}
存在的问题
上面这个方法是很难单元测试的，因为：
- 这个方法的行为严重依赖service变量的
-[MyLoggerService isLogFull]方法的返回，但是我们却不知道什么时候这个方法返回YES，什么时候返回NO； -
service变量在方法体内部初始化，我们无法Mock，所以无法控制这个方法的执行路径。
其实根本原因在于MyLogger对MyLoggerService有一个强依赖。如下图：
不可测试的实现.png
强依赖不仅导致了可测性的问题，还导致了扩展性的问题：如果想换一个log的实现方案，需要修改MyLogger的实现，而如果MyLogger已经作为一个组件发布的话，则需要重新发布（开放闭合原则）。
解决方法
对于上面的问题，也许我们已经有了解决方案：将MyLoggerService作为参数传递给MyLogger，这样就可以打破MyLogger对MyLoggerService的依赖（不彻底的打破），类图如下：
实现代码
// MyLogger.m
- (void)writeLog:(NSString *)log usingService:(MyLoggerService *)service {
if ([service isLogFull]) {
// Do something else
}
else {
[service writeLog:log];
}
}
测试代码
- (void)testWriteLog {
id service1 = OCMClassMock([MyLoggerService class]);
OCMStub([service1 isLogFull]).andReturn(YES);
__block BOOL isCalled = NO;
OCMStub([service1 writeLog:[OCMArg any]]).andDo(^(NSInvocation *invocation){
isCalled = YES;
});
MyLogger *logger = [[MyLogger alloc] init];
[logger writeLog:@"123" usingService:service1];
XCTAssertFalse(isCalled, @"[MyLoggerService writeLog:] should never be called");
/////////////////////////////////////////////////////////////////////////////////
id service2 = OCMClassMock([MyLoggerService class]);
OCMStub([service2 isLogFull]).andReturn(NO);
isCalled = NO;
OCMStub([service2 writeLog:[OCMArg any]]).andDo(^(NSInvocation *invocation){
isCalled = YES;
});
[logger writeLog:@"123" usingService:service2];
XCTAssertTrue(isCalled, @"[MyLoggerService writeLog:] should be called");
}
依赖注入
其实上面的这个小重构（没错，这就是重构！）使用了依赖注入的原则，维基百科上将依赖注入定义为：
In software engineering, dependency injection is a technique whereby one object supplies the dependencies of another object. A dependency is an object that can be used (a service). An injection is the passing of a dependency to a dependent object (a client) that would use it. The service is made part of the client's state. Passing the service to the client, rather than allowing a client to build or find the service, is the fundamental requirement of the pattern.
简单的来说就是Client不应该自己构造Service对象，而应该通过外部传入Service对象。
问题依然存在
通过这种方式，虽然可以让MyLogger不那么依赖MyLoggerService，使得MyLogger可以被测试，但是依赖依然存在，因为MyLogger中有一个硬编码的MyLoggerService类。
如果我们需要更换一个log的实现方案，虽然不用修改MyLogger类了，但是却需要修改MyLoggerService类，这样的修改是我们不能容忍的。
我们还需要做一次重构，这次我们使用接口（或者说协议）完全打破MyLogger对MyLoggerService的依赖。
使用接口
首先我们定义LoggerService的接口：
@protocol LoggerServiceProtocol
- (BOOL)isLoggerFull;
- (void)writeLog:(NSString *)log;
@end
然后我们修改MyLogger的实现：
- (void)writeLog:(NSString *)log usingService:(id<LoggerServiceProtocol>)service {
if ([service isLoggerFull]) {
// Do something else
}
else {
[service writeLog:log];
}
}
类图如下：
使用接口实现方式，可以做到极大的灵活性，只要是实现了LoggerServiceProtocol的类，调用者都可以自由的选择用来记录log了。
当然，我们也可以通过实现LoggerServiceProtocol，不依赖Mock和Stub完成MyLogger的单元测试，如下是一个示例：
// InsufficientLoggerService.m
- (BOOL)isLoggerFull {
self.isCalled = NO;
return YES;
}
- (void)writeLog:(NSString *)log {
self.isCalled = YES;
}
// MyLoggerTests.m
- (void)testWriteLog {
MyLogger *logger = [[MyLogger alloc] init];
InsufficientLoggerService *insufficient = [[InsufficientLoggerService alloc] init];
[logger writeLog:@"123" usingService:insufficient];
XCTAssertFalse(insufficient.isCalled, @"writeLog should never be called");
}
总结
- 代码中的强依赖很有可能导致不可测的问题，依赖注入可以有效的解决强依赖；
- 尽量不使用局部变量，因为局部变量难以mock；
- 同样的，静态变量也是不受欢迎的，因为静态变量只能初始化一次，也难以mock，后续状态难以跟踪；
- 单例模式尽量少用，因为单例也算一个广义的静态变（另外异步更新单例也容易产生诡异的bug）。
