Testing void methods using OCMock in iOS

Question

I am trying to write a test case for a method in Objective-C class which returns void. The method mobileTest just creates another object of class AnotherClass and calls a method makeNoise. How to test this ?

I tried to use OCMock to create test this. Created a mock object of AnotherClass, and called mobileTest method. Obviously, the OCMVerify([mockObject makeNoise]) won't work, as I am not setting this object anywhere in the code. So, how to test in such cases ?

@interface Hello
@end

@implementation HelloWorldClass()

-(void)mobileTest{
    AnotherClass *anotherClassObject = [AnotherClass alloc] init];
    [anotherClassObject makeNoise];
}
@end


@interface AnotherClass
@end

@implementation AnotherClass()
-(void) makeNoise{
    NSLog(@"Makes lot of noise");   
}
@end

Test case for the above is as follows :

-(void)testMobileTest{
    id mockObject = OCMClassMock([AnotherClass class]);
    HelloWorldClass *helloWorldObject = [[HelloWorld alloc] init];
    [helloWorldObject mobileTest];
    OCMVerify([mockObject makeNoise]);
}

Answer 1

There's not a simple answer to this without going a bit into what OCMock is meant for and what test design paradigm it implies.

The short version is: You should not test this like that in the first place. Tests should treat the tested methods as a black box and only compare & verify input vs output.

Longer version: You're trying to test for a side effect, basically, since makeNoise doesn't do anything that the HelloWorldClass even registers (or "sees"). Or to put it in a more positive way: As long as makeNoise is properly tested in the tests written for AnotherClass you don't need to test that simple call.

The example you provide may be a bit confusing, since obviously that doesn't leave anything meaningful to test in mobileTest's unit test, but considering that you might also question why to outsource the simple NSLog call to another class in the first place (and testing for an NSLog call is kind of pointless, of course). Of course I understand you're just using this as an example and envision a more complex different scenario in which you want to ensure that a specific call happens.

In such a situation, you should always ask yourself "Is this the correct place to verify this?" If the answer is "yes" that should imply that whatever message you want to test to be called needs to go to an object that's not completely inside the scope of the tested class only. For example, it could be a singleton (some global logging class) or a property of the class. Then you have a handle, an object that you can properly mock (for example, set the property to a partially mocked object) and verify.

In rare cases that might lead you to provide a handle/property for an object simply to be able to replace it with a mock during testing, but that often indicates a sub-optimal class and/or method design (I'm not gonna claim that's always the case, though).

Let me provide three examples from one of my projects to illustrate something similar to your situation:

Example 1: Verifying that an URL is opened (in mobile Safari): This is basically verifying that openURL: is called on the shared NSApplication instance, something very similar to what you have in mind. Note that the shared instance is not "completely inside the tested methods scope" as it is a singleton"

id mockApp = OCMPartialMock([UIApplication sharedApplication]);
OCMExpect([mockApp openURL:[OCMArg any]]);
// call the method to test that should call openURL:
OCMVerify([mockApp openURL:[OCMArg any]]);

Note that this works due to the specifics of a partial mock: Even though openURL: is not called on the mock, because the mock has a relationship to same instance that is used in the tested method it can still verify the call. If the instance weren't a singleton that would not work, you would not be able to create the mock from the same object that is used in your method.

Example 2: Adapted version of your code to allow "grabbing" the internal object.

@interface HelloWorldClass
@property (nonatomic, strong) AnotherClass *lazyLoadedClass;
@end

@implementation HelloWorldClass()
// ...
// overridden getter
-(AnotherClass *)lazyLoadedClass {
    if (!_lazyLoadedClass) {
        _lazyLoadedClass = [[AnotherClass alloc] init];
    }
    return _lazyLoadedClass;
}
-(void)mobileTest{
    [self.lazyLoadedClass makeNoise];
}
@end

And now the test:

-(void)testMobileTest{
    HelloWorldClass *helloWorldObject = [[HelloWorld alloc] init];
    id mockObject = OCMPartialMock([helloWorldObject lazyLoadedClass]);
    OCMExpect([mockObject makeNoise]);
    [helloWorldObject mobileTest];
    OCMVerify([mockObject makeNoise]);
}

The lazyLoadedClass method might even be in a class extension, i.e. "private". In that case, just copy the according category definition to the top of your test file (I usually do this, and yes, this is, IMO, a valid case of basically "testing private methods"). This approach makes sense if AnotherClass is more complex and requires elaborate setup or something. Usually stuff like this then leads to the scenario you have in the first place, i.e. its complexity makes it to more than just a helper than can be thrown away after the method finishes. this will then also lead you to better code structure, since you have its initializer in a separate method and can test that accordingly, too.

Example 3: If AnotherClass has a non-standard initializer (like a singleton, or it comes from a factory class) you can stub that and return a mocked object (this is kind of a brain-knot, but I have used it)

@implementation AnotherClass()
// ...
-(AnotherClass *)crazyInitializer { // this is in addition to the normal one...
    return [[AnotherClass alloc] init];
}
@end

-(void)testMobileTest{
    HelloWorldClass *helloWorldObject = [[HelloWorld alloc] init];
    id mockForStubbingClassMethod = OCMClassMock([AnotherClass class]);
    AnotherClass *baseForPartialMock = [[AnotherClass alloc] init];
    // maybe do something with it for test settup
    id mockObject = OCMPartialMock(baseForPartialMock);
    OCMStub([mockForStubbingClassMethod crazyInitializer]).andReturn(mockObject);
    OCMExpect([mockObject makeNoise]);
    [helloWorldObject mobileTest];
    OCMVerify([mockObject makeNoise]);
}

This looks kind of stupid and I admit it's plain ugly, but I have used this in some tests (you know that point in a project...). Here I tried to make it easier to read and used two mocks, one to stub the class method (i.e. the initializer) and one that then is returned. The mobileTest method should then obviously use the custom initializer of AnotherClass, then it gets the mocked object (like a cuckoo's egg...). This is useful if you want to specially prepare the object (which is why I used a partial mock here). I am actually not sure atm if you could also do this with only one class mock (stub the class method/initializer on it so it returns itself, then expect the method call you want to verify)... as I said, brain-knotting.