Compilation error with OCMockito verify and NSError**

I can not compile this code:

[verify(mockedContext) deleteObject:item1];
[verify(mockedContext) deleteObject:item2];
[verify(mockedContext) save:anything()];<--compilation error for conversion id to NSError**

However I'm able to pass compilation in similar case with given macros with additional syntax:

    [[given([mockedContext save:nil]) withMatcher:anything()] willReturn:nil];

Are there anything to help me pass compilation with verify?

Here is compilation error:

Implicit conversion of an Objective-C pointer to 'NSError *__autoreleasing *' is disallowed with ARC

I assume the save: method on the 'mockedContext' takes a pointer-to-pointer to NSError.

So actually, the NSError must be seen as an extra return value of the save:method. This means that you should rather setup an expectation in the first place.

I worked out a small example:

We start with the Context protocol with a simple method taking an NSError**.

@protocol Context <NSObject>
- (id)doWithError:(NSError *__autoreleasing *)err;
@end

Next is a class using this protocol, much like your SUT. I called it ContextUsingClass

@interface ContextUsingClass : NSObject

@property (nonatomic, strong) id<Context> context;
@property BOOL recordedError;

- (void)call;

@end

@implementation ContextUsingClass

- (void)call {
    NSError *error;
    [self.context doWithError:&error];
    if (error) {
        self.recordedError = YES;
    }
}

@end

As you can see, when the context method doWithError: returns an error, the recordedError property is set to YES. This is something we can expect to be true or false in our test. The only problem is, how do we tell the mock to result in an error (or to succeed without error)?

The answer is fairly straight forward, and was almost part of your question: we pass an OCHamcrest matcher to the given statement, which in turn will set the error for us through a block. Bear with me, we'll get there. Let's first write the fitting matcher:

typedef void(^ErrorSettingBlock)(NSError **item);

@interface ErrorSettingBlockMatcher : HCBaseMatcher

@property (nonatomic, strong) ErrorSettingBlock errorSettingBlock;

@end


@implementation ErrorSettingBlockMatcher

- (BOOL)matches:(id)item {
    if (self.errorSettingBlock) {
        self.errorSettingBlock((NSError * __autoreleasing *)[item pointerValue]);
    }
    return YES;
}

@end

This matcher will call the errorSettingBlock if it has been set, and will always return YES as it accepts all items. The matchers sole purpose is to set the error, when the test asks as much. From OCMockito issue 22 and it's fix, we learn that pointer-to-pointers are wrapped in NSValue objects, so we should unwrap it, and cast it to our well known NSError **

Now finally, here is how the test looks:

@implementation StackOverFlowAnswersTests {
    id<Context> context;
    ContextUsingClass *sut;
    ErrorSettingBlockMatcher *matcher;
}

- (void)setUp {
    [super setUp];
    context = mockProtocol(@protocol(Context));
    sut = [[ContextUsingClass alloc] init];
    sut.context = context;
    matcher = [[ErrorSettingBlockMatcher alloc] init];
}

- (void)testContextResultsInError {
    matcher.errorSettingBlock = ^(NSError **error) {
        *error = [NSError  errorWithDomain:@"dom" code:-100 userInfo:@{}];
    };

    [[given([context doWithError:nil]) withMatcher:matcher] willReturn:nil];
    [sut call];
    assertThatBool(sut.recordedError, is(equalToBool(YES)));
}

- (void)testContextResultsInSuccess {
    [[given([context doWithError:nil]) withMatcher:matcher] willReturn:nil];
    [sut call];
    assertThatBool(sut.recordedError, is(equalToBool(NO)));
}

@end

Conclusion

When you call methods within your SUT which are returning errors through pointer-to-pointers, you should probably test for the different possible outcomes, rather than just verifying if the method has been called.

If your SUT is ignoring the error, then let the block you pass into the matcher keep a boolean flag to indicate that it was called like so:

- (void)testNotCaringAboutTheError {
    __block BOOL called = NO;
    matcher.errorSettingBlock = ^(NSError **error) {
        called = YES;
    };

    [[given([context doWithError:nil]) withMatcher:matcher] willReturn:nil];
    [sut call];
    assertThatBool(called, is(equalToBool(YES)));
}

Or with simple verification:

- (void)testWithVerifyOnly {
    [sut call];
    [[verify(context) withMatcher:matcher] doWithError:nil];
}

PS: Ignoring errors is probably something you don't want to do...