不可测的代码

假设我们需要记录一些日志，而日志的容器有一定的容量，如果日志满了就无法记录了，我们可能会写出如下的代码

// MyLogger.m
- (void)writeLog:(NSString *)log {
    MyLoggerService *service = [[MyLoggerService alloc] init];
    if ([service isLogFull]) {
        // Do something else
    }
    else {
        [service writeLog:log];
    }
}

存在的问题

上面这个方法是很难单元测试的，因为：

1. 这个方法的行为严重依赖service变量的-[MyLoggerService isLogFull]方法的返回，但是我们却不知道什么时候这个方法返回YES，什么时候返回NO；

2. service变量在方法体内部初始化，我们无法Mock，所以无法控制这个方法的执行路径。
   其实根本原因在于MyLogger对MyLoggerService有一个强依赖。如下图：

   
   不可测试的实现.png
   

   强依赖不仅导致了可测性的问题，还导致了扩展性的问题：如果想换一个log的实现方案，需要修改MyLogger的实现，而如果MyLogger已经作为一个组件发布的话，则需要重新发布（开放闭合原则）。

解决方法

对于上面的问题，也许我们已经有了解决方案：将MyLoggerService作为参数传递给MyLogger，这样就可以打破MyLogger对MyLoggerService的依赖（不彻底的打破），类图如下：

依赖注入.png

实现代码

// 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];
    }
}

类图如下：

接口.png

使用接口实现方式，可以做到极大的灵活性，只要是实现了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");
}

总结

1. 代码中的强依赖很有可能导致不可测的问题，依赖注入可以有效的解决强依赖；
2. 尽量不使用局部变量，因为局部变量难以mock；
3. 同样的，静态变量也是不受欢迎的，因为静态变量只能初始化一次，也难以mock，后续状态难以跟踪；
4. 单例模式尽量少用，因为单例也算一个广义的静态变（另外异步更新单例也容易产生诡异的bug）。