firebase-ios-sdk/Example/Database/Tests/Integration/FTransactionTest.m

/*
 * Copyright 2017 Google
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#import "FTransactionTest.h"
#import "FTestHelpers.h"
#import "FEventTester.h"
#import "FTupleEventTypeString.h"
#import "FIRDatabaseQuery_Private.h"
#import "FIRDatabaseConfig_Private.h"


// HACK used by testUnsentTransactionsAreNotCancelledOnDisconnect to return one bad token and then a nil token.
@interface FIROneBadTokenProvider : NSObject <FAuthTokenProvider> {
    BOOL firstFetch;
}
@end

@implementation FIROneBadTokenProvider
- (instancetype) init {
    self = [super init];
    if (self) {
        firstFetch = YES;
    }
    return self;
}

- (void) fetchTokenForcingRefresh:(BOOL)forceRefresh withCallback:(fbt_void_nsstring_nserror)callback {
    // Simulate delay
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(10 * NSEC_PER_MSEC)), [FIRDatabaseQuery sharedQueue], ^{
        if (firstFetch) {
            firstFetch = NO;
            callback(@"bad-token", nil);
        } else {
            callback(nil, nil);
        }
    });
}

- (void) listenForTokenChanges:(fbt_void_nsstring)listener {
}

@end
@implementation FTransactionTest

- (void) testNewValueIsImmediatelyVisible {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];

    __block BOOL runOnce = NO;
    [[node child:@"foo"] runTransactionBlock:^(FIRMutableData * currentValue){
        runOnce = YES;
        [currentValue setValue:@42];
        return [FIRTransactionResult successWithValue:currentValue];
    }];

    [self waitUntil:^BOOL{
        return runOnce;
    }];

    __block BOOL ready = NO;
    [[node child:@"foo"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        if (!ready) {
            NSNumber *val = [snapshot value];
            XCTAssertTrue([val isEqualToNumber:@42], @"Got value set in transaction");
            ready = YES;
        }
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];
}

- (void) testNonAbortedTransactionSetsCommittedToTrueInCallback {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];

    __block BOOL done = NO;
    [[node child:@"foo"] runTransactionBlock:^(FIRMutableData * currentValue){
        [currentValue setValue:@42];
        return [FIRTransactionResult successWithValue:currentValue];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertTrue(committed, @"Should not have aborted");
        done = YES;
    }];

    [self waitUntil:^BOOL{
        return done;
    }];
}

- (void) testAbortedTransactionSetsCommittedToFalseInCallback {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];

    __block BOOL done = NO;
    [[node child:@"foo"] runTransactionBlock:^(FIRMutableData * currentValue){
        return [FIRTransactionResult abort];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertFalse(committed, @"Should have aborted");
        done = YES;
    }];

    [self waitUntil:^BOOL{
        return done;
    }];
}

- (void) testBugTestSetDataReconnectDoTransactionThatAbortsOnceDataArrivesVerifyCorrectEvents {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * reader = refs.one;

    __block BOOL dataWritten = NO;
    [[reader child:@"foo"] setValue:@42 withCompletionBlock:^(NSError *error, FIRDatabaseReference * ref) {
        dataWritten = YES;
    }];

    [self waitUntil:^BOOL{
        return dataWritten;
    }];

    FIRDatabaseReference * writer = refs.two;
    __block int eventsReceived = 0;
    [[writer child:@"foo"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        if (eventsReceived == 0) {
            NSString *val = [snapshot value];
            XCTAssertTrue([val isEqualToString:@"temp value"], @"Got initial transaction value");
        } else if (eventsReceived == 1) {
            NSNumber *val = [snapshot value];
            XCTAssertTrue([val isEqualToNumber:@42], @"Got hidden original value");
        } else {
            XCTFail(@"Too many events");
        }
        eventsReceived++;
    }];

    [[writer child:@"foo"] runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        id current = [currentData value];
        if (current == [NSNull null]) {
            [currentData setValue:@"temp value"];
            return [FIRTransactionResult successWithValue:currentData];
        } else {
            return [FIRTransactionResult abort];
        }
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertFalse(committed, @"This transaction should never commit");
        XCTAssertTrue(error == nil, @"This transaction should not have an error");
    }];

    [self waitUntil:^BOOL{
        return eventsReceived == 2;
    }];

}

- (void) testUseTransactionToCreateANodeMakeSureExactlyOneEventIsReceived {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];

    __block int events = 0;
    __block BOOL done = NO;

    [[node child:@"a"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        events++;
        if (events > 1) {
            XCTFail(@"Too many events");
        }
    }];

    [[node child:@"a"] runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        [currentData setValue:@42];
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        done = YES;
    }];

    [self waitUntil:^BOOL{
        return done && events == 1;
    }];
}

- (void) testUseTransactionToUpdateTwoExistingChildNodesMakeSureEventsAreOnlyRaisedForChangedNode {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * node1 = [refs.one child:@"foo"];
    FIRDatabaseReference * node2 = [refs.two child:@"foo"];

    __block BOOL ready = NO;
    [[node1 child:@"a"] setValue:@42];
    [[node1 child:@"b"] setValue:@42 withCompletionBlock:^(NSError *error, FIRDatabaseReference * ref) {
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    FEventTester* et = [[FEventTester alloc] initFrom:self];
    NSArray* expect = @[
            [[FTupleEventTypeString alloc] initWithFirebase:[node2 child:@"a"] withEvent:FIRDataEventTypeValue withString:nil],
            [[FTupleEventTypeString alloc] initWithFirebase:[node2 child:@"b"] withEvent:FIRDataEventTypeValue withString:nil]
    ];

    [et addLookingFor:expect];
    [et wait];

    expect = @[
            [[FTupleEventTypeString alloc] initWithFirebase:[node2 child:@"b"] withEvent:FIRDataEventTypeValue withString:nil]
    ];

    [et addLookingFor:expect];

    ready = NO;
    [node2 runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        NSDictionary* toSet = @{@"a": @42, @"b": @87};
        [currentData setValue:toSet];
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    [et wait];
}

- (void) testTransactionOnlyCalledOnceWhenInitializingAnEmptyNode {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];

    __block BOOL updateCalled = NO;
    [node runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        id val = [currentData value];
        XCTAssertTrue(val == [NSNull null], @"Should be no value here to start with");
        if (updateCalled) {
            XCTFail(@"Should not be called again");
        }
        updateCalled = YES;
        [currentData setValue:@{@"a": @5, @"b": @6}];
        return [FIRTransactionResult successWithValue:currentData];
    }];

    [self waitUntil:^BOOL{
        return updateCalled;
    }];
}

- (void) testSecondTransactionGetsRunImmediatelyOnPreviousOutputAndOnlyRunsOnce {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * ref1 = refs.one;
    FIRDatabaseReference * ref2 = refs.two;

    __block BOOL firstRun = NO;
    __block BOOL firstDone = NO;
    __block BOOL secondRun = NO;
    __block BOOL secondDone = NO;

    [ref1 runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        XCTAssertFalse(firstRun, @"Should not be run twice");
        firstRun = YES;
        [currentData setValue:@42];
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertTrue(committed, @"Should not fail");
        firstDone = YES;
    }];

    [self waitUntil:^BOOL{
        return firstRun;
    }];

    [ref1 runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        XCTAssertFalse(secondRun, @"Should only run once");
        secondRun = YES;
        NSNumber* val = [currentData value];
        XCTAssertTrue([val isEqualToNumber:@42], @"Should see result of last transaction");
        [currentData setValue:@84];
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertTrue(committed, @"Should not fail");
        secondDone = YES;
    }];

    [self waitUntil:^BOOL{
        return secondRun;
    }];

    __block FIRDataSnapshot * snap = nil;
    [ref1 observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        snap = snapshot;
    }];

    [self waitUntil:^BOOL{
        return snap != nil;
    }];

    XCTAssertTrue([[snap value] isEqualToNumber:@84], @"Should get updated value");

    [self waitUntil:^BOOL{
        return firstDone && secondDone;
    }];

    snap = nil;
    [ref2 observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        snap = snapshot;
    }];

    [self waitUntil:^BOOL{
        return snap != nil;
    }];

    XCTAssertTrue([[snap value] isEqualToNumber:@84], @"Should get updated value");
}

// The js test, "Set() cancels pending transactions and re-runs affected transactions.", does not cleanly port to ios
// due to everything being asynchronous. Rather than attempt to mitigate the various race conditions inherent in a port,
// I'm adding tests to cover the specific behaviors wrapped up in that one test.

- (void) testSetCancelsPendingTransaction {
    FIRDatabaseReference * node = [FTestHelpers getRandomNode];

    __block FIRDataSnapshot * nodeSnap = nil;
    __block FIRDataSnapshot * nodeFooSnap = nil;

    [node observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        nodeSnap = snapshot;
    }];

    [[node child:@"foo"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        nodeFooSnap = snapshot;
    }];

    __block BOOL firstDone = NO;
    __block BOOL secondDone = NO;
    __block BOOL firstRun = NO;

    [[node child:@"foo"] runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        XCTAssertFalse(firstRun, @"Should only run once");
        firstRun = YES;
        [currentData setValue:@42];
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertTrue(committed, @"Should not fail");
        firstDone = YES;
    }];

    [self waitUntil:^BOOL{
        return nodeFooSnap != nil;
    }];

    XCTAssertTrue([[nodeFooSnap value] isEqualToNumber:@42], @"Got first value");

    [node runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        [currentData setValue:@{@"foo": @84, @"bar": @1}];
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertFalse(committed, @"This should not ever be committed");
        secondDone = YES;
    }];

    [self waitUntil:^BOOL{
        return nodeSnap != nil;
    }];

    [[node child:@"foo"] setValue:@0];
}

// It's difficult to force a transaction re-run on ios, since everything is async. There is also an outstanding case that prevents
// this test from being before a connection is established (#1981)
/*
- (void) testSetRerunsAffectedTransactions  {

    Firebase* node = [FTestHelpers getRandomNode];

    __block BOOL ready = NO;
    [[node.parent child:@".info/connected"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        ready = [[snapshot value] boolValue];
    }];
    [self waitUntil:^BOOL{
        return ready;
    }];

    __block FIRDataSnapshot* nodeSnap = nil;

    [node observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        nodeSnap = snapshot;
        NSLog(@"SNAP value: %@", [snapshot value]);
    }];

    __block BOOL firstDone = NO;
    __block BOOL secondDone = NO;
    __block BOOL firstRun = NO;
    __block int secondCount = 0;
    __block BOOL setDone = NO;

    [node runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        STAssertFalse(firstRun, @"Should only run once");
        firstRun = YES;
        [currentData setValue:@42];
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        STAssertTrue(committed, @"Should not fail");
        firstDone = YES;
    }];

    [[node child:@"bar"] runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        NSLog(@"RUNNING TRANSACTION");
        secondCount++;
        id val = [currentData value];
        if (secondCount == 1) {
            STAssertTrue(val == [NSNull null], @"Should not have a value");
            [currentData setValue:@"first"];
            return [FIRTransactionResult successWithValue:currentData];
        } else if (secondCount == 2) {
            NSLog(@"val: %@", val);
            STAssertTrue(val == [NSNull null], @"Should not have a value");
            [currentData setValue:@"second"];
            return [FIRTransactionResult successWithValue:currentData];
        } else {
            STFail(@"Called too many times");
            return [FIRTransactionResult abort];
        }
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        STAssertTrue(committed, @"Should eventually be committed");
        secondDone = YES;
    }];

    [[node child:@"foo"] setValue:@0 andCompletionBlock:^(NSError *error) {
        setDone = YES;
    }];

    [self waitUntil:^BOOL{
        return setDone;
    }];

    NSDictionary* expected = @{@"bar": @"second", @"foo": @0};
    STAssertTrue([[nodeSnap value] isEqualToDictionary:expected], @"Got last value");

    STAssertTrue(secondCount == 2, @"Should have re-run second transaction");
}*/

- (void) testTransactionSetSetWorks {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];

    __block BOOL done = NO;
    [ref runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        id val = [currentData value];
        XCTAssertTrue(val == [NSNull null], @"Initial data should be null");
        [currentData setValue:@"hi!"];
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertTrue(error == nil, @"Should not be an error");
        XCTAssertTrue(committed, @"Should commit");
        done = YES;
    }];

    [ref setValue:@"foo"];
    [ref setValue:@"bar"];

    [self waitUntil:^BOOL{
        return done;
    }];
}

- (void) testPriorityIsNotPreservedWhenSettingData {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];

    __block FIRDataSnapshot * snap = nil;
    [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        snap = snapshot;
    }];

    [ref setValue:@"test" andPriority:@5];

    __block BOOL ready = NO;
    [ref runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        [currentData setValue:@"new value"];
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    id val = [snap value];
    id pri = [snap priority];
    XCTAssertTrue(pri == [NSNull null], @"Got priority");
    XCTAssertTrue([val isEqualToString:@"new value"], @"Get new value");
}

// Skipping test with nested transactions. Everything is async on ios, so new transactions just get placed in a queue

- (void) testResultSnapshotIsPassedToOnComplete {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * ref1 = refs.one;
    FIRDatabaseReference * ref2 = refs.two;

    __block BOOL done = NO;
    [ref1 runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        id val = [currentData value];
        if (val == [NSNull null]) {
            [currentData setValue:@"hello!"];
            return [FIRTransactionResult successWithValue:currentData];
        } else {
            return [FIRTransactionResult abort];
        }
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertTrue(committed, @"Should commit");
        XCTAssertTrue([[snapshot value] isEqualToString:@"hello!"], @"Got correct snapshot");
        done = YES;
    }];

    [self waitUntil:^BOOL{
        return done;
    }];
    // do it again for the aborted case

    done = NO;
    [ref1 runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        id val = [currentData value];
        if (val == [NSNull null]) {
            [currentData setValue:@"hello!"];
            return [FIRTransactionResult successWithValue:currentData];
        } else {
            return [FIRTransactionResult abort];
        }
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertFalse(committed, @"Should not commit");
        XCTAssertTrue([[snapshot value] isEqualToString:@"hello!"], @"Got correct snapshot");
        done = YES;
    }];

    [self waitUntil:^BOOL{
        return done;
    }];

    // do it again on a fresh connection, for the aborted case
    done = NO;
    [ref2 runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        id val = [currentData value];
        if (val == [NSNull null]) {
            [currentData setValue:@"hello!"];
            return [FIRTransactionResult successWithValue:currentData];
        } else {
            return [FIRTransactionResult abort];
        }
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertFalse(committed, @"Should not commit");
        XCTAssertTrue([[snapshot value] isEqualToString:@"hello!"], @"Got correct snapshot");
        done = YES;
    }];

    [self waitUntil:^BOOL{
        return done;
    }];
}

- (void) testTransactionAbortsAfter25Retries {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];

    [ref.repo setHijackHash:YES];

    __block int tries = 0;
    __block BOOL done = NO;
    [ref runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        XCTAssertTrue(tries < 25, @"Should not be more than 25 tries");
        tries++;
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertTrue(error != nil, @"Should fail, too many retries");
        XCTAssertFalse(committed, @"Should not commit");
        done = YES;
    }];

    [self waitUntil:^BOOL{
        return done;
    }];

    [ref.repo setHijackHash:NO];
}

- (void) testSetShouldCancelSentTransactionsThatComeBackAsDatastale {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * ref1 = refs.one;
    FIRDatabaseReference * ref2 = refs.two;

    __block BOOL ready = NO;
    [ref1 setValue:@5 withCompletionBlock:^(NSError *error, FIRDatabaseReference * ref) {
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    ready = NO;
    [ref2 runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        id val = [currentData value];
        XCTAssertTrue(val == [NSNull null], @"No current value");
        [currentData setValue:@72];
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertTrue(error != nil, @"Should abort");
        XCTAssertFalse(committed, @"Should not commit");
        ready = YES;
    }];

    [ref2 setValue:@32];

    [self waitUntil:^BOOL{
        return ready;
    }];
}

- (void) testUpdateShouldNotCancelUnrelatedTransactions {
    FIRDatabaseReference* ref = [FTestHelpers getRandomNode];

    __block BOOL fooTransactionDone = NO;
    __block BOOL barTransactionDone = NO;

    [self waitForCompletionOf:[ref child:@"foo"] setValue:@"oldValue"];

    [ref.repo setHijackHash:YES];

    // This transaction should get cancelled as we update "foo" later on.
    [[ref child:@"foo"] runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        [currentData setValue:@72];
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertTrue(error != nil, @"Should abort");
        XCTAssertFalse(committed, @"Should not commit");
        fooTransactionDone = YES;
    }];

    // This transaction should not get cancelled since we don't update "bar".
    [[ref child:@"bar"] runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        [currentData setValue:@72];
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        // Note: In rare cases, this might get aborted since failed transactions (forced by setHijackHash) are only
        // retried 25 times. If we hit this limit before we stop hijacking the hash below, this test will flake.
        XCTAssertTrue(error == nil, @"Should not abort");
        XCTAssertTrue(committed, @"Should commit");
        barTransactionDone = YES;
    }];

    NSDictionary *udpateData = @{ @"foo": @"newValue",
                                  @"boo": @"newValue",
                                  @"doo/foo": @"newValue",
                                  @"loo" : @{ @"doo": @{ @"boo":@"newValue"}}} ;

    [self waitForCompletionOf:ref updateChildValues:udpateData];
    XCTAssertTrue(fooTransactionDone, "Should have gotten cancelled before the update");
    XCTAssertFalse(barTransactionDone, "Should run after the update");
    [ref.repo setHijackHash:NO];

    WAIT_FOR(barTransactionDone);
}

- (void) testTransactionOnWackyUnicode {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * ref1 = refs.one;
    FIRDatabaseReference * ref2 = refs.two;

    __block BOOL ready = NO;
    [ref1 setValue:@"♜♞♝♛♚♝♞♜" withCompletionBlock:^(NSError *error, FIRDatabaseReference * ref) {
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];

    ready = NO;
    [ref2 runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        id val = [currentData value];
        if (val != [NSNull null]) {
            XCTAssertTrue([val isEqualToString:@"♜♞♝♛♚♝♞♜"], @"Got crazy unicode");
        }
        [currentData setValue:@"♖♘♗♕♔♗♘♖"];
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertTrue(error == nil, @"Should not abort");
        XCTAssertTrue(committed, @"Should commit");
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];
}

- (void) testImmediatelyAbortedTransactions {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];

    [ref runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        return [FIRTransactionResult abort];
    }];

    __block BOOL ready = NO;
    [ref runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        return [FIRTransactionResult abort];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertTrue(error == nil, @"No error occurred, we just aborted");
        XCTAssertFalse(committed, @"Should not commit");
        ready = YES;
    }];

    [self waitUntil:^BOOL{
        return ready;
    }];
}

- (void) testAddingToAnArrayWithATransaction {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];

    __block BOOL done = NO;
    [ref setValue:@[@"cat", @"horse"] withCompletionBlock:^(NSError *error, FIRDatabaseReference * ref) {
        done = YES;
    }];

    [self waitUntil:^BOOL{
        return done;
    }];

    done = NO;

    [ref runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        id val = [currentData value];
        if (val != [NSNull null]) {
            NSArray* arr = val;
            NSMutableArray* toSet = [arr mutableCopy];
            [toSet addObject:@"dog"];
            [currentData setValue:toSet];
            return [FIRTransactionResult successWithValue:currentData];
        } else {
            [currentData setValue:@[@"dog"]];
            return [FIRTransactionResult successWithValue:currentData];
        }
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertTrue(committed, @"Should commit");
        NSArray* val = [snapshot value];
        NSArray* expected = @[@"cat", @"horse", @"dog"];
        XCTAssertTrue([val isEqualToArray:expected], @"Got whole array");
        done = YES;
    }];

    [self waitUntil:^BOOL{
        return done;
    }];
}

- (void) testMergedTransactionsHaveCorrectSnapshotInOnComplete {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * node1 = refs.one;
    FIRDatabaseReference * node2 = refs.two;

    __block BOOL done = NO;
    [node1 setValue:@{@"a": @0} withCompletionBlock:^(NSError *error, FIRDatabaseReference * ref) {
        done = YES;
    }];

    [self waitUntil:^BOOL{
        return done;
    }];

    __block BOOL transaction1Done = NO;
    __block BOOL transaction2Done = NO;

    [node2 runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        id val = [currentData value];
        if (val != [NSNull null]) {
            XCTAssertTrue([@{@"a": @0} isEqualToDictionary:val], @"Got initial data");
        }
        [currentData setValue:@{@"a": @1}];
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertTrue(committed, @"Should commit");
        XCTAssertTrue([snapshot.key isEqualToString:node2.key], @"Correct snapshot name");
        NSDictionary* val = [snapshot value];
        // Per new behavior, will include the accepted value of the transaction, if it was successful.
        NSDictionary* expected = @{@"a": @1};
        XCTAssertTrue([val isEqualToDictionary:expected], @"Got final result");
        transaction1Done = YES;
    }];

    [[node2 child:@"a"] runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        id val = [currentData value];
        if (val != [NSNull null]) {
            XCTAssertTrue([@1 isEqualToNumber:val], @"Got initial data");
        }
        [currentData setValue:@2];
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertTrue(committed, @"Should commit");
        XCTAssertTrue([snapshot.key isEqualToString:@"a"], @"Correct snapshot name");
        NSNumber* val = [snapshot value];
        NSNumber* expected = @2;
        XCTAssertTrue([val isEqualToNumber:expected], @"Got final result");
        transaction2Done = YES;
    }];

    [self waitUntil:^BOOL{
        return transaction1Done && transaction2Done;
    }];
}

// Skipping two tests on nested calls. Since iOS uses a work queue, nested calls don't actually happen synchronously, so they aren't problematic

- (void) testPendingTransactionsAreCancelledOnDisconnect {
    FIRDatabaseConfig *cfg = [FTestHelpers configForName:@"pending-transactions"];
    FIRDatabaseReference * ref = [[[FIRDatabaseReference alloc] initWithConfig:cfg] childByAutoId];

    __block BOOL done = NO;
    [[ref child:@"a"] setValue:@"initial" withCompletionBlock:^(NSError *error, FIRDatabaseReference * ref) {
        done = YES;
    }];

    [self waitUntil:^BOOL{
        return done;
    }];

    done = NO;
    [[ref child:@"b"] runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        [currentData setValue:@"new"];
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertFalse(committed, @"Should not commit");
        XCTAssertTrue(error != nil, @"Should be an error");
        done = YES;
    }];

    [FRepoManager interrupt:cfg];

    [self waitUntil:^BOOL{
        return done;
    }];

    // cleanup
    [FRepoManager interrupt:cfg];
    [FRepoManager disposeRepos:cfg];
}

- (void) testTransactionWithoutLocalEvents1 {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
    NSMutableArray* values = [[NSMutableArray alloc] init];
    [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        [values addObject:[snapshot value]];
    }];

    [self waitUntil:^BOOL{
        // get initial data
        return values.count > 0;
    }];

    __block BOOL done = NO;
    [ref runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        [currentData setValue:@"hello!"];
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertTrue(error == nil, @"Should not be an error");
        XCTAssertTrue(committed, @"Committed");
        XCTAssertTrue([[snapshot value] isEqualToString:@"hello!"], @"got correct snapshot");
        done = YES;
    } withLocalEvents:NO];

    NSArray* expected = @[[NSNull null]];
    XCTAssertTrue([values isEqualToArray:expected], @"Should not have gotten any values yet");

    [self waitUntil:^BOOL{
        return done;
    }];

    expected = @[[NSNull null], @"hello!"];
    XCTAssertTrue([values isEqualToArray:expected], @"Should have the new value now");
}

- (void) testTransactionWithoutLocalEvents2 {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * ref1 = refs.one;
    FIRDatabaseReference * ref2 = refs.two;
    int SETS = 4;

    [ref1.repo setHijackHash:YES];

    NSMutableArray* events = [[NSMutableArray alloc] init];
    [ref1 setValue:@0];
    [ref1 observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        [events addObject:[snapshot value]];
    }];

    [self waitUntil:^BOOL{
        return events.count > 0;
    }];

    NSArray* expected = @[@0];
    XCTAssertTrue([events isEqualToArray:expected], @"Got initial set");

    __block int retries = 0;
    __block BOOL done = NO;
    [ref1 runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        retries++;
        id val = [currentData value];
        NSNumber* num = @0;
        if (val != [NSNull null]) {
            num = val;
        }
        int eventCount = [num intValue];
        if (eventCount == SETS - 1) {
            [ref1.repo setHijackHash:NO];
        }

        [currentData setValue:@"txn result"];
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertTrue(error == nil, @"Should not be an error");
        XCTAssertTrue(committed, @"Committed");
        XCTAssertTrue([[snapshot value] isEqualToString:@"txn result"], @"got correct snapshot");
        done = YES;
    } withLocalEvents:NO];

    // Meanwhile, do sets from the second connection
    for (int i = 0; i < SETS; ++i) {
        __block BOOL setDone = NO;
        [ref2 setValue:[NSNumber numberWithInt:i] withCompletionBlock:^(NSError *error, FIRDatabaseReference * ref) {
            setDone = YES;
        }];
        [self waitUntil:^BOOL{
            return setDone;
        }];
    }

    [self waitUntil:^BOOL{
        return done;
    }];

    XCTAssertTrue(retries > 0, @"Transaction should have retried");
    XCTAssertEqualObjects([events lastObject], @"txn result", @"Final value matches expected value from txn");
}

// Skipping test of calling transaction from value callback. Since all api calls are async on iOS, nested calls are not a problem.

- (void) testTransactionRevertsDataWhenAddADeeperListen {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * ref1 = refs.one;
    FIRDatabaseReference * ref2 = refs.two;

    __block BOOL done = NO;
    [[ref1 child:@"y"] setValue:@"test" withCompletionBlock:^(NSError *error, FIRDatabaseReference * ref) {
        [ref2 runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
            if (currentData.value == [NSNull null]) {
                [[currentData childDataByAppendingPath:@"x"] setValue:@5];
                return [FIRTransactionResult successWithValue:currentData];
            } else {
                return [FIRTransactionResult abort];
            }
        }];

        [[ref2 child:@"y"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
            if ([snapshot.value isEqual:@"test"]) {
                done = YES;
            }
        }];
    }];

    [self waitUntil:^BOOL{
        return done;
    }];
}

- (void) testTransactionWithIntegerKeys {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
    __block BOOL done = NO;
    NSDictionary* toSet = @{@"1": @1, @"5": @5, @"10": @10, @"20": @20};
    [ref setValue:toSet withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) {
        [ref runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
            [currentData setValue:@42];
            return [FIRTransactionResult successWithValue:currentData];
        } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
            XCTAssertNil(error, @"Error should be nil.");
            XCTAssertTrue(committed, @"Transaction should have committed.");
            done = YES;
        }];
    }];

    [self waitUntil:^BOOL{
        return done;
    }];
}

// https://app.asana.com/0/5673976843758/9259161251948
- (void) testBubbleAppTransactionBug {
    FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
    __block BOOL done = NO;
    [[ref child:@"a"] runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        [currentData setValue:@1];
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) { }];

    [[ref child:@"a"] runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        NSNumber* val = currentData.value;
        NSNumber *new = [NSNumber numberWithInt:(val.intValue + 42)];
        [currentData setValue:new];
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) { }];

    [[ref child:@"b"] runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        [currentData setValue:@7];
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) { }];

    [ref runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        NSNumber* a = [currentData childDataByAppendingPath:@"a"].value;
        NSNumber* b = [currentData childDataByAppendingPath:@"b"].value;
        NSNumber *new = [NSNumber numberWithInt:a.intValue + b.intValue];
        [currentData setValue:new];
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertNil(error, @"Error should be nil.");
        XCTAssertTrue(committed, @"Committed should be true.");
        XCTAssertEqualObjects(@50, snapshot.value, @"Result should be 50.");
        done = YES;
    }];

    [self waitUntil:^BOOL{
        return done;
    }];
}

// If we have cached data, transactions shouldn't run on null.
- (void) testTransactionsAreRunInitiallyOnCurrentlyCachedData {
    FIRDatabaseReference *ref = [FTestHelpers getRandomNode];
    id initialData = @{
            @"a": @"a-val",
            @"b": @"b-val"
    };
    __block BOOL done = NO;
    __weak FIRDatabaseReference *weakRef = ref;
    [ref setValue:initialData withCompletionBlock:^(NSError *error, FIRDatabaseReference *r) {
        [weakRef observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
            [weakRef runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
                XCTAssertEqualObjects(currentData.value, initialData, @"Should be initial data.");
                done = YES;
                return [FIRTransactionResult abort];
            }];
        }];
    }];

    [self waitUntil:^BOOL{
        return done;
    }];
}

- (void) testMultipleLevels {
    FIRDatabaseReference *ref = [FTestHelpers getRandomNode];
    __block BOOL done = NO;

    [ref runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        return [FIRTransactionResult successWithValue:currentData];
    }];

    [[ref child:@"a"] runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        return [FIRTransactionResult successWithValue:currentData];
    }];

    [[ref child:@"b"] runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        return [FIRTransactionResult successWithValue:currentData];
    }];

    [ref runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        done = YES;
    }];

    WAIT_FOR(done);
}

- (void) testLocalServerValuesEventuallyButNotImmediatelyMatchServerWithTxns {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * writer = refs.one;
    FIRDatabaseReference * reader = refs.two;
    __block int done = 0;

    NSMutableArray* readSnaps = [[NSMutableArray alloc] init];
    NSMutableArray* writeSnaps = [[NSMutableArray alloc] init];

    [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        if ([snapshot value] != [NSNull null]) {
            [readSnaps addObject:snapshot];
            if (readSnaps.count == 1) {
                done += 1;
            }
        }
    }];

    [writer observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        if ([snapshot value] != [NSNull null]) {
            [writeSnaps addObject:snapshot];
            if (writeSnaps.count == 2) {
                done += 1;
            }
        }
    }];

    [writer runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        [currentData setValue:[FIRServerValue timestamp]];
        [currentData setPriority:[FIRServerValue timestamp]];
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {}];

    [self waitUntil:^BOOL{
        return done == 2;
    }];

    XCTAssertEqual((unsigned long)[readSnaps count], (unsigned long)1, @"Should have received one snapshot on reader");
    XCTAssertEqual((unsigned long)[writeSnaps count], (unsigned long)2, @"Should have received two snapshots on writer");

    FIRDataSnapshot * firstReadSnap = [readSnaps objectAtIndex:0];
    FIRDataSnapshot * firstWriteSnap = [writeSnaps objectAtIndex:0];
    FIRDataSnapshot * secondWriteSnap = [writeSnaps objectAtIndex:1];

    NSNumber* now = [NSNumber numberWithDouble:round([[NSDate date] timeIntervalSince1970]*1000)];
    XCTAssertTrue([now doubleValue] - [firstWriteSnap.value doubleValue] < 2000, @"Should have received a local event with a value close to timestamp");
    XCTAssertTrue([now doubleValue] - [firstWriteSnap.priority doubleValue] < 2000, @"Should have received a local event with a priority close to timestamp");
    XCTAssertTrue([now doubleValue] - [secondWriteSnap.value doubleValue] < 2000, @"Should have received a server event with a value close to timestamp");
    XCTAssertTrue([now doubleValue] - [secondWriteSnap.priority doubleValue] < 2000, @"Should have received a server event with a priority close to timestamp");

    XCTAssertFalse([firstWriteSnap value] == [secondWriteSnap value], @"Initial and future writer values should be different");
    XCTAssertFalse([firstWriteSnap priority] == [secondWriteSnap priority], @"Initial and future writer priorities should be different");
    XCTAssertEqualObjects(firstReadSnap.value, secondWriteSnap.value, @"Eventual reader and writer values should be equal");
    XCTAssertEqualObjects(firstReadSnap.priority, secondWriteSnap.priority, @"Eventual reader and writer priorities should be equal");
}

- (void) testTransactionWithQueryListen {
    FIRDatabaseReference *ref = [FTestHelpers getRandomNode];
    __block BOOL done = NO;

    [ref setValue:@{@"a": @1, @"b": @2} withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) {
        [[ref queryLimitedToFirst:1] observeEventType:FIRDataEventTypeChildAdded andPreviousSiblingKeyWithBlock:^(FIRDataSnapshot *snapshot, NSString *prevName) {
        }                             withCancelBlock:^(NSError *error) {
        }];

        [[ref child:@"a"] runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
            return [FIRTransactionResult successWithValue:currentData];
        } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
            XCTAssertNil(error, @"This transaction should not have an error");
            XCTAssertTrue(committed, @"Should not have aborted");
            XCTAssertEqualObjects([snapshot value], @1, @"Transaction value should match initial set");
            done = YES;
        }];
    }];

    WAIT_FOR(done);
}

- (void) testTransactionDoesNotPickUpCachedDataFromPreviousOnce {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * me = refs.one;
    FIRDatabaseReference * other = refs.two;
    __block BOOL done = NO;

    [me setValue:@"not null" withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) {
        done = YES;
    }];

    WAIT_FOR(done);
    done = NO;

    [me observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
        done = YES;
    }];

    WAIT_FOR(done);
    done = NO;

    [other setValue:[NSNull null] withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) {
        done = YES;
    }];

    WAIT_FOR(done);
    done = NO;

    [me runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        id current = [currentData value];
        if (current == [NSNull null]) {
            [currentData setValue:@"it was null!"];
        } else {
            [currentData setValue:@"it was not null!"];
        }
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertNil(error, @"This transaction should not have an error");
        XCTAssertTrue(committed, @"Should not have aborted");
        XCTAssertEqualObjects([snapshot value], @"it was null!", @"Transaction value should match remote null set");
        done = YES;
    }];

    WAIT_FOR(done);
}

- (void) testTransactionDoesNotPickUpCachedDataFromPreviousTransaction {
    FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
    FIRDatabaseReference * me = refs.one;
    FIRDatabaseReference * other = refs.two;
    __block BOOL done = NO;

    [me runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        [currentData setValue:@"not null"];
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertNil(error, @"This transaction should not have an error");
        XCTAssertTrue(committed, @"Should not have aborted");
        done = YES;
    }];

    WAIT_FOR(done);
    done = NO;

    [other setValue:[NSNull null] withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) {
        done = YES;
    }];

    WAIT_FOR(done);
    done = NO;

    [me runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        id current = [currentData value];
        if (current == [NSNull null]) {
            [currentData setValue:@"it was null!"];
        } else {
            [currentData setValue:@"it was not null!"];
        }
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertNil(error, @"This transaction should not have an error");
        XCTAssertTrue(committed, @"Should not have aborted");
        XCTAssertEqualObjects([snapshot value], @"it was null!", @"Transaction value should match remote null set");
        done = YES;
    }];

    WAIT_FOR(done);
}

- (void) testTransactionOnQueriedLocationDoesntRunInitiallyOnNull {
    FIRDatabaseReference *ref = [FTestHelpers getRandomNode];
    __block BOOL txnDone = NO;

    [self waitForCompletionOf:[ref childByAutoId] setValue:@{ @"a": @1, @"b": @2 }];

    [[ref queryLimitedToFirst:1] observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
        [snapshot.ref runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
            id expected = @{@"a" : @1, @"b" : @2};
            XCTAssertEqualObjects(currentData.value, expected, @"");
            [currentData setValue:[NSNull null]];
            return [FIRTransactionResult successWithValue:currentData];
        }              andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
            XCTAssertNil(error, @"");
            XCTAssertTrue(committed, @"");
            XCTAssertEqualObjects(snapshot.value, [NSNull null], @"");
            txnDone = YES;
        }];
    }];

    WAIT_FOR(txnDone);
}

- (void) testTransactionsRaiseCorrectChildChangedEventsOnQueries {
    FIRDatabaseReference *ref = [FTestHelpers getRandomNode];
    __block BOOL txnDone = NO;
    NSMutableArray *snapshots = [[NSMutableArray alloc] init];

    [self waitForCompletionOf:ref setValue:@{ @"foo": @{ @"value": @1 }}];

    FIRDatabaseQuery *query = [ref queryEndingAtValue:@(DBL_MIN)];

    [query observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
        [snapshots addObject:snapshot];
    }];

    [query observeEventType:FIRDataEventTypeChildChanged withBlock:^(FIRDataSnapshot *snapshot) {
        [snapshots addObject:snapshot];
    }];

    [[ref child:@"foo"] runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        [[currentData childDataByAppendingPath:@"value"] setValue:@2];
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertNil(error, @"");
        XCTAssertTrue(committed, @"");
        txnDone = YES;
    } withLocalEvents:NO];

    WAIT_FOR(txnDone);

    XCTAssertTrue(snapshots.count == 2, @"");
    FIRDataSnapshot *addedSnapshot = snapshots[0];
    XCTAssertEqualObjects(addedSnapshot.key, @"foo", @"");
    XCTAssertEqualObjects(addedSnapshot.value, @{ @"value": @1 }, @"");

    FIRDataSnapshot *changedSnapshot = snapshots[1];
    XCTAssertEqualObjects(changedSnapshot.key, @"foo", @"");
    XCTAssertEqualObjects(changedSnapshot.value, @{ @"value": @2 }, @"");
}

- (void) testTransactionsUseLocalMerges {
    FIRDatabaseReference *ref = [FTestHelpers getRandomNode];
    __block BOOL txnDone = NO;
    [ref updateChildValues:@{ @"foo": @"bar"}];

    [[ref child:@"foo"] runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        XCTAssertEqualObjects(currentData.value, @"bar", @"Transaction value matches local updates");
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertNil(error, @"");
        XCTAssertTrue(committed, @"");
        txnDone = YES;
    }];

    WAIT_FOR(txnDone);
}

//See https://app.asana.com/0/15566422264127/23303789496881
- (void)testOutOfOrderRemoveWritesAreHandledCorrectly
{
    FIRDatabaseReference *ref = [FTestHelpers getRandomNode];
    [ref setValue:@{@"foo": @"bar"}];
    [ref runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        [currentData setValue:@"transaction-1"];
        return [FIRTransactionResult successWithValue:currentData];
    }];
    [ref runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        [currentData setValue:@"transaction-2"];
        return [FIRTransactionResult successWithValue:currentData];
    }];
    __block BOOL done = NO;
    // This will trigger an abort of the transaction which should not cause the client to crash
    [ref updateChildValues:@{@"qux": @"quu"} withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) {
        XCTAssertNil(error);
        done = YES;
    }];

    WAIT_FOR(done);
}

- (void)testUnsentTransactionsAreNotCancelledOnDisconnect {
    // Hack: To trigger us to disconnect before restoring state, we inject a bad auth token.
    // In real-world usage the much more common case is that we get redirected to a different
    // server, but that's harder to manufacture from a test.
    NSString *configName = @"testUnsentTransactionsAreNotCancelledOnDisconnect";
    FIRDatabaseConfig *config = [FTestHelpers configForName:configName];
    config.authTokenProvider = [[FIROneBadTokenProvider alloc] init];

    // Queue a transaction offline.
    FIRDatabaseReference *root = [[FIRDatabaseReference alloc] initWithConfig:config];
    [root.database goOffline];
    __block BOOL done = NO;
    [[root childByAutoId] runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) {
        [currentData setValue:@0];
        return [FIRTransactionResult successWithValue:currentData];
    } andCompletionBlock:^(NSError *error, BOOL committed, FIRDataSnapshot *snapshot) {
        XCTAssertNil(error);
        XCTAssertTrue(committed);
        done = YES;
    }];

    [root.database goOnline];
    WAIT_FOR(done);
}

@end