mirror of
https://github.com/zhigang1992/RestKit.git
synced 2026-04-02 22:42:45 +08:00
2127 lines
131 KiB
Objective-C
2127 lines
131 KiB
Objective-C
//
|
|
// RKTableControllerTest.m
|
|
// RestKit
|
|
//
|
|
// Created by Blake Watters on 8/3/11.
|
|
// Copyright (c) 2009-2012 RestKit. All rights reserved.
|
|
//
|
|
|
|
#import "RKTestEnvironment.h"
|
|
#import "RKTableController.h"
|
|
#import "RKTableSection.h"
|
|
#import "RKTestUser.h"
|
|
#import "RKMappableObject.h"
|
|
#import "RKAbstractTableController_Internals.h"
|
|
|
|
// Expose the object loader delegate for testing purposes...
|
|
@interface RKTableController () <RKObjectLoaderDelegate>
|
|
- (void)animationDidStopAddingSwipeView:(NSString*)animationID finished:(NSNumber*)finished context:(void*)context;
|
|
@end
|
|
|
|
@interface RKTestTableControllerDelegate : NSObject <RKTableControllerDelegate>
|
|
|
|
@property(nonatomic, readonly, getter = isCancelled) BOOL cancelled;
|
|
@property(nonatomic, assign) NSTimeInterval timeout;
|
|
@property(nonatomic, assign) BOOL awaitingResponse;
|
|
|
|
+ (id)tableControllerDelegate;
|
|
- (void)waitForLoad;
|
|
@end
|
|
|
|
@implementation RKTestTableControllerDelegate
|
|
|
|
@synthesize timeout = _timeout;
|
|
@synthesize awaitingResponse = _awaitingResponse;
|
|
@synthesize cancelled = _cancelled;
|
|
|
|
+ (id)tableControllerDelegate {
|
|
return [[self new] autorelease];
|
|
}
|
|
|
|
- (id)init {
|
|
self = [super init];
|
|
if (self) {
|
|
_timeout = 3;
|
|
_awaitingResponse = NO;
|
|
_cancelled = NO;
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
- (void)waitForLoad {
|
|
_awaitingResponse = YES;
|
|
NSDate* startDate = [NSDate date];
|
|
|
|
while (_awaitingResponse) {
|
|
NSLog(@"Awaiting response = %d", _awaitingResponse);
|
|
[[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.1]];
|
|
if ([[NSDate date] timeIntervalSinceDate:startDate] > self.timeout) {
|
|
NSLog(@"%@: Timed out!!!", self);
|
|
_awaitingResponse = NO;
|
|
[NSException raise:nil format:@"*** Operation timed out after %f seconds...", self.timeout];
|
|
}
|
|
}
|
|
}
|
|
|
|
#pragma RKTableControllerDelegate methods
|
|
|
|
- (void)tableControllerDidFinishLoad:(RKAbstractTableController*)tableController {
|
|
_awaitingResponse = NO;
|
|
}
|
|
|
|
- (void)tableController:(RKAbstractTableController*)tableController didFailLoadWithError:(NSError *)error {
|
|
_awaitingResponse = NO;
|
|
}
|
|
|
|
- (void)tableControllerDidCancelLoad:(RKAbstractTableController*)tableController {
|
|
_awaitingResponse = NO;
|
|
_cancelled = YES;
|
|
}
|
|
|
|
// NOTE - Delegate methods below are implemented to allow trampoline through
|
|
// OCMock expectations
|
|
|
|
- (void)tableControllerDidStartLoad:(RKAbstractTableController*)tableController {}
|
|
- (void)tableControllerDidBecomeEmpty:(RKAbstractTableController*)tableController {}
|
|
- (void)tableController:(RKAbstractTableController*)tableController willLoadTableWithObjectLoader:(RKObjectLoader*)objectLoader {}
|
|
- (void)tableController:(RKAbstractTableController*)tableController didLoadTableWithObjectLoader:(RKObjectLoader*)objectLoader {}
|
|
- (void)tableController:(RKAbstractTableController*)tableController willBeginEditing:(id)object atIndexPath:(NSIndexPath*)indexPath {}
|
|
- (void)tableController:(RKAbstractTableController*)tableController didEndEditing:(id)object atIndexPath:(NSIndexPath*)indexPath {}
|
|
- (void)tableController:(RKAbstractTableController*)tableController didInsertSection:(RKTableSection*)section atIndex:(NSUInteger)sectionIndex {}
|
|
- (void)tableController:(RKAbstractTableController*)tableController didRemoveSection:(RKTableSection*)section atIndex:(NSUInteger)sectionIndex {}
|
|
- (void)tableController:(RKAbstractTableController*)tableController didInsertObject:(id)object atIndexPath:(NSIndexPath*)indexPath {}
|
|
- (void)tableController:(RKAbstractTableController*)tableController didUpdateObject:(id)object atIndexPath:(NSIndexPath*)indexPath {}
|
|
- (void)tableController:(RKAbstractTableController*)tableController didDeleteObject:(id)object atIndexPath:(NSIndexPath*)indexPath {}
|
|
- (void)tableController:(RKAbstractTableController*)tableController willAddSwipeView:(UIView*)swipeView toCell:(UITableViewCell*)cell forObject:(id)object {}
|
|
- (void)tableController:(RKAbstractTableController*)tableController willRemoveSwipeView:(UIView*)swipeView fromCell:(UITableViewCell*)cell forObject:(id)object {}
|
|
- (void)tableControllerDidFinalizeLoad:(RKAbstractTableController *)tableController {}
|
|
|
|
@end
|
|
|
|
@interface RKTableControllerTestTableViewController : UITableViewController
|
|
@end
|
|
|
|
@implementation RKTableControllerTestTableViewController
|
|
@end
|
|
|
|
@interface RKTableControllerSpecViewController : UIViewController
|
|
@end
|
|
|
|
@implementation RKTableControllerSpecViewController
|
|
@end
|
|
|
|
@interface RKTestUserTableViewCell : UITableViewCell
|
|
@end
|
|
|
|
@implementation RKTestUserTableViewCell
|
|
@end
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
@interface RKTableControllerTest : SenTestCase
|
|
|
|
@end
|
|
|
|
@implementation RKTableControllerTest
|
|
|
|
- (void)setUp
|
|
{
|
|
[RKTestFactory setUp];
|
|
}
|
|
|
|
- (void)tearDown
|
|
{
|
|
[RKTestFactory tearDown];
|
|
}
|
|
|
|
- (void)testInitializeWithATableViewController {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
assertThat(viewController.tableView, is(notNilValue()));
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
assertThat(tableController.viewController, is(equalTo(viewController)));
|
|
assertThat(tableController.tableView, is(equalTo(viewController.tableView)));
|
|
}
|
|
|
|
- (void)testInitializeWithATableViewAndViewController {
|
|
UITableView* tableView = [UITableView new];
|
|
RKTableControllerSpecViewController* viewController = [RKTableControllerSpecViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerWithTableView:tableView forViewController:viewController];
|
|
assertThat(tableController.viewController, is(equalTo(viewController)));
|
|
assertThat(tableController.tableView, is(equalTo(tableView)));
|
|
}
|
|
|
|
- (void)testAlwaysHaveAtLeastOneSection {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
assertThat(viewController.tableView, is(notNilValue()));
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
assertThatInt(tableController.sectionCount, is(equalToInt(1)));
|
|
}
|
|
|
|
- (void)testDisconnectFromTheTableViewOnDealloc {
|
|
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
|
|
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
assertThatInt(tableController.sectionCount, is(equalToInt(1)));
|
|
[pool drain];
|
|
assertThat(viewController.tableView.delegate, is(nilValue()));
|
|
assertThat(viewController.tableView.dataSource, is(nilValue()));
|
|
}
|
|
|
|
- (void)testNotDisconnectFromTheTableViewIfDelegateOrDataSourceAreNotSelf {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [[RKTableController alloc] initWithTableView:viewController.tableView viewController:viewController];
|
|
viewController.tableView.delegate = viewController;
|
|
viewController.tableView.dataSource = viewController;
|
|
assertThatInt(tableController.sectionCount, is(equalToInt(1)));
|
|
[tableController release];
|
|
assertThat(viewController.tableView.delegate, isNot(nilValue()));
|
|
assertThat(viewController.tableView.dataSource, isNot(nilValue()));
|
|
}
|
|
|
|
#pragma mark - Section Management
|
|
|
|
- (void)testAddASection {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
RKTableSection* section = [RKTableSection section];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
id mockDelegate = [OCMockObject partialMockForObject:delegate];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didInsertSection:section
|
|
atIndex:1];
|
|
tableController.delegate = mockDelegate;
|
|
[tableController addSection:section];
|
|
assertThatInt([tableController.sections count], is(equalToInt(2)));
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
- (void)testConnectTheSectionToTheTableModelOnAdd {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
RKTableSection* section = [RKTableSection section];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
id mockDelegate = [OCMockObject partialMockForObject:delegate];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didInsertSection:section
|
|
atIndex:1];
|
|
tableController.delegate = mockDelegate;
|
|
[tableController addSection:section];
|
|
assertThat(section.tableController, is(equalTo(tableController)));
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
- (void)testConnectTheSectionToTheCellMappingsOfTheTableModelWhenNil {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
RKTableSection* section = [RKTableSection section];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
id mockDelegate = [OCMockObject partialMockForObject:delegate];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didInsertSection:section
|
|
atIndex:1];
|
|
tableController.delegate = mockDelegate;
|
|
assertThat(section.cellMappings, is(nilValue()));
|
|
[tableController addSection:section];
|
|
assertThat(section.cellMappings, is(equalTo(tableController.cellMappings)));
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
- (void)testNotConnectTheSectionToTheCellMappingsOfTheTableModelWhenNonNil {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
RKTableSection* section = [RKTableSection section];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
id mockDelegate = [OCMockObject partialMockForObject:delegate];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didInsertSection:section
|
|
atIndex:1];
|
|
tableController.delegate = mockDelegate;
|
|
section.cellMappings = [NSMutableDictionary dictionary];
|
|
[tableController addSection:section];
|
|
assertThatBool(section.cellMappings == tableController.cellMappings, is(equalToBool(NO)));
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
- (void)testCountTheSections {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
RKTableSection* section = [RKTableSection section];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
id mockDelegate = [OCMockObject partialMockForObject:delegate];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didInsertSection:section
|
|
atIndex:1];
|
|
tableController.delegate = mockDelegate;
|
|
[tableController addSection:section];
|
|
assertThatInt(tableController.sectionCount, is(equalToInt(2)));
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
- (void)testRemoveASection {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
RKTableSection* section = [RKTableSection section];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
id mockDelegate = [OCMockObject partialMockForObject:delegate];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didInsertSection:section
|
|
atIndex:1];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didRemoveSection:section
|
|
atIndex:1];
|
|
tableController.delegate = mockDelegate;
|
|
[tableController addSection:section];
|
|
assertThatInt(tableController.sectionCount, is(equalToInt(2)));
|
|
[tableController removeSection:section];
|
|
assertThatInt(tableController.sectionCount, is(equalToInt(1)));
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
- (void)testNotLetRemoveTheLastSection {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
RKTableSection* section = [RKTableSection section];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
id mockDelegate = [OCMockObject partialMockForObject:delegate];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didInsertSection:section
|
|
atIndex:1];
|
|
tableController.delegate = mockDelegate;
|
|
[tableController addSection:section];
|
|
assertThatInt(tableController.sectionCount, is(equalToInt(2)));
|
|
[tableController removeSection:section];
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
- (void)testInsertASectionAtASpecificIndex {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
RKTableSection* referenceSection = [RKTableSection section];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
id mockDelegate = [OCMockObject partialMockForObject:delegate];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didInsertSection:referenceSection
|
|
atIndex:2];
|
|
[tableController addSection:[RKTableSection section]];
|
|
[tableController addSection:[RKTableSection section]];
|
|
[tableController addSection:[RKTableSection section]];
|
|
[tableController addSection:[RKTableSection section]];
|
|
tableController.delegate = mockDelegate;
|
|
[tableController insertSection:referenceSection atIndex:2];
|
|
assertThatInt(tableController.sectionCount, is(equalToInt(6)));
|
|
assertThat([tableController.sections objectAtIndex:2], is(equalTo(referenceSection)));
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
- (void)testRemoveASectionByIndex {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
RKTableSection* section = [RKTableSection section];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
id mockDelegate = [OCMockObject partialMockForObject:delegate];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didInsertSection:section
|
|
atIndex:1];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didRemoveSection:section
|
|
atIndex:1];
|
|
tableController.delegate = mockDelegate;
|
|
[tableController addSection:section];
|
|
assertThatInt(tableController.sectionCount, is(equalToInt(2)));
|
|
[tableController removeSectionAtIndex:1];
|
|
assertThatInt(tableController.sectionCount, is(equalToInt(1)));
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
- (void)testRaiseAnExceptionWhenAttemptingToRemoveTheLastSection {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
NSException* exception = nil;
|
|
@try {
|
|
[tableController removeSectionAtIndex:0];
|
|
}
|
|
@catch (NSException *e) {
|
|
exception = e;
|
|
}
|
|
@finally {
|
|
assertThat(exception, isNot(nilValue()));
|
|
}
|
|
}
|
|
|
|
- (void)testReturnTheSectionAtAGivenIndex {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
RKTableSection* referenceSection = [RKTableSection section];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
id mockDelegate = [OCMockObject partialMockForObject:delegate];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didInsertSection:referenceSection
|
|
atIndex:2];
|
|
[tableController addSection:[RKTableSection section]];
|
|
[tableController addSection:[RKTableSection section]];
|
|
[tableController addSection:[RKTableSection section]];
|
|
[tableController addSection:[RKTableSection section]];
|
|
tableController.delegate = mockDelegate;
|
|
[tableController insertSection:referenceSection atIndex:2];
|
|
assertThatInt(tableController.sectionCount, is(equalToInt(6)));
|
|
assertThat([tableController sectionAtIndex:2], is(equalTo(referenceSection)));
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
- (void)testRemoveAllSections {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
id mockDelegate = [OCMockObject partialMockForObject:delegate];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didInsertSection:OCMOCK_ANY
|
|
atIndex:0];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didInsertSection:OCMOCK_ANY
|
|
atIndex:1];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didInsertSection:OCMOCK_ANY
|
|
atIndex:2];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didInsertSection:OCMOCK_ANY
|
|
atIndex:3];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didInsertSection:OCMOCK_ANY
|
|
atIndex:4];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didRemoveSection:OCMOCK_ANY
|
|
atIndex:0];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didRemoveSection:OCMOCK_ANY
|
|
atIndex:1];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didRemoveSection:OCMOCK_ANY
|
|
atIndex:2];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didRemoveSection:OCMOCK_ANY
|
|
atIndex:3];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didRemoveSection:OCMOCK_ANY
|
|
atIndex:4];
|
|
tableController.delegate = mockDelegate;
|
|
[tableController addSection:[RKTableSection section]];
|
|
[tableController addSection:[RKTableSection section]];
|
|
[tableController addSection:[RKTableSection section]];
|
|
[tableController addSection:[RKTableSection section]];
|
|
assertThatInt(tableController.sectionCount, is(equalToInt(5)));
|
|
[tableController removeAllSections];
|
|
assertThatInt(tableController.sectionCount, is(equalToInt(1)));
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
- (void)testReturnASectionByHeaderTitle {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
[tableController addSection:[RKTableSection section]];
|
|
[tableController addSection:[RKTableSection section]];
|
|
RKTableSection* titledSection = [RKTableSection section];
|
|
titledSection.headerTitle = @"Testing";
|
|
[tableController addSection:titledSection];
|
|
[tableController addSection:[RKTableSection section]];
|
|
assertThat([tableController sectionWithHeaderTitle:@"Testing"], is(equalTo(titledSection)));
|
|
}
|
|
|
|
- (void)testNotifyTheTableViewOnSectionInsertion {
|
|
RKTableControllerSpecViewController *viewController = [RKTableControllerSpecViewController new];
|
|
id mockTableView = [OCMockObject niceMockForClass:[UITableView class]];
|
|
RKTableController *tableController = [RKTableController tableControllerWithTableView:mockTableView forViewController:viewController];
|
|
[[mockTableView expect] insertSections:[NSIndexSet indexSetWithIndex:1] withRowAnimation:tableController.defaultRowAnimation];
|
|
[tableController addSection:[RKTableSection section]];
|
|
[mockTableView verify];
|
|
}
|
|
|
|
- (void)testNotifyTheTableViewOnSectionRemoval {
|
|
RKTableControllerSpecViewController *viewController = [RKTableControllerSpecViewController new];
|
|
id mockTableView = [OCMockObject niceMockForClass:[UITableView class]];
|
|
RKTableController *tableController = [RKTableController tableControllerWithTableView:mockTableView forViewController:viewController];
|
|
[[mockTableView expect] insertSections:[NSIndexSet indexSetWithIndex:1] withRowAnimation:tableController.defaultRowAnimation];
|
|
[[mockTableView expect] deleteSections:[NSIndexSet indexSetWithIndex:1] withRowAnimation:tableController.defaultRowAnimation];
|
|
RKTableSection *section = [RKTableSection section];
|
|
[tableController addSection:section];
|
|
[tableController removeSection:section];
|
|
[mockTableView verify];
|
|
}
|
|
|
|
- (void)testNotifyTheTableOfSectionRemovalAndReaddWhenRemovingAllSections {
|
|
RKTableControllerSpecViewController *viewController = [RKTableControllerSpecViewController new];
|
|
id mockTableView = [OCMockObject niceMockForClass:[UITableView class]];
|
|
RKTableController *tableController = [RKTableController tableControllerWithTableView:mockTableView forViewController:viewController];
|
|
[[mockTableView expect] deleteSections:[NSIndexSet indexSetWithIndex:0] withRowAnimation:tableController.defaultRowAnimation];
|
|
[[mockTableView expect] deleteSections:[NSIndexSet indexSetWithIndex:1] withRowAnimation:tableController.defaultRowAnimation];
|
|
[[mockTableView expect] insertSections:[NSIndexSet indexSetWithIndex:0] withRowAnimation:tableController.defaultRowAnimation];
|
|
RKTableSection *section = [RKTableSection section];
|
|
[tableController addSection:section];
|
|
[tableController removeAllSections];
|
|
[mockTableView verify];
|
|
}
|
|
|
|
#pragma mark - UITableViewDataSource specs
|
|
|
|
- (void)testRaiseAnExceptionIfSentAMessageWithATableViewItIsNotBoundTo {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
NSException* exception = nil;
|
|
@try {
|
|
[tableController numberOfSectionsInTableView:[UITableView new]];
|
|
}
|
|
@catch (NSException* e) {
|
|
exception = e;
|
|
}
|
|
@finally {
|
|
assertThat(exception, is(notNilValue()));
|
|
}
|
|
}
|
|
|
|
- (void)testReturnTheNumberOfSectionsInTableView {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
assertThatInt([tableController numberOfSectionsInTableView:viewController.tableView], is(equalToInt(1)));
|
|
[tableController addSection:[RKTableSection section]];
|
|
assertThatInt([tableController numberOfSectionsInTableView:viewController.tableView], is(equalToInt(2)));
|
|
}
|
|
|
|
- (void)testReturnTheNumberOfRowsInSectionInTableView {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
assertThatInt([tableController tableView:viewController.tableView numberOfRowsInSection:0], is(equalToInt(0)));
|
|
NSArray* objects = [NSArray arrayWithObject:@"one"];
|
|
[tableController loadObjects:objects];
|
|
assertThatInt([tableController tableView:viewController.tableView numberOfRowsInSection:0], is(equalToInt(1)));
|
|
}
|
|
|
|
- (void)testReturnTheHeaderTitleForSection {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
RKTableSection* section = [RKTableSection section];
|
|
[tableController addSection:section];
|
|
assertThat([tableController tableView:viewController.tableView titleForHeaderInSection:1], is(nilValue()));
|
|
section.headerTitle = @"RestKit!";
|
|
assertThat([tableController tableView:viewController.tableView titleForHeaderInSection:1], is(equalTo(@"RestKit!")));
|
|
}
|
|
|
|
- (void)testReturnTheTitleForFooterInSection {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
RKTableSection* section = [RKTableSection section];
|
|
[tableController addSection:section];
|
|
assertThat([tableController tableView:viewController.tableView titleForFooterInSection:1], is(nilValue()));
|
|
section.footerTitle = @"RestKit!";
|
|
assertThat([tableController tableView:viewController.tableView titleForFooterInSection:1], is(equalTo(@"RestKit!")));
|
|
}
|
|
|
|
- (void)testReturnTheNumberOfRowsAcrossAllSections {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
RKTableSection* section = [RKTableSection section];
|
|
id sectionMock = [OCMockObject partialMockForObject:section];
|
|
NSUInteger rowCount = 5;
|
|
[[[sectionMock stub] andReturnValue:OCMOCK_VALUE(rowCount)] rowCount];
|
|
[tableController addSection:section];
|
|
assertThatInt(tableController.rowCount, is(equalToInt(5)));
|
|
}
|
|
|
|
- (void)testReturnTheTableViewCellForRowAtIndexPath {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
RKTableItem* item = [RKTableItem tableItemWithText:@"Test!" detailText:@"Details!" image:nil];
|
|
[tableController loadTableItems:[NSArray arrayWithObject:item] inSection:0 withMapping:[RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* cellMapping) {
|
|
// Detail text label won't appear with default style...
|
|
cellMapping.style = UITableViewCellStyleValue1;
|
|
[cellMapping addDefaultMappings];
|
|
}]];
|
|
UITableViewCell* cell = [tableController tableView:tableController.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
assertThat(cell.textLabel.text, is(equalTo(@"Test!")));
|
|
assertThat(cell.detailTextLabel.text, is(equalTo(@"Details!")));
|
|
|
|
}
|
|
|
|
#pragma mark - Table Cell Mapping
|
|
|
|
- (void)testInitializeCellMappings {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
assertThat(tableController.cellMappings, is(notNilValue()));
|
|
}
|
|
|
|
- (void)testRegisterMappingsForObjectsToTableViewCell {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
assertThat([tableController.cellMappings cellMappingForClass:[RKTestUser class]], is(nilValue()));
|
|
[tableController mapObjectsWithClass:[RKTestUser class] toTableCellsWithMapping:[RKTableViewCellMapping cellMapping]];
|
|
RKObjectMapping* mapping = [tableController.cellMappings cellMappingForClass:[RKTestUser class]];
|
|
assertThat(mapping, isNot(nilValue()));
|
|
assertThatBool([mapping.objectClass isSubclassOfClass:[UITableViewCell class]], is(equalToBool(YES)));
|
|
}
|
|
|
|
- (void)testDefaultTheReuseIdentifierToTheNameOfTheObjectClass {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
assertThat([tableController.cellMappings cellMappingForClass:[RKTestUser class]], is(nilValue()));
|
|
RKTableViewCellMapping* cellMapping = [RKTableViewCellMapping cellMapping];
|
|
[tableController mapObjectsWithClass:[RKTestUser class] toTableCellsWithMapping:cellMapping];
|
|
assertThat(cellMapping.reuseIdentifier, is(equalTo(@"UITableViewCell")));
|
|
}
|
|
|
|
- (void)testDefaultTheReuseIdentifierToTheNameOfTheObjectClassWhenCreatingMappingWithBlockSyntax {
|
|
RKTableControllerTestTableViewController *viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController *tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
assertThat([tableController.cellMappings cellMappingForClass:[RKTestUser class]], is(nilValue()));
|
|
RKTableViewCellMapping *cellMapping = [RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping *cellMapping) {
|
|
cellMapping.cellClass = [RKTestUserTableViewCell class];
|
|
}];
|
|
[tableController mapObjectsWithClass:[RKTestUser class] toTableCellsWithMapping:cellMapping];
|
|
assertThat(cellMapping.reuseIdentifier, is(equalTo(@"RKTestUserTableViewCell")));
|
|
}
|
|
|
|
- (void)testReturnTheObjectForARowAtIndexPath {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
RKTestUser* user = [RKTestUser user];
|
|
[tableController loadObjects:[NSArray arrayWithObject:user]];
|
|
NSIndexPath* indexPath = [NSIndexPath indexPathForRow:0 inSection:0];
|
|
assertThatBool(user == [tableController objectForRowAtIndexPath:indexPath], is(equalToBool(YES)));
|
|
}
|
|
|
|
- (void)testReturnTheCellMappingForTheRowAtIndexPath {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
RKTableViewCellMapping* cellMapping = [RKTableViewCellMapping cellMapping];
|
|
[tableController mapObjectsWithClass:[RKTestUser class] toTableCellsWithMapping:cellMapping];
|
|
[tableController loadObjects:[NSArray arrayWithObject:[RKTestUser user]]];
|
|
NSIndexPath* indexPath = [NSIndexPath indexPathForRow:0 inSection:0];
|
|
assertThat([tableController cellMappingForObjectAtIndexPath:indexPath], is(equalTo(cellMapping)));
|
|
}
|
|
|
|
- (void)testReturnATableViewCellForTheObjectAtAGivenIndexPath {
|
|
RKMappableObject* object = [RKMappableObject new];
|
|
object.stringTest = @"Testing!!";
|
|
RKTableViewCellMapping* cellMapping = [RKTableViewCellMapping mappingForClass:[UITableViewCell class]];
|
|
[cellMapping mapKeyPath:@"stringTest" toAttribute:@"textLabel.text"];
|
|
NSArray* objects = [NSArray arrayWithObject:object];
|
|
RKTableViewCellMappings* mappings = [RKTableViewCellMappings new];
|
|
[mappings setCellMapping:cellMapping forClass:[RKMappableObject class]];
|
|
RKTableSection* section = [RKTableSection sectionForObjects:objects withMappings:mappings];
|
|
UITableViewController* tableViewController = [UITableViewController new];
|
|
tableViewController.tableView = [[UITableView alloc] initWithFrame:CGRectMake(0,0,0,0) style:UITableViewStylePlain];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:tableViewController];
|
|
[tableController insertSection:section atIndex:0];
|
|
tableController.cellMappings = mappings;
|
|
|
|
UITableViewCell* cell = [tableController cellForObjectAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
assertThat(cell, isNot(nilValue()));
|
|
assertThat(cell.textLabel.text, is(equalTo(@"Testing!!")));
|
|
}
|
|
|
|
- (void)testChangeTheReuseIdentifierWhenMutatedWithinTheBlockInitializer {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
assertThat([tableController.cellMappings cellMappingForClass:[RKTestUser class]], is(nilValue()));
|
|
[tableController mapObjectsWithClass:[RKTestUser class] toTableCellsWithMapping:[RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping *cellMapping) {
|
|
cellMapping.cellClass = [RKTestUserTableViewCell class];
|
|
cellMapping.reuseIdentifier = @"RKTestUserOverride";
|
|
}]];
|
|
RKTableViewCellMapping* userCellMapping = [tableController.cellMappings cellMappingForClass:[RKTestUser class]];
|
|
assertThat(userCellMapping, isNot(nilValue()));
|
|
assertThat(userCellMapping.reuseIdentifier, is(equalTo(@"RKTestUserOverride")));
|
|
}
|
|
|
|
#pragma mark - Static Object Loading
|
|
|
|
- (void)testLoadAnArrayOfObjects {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
NSArray* objects = [NSArray arrayWithObject:@"one"];
|
|
assertThat([tableController sectionAtIndex:0].objects, is(empty()));
|
|
[tableController loadObjects:objects];
|
|
assertThat([tableController sectionAtIndex:0].objects, is(equalTo(objects)));
|
|
}
|
|
|
|
- (void)testLoadAnArrayOfObjectsToTheSpecifiedSection {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
[tableController addSection:[RKTableSection section]];
|
|
NSArray* objects = [NSArray arrayWithObject:@"one"];
|
|
assertThat([tableController sectionAtIndex:1].objects, is(empty()));
|
|
[tableController loadObjects:objects inSection:1];
|
|
assertThat([tableController sectionAtIndex:1].objects, is(equalTo(objects)));
|
|
}
|
|
|
|
- (void)testLoadAnArrayOfTableItems {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
NSArray* tableItems = [RKTableItem tableItemsFromStrings:@"One", @"Two", @"Three", nil];
|
|
[tableController loadTableItems:tableItems];
|
|
assertThatBool([tableController isLoaded], is(equalToBool(YES)));
|
|
assertThatInt(tableController.rowCount, is(equalToInt(3)));
|
|
UITableViewCell* cellOne = [tableController tableView:tableController.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
UITableViewCell* cellTwo = [tableController tableView:tableController.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:1 inSection:0]];
|
|
UITableViewCell* cellThree = [tableController tableView:tableController.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:2 inSection:0]];
|
|
assertThat(cellOne.textLabel.text, is(equalTo(@"One")));
|
|
assertThat(cellTwo.textLabel.text, is(equalTo(@"Two")));
|
|
assertThat(cellThree.textLabel.text, is(equalTo(@"Three")));
|
|
}
|
|
|
|
- (void)testAllowYouToTriggerAnEmptyLoad {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
assertThatBool([tableController isLoaded], is(equalToBool(NO)));
|
|
[tableController loadEmpty];
|
|
assertThatBool([tableController isLoaded], is(equalToBool(YES)));
|
|
assertThatBool([tableController isEmpty], is(equalToBool(YES)));
|
|
}
|
|
|
|
#pragma mark - Network Load
|
|
|
|
- (void)testLoadCollectionOfObjectsAndMapThemIntoTableViewCells {
|
|
RKObjectManager* objectManager = [RKTestFactory objectManager];
|
|
objectManager.client.cachePolicy = RKRequestCachePolicyNone;
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.objectManager = objectManager;
|
|
[tableController mapObjectsWithClass:[RKTestUser class] toTableCellsWithMapping:[RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* mapping) {
|
|
mapping.cellClass = [RKTestUserTableViewCell class];
|
|
[mapping mapKeyPath:@"name" toAttribute:@"textLabel.text"];
|
|
[mapping mapKeyPath:@"nickName" toAttribute:@"detailTextLabel.text"];
|
|
}]];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate tableControllerDelegate];
|
|
delegate.timeout = 10;
|
|
tableController.delegate = delegate;
|
|
[tableController loadTableFromResourcePath:@"/JSON/users.json" usingBlock:^(RKObjectLoader* objectLoader) {
|
|
objectLoader.objectMapping = [RKObjectMapping mappingForClass:[RKTestUser class] usingBlock:^(RKObjectMapping* mapping) {
|
|
[mapping mapAttributes:@"name", nil];
|
|
}];
|
|
}];
|
|
[delegate waitForLoad];
|
|
assertThatBool([tableController isLoaded], is(equalToBool(YES)));
|
|
assertThatInt(tableController.rowCount, is(equalToInt(3)));
|
|
}
|
|
|
|
- (void)testSetTheModelToTheLoadedStateIfObjectsAreLoadedSuccessfully {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
assertThatBool([tableController isLoaded], is(equalToBool(NO)));
|
|
NSArray* objects = [NSArray arrayWithObject:[RKTestUser new]];
|
|
id mockLoader = [OCMockObject mockForClass:[RKObjectLoader class]];
|
|
[tableController objectLoader:mockLoader didLoadObjects:objects];
|
|
assertThatBool([tableController isLoading], is(equalToBool(NO)));
|
|
assertThatBool([tableController isLoaded], is(equalToBool(YES)));
|
|
}
|
|
|
|
- (void)testSetTheModelToErrorStateIfTheObjectLoaderFailsWithAnError {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
id mockObjectLoader = [OCMockObject niceMockForClass:[RKObjectLoader class]];
|
|
NSError* error = [NSError errorWithDomain:@"Test" code:0 userInfo:nil];
|
|
[tableController objectLoader:mockObjectLoader didFailWithError:error];
|
|
assertThatBool([tableController isLoading], is(equalToBool(NO)));
|
|
assertThatBool([tableController isLoaded], is(equalToBool(YES)));
|
|
assertThatBool([tableController isError], is(equalToBool(YES)));
|
|
assertThatBool([tableController isEmpty], is(equalToBool(YES)));
|
|
}
|
|
|
|
- (void)testSetTheModelToAnEmptyStateIfTheObjectLoaderReturnsAnEmptyCollection {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
assertThatBool([tableController isLoaded], is(equalToBool(NO)));
|
|
NSArray* objects = [NSArray array];
|
|
id mockLoader = [OCMockObject mockForClass:[RKObjectLoader class]];
|
|
[tableController objectLoader:mockLoader didLoadObjects:objects];
|
|
assertThatBool([tableController isLoading], is(equalToBool(NO)));
|
|
assertThatBool([tableController isEmpty], is(equalToBool(YES)));
|
|
}
|
|
|
|
- (void)testSetTheModelToALoadedStateEvenIfTheObjectLoaderReturnsAnEmptyCollection {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
assertThatBool([tableController isLoaded], is(equalToBool(NO)));
|
|
NSArray* objects = [NSArray array];
|
|
id mockLoader = [OCMockObject mockForClass:[RKObjectLoader class]];
|
|
[tableController objectLoader:mockLoader didLoadObjects:objects];
|
|
assertThatBool([tableController isLoading], is(equalToBool(NO)));
|
|
assertThatBool([tableController isEmpty], is(equalToBool(YES)));
|
|
assertThatBool([tableController isLoaded], is(equalToBool(YES)));
|
|
}
|
|
|
|
- (void)testEnterTheLoadingStateWhenTheRequestStartsLoading {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
assertThatBool([tableController isLoaded], is(equalToBool(NO)));
|
|
assertThatBool([tableController isLoading], is(equalToBool(NO)));
|
|
id mockLoader = [OCMockObject mockForClass:[RKObjectLoader class]];
|
|
[tableController requestDidStartLoad:mockLoader];
|
|
assertThatBool([tableController isLoading], is(equalToBool(YES)));
|
|
}
|
|
|
|
- (void)testExitTheLoadingStateWhenTheRequestFinishesLoading {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
assertThatBool([tableController isLoaded], is(equalToBool(NO)));
|
|
assertThatBool([tableController isLoading], is(equalToBool(NO)));
|
|
id mockLoader = [OCMockObject mockForClass:[RKObjectLoader class]];
|
|
[tableController requestDidStartLoad:mockLoader];
|
|
assertThatBool([tableController isLoading], is(equalToBool(YES)));
|
|
[tableController objectLoaderDidFinishLoading:mockLoader];
|
|
assertThatBool([tableController isLoading], is(equalToBool(NO)));
|
|
}
|
|
|
|
- (void)testClearTheLoadingStateWhenARequestIsCancelled {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
assertThatBool([tableController isLoaded], is(equalToBool(NO)));
|
|
assertThatBool([tableController isLoading], is(equalToBool(NO)));
|
|
id mockLoader = [OCMockObject mockForClass:[RKObjectLoader class]];
|
|
[tableController requestDidStartLoad:mockLoader];
|
|
assertThatBool([tableController isLoading], is(equalToBool(YES)));
|
|
[tableController requestDidCancelLoad:mockLoader];
|
|
assertThatBool([tableController isLoading], is(equalToBool(NO)));
|
|
}
|
|
|
|
- (void)testClearTheLoadingStateWhenARequestTimesOut {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
assertThatBool([tableController isLoaded], is(equalToBool(NO)));
|
|
assertThatBool([tableController isLoading], is(equalToBool(NO)));
|
|
id mockLoader = [OCMockObject mockForClass:[RKObjectLoader class]];
|
|
[tableController requestDidStartLoad:mockLoader];
|
|
assertThatBool([tableController isLoading], is(equalToBool(YES)));
|
|
[tableController requestDidTimeout:mockLoader];
|
|
assertThatBool([tableController isLoading], is(equalToBool(NO)));
|
|
}
|
|
|
|
- (void)testDoSomethingWhenTheRequestLoadsAnUnexpectedResponse {
|
|
RKLogCritical(@"PENDING - Undefined Behavior!!!");
|
|
}
|
|
|
|
- (void)testLoadCollectionOfObjectsAndMapThemIntoSections {
|
|
RKObjectManager* objectManager = [RKTestFactory objectManager];
|
|
objectManager.client.cachePolicy = RKRequestCachePolicyNone;
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.objectManager = objectManager;
|
|
[tableController mapObjectsWithClass:[RKTestUser class] toTableCellsWithMapping:[RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* mapping) {
|
|
mapping.cellClass = [RKTestUserTableViewCell class];
|
|
[mapping mapKeyPath:@"name" toAttribute:@"textLabel.text"];
|
|
[mapping mapKeyPath:@"nickName" toAttribute:@"detailTextLabel.text"];
|
|
}]];
|
|
tableController.sectionNameKeyPath = @"name";
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate tableControllerDelegate];
|
|
delegate.timeout = 10;
|
|
tableController.delegate = delegate;
|
|
[tableController loadTableFromResourcePath:@"/JSON/users.json" usingBlock:^(RKObjectLoader* objectLoader) {
|
|
objectLoader.objectMapping = [RKObjectMapping mappingForClass:[RKTestUser class] usingBlock:^(RKObjectMapping* mapping) {
|
|
[mapping mapAttributes:@"name", nil];
|
|
}];
|
|
}];
|
|
[delegate waitForLoad];
|
|
assertThatBool([tableController isLoaded], is(equalToBool(YES)));
|
|
assertThatInt(tableController.sectionCount, is(equalToInt(3)));
|
|
assertThatInt(tableController.rowCount, is(equalToInt(3)));
|
|
}
|
|
|
|
#pragma mark - RKTableViewDelegate specs
|
|
|
|
- (void)testNotifyTheDelegateWhenLoadingStarts {
|
|
RKObjectManager* objectManager = [RKTestFactory objectManager];
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.objectManager = objectManager;
|
|
[tableController mapObjectsWithClass:[RKTestUser class] toTableCellsWithMapping:[RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* mapping) {
|
|
mapping.cellClass = [RKTestUserTableViewCell class];
|
|
[mapping mapKeyPath:@"name" toAttribute:@"textLabel.text"];
|
|
[mapping mapKeyPath:@"nickName" toAttribute:@"detailTextLabel.text"];
|
|
}]];
|
|
id mockDelegate = [OCMockObject partialMockForObject:[RKTestTableControllerDelegate new]];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableControllerDidStartLoad:tableController];
|
|
tableController.delegate = mockDelegate;
|
|
[tableController loadTableFromResourcePath:@"/JSON/users.json" usingBlock:^(RKObjectLoader* objectLoader) {
|
|
objectLoader.objectMapping = [RKObjectMapping mappingForClass:[RKTestUser class] usingBlock:^(RKObjectMapping* mapping) {
|
|
[mapping mapAttributes:@"name", nil];
|
|
}];
|
|
}];
|
|
[mockDelegate waitForLoad];
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
- (void)testNotifyTheDelegateWhenLoadingFinishes {
|
|
RKObjectManager* objectManager = [RKTestFactory objectManager];
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.objectManager = objectManager;
|
|
[tableController mapObjectsWithClass:[RKTestUser class] toTableCellsWithMapping:[RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* mapping) {
|
|
mapping.cellClass = [RKTestUserTableViewCell class];
|
|
[mapping mapKeyPath:@"name" toAttribute:@"textLabel.text"];
|
|
[mapping mapKeyPath:@"nickName" toAttribute:@"detailTextLabel.text"];
|
|
}]];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
id mockDelegate = [OCMockObject partialMockForObject:delegate];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableControllerDidFinishLoad:tableController];
|
|
tableController.delegate = mockDelegate;
|
|
[tableController loadTableFromResourcePath:@"/JSON/users.json" usingBlock:^(RKObjectLoader* objectLoader) {
|
|
objectLoader.objectMapping = [RKObjectMapping mappingForClass:[RKTestUser class] usingBlock:^(RKObjectMapping* mapping) {
|
|
[mapping mapAttributes:@"name", nil];
|
|
}];
|
|
}];
|
|
[mockDelegate waitForLoad];
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
- (void)testNotifyTheDelegateOnDidFinalizeLoad {
|
|
RKObjectManager* objectManager = [RKTestFactory objectManager];
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.objectManager = objectManager;
|
|
[tableController mapObjectsWithClass:[RKTestUser class] toTableCellsWithMapping:[RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* mapping) {
|
|
mapping.cellClass = [RKTestUserTableViewCell class];
|
|
[mapping mapKeyPath:@"name" toAttribute:@"textLabel.text"];
|
|
[mapping mapKeyPath:@"nickName" toAttribute:@"detailTextLabel.text"];
|
|
}]];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
id mockDelegate = [OCMockObject partialMockForObject:delegate];
|
|
[[mockDelegate expect] tableControllerDidFinalizeLoad:tableController];
|
|
tableController.delegate = mockDelegate;
|
|
[tableController loadTableFromResourcePath:@"/JSON/users.json" usingBlock:^(RKObjectLoader* objectLoader) {
|
|
objectLoader.objectMapping = [RKObjectMapping mappingForClass:[RKTestUser class] usingBlock:^(RKObjectMapping* mapping) {
|
|
[mapping mapAttributes:@"name", nil];
|
|
}];
|
|
}];
|
|
[mockDelegate waitForLoad];
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
- (void)testNotifyTheDelegateWhenAnErrorOccurs {
|
|
RKObjectManager* objectManager = [RKTestFactory objectManager];
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.objectManager = objectManager;
|
|
[tableController mapObjectsWithClass:[RKTestUser class] toTableCellsWithMapping:[RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* mapping) {
|
|
mapping.cellClass = [RKTestUserTableViewCell class];
|
|
[mapping mapKeyPath:@"name" toAttribute:@"textLabel.text"];
|
|
[mapping mapKeyPath:@"nickName" toAttribute:@"detailTextLabel.text"];
|
|
}]];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
id mockDelegate = [OCMockObject partialMockForObject:delegate];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController didFailLoadWithError:OCMOCK_ANY];
|
|
tableController.delegate = mockDelegate;
|
|
[tableController loadTableFromResourcePath:@"/fail" usingBlock:^(RKObjectLoader* objectLoader) {
|
|
objectLoader.objectMapping = [RKObjectMapping mappingForClass:[RKTestUser class] usingBlock:^(RKObjectMapping* mapping) {
|
|
[mapping mapAttributes:@"name", nil];
|
|
}];
|
|
}];
|
|
[mockDelegate waitForLoad];
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
- (void)testNotifyTheDelegateWhenAnEmptyCollectionIsLoaded {
|
|
RKObjectManager* objectManager = [RKTestFactory objectManager];
|
|
objectManager.client.cachePolicy = RKRequestCachePolicyNone;
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.objectManager = objectManager;
|
|
[tableController mapObjectsWithClass:[RKTestUser class] toTableCellsWithMapping:[RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* mapping) {
|
|
mapping.cellClass = [RKTestUserTableViewCell class];
|
|
[mapping mapKeyPath:@"name" toAttribute:@"textLabel.text"];
|
|
[mapping mapKeyPath:@"nickName" toAttribute:@"detailTextLabel.text"];
|
|
}]];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
delegate.timeout = 5;
|
|
id mockDelegate = [OCMockObject partialMockForObject:delegate];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableControllerDidBecomeEmpty:tableController];
|
|
tableController.delegate = mockDelegate;
|
|
[tableController loadTableFromResourcePath:@"/empty/array" usingBlock:^(RKObjectLoader* objectLoader) {
|
|
objectLoader.objectMapping = [RKObjectMapping mappingForClass:[RKTestUser class] usingBlock:^(RKObjectMapping* mapping) {
|
|
[mapping mapAttributes:@"name", nil];
|
|
}];
|
|
}];
|
|
[mockDelegate waitForLoad];
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
- (void)testNotifyTheDelegateWhenModelWillLoadWithObjectLoader {
|
|
RKObjectManager* objectManager = [RKTestFactory objectManager];
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.objectManager = objectManager;
|
|
[tableController mapObjectsWithClass:[RKTestUser class] toTableCellsWithMapping:[RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* mapping) {
|
|
mapping.cellClass = [RKTestUserTableViewCell class];
|
|
[mapping mapKeyPath:@"name" toAttribute:@"textLabel.text"];
|
|
[mapping mapKeyPath:@"nickName" toAttribute:@"detailTextLabel.text"];
|
|
}]];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
id mockDelegate = [OCMockObject partialMockForObject:delegate];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController willLoadTableWithObjectLoader:OCMOCK_ANY];
|
|
tableController.delegate = mockDelegate;
|
|
[tableController loadTableFromResourcePath:@"/empty/array" usingBlock:^(RKObjectLoader* objectLoader) {
|
|
objectLoader.objectMapping = [RKObjectMapping mappingForClass:[RKTestUser class] usingBlock:^(RKObjectMapping* mapping) {
|
|
[mapping mapAttributes:@"name", nil];
|
|
}];
|
|
}];
|
|
[mockDelegate waitForLoad];
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
- (void)testNotifyTheDelegateWhenModelDidLoadWithObjectLoader {
|
|
RKObjectManager* objectManager = [RKTestFactory objectManager];
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.objectManager = objectManager;
|
|
[tableController mapObjectsWithClass:[RKTestUser class] toTableCellsWithMapping:[RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* mapping) {
|
|
mapping.cellClass = [RKTestUserTableViewCell class];
|
|
[mapping mapKeyPath:@"name" toAttribute:@"textLabel.text"];
|
|
[mapping mapKeyPath:@"nickName" toAttribute:@"detailTextLabel.text"];
|
|
}]];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
id mockDelegate = [OCMockObject partialMockForObject:delegate];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController didLoadTableWithObjectLoader:OCMOCK_ANY];
|
|
tableController.delegate = mockDelegate;
|
|
[tableController loadTableFromResourcePath:@"/empty/array" usingBlock:^(RKObjectLoader* objectLoader) {
|
|
objectLoader.objectMapping = [RKObjectMapping mappingForClass:[RKTestUser class] usingBlock:^(RKObjectMapping* mapping) {
|
|
[mapping mapAttributes:@"name", nil];
|
|
}];
|
|
}];
|
|
[mockDelegate waitForLoad];
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
- (void)testNotifyTheDelegateWhenModelDidCancelLoad {
|
|
RKObjectManager* objectManager = [RKTestFactory objectManager];
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.objectManager = objectManager;
|
|
[tableController mapObjectsWithClass:[RKTestUser class] toTableCellsWithMapping:[RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* mapping) {
|
|
mapping.cellClass = [RKTestUserTableViewCell class];
|
|
[mapping mapKeyPath:@"name" toAttribute:@"textLabel.text"];
|
|
[mapping mapKeyPath:@"nickName" toAttribute:@"detailTextLabel.text"];
|
|
}]];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
id mockDelegate = [OCMockObject partialMockForObject:delegate];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableControllerDidCancelLoad:tableController];
|
|
tableController.delegate = mockDelegate;
|
|
[tableController loadTableFromResourcePath:@"/empty/array" usingBlock:^(RKObjectLoader* objectLoader) {
|
|
objectLoader.objectMapping = [RKObjectMapping mappingForClass:[RKTestUser class] usingBlock:^(RKObjectMapping* mapping) {
|
|
[mapping mapAttributes:@"name", nil];
|
|
}];
|
|
}];
|
|
[tableController cancelLoad];
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
- (void)testNotifyTheDelegateWhenDidEndEditingARow {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
RKTableItem* tableItem = [RKTableItem tableItem];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
id mockDelegate = [OCMockObject partialMockForObject:delegate];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didEndEditing:OCMOCK_ANY
|
|
atIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
tableController.delegate = mockDelegate;
|
|
[tableController loadTableItems:[NSArray arrayWithObject:tableItem]];
|
|
[tableController tableView:tableController.tableView didEndEditingRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
- (void)testNotifyTheDelegateWhenWillBeginEditingARow {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
RKTableItem* tableItem = [RKTableItem tableItem];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
id mockDelegate = [OCMockObject partialMockForObject:delegate];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
willBeginEditing:OCMOCK_ANY
|
|
atIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
tableController.delegate = mockDelegate;
|
|
[tableController loadTableItems:[NSArray arrayWithObject:tableItem]];
|
|
[tableController tableView:tableController.tableView willBeginEditingRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
- (void)testNotifyTheDelegateWhenAnObjectIsInserted {
|
|
NSArray* objects = [NSArray arrayWithObject:@"first object"];
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
id mockDelegate = [OCMockObject partialMockForObject:delegate];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didInsertObject:@"first object"
|
|
atIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didInsertObject:@"new object"
|
|
atIndexPath:[NSIndexPath indexPathForRow:1 inSection:0]];
|
|
tableController.delegate = mockDelegate;
|
|
[tableController loadObjects:objects];
|
|
assertThat([tableController objectForRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]],
|
|
is(equalTo(@"first object")));
|
|
[[tableController.sections objectAtIndex:0] insertObject:@"new object" atIndex:1];
|
|
assertThat([[tableController.sections objectAtIndex:0] objectAtIndex:0], is(equalTo(@"first object")));
|
|
assertThat([[tableController.sections objectAtIndex:0] objectAtIndex:1], is(equalTo(@"new object")));
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
- (void)testNotifyTheDelegateWhenAnObjectIsUpdated {
|
|
NSArray* objects = [NSArray arrayWithObjects:@"first object", @"second object", nil];
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
id mockDelegate = [OCMockObject partialMockForObject:delegate];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didInsertObject:@"first object"
|
|
atIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didInsertObject:@"second object"
|
|
atIndexPath:[NSIndexPath indexPathForRow:1 inSection:0]];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didUpdateObject:@"new second object"
|
|
atIndexPath:[NSIndexPath indexPathForRow:1 inSection:0]];
|
|
tableController.delegate = mockDelegate;
|
|
[tableController loadObjects:objects];
|
|
assertThat([[tableController.sections objectAtIndex:0] objectAtIndex:0], is(equalTo(@"first object")));
|
|
assertThat([[tableController.sections objectAtIndex:0] objectAtIndex:1], is(equalTo(@"second object")));
|
|
[[tableController.sections objectAtIndex:0] replaceObjectAtIndex:1 withObject:@"new second object"];
|
|
assertThat([[tableController.sections objectAtIndex:0] objectAtIndex:1], is(equalTo(@"new second object")));
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
- (void)testNotifyTheDelegateWhenAnObjectIsDeleted {
|
|
NSArray* objects = [NSArray arrayWithObjects:@"first object", @"second object", nil];
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
id mockDelegate = [OCMockObject partialMockForObject:delegate];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didInsertObject:@"first object"
|
|
atIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didInsertObject:@"second object"
|
|
atIndexPath:[NSIndexPath indexPathForRow:1 inSection:0]];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
didDeleteObject:@"second object"
|
|
atIndexPath:[NSIndexPath indexPathForRow:1 inSection:0]];
|
|
tableController.delegate = mockDelegate;
|
|
[tableController loadObjects:objects];
|
|
assertThat([[tableController.sections objectAtIndex:0] objectAtIndex:0], is(equalTo(@"first object")));
|
|
assertThat([[tableController.sections objectAtIndex:0] objectAtIndex:1], is(equalTo(@"second object")));
|
|
[[tableController.sections objectAtIndex:0] removeObjectAtIndex:1];
|
|
assertThat([[tableController.sections objectAtIndex:0] objectAtIndex:0], is(equalTo(@"first object")));
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
#pragma mark - Notifications
|
|
|
|
- (void)testPostANotificationWhenLoadingStarts {
|
|
RKObjectManager* objectManager = [RKTestFactory objectManager];
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.objectManager = objectManager;
|
|
[tableController mapObjectsWithClass:[RKTestUser class] toTableCellsWithMapping:[RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* mapping) {
|
|
mapping.cellClass = [RKTestUserTableViewCell class];
|
|
[mapping mapKeyPath:@"name" toAttribute:@"textLabel.text"];
|
|
[mapping mapKeyPath:@"nickName" toAttribute:@"detailTextLabel.text"];
|
|
}]];
|
|
id observerMock = [OCMockObject observerMock];
|
|
[[NSNotificationCenter defaultCenter] addMockObserver:observerMock name:RKTableControllerDidStartLoadNotification object:tableController];
|
|
[[observerMock expect] notificationWithName:RKTableControllerDidStartLoadNotification object:tableController];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
tableController.delegate = delegate;
|
|
[tableController loadTableFromResourcePath:@"/JSON/users.json" usingBlock:^(RKObjectLoader* objectLoader) {
|
|
objectLoader.objectMapping = [RKObjectMapping mappingForClass:[RKTestUser class] usingBlock:^(RKObjectMapping* mapping) {
|
|
[mapping mapAttributes:@"name", nil];
|
|
}];
|
|
}];
|
|
[delegate waitForLoad];
|
|
[observerMock verify];
|
|
}
|
|
|
|
- (void)testPostANotificationWhenLoadingFinishes {
|
|
RKObjectManager* objectManager = [RKTestFactory objectManager];
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.objectManager = objectManager;
|
|
[tableController mapObjectsWithClass:[RKTestUser class] toTableCellsWithMapping:[RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* mapping) {
|
|
mapping.cellClass = [RKTestUserTableViewCell class];
|
|
[mapping mapKeyPath:@"name" toAttribute:@"textLabel.text"];
|
|
[mapping mapKeyPath:@"nickName" toAttribute:@"detailTextLabel.text"];
|
|
}]];
|
|
|
|
id observerMock = [OCMockObject observerMock];
|
|
[[NSNotificationCenter defaultCenter] addMockObserver:observerMock name:RKTableControllerDidFinishLoadNotification object:tableController];
|
|
[[observerMock expect] notificationWithName:RKTableControllerDidFinishLoadNotification object:tableController];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
tableController.delegate = delegate;
|
|
|
|
[tableController loadTableFromResourcePath:@"/JSON/users.json" usingBlock:^(RKObjectLoader* objectLoader) {
|
|
objectLoader.objectMapping = [RKObjectMapping mappingForClass:[RKTestUser class] usingBlock:^(RKObjectMapping* mapping) {
|
|
[mapping mapAttributes:@"name", nil];
|
|
}];
|
|
}];
|
|
[delegate waitForLoad];
|
|
[observerMock verify];
|
|
}
|
|
|
|
- (void)testPostANotificationWhenAnErrorOccurs {
|
|
RKObjectManager* objectManager = [RKTestFactory objectManager];
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.objectManager = objectManager;
|
|
[tableController mapObjectsWithClass:[RKTestUser class] toTableCellsWithMapping:[RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* mapping) {
|
|
mapping.cellClass = [RKTestUserTableViewCell class];
|
|
[mapping mapKeyPath:@"name" toAttribute:@"textLabel.text"];
|
|
[mapping mapKeyPath:@"nickName" toAttribute:@"detailTextLabel.text"];
|
|
}]];
|
|
|
|
id observerMock = [OCMockObject observerMock];
|
|
[[NSNotificationCenter defaultCenter] addMockObserver:observerMock name:RKTableControllerDidLoadErrorNotification object:tableController];
|
|
[[observerMock expect] notificationWithName:RKTableControllerDidLoadErrorNotification object:tableController userInfo:OCMOCK_ANY];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
tableController.delegate = delegate;
|
|
|
|
[tableController loadTableFromResourcePath:@"/fail" usingBlock:^(RKObjectLoader* objectLoader) {
|
|
objectLoader.objectMapping = [RKObjectMapping mappingForClass:[RKTestUser class] usingBlock:^(RKObjectMapping* mapping) {
|
|
[mapping mapAttributes:@"name", nil];
|
|
}];
|
|
}];
|
|
[delegate waitForLoad];
|
|
[observerMock verify];
|
|
}
|
|
|
|
- (void)testPostANotificationWhenAnEmptyCollectionIsLoaded {
|
|
RKObjectManager* objectManager = [RKTestFactory objectManager];
|
|
objectManager.client.cachePolicy = RKRequestCachePolicyNone;
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.objectManager = objectManager;
|
|
[tableController mapObjectsWithClass:[RKTestUser class] toTableCellsWithMapping:[RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* mapping) {
|
|
mapping.cellClass = [RKTestUserTableViewCell class];
|
|
[mapping mapKeyPath:@"name" toAttribute:@"textLabel.text"];
|
|
[mapping mapKeyPath:@"nickName" toAttribute:@"detailTextLabel.text"];
|
|
}]];
|
|
|
|
id observerMock = [OCMockObject observerMock];
|
|
[[NSNotificationCenter defaultCenter] addMockObserver:observerMock name:RKTableControllerDidLoadEmptyNotification object:tableController];
|
|
[[observerMock expect] notificationWithName:RKTableControllerDidLoadEmptyNotification object:tableController];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
tableController.delegate = delegate;
|
|
[tableController loadTableFromResourcePath:@"/empty/array" usingBlock:^(RKObjectLoader* objectLoader) {
|
|
objectLoader.objectMapping = [RKObjectMapping mappingForClass:[RKTestUser class] usingBlock:^(RKObjectMapping* mapping) {
|
|
[mapping mapAttributes:@"name", nil];
|
|
}];
|
|
}];
|
|
[delegate waitForLoad];
|
|
[observerMock verify];
|
|
}
|
|
|
|
#pragma mark - State Views
|
|
|
|
- (void)testPermitYouToOverlayAnImageOnTheTable {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
UIImage* image = [RKTestFixture imageWithContentsOfFixture:@"blake.png"];
|
|
[tableController showImageInOverlay:image];
|
|
UIImageView* imageView = tableController.stateOverlayImageView;
|
|
assertThat(imageView, isNot(nilValue()));
|
|
assertThat(imageView.image, is(equalTo(image)));
|
|
}
|
|
|
|
- (void)testPermitYouToRemoveAnImageOverlayFromTheTable {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
UIImage* image = [RKTestFixture imageWithContentsOfFixture:@"blake.png"];
|
|
[tableController showImageInOverlay:image];
|
|
assertThat([tableController.tableView.superview subviews], isNot(empty()));
|
|
[tableController removeImageOverlay];
|
|
assertThat([tableController.tableView.superview subviews], is(nilValue()));
|
|
}
|
|
|
|
- (void)testTriggerDisplayOfTheErrorViewOnTransitionToErrorState {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
UIImage* image = [RKTestFixture imageWithContentsOfFixture:@"blake.png"];
|
|
tableController.imageForError = image;
|
|
id mockError = [OCMockObject mockForClass:[NSError class]];
|
|
[tableController objectLoader:nil didFailWithError:mockError];
|
|
assertThatBool([tableController isError], is(equalToBool(YES)));
|
|
UIImageView* imageView = tableController.stateOverlayImageView;
|
|
assertThat(imageView, isNot(nilValue()));
|
|
assertThat(imageView.image, is(equalTo(image)));
|
|
}
|
|
|
|
- (void)testTriggerHidingOfTheErrorViewOnTransitionOutOfTheErrorState {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
UIImage* image = [RKTestFixture imageWithContentsOfFixture:@"blake.png"];
|
|
tableController.imageForError = image;
|
|
id mockError = [OCMockObject niceMockForClass:[NSError class]];
|
|
[tableController objectLoader:nil didFailWithError:mockError];
|
|
assertThatBool([tableController isError], is(equalToBool(YES)));
|
|
UIImageView* imageView = tableController.stateOverlayImageView;
|
|
assertThat(imageView, isNot(nilValue()));
|
|
assertThat(imageView.image, is(equalTo(image)));
|
|
[tableController loadTableItems:[NSArray arrayWithObject:[RKTableItem tableItem]]];
|
|
assertThat(tableController.error, is(nilValue()));
|
|
assertThat(tableController.stateOverlayImageView.image, is(nilValue()));
|
|
}
|
|
|
|
- (void)testTriggerDisplayOfTheEmptyViewOnTransitionToEmptyState {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
UIImage* image = [RKTestFixture imageWithContentsOfFixture:@"blake.png"];
|
|
tableController.imageForEmpty = image;
|
|
[tableController loadEmpty];
|
|
assertThatBool([tableController isEmpty], is(equalToBool(YES)));
|
|
UIImageView* imageView = tableController.stateOverlayImageView;
|
|
assertThat(imageView, isNot(nilValue()));
|
|
assertThat(imageView.image, is(equalTo(image)));
|
|
}
|
|
|
|
- (void)testTriggerHidingOfTheEmptyViewOnTransitionOutOfTheEmptyState {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
UIImage* image = [RKTestFixture imageWithContentsOfFixture:@"blake.png"];
|
|
tableController.imageForEmpty = image;
|
|
[tableController loadEmpty];
|
|
assertThatBool([tableController isEmpty], is(equalToBool(YES)));
|
|
UIImageView* imageView = tableController.stateOverlayImageView;
|
|
assertThat(imageView, isNot(nilValue()));
|
|
assertThat(imageView.image, is(equalTo(image)));
|
|
[tableController loadTableItems:[NSArray arrayWithObject:[RKTableItem tableItem]]];
|
|
assertThat(tableController.stateOverlayImageView.image, is(nilValue()));
|
|
}
|
|
|
|
- (void)testTriggerDisplayOfTheLoadingViewOnTransitionToTheLoadingState {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
UIActivityIndicatorView* spinner = [[UIActivityIndicatorView alloc] initWithActivityIndicatorStyle:UIActivityIndicatorViewStyleGray];
|
|
tableController.loadingView = spinner;
|
|
[tableController setValue:[NSNumber numberWithBool:YES] forKey:@"loading"];
|
|
UIView* view = [tableController.tableOverlayView.subviews lastObject];
|
|
assertThatBool(view == spinner, is(equalToBool(YES)));
|
|
}
|
|
|
|
- (void)testTriggerHidingOfTheLoadingViewOnTransitionOutOfTheLoadingState {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
UIActivityIndicatorView* spinner = [[UIActivityIndicatorView alloc] initWithActivityIndicatorStyle:UIActivityIndicatorViewStyleGray];
|
|
tableController.loadingView = spinner;
|
|
[tableController setValue:[NSNumber numberWithBool:YES] forKey:@"loading"];
|
|
UIView* loadingView = [tableController.tableOverlayView.subviews lastObject];
|
|
assertThatBool(loadingView == spinner, is(equalToBool(YES)));
|
|
[tableController setValue:[NSNumber numberWithBool:NO] forKey:@"loading"];
|
|
loadingView = [tableController.tableOverlayView.subviews lastObject];
|
|
assertThat(loadingView, is(nilValue()));
|
|
}
|
|
|
|
#pragma mark - Header, Footer, and Empty Rows
|
|
|
|
- (void)testShowHeaderRows {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
[tableController addHeaderRowForItem:[RKTableItem tableItemUsingBlock:^(RKTableItem* tableItem) {
|
|
tableItem.text = @"Header";
|
|
tableItem.cellMapping = [RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* cellMapping) {
|
|
[cellMapping addDefaultMappings];
|
|
}];
|
|
}]];
|
|
NSArray* tableItems = [RKTableItem tableItemsFromStrings:@"One", @"Two", @"Three", nil];
|
|
[tableController loadTableItems:tableItems];
|
|
assertThatBool([tableController isLoaded], is(equalToBool(YES)));
|
|
assertThatInt(tableController.rowCount, is(equalToInt(4)));
|
|
UITableViewCell* cellOne = [tableController tableView:tableController.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
UITableViewCell* cellTwo = [tableController tableView:tableController.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:1 inSection:0]];
|
|
UITableViewCell* cellThree = [tableController tableView:tableController.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:2 inSection:0]];
|
|
UITableViewCell* cellFour = [tableController tableView:tableController.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:3 inSection:0]];
|
|
assertThat(cellOne.textLabel.text, is(equalTo(@"Header")));
|
|
assertThat(cellTwo.textLabel.text, is(equalTo(@"One")));
|
|
assertThat(cellThree.textLabel.text, is(equalTo(@"Two")));
|
|
assertThat(cellFour.textLabel.text, is(equalTo(@"Three")));
|
|
[tableController tableView:tableController.tableView willDisplayCell:cellOne forRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
[tableController tableView:tableController.tableView willDisplayCell:cellTwo forRowAtIndexPath:[NSIndexPath indexPathForRow:1 inSection:0]];
|
|
[tableController tableView:tableController.tableView willDisplayCell:cellThree forRowAtIndexPath:[NSIndexPath indexPathForRow:2 inSection:0]];
|
|
[tableController tableView:tableController.tableView willDisplayCell:cellFour forRowAtIndexPath:[NSIndexPath indexPathForRow:3 inSection:0]];
|
|
assertThatBool(cellOne.hidden, is(equalToBool(NO)));
|
|
assertThatBool(cellTwo.hidden, is(equalToBool(NO)));
|
|
assertThatBool(cellThree.hidden, is(equalToBool(NO)));
|
|
assertThatBool(cellFour.hidden, is(equalToBool(NO)));
|
|
}
|
|
|
|
- (void)testShowFooterRows {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
[tableController addFooterRowForItem:[RKTableItem tableItemUsingBlock:^(RKTableItem* tableItem) {
|
|
tableItem.text = @"Footer";
|
|
tableItem.cellMapping = [RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* cellMapping) {
|
|
[cellMapping addDefaultMappings];
|
|
}];
|
|
}]];
|
|
NSArray* tableItems = [RKTableItem tableItemsFromStrings:@"One", @"Two", @"Three", nil];
|
|
[tableController loadTableItems:tableItems];
|
|
assertThatBool([tableController isLoaded], is(equalToBool(YES)));
|
|
assertThatInt(tableController.rowCount, is(equalToInt(4)));
|
|
UITableViewCell* cellOne = [tableController tableView:tableController.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
UITableViewCell* cellTwo = [tableController tableView:tableController.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:1 inSection:0]];
|
|
UITableViewCell* cellThree = [tableController tableView:tableController.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:2 inSection:0]];
|
|
UITableViewCell* cellFour = [tableController tableView:tableController.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:3 inSection:0]];
|
|
assertThat(cellOne.textLabel.text, is(equalTo(@"One")));
|
|
assertThat(cellTwo.textLabel.text, is(equalTo(@"Two")));
|
|
assertThat(cellThree.textLabel.text, is(equalTo(@"Three")));
|
|
assertThat(cellFour.textLabel.text, is(equalTo(@"Footer")));
|
|
[tableController tableView:tableController.tableView willDisplayCell:cellOne forRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
[tableController tableView:tableController.tableView willDisplayCell:cellTwo forRowAtIndexPath:[NSIndexPath indexPathForRow:1 inSection:0]];
|
|
[tableController tableView:tableController.tableView willDisplayCell:cellThree forRowAtIndexPath:[NSIndexPath indexPathForRow:2 inSection:0]];
|
|
[tableController tableView:tableController.tableView willDisplayCell:cellFour forRowAtIndexPath:[NSIndexPath indexPathForRow:3 inSection:0]];
|
|
assertThatBool(cellOne.hidden, is(equalToBool(NO)));
|
|
assertThatBool(cellTwo.hidden, is(equalToBool(NO)));
|
|
assertThatBool(cellThree.hidden, is(equalToBool(NO)));
|
|
assertThatBool(cellFour.hidden, is(equalToBool(NO)));
|
|
}
|
|
|
|
- (void)testHideHeaderRowsWhenEmptyWhenPropertyIsNotSet {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
[tableController addHeaderRowForItem:[RKTableItem tableItemUsingBlock:^(RKTableItem* tableItem) {
|
|
tableItem.text = @"Header";
|
|
tableItem.cellMapping = [RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* cellMapping) {
|
|
[cellMapping addDefaultMappings];
|
|
}];
|
|
}]];
|
|
tableController.showsHeaderRowsWhenEmpty = NO;
|
|
[tableController loadEmpty];
|
|
assertThatBool([tableController isLoaded], is(equalToBool(YES)));
|
|
assertThatInt(tableController.rowCount, is(equalToInt(1)));
|
|
assertThatBool([tableController isEmpty], is(equalToBool(YES)));
|
|
UITableViewCell* cellOne = [tableController tableView:tableController.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
assertThat(cellOne.textLabel.text, is(equalTo(@"Header")));
|
|
[tableController tableView:tableController.tableView willDisplayCell:cellOne forRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
assertThatBool(cellOne.hidden, is(equalToBool(YES)));
|
|
}
|
|
|
|
- (void)testHideFooterRowsWhenEmptyWhenPropertyIsNotSet {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
[tableController addFooterRowForItem:[RKTableItem tableItemUsingBlock:^(RKTableItem* tableItem) {
|
|
tableItem.text = @"Footer";
|
|
tableItem.cellMapping = [RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* cellMapping) {
|
|
[cellMapping addDefaultMappings];
|
|
}];
|
|
}]];
|
|
tableController.showsFooterRowsWhenEmpty = NO;
|
|
[tableController loadEmpty];
|
|
assertThatBool([tableController isLoaded], is(equalToBool(YES)));
|
|
assertThatInt(tableController.rowCount, is(equalToInt(1)));
|
|
assertThatBool([tableController isEmpty], is(equalToBool(YES)));
|
|
UITableViewCell* cellOne = [tableController tableView:tableController.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
assertThat(cellOne.textLabel.text, is(equalTo(@"Footer")));
|
|
[tableController tableView:tableController.tableView willDisplayCell:cellOne forRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
assertThatBool(cellOne.hidden, is(equalToBool(YES)));
|
|
}
|
|
|
|
- (void)testRemoveHeaderAndFooterCountsWhenDeterminingIsEmpty {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
[tableController addHeaderRowForItem:[RKTableItem tableItemUsingBlock:^(RKTableItem* tableItem) {
|
|
tableItem.text = @"Header";
|
|
tableItem.cellMapping = [RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* cellMapping) {
|
|
[cellMapping addDefaultMappings];
|
|
}];
|
|
}]];
|
|
[tableController addFooterRowForItem:[RKTableItem tableItemUsingBlock:^(RKTableItem* tableItem) {
|
|
tableItem.text = @"Footer";
|
|
tableItem.cellMapping = [RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* cellMapping) {
|
|
[cellMapping addDefaultMappings];
|
|
}];
|
|
}]];
|
|
[tableController setEmptyItem:[RKTableItem tableItemUsingBlock:^(RKTableItem* tableItem) {
|
|
tableItem.text = @"Empty";
|
|
tableItem.cellMapping = [RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* cellMapping) {
|
|
[cellMapping addDefaultMappings];
|
|
}];
|
|
}]];
|
|
tableController.showsFooterRowsWhenEmpty = NO;
|
|
tableController.showsHeaderRowsWhenEmpty = NO;
|
|
[tableController loadEmpty];
|
|
assertThatBool([tableController isLoaded], is(equalToBool(YES)));
|
|
assertThatInt(tableController.rowCount, is(equalToInt(3)));
|
|
assertThatBool([tableController isEmpty], is(equalToBool(YES)));
|
|
}
|
|
|
|
- (void)testNotShowTheEmptyItemWhenTheTableIsNotEmpty {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
[tableController addHeaderRowForItem:[RKTableItem tableItemUsingBlock:^(RKTableItem* tableItem) {
|
|
tableItem.text = @"Header";
|
|
tableItem.cellMapping = [RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* cellMapping) {
|
|
[cellMapping addDefaultMappings];
|
|
}];
|
|
}]];
|
|
[tableController addFooterRowForItem:[RKTableItem tableItemUsingBlock:^(RKTableItem* tableItem) {
|
|
tableItem.text = @"Footer";
|
|
tableItem.cellMapping = [RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* cellMapping) {
|
|
[cellMapping addDefaultMappings];
|
|
}];
|
|
}]];
|
|
[tableController setEmptyItem:[RKTableItem tableItemUsingBlock:^(RKTableItem* tableItem) {
|
|
tableItem.text = @"Empty";
|
|
tableItem.cellMapping = [RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* cellMapping) {
|
|
[cellMapping addDefaultMappings];
|
|
}];
|
|
}]];
|
|
NSArray* tableItems = [RKTableItem tableItemsFromStrings:@"One", @"Two", @"Three", nil];
|
|
[tableController loadTableItems:tableItems];
|
|
assertThatBool([tableController isLoaded], is(equalToBool(YES)));
|
|
assertThatInt(tableController.rowCount, is(equalToInt(6)));
|
|
UITableViewCell* cellOne = [tableController tableView:tableController.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
UITableViewCell* cellTwo = [tableController tableView:tableController.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:1 inSection:0]];
|
|
UITableViewCell* cellThree = [tableController tableView:tableController.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:2 inSection:0]];
|
|
UITableViewCell* cellFour = [tableController tableView:tableController.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:3 inSection:0]];
|
|
UITableViewCell* cellFive = [tableController tableView:tableController.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:4 inSection:0]];
|
|
UITableViewCell* cellSix = [tableController tableView:tableController.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:5 inSection:0]];
|
|
assertThat(cellOne.textLabel.text, is(equalTo(@"Empty")));
|
|
assertThat(cellTwo.textLabel.text, is(equalTo(@"Header")));
|
|
assertThat(cellThree.textLabel.text, is(equalTo(@"One")));
|
|
assertThat(cellFour.textLabel.text, is(equalTo(@"Two")));
|
|
assertThat(cellFive.textLabel.text, is(equalTo(@"Three")));
|
|
assertThat(cellSix.textLabel.text, is(equalTo(@"Footer")));
|
|
[tableController tableView:tableController.tableView willDisplayCell:cellOne forRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
[tableController tableView:tableController.tableView willDisplayCell:cellTwo forRowAtIndexPath:[NSIndexPath indexPathForRow:1 inSection:0]];
|
|
[tableController tableView:tableController.tableView willDisplayCell:cellThree forRowAtIndexPath:[NSIndexPath indexPathForRow:2 inSection:0]];
|
|
[tableController tableView:tableController.tableView willDisplayCell:cellFour forRowAtIndexPath:[NSIndexPath indexPathForRow:3 inSection:0]];
|
|
[tableController tableView:tableController.tableView willDisplayCell:cellFive forRowAtIndexPath:[NSIndexPath indexPathForRow:4 inSection:0]];
|
|
[tableController tableView:tableController.tableView willDisplayCell:cellSix forRowAtIndexPath:[NSIndexPath indexPathForRow:5 inSection:0]];
|
|
assertThatBool(cellOne.hidden, is(equalToBool(YES)));
|
|
assertThatBool(cellTwo.hidden, is(equalToBool(NO)));
|
|
assertThatBool(cellThree.hidden, is(equalToBool(NO)));
|
|
assertThatBool(cellFour.hidden, is(equalToBool(NO)));
|
|
assertThatBool(cellFive.hidden, is(equalToBool(NO)));
|
|
assertThatBool(cellSix.hidden, is(equalToBool(NO)));
|
|
}
|
|
|
|
- (void)testShowTheEmptyItemWhenTheTableIsEmpty {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
[tableController addHeaderRowForItem:[RKTableItem tableItemUsingBlock:^(RKTableItem* tableItem) {
|
|
tableItem.text = @"Header";
|
|
tableItem.cellMapping = [RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* cellMapping) {
|
|
[cellMapping addDefaultMappings];
|
|
}];
|
|
}]];
|
|
[tableController addFooterRowForItem:[RKTableItem tableItemUsingBlock:^(RKTableItem* tableItem) {
|
|
tableItem.text = @"Footer";
|
|
tableItem.cellMapping = [RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* cellMapping) {
|
|
[cellMapping addDefaultMappings];
|
|
}];
|
|
}]];
|
|
[tableController setEmptyItem:[RKTableItem tableItemUsingBlock:^(RKTableItem* tableItem) {
|
|
tableItem.text = @"Empty";
|
|
tableItem.cellMapping = [RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* cellMapping) {
|
|
[cellMapping addDefaultMappings];
|
|
}];
|
|
}]];
|
|
tableController.showsHeaderRowsWhenEmpty = NO;
|
|
tableController.showsFooterRowsWhenEmpty = NO;
|
|
[tableController loadEmpty];
|
|
assertThatBool([tableController isLoaded], is(equalToBool(YES)));
|
|
assertThatInt(tableController.rowCount, is(equalToInt(3)));
|
|
assertThatBool([tableController isEmpty], is(equalToBool(YES)));
|
|
UITableViewCell* cellOne = [tableController tableView:tableController.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
UITableViewCell* cellTwo = [tableController tableView:tableController.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:1 inSection:0]];
|
|
UITableViewCell* cellThree = [tableController tableView:tableController.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:2 inSection:0]];
|
|
assertThat(cellOne.textLabel.text, is(equalTo(@"Empty")));
|
|
assertThat(cellTwo.textLabel.text, is(equalTo(@"Header")));
|
|
assertThat(cellThree.textLabel.text, is(equalTo(@"Footer")));
|
|
[tableController tableView:tableController.tableView willDisplayCell:cellOne forRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
[tableController tableView:tableController.tableView willDisplayCell:cellTwo forRowAtIndexPath:[NSIndexPath indexPathForRow:1 inSection:0]];
|
|
[tableController tableView:tableController.tableView willDisplayCell:cellThree forRowAtIndexPath:[NSIndexPath indexPathForRow:2 inSection:0]];
|
|
assertThatBool(cellOne.hidden, is(equalToBool(NO)));
|
|
assertThatBool(cellTwo.hidden, is(equalToBool(YES)));
|
|
assertThatBool(cellThree.hidden, is(equalToBool(YES)));
|
|
}
|
|
|
|
- (void)testShowTheEmptyItemPlusHeadersAndFootersWhenTheTableIsEmpty {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
[tableController addHeaderRowForItem:[RKTableItem tableItemUsingBlock:^(RKTableItem* tableItem) {
|
|
tableItem.text = @"Header";
|
|
tableItem.cellMapping = [RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* cellMapping) {
|
|
[cellMapping addDefaultMappings];
|
|
}];
|
|
}]];
|
|
[tableController addFooterRowForItem:[RKTableItem tableItemUsingBlock:^(RKTableItem* tableItem) {
|
|
tableItem.text = @"Footer";
|
|
tableItem.cellMapping = [RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* cellMapping) {
|
|
[cellMapping addDefaultMappings];
|
|
}];
|
|
}]];
|
|
[tableController setEmptyItem:[RKTableItem tableItemUsingBlock:^(RKTableItem* tableItem) {
|
|
tableItem.text = @"Empty";
|
|
tableItem.cellMapping = [RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* cellMapping) {
|
|
[cellMapping addDefaultMappings];
|
|
}];
|
|
}]];
|
|
tableController.showsHeaderRowsWhenEmpty = YES;
|
|
tableController.showsFooterRowsWhenEmpty = YES;
|
|
[tableController loadEmpty];
|
|
assertThatBool([tableController isLoaded], is(equalToBool(YES)));
|
|
assertThatInt(tableController.rowCount, is(equalToInt(3)));
|
|
assertThatBool([tableController isEmpty], is(equalToBool(YES)));
|
|
UITableViewCell* cellOne = [tableController tableView:tableController.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
UITableViewCell* cellTwo = [tableController tableView:tableController.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:1 inSection:0]];
|
|
UITableViewCell* cellThree = [tableController tableView:tableController.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:2 inSection:0]];
|
|
assertThat(cellOne.textLabel.text, is(equalTo(@"Empty")));
|
|
assertThat(cellTwo.textLabel.text, is(equalTo(@"Header")));
|
|
assertThat(cellThree.textLabel.text, is(equalTo(@"Footer")));
|
|
[tableController tableView:tableController.tableView willDisplayCell:cellOne forRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
[tableController tableView:tableController.tableView willDisplayCell:cellTwo forRowAtIndexPath:[NSIndexPath indexPathForRow:1 inSection:0]];
|
|
[tableController tableView:tableController.tableView willDisplayCell:cellThree forRowAtIndexPath:[NSIndexPath indexPathForRow:2 inSection:0]];
|
|
assertThatBool(cellOne.hidden, is(equalToBool(NO)));
|
|
assertThatBool(cellTwo.hidden, is(equalToBool(NO)));
|
|
assertThatBool(cellThree.hidden, is(equalToBool(NO)));
|
|
}
|
|
|
|
#pragma mark - UITableViewDelegate specs
|
|
|
|
- (void)testInvokeTheOnSelectCellForObjectAtIndexPathBlockHandler {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
RKTableItem* tableItem = [RKTableItem tableItem];
|
|
__block BOOL dispatched = NO;
|
|
[tableController loadTableItems:[NSArray arrayWithObject:tableItem] withMapping:[RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* cellMapping) {
|
|
cellMapping.onSelectCellForObjectAtIndexPath = ^(UITableViewCell* cell, id object, NSIndexPath* indexPath) {
|
|
dispatched = YES;
|
|
};
|
|
}]];
|
|
[tableController tableView:tableController.tableView didSelectRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
assertThatBool(dispatched, is(equalToBool(YES)));
|
|
}
|
|
|
|
- (void)testInvokeTheOnCellWillAppearForObjectAtIndexPathBlockHandler {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
RKTableItem* tableItem = [RKTableItem tableItem];
|
|
__block BOOL dispatched = NO;
|
|
[tableController loadTableItems:[NSArray arrayWithObject:tableItem] withMapping:[RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* cellMapping) {
|
|
cellMapping.onCellWillAppearForObjectAtIndexPath = ^(UITableViewCell* cell, id object, NSIndexPath* indexPath) {
|
|
dispatched = YES;
|
|
};
|
|
}]];
|
|
id mockCell = [OCMockObject niceMockForClass:[UITableViewCell class]];
|
|
[tableController tableView:tableController.tableView willDisplayCell:mockCell forRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
assertThatBool(dispatched, is(equalToBool(YES)));
|
|
}
|
|
|
|
- (void)testOptionallyHideHeaderRowsWhenTheyAppearAndTheTableIsEmpty {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.showsHeaderRowsWhenEmpty = NO;
|
|
RKTableItem* tableItem = [RKTableItem tableItem];
|
|
[tableController addHeaderRowForItem:tableItem];
|
|
[tableController loadEmpty];
|
|
id mockCell = [OCMockObject niceMockForClass:[UITableViewCell class]];
|
|
[[mockCell expect] setHidden:YES];
|
|
[tableController tableView:tableController.tableView willDisplayCell:mockCell forRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
[mockCell verify];
|
|
}
|
|
|
|
- (void)testOptionallyHideFooterRowsWhenTheyAppearAndTheTableIsEmpty {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.showsFooterRowsWhenEmpty = NO;
|
|
RKTableItem* tableItem = [RKTableItem tableItem];
|
|
[tableController addFooterRowForItem:tableItem];
|
|
[tableController loadEmpty];
|
|
id mockCell = [OCMockObject niceMockForClass:[UITableViewCell class]];
|
|
[[mockCell expect] setHidden:YES];
|
|
[tableController tableView:tableController.tableView willDisplayCell:mockCell forRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
[mockCell verify];
|
|
}
|
|
|
|
- (void)testInvokeABlockCallbackWhenTheCellAccessoryButtonIsTapped {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
RKTableItem* tableItem = [RKTableItem tableItem];
|
|
__block BOOL dispatched = NO;
|
|
RKTableViewCellMapping *mapping = [RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping *cellMapping) {
|
|
cellMapping.onTapAccessoryButtonForObjectAtIndexPath = ^(UITableViewCell* cell, id object, NSIndexPath* indexPath) {
|
|
dispatched = YES;
|
|
};
|
|
}];
|
|
[tableController loadTableItems:[NSArray arrayWithObject:tableItem] withMapping:mapping];
|
|
[tableController tableView:tableController.tableView accessoryButtonTappedForRowWithIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
assertThatBool(dispatched, is(equalToBool(YES)));
|
|
}
|
|
|
|
- (void)testInvokeABlockCallbackWhenTheDeleteConfirmationButtonTitleIsDetermined {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
RKTableItem* tableItem = [RKTableItem tableItem];
|
|
NSString* deleteTitle = @"Delete Me";
|
|
RKTableViewCellMapping *mapping = [RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping *cellMapping) {
|
|
cellMapping.titleForDeleteButtonForObjectAtIndexPath = ^ NSString*(UITableViewCell* cell, id object, NSIndexPath* indexPath) {
|
|
return deleteTitle;
|
|
};
|
|
}];
|
|
[tableController loadTableItems:[NSArray arrayWithObject:tableItem] withMapping:mapping];
|
|
NSString* delegateTitle = [tableController tableView:tableController.tableView
|
|
titleForDeleteConfirmationButtonForRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
assertThat(delegateTitle, is(equalTo(deleteTitle)));
|
|
}
|
|
|
|
- (void)testInvokeABlockCallbackWhenCellEditingStyleIsDetermined {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.canEditRows = YES;
|
|
RKTableItem* tableItem = [RKTableItem tableItem];
|
|
RKTableViewCellMapping *mapping = [RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping *cellMapping) {
|
|
cellMapping.editingStyleForObjectAtIndexPath = ^ UITableViewCellEditingStyle(UITableViewCell* cell, id object, NSIndexPath* indexPath) {
|
|
return UITableViewCellEditingStyleInsert;
|
|
};
|
|
}];
|
|
[tableController loadTableItems:[NSArray arrayWithObject:tableItem] withMapping:mapping];
|
|
UITableViewCellEditingStyle delegateStyle = [tableController tableView:tableController.tableView
|
|
editingStyleForRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
assertThatInt(delegateStyle, is(equalToInt(UITableViewCellEditingStyleInsert)));
|
|
}
|
|
|
|
- (void)testInvokeABlockCallbackWhenACellIsMoved {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.canMoveRows = YES;
|
|
RKTableItem* tableItem = [RKTableItem tableItem];
|
|
NSIndexPath* moveToIndexPath = [NSIndexPath indexPathForRow:2 inSection:0];
|
|
[tableController loadTableItems:[NSArray arrayWithObject:tableItem] withMapping:[RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* cellMapping) {
|
|
cellMapping.targetIndexPathForMove = ^ NSIndexPath*(UITableViewCell* cell, id object, NSIndexPath* sourceIndexPath, NSIndexPath* destinationIndexPath) {
|
|
return moveToIndexPath;
|
|
};
|
|
}]];
|
|
NSIndexPath* delegateIndexPath = [tableController tableView:tableController.tableView
|
|
targetIndexPathForMoveFromRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]toProposedIndexPath:[NSIndexPath indexPathForRow:1 inSection:0]];
|
|
assertThat(delegateIndexPath, is(equalTo(moveToIndexPath)));
|
|
}
|
|
|
|
#pragma mark Variable Height Rows
|
|
|
|
- (void)testReturnTheRowHeightConfiguredOnTheTableViewWhenVariableHeightRowsIsDisabled {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.variableHeightRows = NO;
|
|
tableController.tableView.rowHeight = 55;
|
|
RKTableItem* tableItem = [RKTableItem tableItem];
|
|
[tableController loadTableItems:[NSArray arrayWithObject:tableItem] withMapping:[RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* cellMapping) {
|
|
cellMapping.rowHeight = 200;
|
|
}]];
|
|
CGFloat height = [tableController tableView:tableController.tableView heightForRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
assertThatFloat(height, is(equalToFloat(55)));
|
|
}
|
|
|
|
- (void)testReturnTheHeightFromTheTableCellMappingWhenVariableHeightRowsAreEnabled {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.variableHeightRows = YES;
|
|
tableController.tableView.rowHeight = 55;
|
|
RKTableItem* tableItem = [RKTableItem tableItem];
|
|
[tableController loadTableItems:[NSArray arrayWithObject:tableItem] withMapping:[RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* cellMapping) {
|
|
cellMapping.rowHeight = 200;
|
|
}]];
|
|
CGFloat height = [tableController tableView:tableController.tableView heightForRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
assertThatFloat(height, is(equalToFloat(200)));
|
|
}
|
|
|
|
- (void)testInvokeAnBlockCallbackToDetermineTheCellHeightWhenVariableHeightRowsAreEnabled {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.variableHeightRows = YES;
|
|
tableController.tableView.rowHeight = 55;
|
|
RKTableItem* tableItem = [RKTableItem tableItem];
|
|
[tableController loadTableItems:[NSArray arrayWithObject:tableItem] withMapping:[RKTableViewCellMapping cellMappingUsingBlock:^(RKTableViewCellMapping* cellMapping) {
|
|
cellMapping.rowHeight = 200;
|
|
cellMapping.heightOfCellForObjectAtIndexPath = ^ CGFloat(id object, NSIndexPath* indexPath) { return 150; };
|
|
}]];
|
|
CGFloat height = [tableController tableView:tableController.tableView heightForRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
assertThatFloat(height, is(equalToFloat(150)));
|
|
}
|
|
|
|
#pragma mark - Editing
|
|
|
|
- (void)testAllowEditingWhenTheCanEditRowsPropertyIsSet {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.canEditRows = YES;
|
|
RKTableItem* tableItem = [RKTableItem tableItem];
|
|
[tableController loadTableItems:[NSArray arrayWithObject:tableItem]];
|
|
BOOL delegateCanEdit = [tableController tableView:tableController.tableView
|
|
canEditRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
assertThatBool(delegateCanEdit, is(equalToBool(YES)));
|
|
}
|
|
|
|
- (void)testCommitADeletionWhenTheCanEditRowsPropertyIsSet {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.canEditRows = YES;
|
|
[tableController loadObjects:[NSArray arrayWithObjects:@"First Object", @"Second Object", nil]];
|
|
assertThatInt([tableController rowCount], is(equalToInt(2)));
|
|
BOOL delegateCanEdit = [tableController tableView:tableController.tableView
|
|
canEditRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
assertThatBool(delegateCanEdit, is(equalToBool(YES)));
|
|
[tableController tableView:tableController.tableView
|
|
commitEditingStyle:UITableViewCellEditingStyleDelete
|
|
forRowAtIndexPath:[NSIndexPath indexPathForRow:1 inSection:0]];
|
|
assertThatInt([tableController rowCount], is(equalToInt(1)));
|
|
assertThat([tableController objectForRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]],
|
|
is(equalTo(@"First Object")));
|
|
}
|
|
|
|
- (void)testNotCommitADeletionWhenTheCanEditRowsPropertyIsNotSet {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
[tableController loadObjects:[NSArray arrayWithObjects:@"First Object", @"Second Object", nil]];
|
|
assertThatInt([tableController rowCount], is(equalToInt(2)));
|
|
BOOL delegateCanEdit = [tableController tableView:tableController.tableView
|
|
canEditRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
assertThatBool(delegateCanEdit, is(equalToBool(NO)));
|
|
[tableController tableView:tableController.tableView
|
|
commitEditingStyle:UITableViewCellEditingStyleDelete
|
|
forRowAtIndexPath:[NSIndexPath indexPathForRow:1 inSection:0]];
|
|
assertThatInt([tableController rowCount], is(equalToInt(2)));
|
|
assertThat([tableController objectForRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]],
|
|
is(equalTo(@"First Object")));
|
|
assertThat([tableController objectForRowAtIndexPath:[NSIndexPath indexPathForRow:1 inSection:0]],
|
|
is(equalTo(@"Second Object")));
|
|
}
|
|
|
|
- (void)testDoNothingToCommitAnInsertionWhenTheCanEditRowsPropertyIsSet {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.canEditRows = YES;
|
|
[tableController loadObjects:[NSArray arrayWithObjects:@"First Object", @"Second Object", nil]];
|
|
assertThatInt([tableController rowCount], is(equalToInt(2)));
|
|
BOOL delegateCanEdit = [tableController tableView:tableController.tableView
|
|
canEditRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
assertThatBool(delegateCanEdit, is(equalToBool(YES)));
|
|
[tableController tableView:tableController.tableView
|
|
commitEditingStyle:UITableViewCellEditingStyleInsert
|
|
forRowAtIndexPath:[NSIndexPath indexPathForRow:2 inSection:0]];
|
|
assertThatInt([tableController rowCount], is(equalToInt(2)));
|
|
assertThat([tableController objectForRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]],
|
|
is(equalTo(@"First Object")));
|
|
assertThat([tableController objectForRowAtIndexPath:[NSIndexPath indexPathForRow:1 inSection:0]],
|
|
is(equalTo(@"Second Object")));
|
|
}
|
|
|
|
- (void)testAllowMovingWhenTheCanMoveRowsPropertyIsSet {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.canMoveRows = YES;
|
|
RKTableItem* tableItem = [RKTableItem tableItem];
|
|
[tableController loadTableItems:[NSArray arrayWithObject:tableItem]];
|
|
BOOL delegateCanMove = [tableController tableView:tableController.tableView
|
|
canMoveRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
assertThatBool(delegateCanMove, is(equalToBool(YES)));
|
|
}
|
|
|
|
- (void)testMoveARowWithinASectionWhenTheCanMoveRowsPropertyIsSet {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.canMoveRows = YES;
|
|
[tableController loadObjects:[NSArray arrayWithObjects:@"First Object", @"Second Object", nil]];
|
|
assertThatInt([tableController rowCount], is(equalToInt(2)));
|
|
BOOL delegateCanMove = [tableController tableView:tableController.tableView
|
|
canMoveRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
assertThatBool(delegateCanMove, is(equalToBool(YES)));
|
|
[tableController tableView:tableController.tableView
|
|
moveRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]
|
|
toIndexPath:[NSIndexPath indexPathForRow:1 inSection:0]];
|
|
assertThatInt([tableController rowCount], is(equalToInt(2)));
|
|
assertThat([tableController objectForRowAtIndexPath:[NSIndexPath indexPathForRow:1 inSection:0]],
|
|
is(equalTo(@"First Object")));
|
|
assertThat([tableController objectForRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]],
|
|
is(equalTo(@"Second Object")));
|
|
}
|
|
|
|
- (void)testMoveARowAcrossSectionsWhenTheCanMoveRowsPropertyIsSet {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.canMoveRows = YES;
|
|
[tableController loadObjects:[NSArray arrayWithObjects:@"First Object", @"Second Object", nil]];
|
|
assertThatInt([tableController rowCount], is(equalToInt(2)));
|
|
assertThatInt([tableController sectionCount], is(equalToInt(1)));
|
|
BOOL delegateCanMove = [tableController tableView:tableController.tableView
|
|
canMoveRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
assertThatBool(delegateCanMove, is(equalToBool(YES)));
|
|
[tableController tableView:tableController.tableView
|
|
moveRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]
|
|
toIndexPath:[NSIndexPath indexPathForRow:0 inSection:1]];
|
|
assertThatInt([tableController rowCount], is(equalToInt(2)));
|
|
assertThatInt([tableController sectionCount], is(equalToInt(2)));
|
|
assertThat([tableController objectForRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:1]],
|
|
is(equalTo(@"First Object")));
|
|
assertThat([tableController objectForRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]],
|
|
is(equalTo(@"Second Object")));
|
|
}
|
|
|
|
- (void)testNotMoveARowWhenTheCanMoveRowsPropertyIsNotSet {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
[tableController loadObjects:[NSArray arrayWithObjects:@"First Object", @"Second Object", nil]];
|
|
assertThatInt([tableController rowCount], is(equalToInt(2)));
|
|
BOOL delegateCanMove = [tableController tableView:tableController.tableView
|
|
canMoveRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
assertThatBool(delegateCanMove, is(equalToBool(NO)));
|
|
[tableController tableView:tableController.tableView
|
|
moveRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]
|
|
toIndexPath:[NSIndexPath indexPathForRow:1 inSection:0]];
|
|
assertThatInt([tableController rowCount], is(equalToInt(2)));
|
|
assertThat([tableController objectForRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]],
|
|
is(equalTo(@"First Object")));
|
|
assertThat([tableController objectForRowAtIndexPath:[NSIndexPath indexPathForRow:1 inSection:0]],
|
|
is(equalTo(@"Second Object")));
|
|
}
|
|
|
|
#pragma mark - Reachability Integration
|
|
|
|
- (void)testTransitionToTheOnlineStateWhenAReachabilityNoticeIsReceived {
|
|
RKObjectManager* objectManager = [RKTestFactory objectManager];
|
|
id mockManager = [OCMockObject partialMockForObject:objectManager];
|
|
BOOL online = YES;
|
|
[[[mockManager stub] andReturnValue:OCMOCK_VALUE(online)] isOnline];
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.objectManager = objectManager;
|
|
[[NSNotificationCenter defaultCenter] postNotificationName:RKObjectManagerDidBecomeOnlineNotification object:objectManager];
|
|
assertThatBool(tableController.isOnline, is(equalToBool(YES)));
|
|
}
|
|
|
|
- (void)testTransitionToTheOfflineStateWhenAReachabilityNoticeIsReceived {
|
|
RKObjectManager* objectManager = [RKTestFactory objectManager];
|
|
id mockManager = [OCMockObject partialMockForObject:objectManager];
|
|
BOOL online = NO;
|
|
[[[mockManager stub] andReturnValue:OCMOCK_VALUE(online)] isOnline];
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.objectManager = objectManager;
|
|
[[NSNotificationCenter defaultCenter] postNotificationName:RKObjectManagerDidBecomeOfflineNotification object:objectManager];
|
|
assertThatBool(tableController.isOnline, is(equalToBool(NO)));
|
|
}
|
|
|
|
- (void)testNotifyTheDelegateOnTransitionToOffline {
|
|
RKObjectManager* objectManager = [RKTestFactory objectManager];
|
|
id mockManager = [OCMockObject partialMockForObject:objectManager];
|
|
[mockManager setExpectationOrderMatters:YES];
|
|
RKObjectManagerNetworkStatus networkStatus = RKObjectManagerNetworkStatusOnline;
|
|
[[[mockManager stub] andReturnValue:OCMOCK_VALUE(networkStatus)] networkStatus];
|
|
BOOL online = YES; // Initial online state for table
|
|
[[[mockManager expect] andReturnValue:OCMOCK_VALUE(online)] isOnline];
|
|
online = NO; // After the notification is posted
|
|
[[[mockManager expect] andReturnValue:OCMOCK_VALUE(online)] isOnline];
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
id mockDelegate = [OCMockObject mockForProtocol:@protocol(RKTableControllerDelegate)];
|
|
[[mockDelegate expect] tableControllerDidBecomeOffline:tableController];
|
|
tableController.delegate = mockDelegate;
|
|
[[NSNotificationCenter defaultCenter] postNotificationName:RKObjectManagerDidBecomeOfflineNotification object:objectManager];
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
- (void)testPostANotificationOnTransitionToOffline {
|
|
RKObjectManager* objectManager = [RKTestFactory objectManager];
|
|
id mockManager = [OCMockObject partialMockForObject:objectManager];
|
|
[mockManager setExpectationOrderMatters:YES];
|
|
RKObjectManagerNetworkStatus networkStatus = RKObjectManagerNetworkStatusOnline;
|
|
[[[mockManager stub] andReturnValue:OCMOCK_VALUE(networkStatus)] networkStatus];
|
|
BOOL online = YES; // Initial online state for table
|
|
[[[mockManager expect] andReturnValue:OCMOCK_VALUE(online)] isOnline];
|
|
online = NO; // After the notification is posted
|
|
[[[mockManager expect] andReturnValue:OCMOCK_VALUE(online)] isOnline];
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
|
|
id observerMock = [OCMockObject observerMock];
|
|
[[NSNotificationCenter defaultCenter] addMockObserver:observerMock name:RKTableControllerDidBecomeOffline object:tableController];
|
|
[[observerMock expect] notificationWithName:RKTableControllerDidBecomeOffline object:tableController];
|
|
|
|
[[NSNotificationCenter defaultCenter] postNotificationName:RKObjectManagerDidBecomeOfflineNotification object:objectManager];
|
|
[observerMock verify];
|
|
}
|
|
|
|
- (void)testNotifyTheDelegateOnTransitionToOnline {
|
|
RKObjectManager* objectManager = [RKTestFactory objectManager];
|
|
id mockManager = [OCMockObject partialMockForObject:objectManager];
|
|
BOOL online = NO;
|
|
[[[mockManager expect] andReturnValue:OCMOCK_VALUE(online)] isOnline];
|
|
online = YES;
|
|
[[[mockManager stub] andReturnValue:OCMOCK_VALUE(online)] isOnline];
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
[RKObjectManager setSharedManager:nil]; // Don't want the controller to initialize with the sharedManager...
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.objectManager = objectManager;
|
|
id mockDelegate = [OCMockObject mockForProtocol:@protocol(RKTableControllerDelegate)];
|
|
[[mockDelegate expect] tableControllerDidBecomeOnline:tableController];
|
|
tableController.delegate = mockDelegate;
|
|
[[NSNotificationCenter defaultCenter] postNotificationName:RKObjectManagerDidBecomeOnlineNotification object:objectManager];
|
|
[[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.3]];
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
- (void)testPostANotificationOnTransitionToOnline {
|
|
RKObjectManager* objectManager = [RKTestFactory objectManager];
|
|
id mockManager = [OCMockObject partialMockForObject:objectManager];
|
|
BOOL online = NO;
|
|
[[[mockManager expect] andReturnValue:OCMOCK_VALUE(online)] isOnline];
|
|
online = YES;
|
|
[[[mockManager stub] andReturnValue:OCMOCK_VALUE(online)] isOnline];
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
[RKObjectManager setSharedManager:nil]; // Don't want the controller to initialize with the sharedManager...
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.objectManager = objectManager;
|
|
|
|
id observerMock = [OCMockObject observerMock];
|
|
[[NSNotificationCenter defaultCenter] addMockObserver:observerMock name:RKTableControllerDidBecomeOnline object:tableController];
|
|
[[observerMock expect] notificationWithName:RKTableControllerDidBecomeOnline object:tableController];
|
|
|
|
[[NSNotificationCenter defaultCenter] postNotificationName:RKObjectManagerDidBecomeOnlineNotification object:objectManager];
|
|
[observerMock verify];
|
|
}
|
|
|
|
- (void)testShowTheOfflineImageOnTransitionToOffline {
|
|
RKObjectManager* objectManager = [RKTestFactory objectManager];
|
|
id mockManager = [OCMockObject partialMockForObject:objectManager];
|
|
[mockManager setExpectationOrderMatters:YES];
|
|
RKObjectManagerNetworkStatus networkStatus = RKObjectManagerNetworkStatusOnline;
|
|
[[[mockManager stub] andReturnValue:OCMOCK_VALUE(networkStatus)] networkStatus];
|
|
BOOL online = YES; // Initial online state for table
|
|
[[[mockManager expect] andReturnValue:OCMOCK_VALUE(online)] isOnline];
|
|
online = NO; // After the notification is posted
|
|
[[[mockManager expect] andReturnValue:OCMOCK_VALUE(online)] isOnline];
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
UIImage* image = [RKTestFixture imageWithContentsOfFixture:@"blake.png"];
|
|
tableController.imageForOffline = image;
|
|
|
|
[[NSNotificationCenter defaultCenter] postNotificationName:RKObjectManagerDidBecomeOfflineNotification object:objectManager];
|
|
assertThatBool(tableController.isOnline, is(equalToBool(NO)));
|
|
UIImageView* imageView = tableController.stateOverlayImageView;
|
|
assertThat(imageView, isNot(nilValue()));
|
|
assertThat(imageView.image, is(equalTo(image)));
|
|
}
|
|
|
|
- (void)testRemoveTheOfflineImageOnTransitionToOnlineFromOffline {
|
|
RKObjectManager* objectManager = [RKTestFactory objectManager];
|
|
id mockManager = [OCMockObject partialMockForObject:objectManager];
|
|
[mockManager setExpectationOrderMatters:YES];
|
|
RKObjectManagerNetworkStatus networkStatus = RKObjectManagerNetworkStatusOnline;
|
|
[[[mockManager stub] andReturnValue:OCMOCK_VALUE(networkStatus)] networkStatus];
|
|
BOOL online = YES; // Initial online state for table
|
|
[[[mockManager expect] andReturnValue:OCMOCK_VALUE(online)] isOnline];
|
|
online = NO; // After the notification is posted
|
|
[[[mockManager expect] andReturnValue:OCMOCK_VALUE(online)] isOnline];
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
UIImage* image = [RKTestFixture imageWithContentsOfFixture:@"blake.png"];
|
|
tableController.imageForOffline = image;
|
|
|
|
[[NSNotificationCenter defaultCenter] postNotificationName:RKObjectManagerDidBecomeOfflineNotification object:objectManager];
|
|
assertThatBool(tableController.isOnline, is(equalToBool(NO)));
|
|
UIImageView* imageView = tableController.stateOverlayImageView;
|
|
assertThat(imageView, isNot(nilValue()));
|
|
assertThat(imageView.image, is(equalTo(image)));
|
|
|
|
online = YES;
|
|
[[[mockManager expect] andReturnValue:OCMOCK_VALUE(online)] isOnline];
|
|
[[NSNotificationCenter defaultCenter] postNotificationName:RKObjectManagerDidBecomeOnlineNotification object:objectManager];
|
|
assertThatBool(tableController.isOnline, is(equalToBool(YES)));
|
|
imageView = tableController.stateOverlayImageView;
|
|
assertThat(imageView.image, is(nilValue()));
|
|
}
|
|
|
|
#pragma mark - Swipe Menus
|
|
|
|
- (void)testAllowSwipeMenusWhenTheSwipeViewsEnabledPropertyIsSet {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.cellSwipeViewsEnabled = YES;
|
|
RKTableItem* tableItem = [RKTableItem tableItem];
|
|
[tableController loadTableItems:[NSArray arrayWithObject:tableItem]];
|
|
assertThatBool(tableController.canEditRows, is(equalToBool(NO)));
|
|
assertThatBool(tableController.cellSwipeViewsEnabled, is(equalToBool(YES)));
|
|
}
|
|
|
|
- (void)testNotAllowEditingWhenTheSwipeViewsEnabledPropertyIsSet {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.cellSwipeViewsEnabled = YES;
|
|
RKTableItem* tableItem = [RKTableItem tableItem];
|
|
[tableController loadTableItems:[NSArray arrayWithObject:tableItem]];
|
|
BOOL delegateCanEdit = [tableController tableView:tableController.tableView
|
|
canEditRowAtIndexPath:[NSIndexPath indexPathForRow:0 inSection:0]];
|
|
assertThatBool(delegateCanEdit, is(equalToBool(NO)));
|
|
}
|
|
|
|
- (void)testRaiseAnExceptionWhenEnablingSwipeViewsWhenTheCanEditRowsPropertyIsSet {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.canEditRows = YES;
|
|
|
|
NSException* exception = nil;
|
|
@try {
|
|
tableController.cellSwipeViewsEnabled = YES;
|
|
}
|
|
@catch (NSException *e) {
|
|
exception = e;
|
|
}
|
|
@finally {
|
|
assertThat(exception, isNot(nilValue()));
|
|
}
|
|
}
|
|
|
|
- (void)testCallTheDelegateBeforeShowingTheSwipeView {
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.cellSwipeViewsEnabled = YES;
|
|
RKTableItem* tableItem = [RKTableItem tableItem];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
id mockDelegate = [OCMockObject partialMockForObject:delegate];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
willAddSwipeView:OCMOCK_ANY
|
|
toCell:OCMOCK_ANY
|
|
forObject:OCMOCK_ANY];
|
|
tableController.delegate = mockDelegate;
|
|
[tableController loadTableItems:[NSArray arrayWithObject:tableItem]];
|
|
[tableController addSwipeViewTo:[RKTestUserTableViewCell new]
|
|
withObject:@"object"
|
|
direction:UISwipeGestureRecognizerDirectionRight];
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
- (void)testCallTheDelegateBeforeHidingTheSwipeView {
|
|
// RKLogConfigureByName("RestKit/UI", RKLogLevelTrace);
|
|
RKTableControllerTestTableViewController* viewController = [RKTableControllerTestTableViewController new];
|
|
RKTableController* tableController = [RKTableController tableControllerForTableViewController:viewController];
|
|
tableController.cellSwipeViewsEnabled = YES;
|
|
RKTableItem* tableItem = [RKTableItem tableItem];
|
|
RKTestTableControllerDelegate* delegate = [RKTestTableControllerDelegate new];
|
|
id mockDelegate = [OCMockObject partialMockForObject:delegate];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
willAddSwipeView:OCMOCK_ANY
|
|
toCell:OCMOCK_ANY
|
|
forObject:OCMOCK_ANY];
|
|
[[[mockDelegate expect] andForwardToRealObject] tableController:tableController
|
|
willRemoveSwipeView:OCMOCK_ANY
|
|
fromCell:OCMOCK_ANY
|
|
forObject:OCMOCK_ANY];
|
|
tableController.delegate = mockDelegate;
|
|
[tableController loadTableItems:[NSArray arrayWithObject:tableItem]];
|
|
[tableController addSwipeViewTo:[RKTestUserTableViewCell new]
|
|
withObject:@"object"
|
|
direction:UISwipeGestureRecognizerDirectionRight];
|
|
[tableController animationDidStopAddingSwipeView:nil
|
|
finished:nil
|
|
context:nil];
|
|
[tableController removeSwipeView:YES];
|
|
STAssertNoThrow([mockDelegate verify], nil);
|
|
}
|
|
|
|
@end
|