/* * 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 "FirebaseDatabase/Tests/Integration/FData.h" #import #import "FirebaseCore/Extension/FirebaseCoreInternal.h" #import "FirebaseDatabase/Sources/Api/Private/FIRDatabaseQuery_Private.h" #import "FirebaseDatabase/Sources/Core/FRepo_Private.h" #import "FirebaseDatabase/Sources/FIRDatabaseConfig_Private.h" #import "FirebaseDatabase/Sources/Public/FirebaseDatabase/FIRServerValue.h" #import "FirebaseDatabase/Tests/Helpers/FEventTester.h" #import "FirebaseDatabase/Tests/Helpers/FTestHelpers.h" #import "FirebaseDatabase/Tests/Helpers/FTupleEventTypeString.h" @implementation FData - (void)testGetNode { __unused FIRDatabaseReference *node = [FTestHelpers getRandomNode]; XCTAssertTrue(YES, @"Properly created node without throwing error"); } - (void)testWriteData { FIRDatabaseReference *node = [FTestHelpers getRandomNode]; [node setValue:@42]; XCTAssertTrue(YES, @"Properly write to node without throwing error"); } - (void)testWriteDataWithDebugLogging { [FIRDatabase setLoggingEnabled:YES]; FIRDatabaseReference *node = [FTestHelpers getRandomNode]; [node setValue:@42]; [FIRDatabase setLoggingEnabled:NO]; XCTAssertTrue(YES, @"Properly write to node without throwing error"); } - (void)testWriteAndReadData { FIRDatabaseReference *node = [FTestHelpers getRandomNode]; [node setValue:@42]; [self snapWaiter:node withBlock:^(FIRDataSnapshot *snapshot) { XCTAssertEqualObjects(@42, [snapshot value], @"Properly saw correct value"); }]; } - (void)testProperParamChecking { // ios doesn't have an equivalent of this test } - (void)testNamespaceCaseInsensitivityWithinARepo { FIRDatabaseReference *ref1 = [[FTestHelpers defaultDatabase] referenceFromURL:[self.databaseURL uppercaseString]]; FIRDatabaseReference *ref2 = [[FTestHelpers defaultDatabase] referenceFromURL:[self.databaseURL lowercaseString]]; XCTAssertTrue([ref1.description isEqualToString:ref2.description], @"Descriptions should match"); } - (void)testRootProperty { FIRDatabaseReference *node = [FTestHelpers getRandomNode]; FIRDatabaseReference *root = node.root; XCTAssertTrue(root != nil, @"Should get a root"); XCTAssertTrue([[root description] isEqualToString:self.databaseURL], @"Root is actually the root"); } - (void)testValReturnsCompoundObjectWithChildren { FIRDatabaseReference *node = [FTestHelpers getRandomNode]; [node setValue:@{@"foo" : @{@"bar" : @5}}]; [self snapWaiter:node withBlock:^(FIRDataSnapshot *snapshot) { XCTAssertEqualObjects([[[snapshot value] objectForKey:@"foo"] objectForKey:@"bar"], @5, @"Properly saw compound object"); }]; } - (void)testWriteDataAndWaitForServerConfirmation { FIRDatabaseReference *node = [FTestHelpers getRandomNode]; [self waitForCompletionOf:node setValue:@42]; } - (void)testWriteAValueAndRead { // dupe of FEvent testWriteLeafExpectValueChanged } - (void)testWriteABunchOfDataAndRead { FTupleFirebase *tuple = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *writeNode = tuple.one; FIRDatabaseReference *readNode = tuple.two; __block BOOL done = NO; [[[[writeNode child:@"a"] child:@"b"] child:@"c"] setValue:@1]; [[[[writeNode child:@"a"] child:@"d"] child:@"e"] setValue:@2]; [[[[writeNode child:@"a"] child:@"d"] child:@"f"] setValue:@3]; [[writeNode child:@"g"] setValue:@4 withCompletionBlock:^(NSError *err, FIRDatabaseReference *ref) { done = YES; }]; [self waitUntil:^BOOL { return done; }]; [super snapWaiter:readNode withBlock:^(FIRDataSnapshot *s) { XCTAssertEqualObjects([[[[s childSnapshotForPath:@"a"] childSnapshotForPath:@"b"] childSnapshotForPath:@"c"] value], @1, @"Proper child value"); XCTAssertEqualObjects([[[[s childSnapshotForPath:@"a"] childSnapshotForPath:@"d"] childSnapshotForPath:@"e"] value], @2, @"Proper child value"); XCTAssertEqualObjects([[[[s childSnapshotForPath:@"a"] childSnapshotForPath:@"d"] childSnapshotForPath:@"f"] value], @3, @"Proper child value"); XCTAssertEqualObjects([[s childSnapshotForPath:@"g"] value], @4, @"Proper child value"); }]; } - (void)testWriteABunchOfDataWithLeadingZeroesAndRead { FTupleFirebase *tuple = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *writeNode = tuple.one; FIRDatabaseReference *readNode = tuple.two; [self waitForCompletionOf:[writeNode child:@"1"] setValue:@1]; [self waitForCompletionOf:[writeNode child:@"01"] setValue:@2]; [self waitForCompletionOf:[writeNode child:@"001"] setValue:@3]; [self waitForCompletionOf:[writeNode child:@"0001"] setValue:@4]; [super snapWaiter:readNode withBlock:^(FIRDataSnapshot *s) { XCTAssertEqualObjects([[s childSnapshotForPath:@"1"] value], @1, @"Proper child value"); XCTAssertEqualObjects([[s childSnapshotForPath:@"01"] value], @2, @"Proper child value"); XCTAssertEqualObjects([[s childSnapshotForPath:@"001"] value], @3, @"Proper child value"); XCTAssertEqualObjects([[s childSnapshotForPath:@"0001"] value], @4, @"Proper child value"); }]; } - (void)testLeadingZeroesTurnIntoDictionary { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; [self waitForCompletionOf:[ref child:@"1"] setValue:@1]; [self waitForCompletionOf:[ref child:@"01"] setValue:@2]; __block BOOL done = NO; __block FIRDataSnapshot *snap = nil; [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { snap = snapshot; done = YES; }]; WAIT_FOR(done); XCTAssertTrue([snap.value isKindOfClass:[NSDictionary class]], @"Should be dictionary"); XCTAssertEqualObjects([snap.value objectForKey:@"1"], @1, @"Proper child value"); XCTAssertEqualObjects([snap.value objectForKey:@"01"], @2, @"Proper child value"); } - (void)testLeadingZerosDontCollapseLocally { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; __block BOOL done = NO; __block FIRDataSnapshot *snap = nil; [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { snap = snapshot; done = (snapshot.childrenCount == 2); }]; [[ref child:@"3"] setValue:@YES]; [[ref child:@"03"] setValue:@NO]; WAIT_FOR(done); XCTAssertEqualObjects([[snap childSnapshotForPath:@"3"] value], @YES, @"Proper child value"); XCTAssertEqualObjects([[snap childSnapshotForPath:@"03"] value], @NO, @"Proper child value"); } - (void)testSnapshotRef { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; __block BOOL done = NO; [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { [snapshot.ref observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { done = YES; }]; }]; WAIT_FOR(done); } - (void)testWriteLeafNodeOverwriteAtParentVerifyExpectedEvents { FIRDatabaseReference *node = [FTestHelpers getRandomNode]; FIRDatabaseReference *connected = [[[FTestHelpers defaultDatabase] reference] child:@".info/connected"]; __block BOOL ready = NO; [connected observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { NSNumber *val = [snapshot value]; ready = [val boolValue]; }]; WAIT_FOR(ready); NSArray *lookingFor = @[ [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil], // 4 [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeChildAdded withString:@"aa"], // 0 [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil], // 4 [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeChildChanged withString:@"aa"], // 2 [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeValue withString:nil], // 4 ]; [[node repo] interrupt]; // Going offline ensures that local events get queued up before server events FEventTester *et = [[FEventTester alloc] initFrom:self]; [et addLookingFor:lookingFor]; [[node child:@"a/aa"] setValue:@1]; [[node child:@"a"] setValue:@{@"aa" : @2}]; [[node repo] resume]; [et wait]; } - (void)testWriteLeafNodeOverwriteAtParentMultipleTimesVerifyExpectedEvents { FIRDatabaseReference *node = [FTestHelpers getRandomNode]; NSArray *lookingFor = @[ [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeChildAdded withString:@"aa"], [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a/bb"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeChildChanged withString:@"aa"], [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeChildChanged withString:@"aa"], [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeValue withString:nil], ]; [[node repo] interrupt]; // Going offline ensures that local events get queued up before server events FEventTester *et = [[FEventTester alloc] initFrom:self]; [et addLookingFor:lookingFor]; [[node child:@"a/aa"] setValue:@1]; [[node child:@"a"] setValue:@{@"aa" : @2}]; [[node child:@"a"] setValue:@{@"aa" : @3}]; [[node child:@"a"] setValue:@{@"aa" : @3}]; [[node repo] resume]; [et wait]; } #ifdef FLAKY_TEST This test flakes frequently on the emulator on travis and almost always on GHA with testWriteLeafNodeRemoveLeafVerifyExpectedEvents, failed : caught "NSInternalInconsistencyException", "Unable to report test assertion failure '(([target isEqualTo:recvd]) is true) failed: throwing "Unable to report test assertion failure '(([target isEqualTo:recvd]) is true) failed - Expected http : // localhost:9000/-M8IJYWb68MuqQKKz2IY/a aa (0) to match http : // localhost:9000/-M8IJYWb68MuqQKKz2IY/a (null) (4)' from / Users / runner / runners / 2.262.1 / work / firebase - ios - sdk / firebase - ios - sdk / Example / Database / Tests / Helpers / FEventTester .m : 123 because it was raised inside test case -[FEventTester(null)] which has no associated XCTestRun object.This may happen when test cases are constructed and invoked independently of standard XCTest infrastructure, or when the test has already finished ." - Expected http://localhost:9000/-M8IJYWb68MuqQKKz2IY/a aa (0) to match " "http://localhost:9000/-M8IJYWb68MuqQKKz2IY/a (null) (4)' from " "/Users/runner/runners/2.262.1/work/firebase-ios-sdk/firebase-ios-sdk/" "Example/Database/Tests/Helpers/FEventTester.m:123 because it was raised " "inside test case -[FEventTester (null)] which has no associated XCTestRun " "object. This may happen when test cases are constructed and invoked " "independently of standard XCTest infrastructure, or when the test has " "already finished." / Users / runner / runners / 2.262.1 / work / firebase - ios - sdk / firebase - ios - sdk / Example / Database / Tests / Helpers / FEventTester.m: 123 ``` FTupleEventTypeString *recvd = [self.actualPathsAndEvents objectAtIndex:i]; XCTAssertTrue([target isEqualTo:recvd], @"Expected %@ to match %@", target, recvd); - (void)testWriteParentNodeOverwriteAtLeafVerifyExpectedEvents { FIRDatabaseReference *node = [FTestHelpers getRandomNode]; NSArray *lookingFor = @[ [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeChildAdded withString:@"aa"], [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeChildChanged withString:@"aa"], [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeValue withString:nil], ]; [[node repo] interrupt]; // Going offline ensures that local events get queued up before server events FEventTester *et = [[FEventTester alloc] initFrom:self]; [et addLookingFor:lookingFor]; [[node child:@"a"] setValue:@{@"aa" : @2}]; [[node child:@"a/aa"] setValue:@1]; [[node repo] resume]; [et wait]; } - (void)testWriteLeafNodeRemoveParentNodeVerifyExpectedEvents { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *writer = refs.one; FIRDatabaseReference *reader = refs.two; NSArray *lookingFor = @[ [[FTupleEventTypeString alloc] initWithFirebase:[writer child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:[writer child:@"a"] withEvent:FIRDataEventTypeChildAdded withString:@"aa"], [[FTupleEventTypeString alloc] initWithFirebase:[writer child:@"a"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:writer withEvent:FIRDataEventTypeChildAdded withString:@"a"], [[FTupleEventTypeString alloc] initWithFirebase:writer withEvent:FIRDataEventTypeValue withString:nil], ]; FEventTester *et = [[FEventTester alloc] initFrom:self]; [et addLookingFor:lookingFor]; [[writer child:@"a/aa"] setValue:@42]; // the local events [et wait]; // the reader should get all of the events intermingled FEventTester *readerEvents = [[FEventTester alloc] initFrom:self]; lookingFor = @[ [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"a"] withEvent:FIRDataEventTypeChildAdded withString:@"aa"], [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"a"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:reader withEvent:FIRDataEventTypeChildAdded withString:@"a"], [[FTupleEventTypeString alloc] initWithFirebase:reader withEvent:FIRDataEventTypeValue withString:nil] ]; [readerEvents addLookingFor:lookingFor]; [readerEvents wait]; lookingFor = @[ [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"a"] withEvent:FIRDataEventTypeChildRemoved withString:@"aa"], [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"a"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:reader withEvent:FIRDataEventTypeChildRemoved withString:@"a"], [[FTupleEventTypeString alloc] initWithFirebase:reader withEvent:FIRDataEventTypeValue withString:nil] ]; [readerEvents addLookingFor:lookingFor]; lookingFor = @[ [[FTupleEventTypeString alloc] initWithFirebase:[writer child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:[writer child:@"a"] withEvent:FIRDataEventTypeChildRemoved withString:@"aa"], [[FTupleEventTypeString alloc] initWithFirebase:[writer child:@"a"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:writer withEvent:FIRDataEventTypeChildRemoved withString:@"a"], [[FTupleEventTypeString alloc] initWithFirebase:writer withEvent:FIRDataEventTypeValue withString:nil] ]; [et addLookingFor:lookingFor]; [[writer child:@"a"] removeValue]; [et wait]; [readerEvents wait]; [et unregister]; [readerEvents unregister]; // Ensure we can write a new value __block NSNumber *readVal = @0.0; __block NSNumber *writeVal = @0.0; [[reader child:@"a/aa"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { id val = [snapshot value]; if (val != [NSNull null]) { readVal = val; } }]; [[writer child:@"a/aa"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { id val = [snapshot value]; if (val != [NSNull null]) { writeVal = val; } }]; [[writer child:@"a/aa"] setValue:@3.1415]; [self waitUntil:^BOOL { return fabs([readVal doubleValue] - 3.1415) < 0.001 && fabs([writeVal doubleValue] - 3.1415) < 0.001; // return [readVal isEqualToNumber:@3.1415] && [writeVal isEqualToNumber:@3.1415]; }]; } - (void)testWriteLeafNodeRemoveLeafVerifyExpectedEvents { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *writer = refs.one; FIRDatabaseReference *reader = refs.two; NSArray *lookingFor = @[ [[FTupleEventTypeString alloc] initWithFirebase:[writer child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:[writer child:@"a"] withEvent:FIRDataEventTypeChildAdded withString:@"aa"], [[FTupleEventTypeString alloc] initWithFirebase:[writer child:@"a"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:writer withEvent:FIRDataEventTypeChildAdded withString:@"a"], [[FTupleEventTypeString alloc] initWithFirebase:writer withEvent:FIRDataEventTypeValue withString:nil], ]; FEventTester *et = [[FEventTester alloc] initFrom:self]; [et addLookingFor:lookingFor]; [[writer child:@"a/aa"] setValue:@42]; // the local events [et wait]; // the reader should get all of the events intermingled FEventTester *readerEvents = [[FEventTester alloc] initFrom:self]; lookingFor = @[ [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"a"] withEvent:FIRDataEventTypeChildAdded withString:@"aa"], [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"a"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:reader withEvent:FIRDataEventTypeChildAdded withString:@"a"], [[FTupleEventTypeString alloc] initWithFirebase:reader withEvent:FIRDataEventTypeValue withString:nil] ]; [readerEvents addLookingFor:lookingFor]; [readerEvents wait]; lookingFor = @[ [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"a"] withEvent:FIRDataEventTypeChildRemoved withString:@"aa"], [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"a"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:reader withEvent:FIRDataEventTypeChildRemoved withString:@"a"], [[FTupleEventTypeString alloc] initWithFirebase:reader withEvent:FIRDataEventTypeValue withString:nil] ]; [readerEvents addLookingFor:lookingFor]; lookingFor = @[ [[FTupleEventTypeString alloc] initWithFirebase:[writer child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:[writer child:@"a"] withEvent:FIRDataEventTypeChildRemoved withString:@"aa"], [[FTupleEventTypeString alloc] initWithFirebase:[writer child:@"a"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:writer withEvent:FIRDataEventTypeChildRemoved withString:@"a"], [[FTupleEventTypeString alloc] initWithFirebase:writer withEvent:FIRDataEventTypeValue withString:nil] ]; [et addLookingFor:lookingFor]; // remove just the leaf [[writer child:@"a/aa"] removeValue]; [et wait]; [readerEvents wait]; [et unregister]; [readerEvents unregister]; // Ensure we can write a new value __block NSNumber *readVal = @0.0; __block NSNumber *writeVal = @0.0; [[reader child:@"a/aa"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { id val = [snapshot value]; if (val != [NSNull null]) { readVal = val; } }]; [[writer child:@"a/aa"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { id val = [snapshot value]; if (val != [NSNull null]) { writeVal = val; } }]; [[writer child:@"a/aa"] setValue:@3.1415]; [self waitUntil:^BOOL { // NSLog(@"readVal: %@, writeVal: %@, vs %@", readVal, writeVal, @3.1415); // return [readVal isEqualToNumber:@3.1415] && [writeVal isEqualToNumber:@3.1415]; return fabs([readVal doubleValue] - 3.1415) < 0.001 && fabs([writeVal doubleValue] - 3.1415) < 0.001; }]; } #endif - (void)testWriteMultipleLeafNodesRemoveOnlyOneVerifyExpectedEvents { // XXX impl } - (void)testVerifyNodeNamesCantStartWithADot { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; XCTAssertThrows([ref child:@".foo"], @"not a valid .prefix"); XCTAssertThrows([ref child:@"foo/.foo"], @"not a valid path"); // Should not throw [[ref parent] child:@".info"]; } - (void)testVerifyWritingToDotLengthAndDotKeysThrows { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; XCTAssertThrows([[ref child:@".keys"] setValue:@42], @"not a valid .prefix"); XCTAssertThrows([[ref child:@".length"] setValue:@42], @"not a valid path"); } - (void)testNumericKeysGetTurnedIntoArrays { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; [[ref child:@"0"] setValue:@"alpha"]; [[ref child:@"1"] setValue:@"bravo"]; [[ref child:@"2"] setValue:@"charlie"]; [[ref child:@"3"] setValue:@"delta"]; [[ref child:@"4"] setValue:@"echo"]; __block BOOL ready = NO; [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { id val = [snapshot value]; XCTAssertTrue([val isKindOfClass:[NSArray class]], @"Expected an array"); NSArray *expected = @[ @"alpha", @"bravo", @"charlie", @"delta", @"echo" ]; XCTAssertTrue([expected isEqualToArray:val], @"Did not get the correct array"); ready = YES; }]; [self waitUntil:^{ return ready; }]; } // This was an issue on 64-bit. - (void)testLargeNumericKeysDontGetTurnedIntoArrays { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; [[ref child:@"100003354884401"] setValue:@"alpha"]; __block BOOL ready = NO; [ref observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { id val = [snapshot value]; XCTAssertTrue([val isKindOfClass:[NSDictionary class]], @"Expected a dictionary."); ready = YES; }]; [self waitUntil:^{ return ready; }]; } - (void)testWriteCompoundObjectAndGetItBack { FIRDatabaseReference *node = [FTestHelpers getRandomNode]; NSDictionary *data = @{ @"a" : @{@"aa" : @5, @"ab" : @3}, @"b" : @{@"ba" : @"hey there!", @"bb" : @{@"bba" : @NO}}, @"c" : @[ @0, @{@"c_1" : @4}, @"hey", @YES, @NO, @"dude" ] }; __block FIRDataSnapshot *snap = nil; [node observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { snap = snapshot; }]; __block BOOL done = NO; [node setValue:data withCompletionBlock:^(NSError *err, FIRDatabaseReference *ref) { done = YES; }]; [self waitUntil:^BOOL { return done; }]; [self snapWaiter:node withBlock:^(FIRDataSnapshot *snapshot) { XCTAssertTrue([[[[snapshot value] objectForKey:@"c"] objectAtIndex:3] boolValue], @"Got proper boolean"); }]; } - (void)testCanPassValueToPush { FIRDatabaseReference *node = [FTestHelpers getRandomNode]; FIRDatabaseReference *pushA = [node childByAutoId]; [pushA setValue:@5]; [self snapWaiter:pushA withBlock:^(FIRDataSnapshot *snapshot) { XCTAssertEqualObjects(@5, [snapshot value], @"Got proper value"); }]; FIRDatabaseReference *pushB = [node childByAutoId]; [pushB setValue:@{@"a" : @5, @"b" : @6}]; [self snapWaiter:pushB withBlock:^(FIRDataSnapshot *snapshot) { XCTAssertEqualObjects(@5, [[snapshot value] objectForKey:@"a"], @"Got proper value"); XCTAssertEqualObjects(@6, [[snapshot value] objectForKey:@"b"], @"Got proper value"); }]; } // Dropped test that tested callbacks to push. Support was removed. - (void)testRemoveCallbackHit { FIRDatabaseReference *node = [FTestHelpers getRandomNode]; __block BOOL setDone = NO; __block BOOL removeDone = NO; __block BOOL readDone = NO; [node setValue:@42 withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { setDone = YES; }]; [self waitUntil:^BOOL { return setDone; }]; [node observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { id val = [snapshot value]; if (val == [NSNull null]) { readDone = YES; } }]; [node removeValueWithCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { XCTAssertTrue(error == nil, @"Should not be an error removing"); removeDone = YES; }]; [self waitUntil:^BOOL { return readDone && removeDone; }]; } - (void)testRemoveCallbackIsHitForNodesThatAreAlreadyRemoved { FIRDatabaseReference *node = [FTestHelpers getRandomNode]; __block int removes = 0; [node removeValueWithCompletionBlock:^(NSError *err, FIRDatabaseReference *ref) { removes = removes + 1; }]; [node removeValueWithCompletionBlock:^(NSError *err, FIRDatabaseReference *ref) { removes = removes + 1; }]; [self waitUntil:^BOOL { return removes == 2; }]; } - (void)testUsingNumbersAsKeysDoesntCreateHugeSparseArrays { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; [[ref child:@"3024"] setValue:@5]; __block BOOL ready = NO; [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { id val = [snapshot value]; XCTAssertTrue(![val isKindOfClass:[NSArray class]], @"Should not be an array"); ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; } - (void)testOnceWithACallbackHitsServer { FTupleFirebase *tuple = [FTestHelpers getRandomNodeTriple]; FIRDatabaseReference *writeNode = tuple.one; FIRDatabaseReference *readNode = tuple.two; FIRDatabaseReference *readNodeB = tuple.three; __block BOOL initialReadDone = NO; [readNode observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { XCTAssertTrue([[snapshot value] isEqual:[NSNull null]], @"First callback is null"); initialReadDone = YES; }]; [self waitUntil:^BOOL { return initialReadDone; }]; __block BOOL writeDone = NO; [writeNode setValue:@42 withCompletionBlock:^(NSError *err, FIRDatabaseReference *ref) { writeDone = YES; }]; [self waitUntil:^BOOL { return writeDone; }]; __block BOOL readDone = NO; [readNodeB observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { XCTAssertEqualObjects(@42, [snapshot value], @"Proper second read"); readDone = YES; }]; [self waitUntil:^BOOL { return readDone; }]; } // Removed test of forEach aborting iteration. Support dropped, use for .. in syntax - (void)testSetAndThenListenForValueEventsAreCorrect { FIRDatabaseReference *node = [FTestHelpers getRandomNode]; __block BOOL setDone = NO; [node setValue:@"moo" withCompletionBlock:^(NSError *err, FIRDatabaseReference *ref) { setDone = YES; }]; __block int calls = 0; [node observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { calls = calls + 1; XCTAssertTrue(calls == 1, @"Only called once"); XCTAssertEqualObjects([snapshot value], @"moo", @"Proper snapshot value"); }]; [self waitUntil:^BOOL { return setDone && calls == 1; }]; [node removeAllObservers]; } - (void)testHasChildrenWorksCorrectly { FIRDatabaseReference *node = [FTestHelpers getRandomNode]; [node setValue:@{@"one" : @42, @"two" : @{@"a" : @5}, @"three" : @{@"a" : @5, @"b" : @6}}]; __block BOOL removedTwo = NO; __block BOOL done = NO; [node observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { if (!removedTwo) { XCTAssertFalse([[snapshot childSnapshotForPath:@"one"] hasChildren], @"nope"); XCTAssertTrue([[snapshot childSnapshotForPath:@"two"] hasChildren], @"nope"); XCTAssertTrue([[snapshot childSnapshotForPath:@"three"] hasChildren], @"nope"); XCTAssertFalse([[snapshot childSnapshotForPath:@"four"] hasChildren], @"nope"); removedTwo = YES; [[node child:@"two"] removeValue]; } else { XCTAssertFalse([[snapshot childSnapshotForPath:@"two"] hasChildren], @"Second time around"); done = YES; } }]; [self waitUntil:^BOOL { return done; }]; } - (void)testNumChildrenWorksCorrectly { FIRDatabaseReference *node = [FTestHelpers getRandomNode]; [node setValue:@{@"one" : @42, @"two" : @{@"a" : @5}, @"three" : @{@"a" : @5, @"b" : @6}}]; __block BOOL removedTwo = NO; __block BOOL done = NO; [node observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { if (!removedTwo) { XCTAssertTrue([snapshot childrenCount] == 3, @"Total children"); XCTAssertTrue([[snapshot childSnapshotForPath:@"one"] childrenCount] == 0, @"Two's children"); XCTAssertTrue([[snapshot childSnapshotForPath:@"two"] childrenCount] == 1, @"Two's children"); XCTAssertTrue([[snapshot childSnapshotForPath:@"three"] childrenCount] == 2, @"Two's children"); XCTAssertTrue([[snapshot childSnapshotForPath:@"four"] childrenCount] == 0, @"Two's children"); removedTwo = YES; [[node child:@"two"] removeValue]; } else { XCTAssertTrue([snapshot childrenCount] == 2, @"Total children"); XCTAssertTrue([[snapshot childSnapshotForPath:@"two"] childrenCount] == 0, @"Two's children"); done = YES; } }]; [self waitUntil:^BOOL { return done; }]; } #ifdef FLAKY_TEST - (void)testSettingANodeWithChildrenToAPrimitiveAndBack { // Can't tolerate stale data; so disable persistence. FTupleFirebase *tuple = [FTestHelpers getRandomNodePairWithoutPersistence]; FIRDatabaseReference *writeNode = tuple.one; FIRDatabaseReference *readNode = tuple.two; __block BOOL done = NO; NSDictionary *compound = @{@"a" : @5, @"b" : @6}; NSNumber *number = @76; [writeNode setValue:compound]; [self snapWaiter:writeNode withBlock:^(FIRDataSnapshot *snapshot) { XCTAssertTrue([snapshot hasChildren], @"Has children"); XCTAssertEqualObjects(@5, [[snapshot childSnapshotForPath:@"a"] value], @"First child"); XCTAssertEqualObjects(@6, [[snapshot childSnapshotForPath:@"b"] value], @"First child"); done = YES; }]; [self waitUntil:^BOOL { return done; }]; done = NO; [self snapWaiter:readNode withBlock:^(FIRDataSnapshot *snapshot) { XCTAssertTrue([snapshot hasChildren], @"has children"); XCTAssertEqualObjects(@5, [[snapshot childSnapshotForPath:@"a"] value], @"First child"); XCTAssertEqualObjects(@6, [[snapshot childSnapshotForPath:@"b"] value], @"First child"); done = YES; }]; [self waitUntil:^BOOL { return done; }]; done = NO; [writeNode setValue:number withCompletionBlock:^(NSError *err, FIRDatabaseReference *ref) { done = YES; }]; [self waitUntil:^BOOL { return done; }]; done = NO; [self snapWaiter:readNode withBlock:^(FIRDataSnapshot *snapshot) { XCTAssertFalse([snapshot hasChildren], @"No more children"); XCTAssertEqualObjects(number, [snapshot value], @"Proper non compound value"); done = YES; }]; [self waitUntil:^BOOL { return done; }]; done = NO; [writeNode setValue:compound withCompletionBlock:^(NSError *err, FIRDatabaseReference *ref) { done = YES; }]; [self waitUntil:^BOOL { return done; }]; done = NO; [self snapWaiter:readNode withBlock:^(FIRDataSnapshot *snapshot) { XCTAssertTrue([snapshot hasChildren], @"Has children"); XCTAssertEqualObjects(@5, [[snapshot childSnapshotForPath:@"a"] value], @"First child"); XCTAssertEqualObjects(@6, [[snapshot childSnapshotForPath:@"b"] value], @"First child"); done = YES; }]; [self waitUntil:^BOOL { return done; }]; XCTAssertTrue(done, @"Properly finished"); } #endif - (void)testWriteLeafRemoveLeafAddChildToRemovedNode { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *writer = refs.one; FIRDatabaseReference *reader = refs.two; __block BOOL ready = NO; [writer setValue:@5]; [writer removeValue]; [[writer child:@"abc"] setValue:@5 withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; __block NSDictionary *readVal = nil; [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { readVal = [snapshot value]; }]; [self waitUntil:^BOOL { return readVal != nil; }]; NSNumber *five = [readVal objectForKey:@"abc"]; XCTAssertTrue([five isEqualToNumber:@5], @"Should get 5"); } - (void)testListenForValueAndThenWriteOnANodeWithExistingData { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *writer = refs.one; FIRDatabaseReference *reader = refs.two; [self waitForCompletionOf:writer setValue:@{@"a" : @5, @"b" : @2}]; __block int calls = 0; [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { calls++; if (calls == 1) { NSDictionary *val = [snapshot value]; NSDictionary *expected = @{@"a" : @10, @"b" : @2}; XCTAssertTrue([val isEqualToDictionary:expected], @"Got the correct value"); } else { XCTFail(@"Should only be called once"); } }]; [[reader child:@"a"] setValue:@10]; [self waitUntil:^BOOL { return calls == 1; }]; [reader removeAllObservers]; } - (void)testSetPriorityOnNonexistentNodeFails { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; __block BOOL ready = NO; [ref setPriority:@5 withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { XCTAssertTrue(error != nil, @"This should not succeed"); ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; } - (void)testSetPriorityOnExistentNodeSucceeds { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; __block BOOL ready = NO; [ref setValue:@"hello!"]; [ref setPriority:@5 withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { XCTAssertTrue(error == nil, @"This should succeed"); ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; } - (void)testSetWithPrioritySetsValueAndPriority { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *writer = refs.one; FIRDatabaseReference *reader = refs.two; [self waitForCompletionOf:writer setValue:@"hello" andPriority:@5]; __block FIRDataSnapshot *writeSnap = nil; __block FIRDataSnapshot *readSnap = nil; [writer observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { writeSnap = snapshot; }]; [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { readSnap = snapshot; }]; [self waitUntil:^BOOL { return readSnap != nil && writeSnap != nil; }]; XCTAssertTrue([@"hello" isEqualToString:[readSnap value]], @"Got the value on the reader"); XCTAssertTrue([@"hello" isEqualToString:[writeSnap value]], @"Got the value on the writer"); XCTAssertTrue([@5 isEqualToNumber:[readSnap priority]], @"Got the priority on the reader"); XCTAssertTrue([@5 isEqualToNumber:[writeSnap priority]], @"Got the priority on the writer"); } - (void)testEffectsOfSetPriorityIsImmediatelyEvident { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; NSMutableArray *values = [[NSMutableArray alloc] init]; NSMutableArray *priorities = [[NSMutableArray alloc] init]; [ref observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { [values addObject:[snapshot value]]; [priorities addObject:[snapshot priority]]; }]; [ref setValue:@5]; [ref setPriority:@10]; __block BOOL ready = NO; [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { [values addObject:[snapshot value]]; [priorities addObject:[snapshot priority]]; ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; NSArray *expectedValues = @[ @5, @5 ]; NSArray *expectedPriorites = @[ [NSNull null], @10 ]; XCTAssertTrue([values isEqualToArray:expectedValues], @"Expected both listeners to get 5, got %@ instead", values); XCTAssertTrue([priorities isEqualToArray:expectedPriorites], @"The first listener should have missed the priority, got %@ instead", priorities); } - (void)testSetOverwritesPriorityOfTopLevelNodeAndSubnodes { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *writer = refs.one; FIRDatabaseReference *reader = refs.two; __block BOOL ready = NO; [writer setValue:@{@"a" : @5}]; [writer setPriority:@10]; [[writer child:@"a"] setPriority:@18]; [writer setValue:@{@"a" : @7} withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; ready = NO; [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { id pri = [snapshot priority]; XCTAssertTrue([NSNull null] == pri, @"Expected null priority"); FIRDataSnapshot *child = [snapshot childSnapshotForPath:@"a"]; XCTAssertTrue([NSNull null] == [child priority], @"Child priority should be null too"); ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; } - (void)testSetPriorityOfLeafSavesCorrectly { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *writer = refs.one; FIRDatabaseReference *reader = refs.two; __block BOOL ready = NO; [writer setValue:@"testleaf" andPriority:@992 withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; ready = NO; [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { id pri = [snapshot priority]; XCTAssertTrue([@992 isEqualToNumber:pri], @"Expected non-null priority"); ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; } - (void)testSetPriorityOfObjectSavesCorrectly { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *writer = refs.one; FIRDatabaseReference *reader = refs.two; __block BOOL ready = NO; [writer setValue:@{@"a" : @5} andPriority:@991 withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; ready = NO; [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { id pri = [snapshot priority]; XCTAssertTrue([@991 isEqualToNumber:pri], @"Expected non-null priority"); ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; } - (void)testSetWithPriorityFollowedBySetClearsPriority { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *writer = refs.one; FIRDatabaseReference *reader = refs.two; __block BOOL ready = NO; [writer setValue:@{@"a" : @5} andPriority:@991 withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; ready = NO; [reader setValue:@{@"a" : @19} withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; ready = NO; [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { id pri = [snapshot priority]; XCTAssertTrue([NSNull null] == pri, @"Expected null priority"); ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; } - (void)testGetPriorityReturnsCorrectType { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; __block FIRDataSnapshot *snap = nil; [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { snap = snapshot; }]; [ref setValue:@"a"]; [self waitUntil:^BOOL { return snap != nil; }]; XCTAssertTrue([snap priority] == [NSNull null], @"Expect null priority"); snap = nil; [ref setValue:@"b" andPriority:@5]; [self waitUntil:^BOOL { return snap != nil; }]; XCTAssertTrue([[snap priority] isEqualToNumber:@5], @"Expect priority"); snap = nil; [ref setValue:@"c" andPriority:@"6"]; [self waitUntil:^BOOL { return snap != nil; }]; XCTAssertTrue([[snap priority] isEqualToString:@"6"], @"Expect priority"); snap = nil; [ref setValue:@"d" andPriority:@7]; [self waitUntil:^BOOL { return snap != nil; }]; XCTAssertTrue([[snap priority] isEqualToNumber:@7], @"Expect priority"); snap = nil; [ref setValue:@{@".value" : @"e", @".priority" : @8}]; [self waitUntil:^BOOL { return snap != nil; }]; XCTAssertTrue([[snap priority] isEqualToNumber:@8], @"Expect priority"); snap = nil; [ref setValue:@{@".value" : @"f", @".priority" : @"8"}]; [self waitUntil:^BOOL { return snap != nil; }]; XCTAssertTrue([[snap priority] isEqualToString:@"8"], @"Expect priority"); snap = nil; [ref setValue:@{@".value" : @"e", @".priority" : [NSNull null]}]; [self waitUntil:^BOOL { return snap != nil; }]; XCTAssertTrue([snap priority] == [NSNull null], @"Expect priority"); snap = nil; } - (void)testExportValIncludesPriorities { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; NSDictionary *contents = @{@"foo" : @{@"bar" : @{@".value" : @5, @".priority" : @7}, @".priority" : @"hi"}}; __block FIRDataSnapshot *snap = nil; [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { snap = snapshot; }]; [ref setValue:contents]; [self waitUntil:^BOOL { return snap != nil; }]; XCTAssertTrue([contents isEqualToDictionary:[snap valueInExportFormat]], @"Expected priorities in snapshot"); } - (void)testPriorityIsOverwrittenByServer { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *reader = refs.one; FIRDatabaseReference *writer = refs.two; __block int event = 0; __block BOOL done = NO; [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { NSLog(@"%@ Snapshot", snapshot); id pri = [snapshot priority]; if (event == 0) { XCTAssertTrue([@100 isEqualToNumber:pri], @"Expect local priority. Got %@ instead.", pri); } else if (event == 1) { XCTAssertTrue(pri == [NSNull null], @"Expect remote priority. Got %@ instead.", pri); } else { XCTFail(@"Extra event"); } event++; if (event == 2) { done = YES; } }]; [writer observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { id pri = [snapshot priority]; if ([[pri class] isSubclassOfClass:[NSNumber class]] && [@100 isEqualToNumber:pri]) { [writer setValue:@"whatever"]; } }]; [reader setValue:@"hi" andPriority:@100]; [self waitUntil:^BOOL { return done; }]; } - (void)testLargeNumericPrioritiesWork { NSNumber *bigPriority = @1356721306842; __block BOOL ready = NO; FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *reader = refs.one; FIRDatabaseReference *writer = refs.two; [self waitForCompletionOf:writer setValue:@5 andPriority:bigPriority]; __block NSNumber *serverPriority = @0; [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { serverPriority = [snapshot priority]; ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; XCTAssertTrue([bigPriority isEqualToNumber:serverPriority], @"Expect big priority back"); } - (void)testToString { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; FIRDatabaseReference *parent = [ref parent]; XCTAssertEqualObjects([parent description], self.databaseURL); FIRDatabaseReference *child = [parent child:@"a/b/c"]; NSString *expected = [NSString stringWithFormat:@"%@/a/b/c", self.databaseURL]; XCTAssertEqualObjects([child description], expected); } - (void)testURLEncodingOfDescriptionAndURLDecodingOfNewFirebase { __block BOOL ready = NO; NSString *test1 = [NSString stringWithFormat:@"%@/a%%b&c@d/space: /non-ascii_character:ΓΈ", self.databaseURL]; NSString *expected1 = [NSString stringWithFormat:@"%@/a%%25b%%26c%%40d/space%%3A%%20/non-ascii_character%%3A%%C3%%B8", self.databaseURL]; FIRDatabaseReference *ref = [[FTestHelpers defaultDatabase] referenceFromURL:test1]; NSString *result = [ref description]; XCTAssertTrue([result isEqualToString:expected1], @"Encodes properly"); int rnd = arc4random_uniform(100000000); NSString *path = [NSString stringWithFormat:@"%i", rnd]; [[ref child:path] setValue:@"testdata" withCompletionBlock:^(NSError *error, FIRDatabaseReference *childRef) { FIRDatabaseReference *other = [[FTestHelpers defaultDatabase] referenceFromURL:[ref description]]; [[other child:path] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { NSString *val = snapshot.value; XCTAssertTrue([val isEqualToString:@"testdata"], @"Expected to get testdata back"); ready = YES; }]; }]; [self waitUntil:^BOOL { return ready; }]; } - (void)testNameAtRootAndNonRootLocations { FIRDatabaseReference *ref = [[FTestHelpers defaultDatabase] referenceFromURL:self.databaseURL]; XCTAssertTrue(ref.key == nil, @"Root key should be nil"); FIRDatabaseReference *child = [ref child:@"a"]; XCTAssertTrue([child.key isEqualToString:@"a"], @"Should be 'a'"); FIRDatabaseReference *deeperChild = [child child:@"b/c"]; XCTAssertTrue([deeperChild.key isEqualToString:@"c"], @"Should be 'c'"); } - (void)testNameAndRefOnSnapshotsForRootAndNonRootLocations { FIRDatabaseReference *ref = [[FTestHelpers defaultDatabase] reference]; __block BOOL ready = NO; [ref removeValueWithCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; ready = NO; [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { XCTAssertTrue(snapshot.key == nil, @"Root snap should not have a key"); NSString *snapString = [snapshot.ref description]; XCTAssertTrue([snapString isEqualToString:snapString], @"Refs should be equivalent"); FIRDataSnapshot *childSnap = [snapshot childSnapshotForPath:@"a"]; XCTAssertTrue([childSnap.key isEqualToString:@"a"], @"Properly keys children"); FIRDatabaseReference *childRef = [ref child:@"a"]; NSString *refString = [childRef description]; snapString = [childSnap.ref description]; XCTAssertTrue([refString isEqualToString:snapString], @"Refs should be equivalent"); childSnap = [childSnap childSnapshotForPath:@"b/c"]; childRef = [childRef child:@"b/c"]; XCTAssertTrue([childSnap.key isEqualToString:@"c"], @"properly keys children"); refString = [childRef description]; snapString = [childSnap.ref description]; XCTAssertTrue([refString isEqualToString:snapString], @"Refs should be equivalent"); ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; ready = NO; // generate value event at root [ref setValue:@"foo"]; [self waitUntil:^BOOL { return ready; }]; } - (void)testParentForRootAndNonRootLocations { FIRDatabaseReference *ref = [[FIRDatabase database] reference]; XCTAssertTrue(ref.parent == nil, @"Parent of root should be nil"); FIRDatabaseReference *child = [ref child:@"a"]; XCTAssertTrue([[child.parent description] isEqualToString:[ref description]], @"Should be equivalent locations"); child = [ref child:@"a/b/c"]; XCTAssertTrue([[child.parent.parent.parent description] isEqualToString:[ref description]], @"Should be equivalent locations"); } - (void)testSettingNumericKeysConvertsToStrings { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; NSDictionary *toSet = @{@4 : @"hi", @5 : @"test"}; XCTAssertThrows([ref setValue:toSet], @"Keys must be strings"); } - (void)testSetChildAndListenAtRootRegressionTest { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *writer = refs.one; FIRDatabaseReference *reader = refs.two; __block BOOL ready = NO; [writer removeValue]; [[writer child:@"foo"] setValue:@"hi" withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { NSDictionary *val = [snapshot value]; NSDictionary *expected = @{@"foo" : @"hi"}; XCTAssertTrue([val isEqualToDictionary:expected], @"Got child"); ready = YES; }]; }]; [self waitUntil:^BOOL { return ready; }]; } - (void)testAccessingInvalidPathsThrows { NSArray *badPaths = @[ @".test", @"test.", @"fo$o", @"[what", @"ever]", @"ha#sh" ]; for (NSString *key in badPaths) { NSString *url = [NSString stringWithFormat:@"%@/%@", self.databaseURL, key]; XCTAssertThrows( ^{ FIRDatabaseReference *ref = [[FIRDatabase database] referenceFromURL:url]; XCTFail(@"Should not get here with ref: %@", ref); }(), @"should throw"); url = [NSString stringWithFormat:@"%@/TESTS/%@", self.databaseURL, key]; XCTAssertThrows( ^{ FIRDatabaseReference *ref = [[FIRDatabase database] referenceFromURL:url]; XCTFail(@"Should not get here with ref: %@", ref); }(), @"should throw"); } __block BOOL ready = NO; FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { for (NSString *key in badPaths) { XCTAssertThrows([snapshot childSnapshotForPath:key], @"should throw"); XCTAssertThrows([snapshot hasChild:key], @"should throw"); } ready = YES; }]; [ref setValue:nil]; [self waitUntil:^BOOL { return ready; }]; } - (void)testSettingObjectsAtInvalidKeysThrow { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; NSArray *badPaths = @[ @".test", @"test.", @"fo$o", @"[what", @"ever]", @"ha#sh", @"/thing", @"th/ing", @"thing/" ]; NSMutableArray *badObjs = [[NSMutableArray alloc] init]; for (NSString *key in badPaths) { [badObjs addObject:@{key : @"test"}]; [badObjs addObject:@{@"deeper" : @{key : @"test"}}]; } for (NSDictionary *badObj in badObjs) { XCTAssertThrows([ref setValue:badObj], @"Should throw"); XCTAssertThrows([ref setValue:badObj andPriority:@5], @"Should throw"); XCTAssertThrows([ref onDisconnectSetValue:badObj], @"Should throw"); XCTAssertThrows([ref onDisconnectSetValue:badObj andPriority:@5], @"Should throw"); // XXX transaction } } - (void)testSettingInvalidObjectsThrow { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; XCTAssertThrows([ref setValue:[NSDate date]], @"Should throw"); NSDictionary *data = @{@"invalid" : @"data", @".sv" : @"timestamp"}; XCTAssertThrows([ref setValue:data], @"Should throw"); data = @{@".value" : @{}}; XCTAssertThrows([ref setValue:data], @"Should throw"); } - (void)testInvalidUpdateThrow { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; NSArray *badUpdates = @[ @{@"/" : @"t", @"a" : @"t"}, @{@"a" : @"t", @"a/b" : @"t"}, @{@"/a" : @"t", @"a/b" : @"t"}, @{@"/a/b" : @"t", @"a" : @"t"}, @{@"/a/b/.priority" : @"t", @"/a/b" : @"t"}, @{@"/a/b/.sv" : @"timestamp"}, @{@"/a/b/.value" : @"t"}, @{@"/a/b/.priority" : @{@"x" : @"y"}} ]; for (NSDictionary *update in badUpdates) { XCTAssertThrows([ref updateChildValues:update], @"Should throw"); XCTAssertThrows([ref onDisconnectUpdateChildValues:update], @"Should throw"); } } - (void)testSettingNull { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; XCTAssertNoThrow([ref setValue:nil], @"Should not throw"); XCTAssertNoThrow([ref setValue:[NSNull null]], @"Should not throw"); } - (void)testSettingNaN { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; XCTAssertThrows([ref setValue:[NSDecimalNumber notANumber]], @"Should throw"); } - (void)testSettingInvalidPriority { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; XCTAssertThrows([ref setValue:@"3" andPriority:[NSDecimalNumber notANumber]], @"Should throw"); XCTAssertThrows([ref setValue:@"4" andPriority:@{}], @"Should throw"); XCTAssertThrows([ref setValue:@"5" andPriority:@[]], @"Should throw"); } - (void)testRemoveFromOnMobileGraffitiBugAtAngelHack { FIRDatabaseReference *node = [FTestHelpers getRandomNode]; __block BOOL done = NO; [node observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) { [[node child:[snapshot key]] removeValueWithCompletionBlock:^(NSError *err, FIRDatabaseReference *ref) { done = YES; }]; }]; [[node childByAutoId] setValue:@"moo"]; [self waitUntil:^BOOL { return done; }]; XCTAssertTrue(done, @"Properly finished"); } - (void)testSetANodeWithAQuotedKey { FIRDatabaseReference *node = [FTestHelpers getRandomNode]; __block BOOL done = NO; __block FIRDataSnapshot *snap; [node observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { snap = snapshot; }]; [node setValue:@{@"\"herp\"" : @1234} withCompletionBlock:^(NSError *err, FIRDatabaseReference *ref) { done = YES; XCTAssertEqualObjects(@1234, [[snap childSnapshotForPath:@"\"herp\""] value], @"Got it back"); }]; [self waitUntil:^BOOL { return done; }]; XCTAssertTrue(done, @"Properly finished"); } - (void)testSetANodeWithASingleQuoteKey { FIRDatabaseReference *node = [FTestHelpers getRandomNode]; __block BOOL done = NO; __block FIRDataSnapshot *snap; [node observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { snap = snapshot; }]; [node setValue:@{@"\"" : @1234} withCompletionBlock:^(NSError *err, FIRDatabaseReference *ref) { done = YES; XCTAssertEqualObjects(@1234, [[snap childSnapshotForPath:@"\""] value], @"Got it back"); }]; [self waitUntil:^BOOL { return done; }]; XCTAssertTrue(done, @"Properly finished"); } - (void)testEmptyChildGetValueEventBeforeParent { FIRDatabaseReference *node = [FTestHelpers getRandomNode]; NSArray *lookingFor = @[ [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a/aa/aaa"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a/aa"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeValue withString:nil], ]; FEventTester *et = [[FEventTester alloc] initFrom:self]; [et addLookingFor:lookingFor]; [node setValue:@{@"b" : @5}]; [et wait]; } // iOS behavior is different from what the recursive set test looks for. We don't raise events // synchronously - (void)testOnAfterSetWaitsForLatestData { // We test here that we don't cache sets, but they would be persisted so make sure we are running // without persistence FTupleFirebase *refs = [FTestHelpers getRandomNodePairWithoutPersistence]; FIRDatabaseReference *node1 = refs.one; FIRDatabaseReference *node2 = refs.two; __block BOOL ready = NO; [node1 setValue:@5 withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { [node2 setValue:@42 withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { ready = YES; }]; }]; [self waitUntil:^BOOL { return ready; }]; ready = NO; [node1 observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { NSNumber *val = [snapshot value]; XCTAssertTrue([val isEqualToNumber:@42], @"Should not have cached earlier set"); ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; } - (void)testOnceWaitsForLatestData { // Can't tolerate stale data; so disable persistence. FTupleFirebase *refs = [FTestHelpers getRandomNodePairWithoutPersistence]; FIRDatabaseReference *node1 = refs.one; FIRDatabaseReference *node2 = refs.two; __block BOOL ready = NO; [node1 observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { id val = [snapshot value]; XCTAssertTrue([NSNull null] == val, @"First value should be null"); [node2 setValue:@5 withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { [node1 observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { NSNumber *val = [snapshot value]; XCTAssertTrue( [val isKindOfClass:[NSNumber class]] && [val isEqualToNumber:@5], @"Should get first value"); ready = YES; }]; }]; }]; [self waitUntil:^BOOL { return ready; }]; ready = NO; [node2 setValue:@42 withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { [node1 observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { NSNumber *val = [snapshot value]; XCTAssertTrue([val isEqualToNumber:@42], @"Got second number"); ready = YES; }]; }]; [self waitUntil:^BOOL { return ready; }]; } - (void)testMemoryFreeingOnUnlistenDoesNotCorruptData { // Can't tolerate stale data; so disable persistence. FTupleFirebase *refs = [FTestHelpers getRandomNodePairWithoutPersistence]; FIRDatabaseReference *node2 = [[refs.one root] childByAutoId]; __block BOOL hasRun = NO; __block BOOL ready = NO; FIRDatabaseHandle handle1 = [refs.one observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { if (!hasRun) { hasRun = YES; id val = [snapshot value]; XCTAssertTrue([NSNull null] == val, @"First time should be null"); [refs.one setValue:@"test" withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { ready = YES; }]; } }]; [self waitUntil:^BOOL { return ready; }]; [refs.one removeObserverWithHandle:handle1]; ready = NO; [node2 setValue:@"hello" withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { [refs.one observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { NSString *val = [snapshot value]; XCTAssertTrue([val isEqualToString:@"test"], @"Get back the value we set above"); [refs.two observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { NSString *val = [snapshot value]; XCTAssertTrue([val isEqualToString:@"test"], @"Get back the value we set above"); ready = YES; }]; }]; }]; [self waitUntil:^BOOL { return ready; }]; // write {x: 1, y : {t: 2, u: 3}} // Listen at /. Then listen at /x/t // unlisten at /y/t. Off at /. Once at /. Ensure data is still all there. // Once at /y. Ensure data is still all there. refs = [FTestHelpers getRandomNodePairWithoutPersistence]; ready = NO; __block FIRDatabaseHandle deeplisten = NSNotFound; __block FIRDatabaseHandle slashlisten = NSNotFound; __weak FIRDatabaseReference *refOne = refs.one; [refs.one setValue:@{@"x" : @1, @"y" : @{@"t" : @2, @"u" : @3}} withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { slashlisten = [refOne observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { deeplisten = [[refOne child:@"y/t"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { [[refOne child:@"y/t"] removeObserverWithHandle:deeplisten]; [refOne removeObserverWithHandle:slashlisten]; ready = YES; }]; }]; }]; [self waitUntil:^BOOL { return ready; }]; ready = NO; [[refs.one child:@"x"] setValue:@"test" withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { [refs.one observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { NSDictionary *val = [snapshot value]; NSDictionary *expected = @{@"x" : @"test", @"y" : @{@"t" : @2, @"u" : @3}}; XCTAssertTrue([val isEqualToDictionary:expected], @"Got the final value"); ready = YES; }]; }]; [self waitUntil:^BOOL { return ready; }]; } - (void)testUpdateRaisesCorrectLocalEvents { FIRDatabaseReference *node = [FTestHelpers getRandomNode]; __block FIRDataSnapshot *snap = nil; [node observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { snap = snapshot; }]; __block BOOL ready = NO; [node setValue:@{@"a" : @1, @"b" : @2, @"c" : @3, @"d" : @4} withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; FEventTester *et = [[FEventTester alloc] initFrom:self]; NSArray *expectations = @[ [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"a"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:[node child:@"d"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:node withEvent:FIRDataEventTypeChildChanged withString:@"a"], [[FTupleEventTypeString alloc] initWithFirebase:node withEvent:FIRDataEventTypeChildChanged withString:@"d"], [[FTupleEventTypeString alloc] initWithFirebase:node withEvent:FIRDataEventTypeValue withString:nil] ]; [et addLookingFor:expectations]; [et waitForInitialization]; [node updateChildValues:@{@"a" : @4, @"d" : @1}]; [et wait]; } - (void)testUpdateRaisesCorrectRemoteEvents { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *reader = refs.one; FIRDatabaseReference *writer = refs.two; __block BOOL ready = NO; [writer setValue:@{@"a" : @1, @"b" : @2, @"c" : @3, @"d" : @4} withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; FEventTester *et = [[FEventTester alloc] initFrom:self]; NSArray *expectations = @[ [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"a"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:[reader child:@"d"] withEvent:FIRDataEventTypeValue withString:nil], [[FTupleEventTypeString alloc] initWithFirebase:reader withEvent:FIRDataEventTypeChildChanged withString:@"a"], [[FTupleEventTypeString alloc] initWithFirebase:reader withEvent:FIRDataEventTypeChildChanged withString:@"d"], [[FTupleEventTypeString alloc] initWithFirebase:reader withEvent:FIRDataEventTypeValue withString:nil] ]; [et addLookingFor:expectations]; [et waitForInitialization]; [writer updateChildValues:@{@"a" : @4, @"d" : @1}]; [et wait]; ready = NO; [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { NSDictionary *result = [snapshot value]; NSDictionary *expected = @{@"a" : @4, @"b" : @2, @"c" : @3, @"d" : @1}; XCTAssertTrue([result isEqualToDictionary:expected], @"Got expected results"); ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; } - (void)testUpdateChangesAreStoredCorrectlyByTheServer { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *reader = refs.one; FIRDatabaseReference *writer = refs.two; [self waitForCompletionOf:writer setValue:@{@"a" : @1, @"b" : @2, @"c" : @3, @"d" : @4}]; [self waitForCompletionOf:writer updateChildValues:@{@"a" : @42}]; [self snapWaiter:reader withBlock:^(FIRDataSnapshot *snapshot) { NSDictionary *result = [snapshot value]; NSDictionary *expected = @{@"a" : @42, @"b" : @2, @"c" : @3, @"d" : @4}; XCTAssertTrue([result isEqualToDictionary:expected], @"Expected updated value"); }]; } - (void)testUpdateDoesntAffectPriorityLocally { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; __block FIRDataSnapshot *snap = nil; [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { snap = snapshot; }]; [ref setValue:@{@"a" : @1, @"b" : @2, @"c" : @3} andPriority:@"testpri"]; [self waitUntil:^BOOL { return snap != nil; }]; XCTAssertTrue([[snap priority] isEqualToString:@"testpri"], @"Got initial priority"); snap = nil; [ref updateChildValues:@{@"a" : @4}]; [self waitUntil:^BOOL { return snap != nil; }]; XCTAssertTrue([[snap priority] isEqualToString:@"testpri"], @"Got initial priority"); } - (void)testUpdateDoesntAffectPriorityRemotely { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *reader = refs.one; FIRDatabaseReference *writer = refs.two; __block BOOL ready = NO; [writer setValue:@{@"a" : @1, @"b" : @2, @"c" : @3} andPriority:@"testpri" withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; ready = NO; [reader observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { NSString *result = [snapshot priority]; XCTAssertTrue([result isEqualToString:@"testpri"], @"Expected initial priority"); ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; ready = NO; [writer updateChildValues:@{@"a" : @4} withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; ready = NO; [reader observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { NSString *result = [snapshot priority]; XCTAssertTrue([result isEqualToString:@"testpri"], @"Expected initial priority"); ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; } - (void)testUpdateReplacesChildrenAndIsNotRecursive { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *reader = refs.one; FIRDatabaseReference *writer = refs.two; __block FIRDataSnapshot *localSnap = nil; __block BOOL ready = NO; [writer observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { localSnap = snapshot; }]; [writer setValue:@{@"a" : @{@"aa" : @1, @"ab" : @2}}]; [writer updateChildValues:@{@"a" : @{@"aa" : @1}} withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; ready = NO; [reader observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { NSDictionary *result = [snapshot value]; NSDictionary *expected = @{@"a" : @{@"aa" : @1}}; XCTAssertTrue([result isEqualToDictionary:expected], @"Should get new value"); ready = YES; }]; [self waitUntil:^BOOL { NSDictionary *result = [localSnap value]; NSDictionary *expected = @{@"a" : @{@"aa" : @1}}; return ready && [result isEqualToDictionary:expected]; }]; } - (void)testDeepUpdatesWork { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *reader = refs.one; FIRDatabaseReference *writer = refs.two; __block FIRDataSnapshot *localSnap = nil; __block BOOL ready = NO; [writer observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { localSnap = snapshot; }]; [writer setValue:@{@"a" : @{@"aa" : @1, @"ab" : @2}}]; [writer updateChildValues:@{ @"a/aa" : @10, @".priority" : @3.0, @"a/ab" : @{@".priority" : @2.0, @".value" : @20} } withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; ready = NO; [reader observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { NSDictionary *result = [snapshot value]; NSDictionary *expected = @{@"a" : @{@"aa" : @10, @"ab" : @20}}; XCTAssertTrue([result isEqualToDictionary:expected], @"Should get new value"); ready = YES; }]; [self waitUntil:^BOOL { NSDictionary *result = [localSnap value]; NSDictionary *expected = @{@"a" : @{@"aa" : @10, @"ab" : @20}}; return ready && [result isEqualToDictionary:expected]; }]; } // Type signature means we don't need a test for updating scalars. They wouldn't compile - (void)testEmptyUpdateWorks { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; __block BOOL ready = NO; [ref updateChildValues:@{} withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { XCTAssertTrue(error == nil, @"Should not be an error"); ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; } // XXX update stress test - (void)testUpdateFiresCorrectEventWhenAChildIsDeleted { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *reader = refs.one; FIRDatabaseReference *writer = refs.two; __block FIRDataSnapshot *localSnap = nil; __block FIRDataSnapshot *remoteSnap = nil; [self waitForCompletionOf:writer setValue:@{@"a" : @12, @"b" : @6}]; [writer observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { localSnap = snapshot; }]; [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { remoteSnap = snapshot; }]; [self waitUntil:^BOOL { return localSnap != nil && remoteSnap != nil; }]; localSnap = nil; remoteSnap = nil; [writer updateChildValues:@{@"a" : [NSNull null]}]; [self waitUntil:^BOOL { return localSnap != nil && remoteSnap != nil; }]; NSDictionary *expected = @{@"b" : @6}; XCTAssertTrue([[remoteSnap value] isEqualToDictionary:expected], @"Removed child"); XCTAssertTrue([[localSnap value] isEqualToDictionary:expected], @"Removed child"); } - (void)testUpdateFiresCorrectEventOnNewChildren { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *reader = refs.one; FIRDatabaseReference *writer = refs.two; __block FIRDataSnapshot *localSnap = nil; __block FIRDataSnapshot *remoteSnap = nil; [[writer child:@"a"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { localSnap = snapshot; }]; [[reader child:@"a"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { remoteSnap = snapshot; }]; [self waitUntil:^BOOL { return localSnap != nil && remoteSnap != nil; }]; localSnap = nil; remoteSnap = nil; [writer updateChildValues:@{@"a" : @42}]; [self waitUntil:^BOOL { return localSnap != nil && remoteSnap != nil; }]; XCTAssertTrue([[remoteSnap value] isEqualToNumber:@42], @"Added child"); XCTAssertTrue([[localSnap value] isEqualToNumber:@42], @"Added child"); } - (void)testUpdateFiresCorrectEventOnDeletedChildren { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *reader = refs.one; FIRDatabaseReference *writer = refs.two; __block FIRDataSnapshot *localSnap = nil; __block FIRDataSnapshot *remoteSnap = nil; [self waitForCompletionOf:writer setValue:@{@"a" : @12}]; [[writer child:@"a"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { localSnap = snapshot; }]; [[reader child:@"a"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { remoteSnap = snapshot; }]; [self waitUntil:^BOOL { return localSnap != nil && remoteSnap != nil; }]; localSnap = nil; remoteSnap = nil; [writer updateChildValues:@{@"a" : [NSNull null]}]; [self waitUntil:^BOOL { return localSnap != nil && remoteSnap != nil; }]; XCTAssertTrue([remoteSnap value] == [NSNull null], @"Removed child"); XCTAssertTrue([localSnap value] == [NSNull null], @"Removed child"); } - (void)testUpdateFiresCorrectEventOnChangedChildren { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *reader = refs.one; FIRDatabaseReference *writer = refs.two; [self waitForCompletionOf:writer setValue:@{@"a" : @12}]; __block FIRDataSnapshot *localSnap = nil; __block FIRDataSnapshot *remoteSnap = nil; [[writer child:@"a"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { localSnap = snapshot; }]; [[reader child:@"a"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { remoteSnap = snapshot; }]; [self waitUntil:^BOOL { return localSnap != nil && remoteSnap != nil; }]; localSnap = nil; remoteSnap = nil; [self waitForCompletionOf:writer updateChildValues:@{@"a" : @11}]; [self waitUntil:^BOOL { return localSnap != nil && remoteSnap != nil; }]; XCTAssertTrue([[remoteSnap value] isEqualToNumber:@11], @"Changed child"); XCTAssertTrue([[localSnap value] isEqualToNumber:@11], @"Changed child"); } - (void)testUpdateOfPriorityWorks { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *reader = refs.one; FIRDatabaseReference *writer = refs.two; __block BOOL ready = NO; [writer setValue:@{@"a" : @5, @".priority" : @"pri1"}]; [writer updateChildValues:@{ @"a" : @6, @".priority" : @"pri2", @"b" : @{@".priority" : @"pri3", @"c" : @10} } withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { NSLog(@"error? %@", error); ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; ready = NO; [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { XCTAssertEqualObjects([[snapshot childSnapshotForPath:@"a"] value], @6, @"Should match write values"); XCTAssertTrue([[snapshot priority] isEqualToString:@"pri2"], @"Should get updated priority"); XCTAssertTrue( [[[snapshot childSnapshotForPath:@"b"] priority] isEqualToString:@"pri3"], @"Should get updated priority"); XCTAssertEqualObjects([[snapshot childSnapshotForPath:@"b/c"] value], @10, @"Should match write values"); ready = YES; }]; [self waitUntil:^BOOL { return ready; }]; } - (void)testSetWithCircularReferenceFails { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; NSMutableDictionary *toSet = [[NSMutableDictionary alloc] init]; NSDictionary *lol = @{@"foo" : @"bar", @"circular" : toSet}; [toSet setObject:lol forKey:@"lol"]; XCTAssertThrows([ref setValue:toSet], @"Should not be able to set circular dictionary"); } - (void)testLargeNumbers { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; long long jsMaxInt = 9007199254740992; long jsMaxIntPlusOne = (long)jsMaxInt + 1; NSNumber *toSet = [NSNumber numberWithLong:jsMaxIntPlusOne]; [ref setValue:toSet]; __block FIRDataSnapshot *snap = nil; [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { snap = snapshot; }]; [self waitUntil:^BOOL { return snap != nil; }]; NSNumber *result = [snap value]; XCTAssertTrue([result isEqualToNumber:toSet], @"Should get back same number"); toSet = [NSNumber numberWithLong:LONG_MAX]; snap = nil; [ref setValue:toSet]; [self waitUntil:^BOOL { return snap != nil; }]; result = [snap value]; XCTAssertTrue([result isEqualToNumber:toSet], @"Should get back same number"); snap = nil; toSet = [NSNumber numberWithDouble:DBL_MAX]; [ref setValue:toSet]; [self waitUntil:^BOOL { return snap != nil; }]; result = [snap value]; XCTAssertTrue([result isEqualToNumber:toSet], @"Should get back same number"); } #ifdef FLAKY_TEST - (void)testParentDeleteShadowsChildListeners { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *writer = refs.one; FIRDatabaseReference *deleter = refs.two; NSString *childName = [writer childByAutoId].key; __block BOOL called = NO; [[deleter child:childName] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { XCTAssertFalse(called, @"Should only be hit once"); called = YES; XCTAssertTrue(snapshot.value == [NSNull null], @"Value should be null"); }]; WAIT_FOR(called); __block BOOL done = NO; [[writer child:childName] setValue:@"foo"]; [deleter removeValueWithCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { done = YES; }]; WAIT_FOR(done); [deleter removeAllObservers]; } #endif - (void)testParentDeleteShadowsChildListenersWithNonDefaultQuery { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *writer = refs.one; FIRDatabaseReference *deleter = refs.two; NSString *childName = [writer childByAutoId].key; __block BOOL queryCalled = NO; __block BOOL deepChildCalled = NO; [[[[deleter child:childName] queryOrderedByPriority] queryStartingAtValue:nil childKey:@"b"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { XCTAssertFalse(queryCalled, @"Should only be hit once"); queryCalled = YES; XCTAssertTrue(snapshot.value == [NSNull null], @"Value should be null"); }]; [[[deleter child:childName] child:@"a"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { XCTAssertFalse(deepChildCalled, @"Should only be hit once"); deepChildCalled = YES; XCTAssertTrue(snapshot.value == [NSNull null], @"Value should be null"); }]; WAIT_FOR(deepChildCalled && queryCalled); __block BOOL done = NO; [[writer child:childName] setValue:@"foo"]; [deleter removeValueWithCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { done = YES; }]; WAIT_FOR(done); } - (void)testLocalServerTimestampEventuallyButNotImmediatelyMatchServer { 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 setValue:[FIRServerValue timestamp] andPriority:[FIRServerValue timestamp]]; [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] < 3000, @"Should have received a local event with a value close to timestamp"); XCTAssertTrue([now doubleValue] - [firstWriteSnap.priority doubleValue] < 3000, @"Should have received a local event with a priority close to timestamp"); XCTAssertTrue([now doubleValue] - [secondWriteSnap.value doubleValue] < 3000, @"Should have received a server event with a value close to timestamp"); XCTAssertTrue([now doubleValue] - [secondWriteSnap.priority doubleValue] < 3000, @"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)testServerTimestampSetWithPriorityRemoteEvents { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *writer = refs.one; FIRDatabaseReference *reader = refs.two; NSDictionary *data = @{ @"a" : [FIRServerValue timestamp], @"b" : @{@".value" : [FIRServerValue timestamp], @".priority" : [FIRServerValue timestamp]} }; __block BOOL done = NO; [writer setValue:data andPriority:[FIRServerValue timestamp] withCompletionBlock:^(NSError *err, FIRDatabaseReference *ref) { done = YES; }]; [self waitUntil:^BOOL { return done; }]; [self snapWaiter:reader withBlock:^(FIRDataSnapshot *snapshot) { NSDictionary *value = [snapshot value]; NSNumber *now = [NSNumber numberWithDouble:round([[NSDate date] timeIntervalSince1970] * 1000)]; NSNumber *timestamp = [snapshot priority]; XCTAssertTrue([[snapshot priority] isKindOfClass:[NSNumber class]], @"Should get back number"); XCTAssertTrue([now doubleValue] - [timestamp doubleValue] < 2000, @"Number should be no more than 2 seconds ago"); XCTAssertEqualObjects([snapshot priority], [value objectForKey:@"a"], @"Should get back matching ServerValue.TIMESTAMP"); XCTAssertEqualObjects([snapshot priority], [value objectForKey:@"b"], @"Should get back matching ServerValue.TIMESTAMP"); XCTAssertEqualObjects([snapshot priority], [[snapshot childSnapshotForPath:@"b"] priority], @"Should get back matching ServerValue.TIMESTAMP"); }]; } - (void)testServerTimestampSetPriorityRemoteEvents { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *writer = refs.one; FIRDatabaseReference *reader = refs.two; __block FIRDataSnapshot *snap = nil; [reader observeEventType:FIRDataEventTypeChildMoved withBlock:^(FIRDataSnapshot *snapshot) { snap = snapshot; }]; [self waitForCompletionOf:[writer child:@"a"] setValue:@1 andPriority:nil]; [self waitForCompletionOf:[writer child:@"b"] setValue:@1 andPriority:@1]; [self waitForValueOf:[reader child:@"a"] toBe:@1]; __block BOOL done = NO; [[writer child:@"a"] setPriority:[FIRServerValue timestamp] withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { done = YES; }]; [self waitUntil:^BOOL { return done && snap != nil; }]; NSNumber *now = [NSNumber numberWithDouble:round([[NSDate date] timeIntervalSince1970] * 1000)]; NSNumber *timestamp = [snap priority]; XCTAssertTrue([[snap priority] isKindOfClass:[NSNumber class]], @"Should get back number"); XCTAssertTrue([now doubleValue] - [timestamp doubleValue] < 2000, @"Number should be no more than 2 seconds ago"); } - (void)testServerTimestampUpdateRemoteEvents { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *writer = refs.one; FIRDatabaseReference *reader = refs.two; __block FIRDataSnapshot *snap = nil; __block BOOL done = NO; [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { snap = snapshot; if (snap && [[snap childSnapshotForPath:@"a/b/d"] value] != [NSNull null]) { done = YES; } }]; [[writer child:@"a/b/c"] setValue:@1]; [[writer child:@"a"] updateChildValues:@{@"b" : @{@"c" : [FIRServerValue timestamp], @"d" : @1}}]; [self waitUntil:^BOOL { return done; }]; NSNumber *now = [NSNumber numberWithDouble:round([[NSDate date] timeIntervalSince1970] * 1000)]; NSNumber *timestamp = [[snap childSnapshotForPath:@"a/b/c"] value]; XCTAssertTrue([[[snap childSnapshotForPath:@"a/b/c"] value] isKindOfClass:[NSNumber class]], @"Should get back number"); XCTAssertTrue([now doubleValue] - [timestamp doubleValue] < 2000, @"Number should be no more than 2 seconds ago"); } - (void)testServerTimestampSetWithPriorityLocalEvents { FIRDatabaseReference *node = [FTestHelpers getRandomNode]; NSDictionary *data = @{ @"a" : [FIRServerValue timestamp], @"b" : @{@".value" : [FIRServerValue timestamp], @".priority" : [FIRServerValue timestamp]} }; __block FIRDataSnapshot *snap = nil; [node observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { snap = snapshot; }]; __block BOOL done = NO; [node setValue:data andPriority:[FIRServerValue timestamp] withCompletionBlock:^(NSError *err, FIRDatabaseReference *ref) { done = YES; }]; [self waitUntil:^BOOL { return done; }]; [self snapWaiter:node withBlock:^(FIRDataSnapshot *snapshot) { NSDictionary *value = [snapshot value]; NSNumber *now = [NSNumber numberWithDouble:round([[NSDate date] timeIntervalSince1970] * 1000)]; NSNumber *timestamp = [snapshot priority]; XCTAssertTrue([[snapshot priority] isKindOfClass:[NSNumber class]], @"Should get back number"); XCTAssertTrue([now doubleValue] - [timestamp doubleValue] < 2000, @"Number should be no more than 2 seconds ago"); XCTAssertEqualObjects([snapshot priority], [value objectForKey:@"a"], @"Should get back matching ServerValue.TIMESTAMP"); XCTAssertEqualObjects([snapshot priority], [value objectForKey:@"b"], @"Should get back matching ServerValue.TIMESTAMP"); XCTAssertEqualObjects([snapshot priority], [[snapshot childSnapshotForPath:@"b"] priority], @"Should get back matching ServerValue.TIMESTAMP"); }]; } - (void)testServerTimestampSetPriorityLocalEvents { FIRDatabaseReference *node = [FTestHelpers getRandomNode]; __block FIRDataSnapshot *snap = nil; [node observeEventType:FIRDataEventTypeChildMoved withBlock:^(FIRDataSnapshot *snapshot) { snap = snapshot; }]; __block BOOL done = NO; [[node child:@"a"] setValue:@1 andPriority:nil]; [[node child:@"b"] setValue:@1 andPriority:@1]; [[node child:@"a"] setPriority:[FIRServerValue timestamp] withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { done = YES; }]; [self waitUntil:^BOOL { return done; }]; NSNumber *now = [NSNumber numberWithDouble:round([[NSDate date] timeIntervalSince1970] * 1000)]; NSNumber *timestamp = [snap priority]; XCTAssertTrue([[snap priority] isKindOfClass:[NSNumber class]], @"Should get back number"); XCTAssertTrue([now doubleValue] - [timestamp doubleValue] < 2000, @"Number should be no more than 2 seconds ago"); } - (void)testServerTimestampUpdateLocalEvents { FIRDatabaseReference *node1 = [FTestHelpers getRandomNode]; __block FIRDataSnapshot *snap1 = nil; [node1 observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { snap1 = snapshot; }]; __block FIRDataSnapshot *snap2 = nil; [node1 observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { snap2 = snapshot; }]; [node1 runTransactionBlock:^FIRTransactionResult *(FIRMutableData *currentData) { [currentData setValue:[FIRServerValue timestamp]]; return [FIRTransactionResult successWithValue:currentData]; }]; [self waitUntil:^BOOL { return snap1 != nil && snap2 != nil && [snap1 value] != nil && [snap2 value] != nil; }]; NSNumber *now = [NSNumber numberWithDouble:round([[NSDate date] timeIntervalSince1970] * 1000)]; NSNumber *timestamp1 = [snap1 value]; XCTAssertTrue([[snap1 value] isKindOfClass:[NSNumber class]], @"Should get back number"); XCTAssertTrue([now doubleValue] - [timestamp1 doubleValue] < 2000, @"Number should be no more than 2 seconds ago"); NSNumber *timestamp2 = [snap2 value]; XCTAssertTrue([[snap2 value] isKindOfClass:[NSNumber class]], @"Should get back number"); XCTAssertTrue([now doubleValue] - [timestamp2 doubleValue] < 2000, @"Number should be no more than 2 seconds ago"); } - (void)testServerTimestampTransactionLocalEvents { FIRDatabaseReference *node = [FTestHelpers getRandomNode]; __block FIRDataSnapshot *snap = nil; [node observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { snap = snapshot; }]; [[node child:@"a/b/c"] setValue:@1]; [[node child:@"a"] updateChildValues:@{@"b" : @{@"c" : [FIRServerValue timestamp], @"d" : @1}}]; [self waitUntil:^BOOL { return snap != nil && [[snap childSnapshotForPath:@"a/b/d"] value] != nil; }]; NSNumber *now = [NSNumber numberWithDouble:round([[NSDate date] timeIntervalSince1970] * 1000)]; NSNumber *timestamp = [[snap childSnapshotForPath:@"a/b/c"] value]; XCTAssertTrue([[[snap childSnapshotForPath:@"a/b/c"] value] isKindOfClass:[NSNumber class]], @"Should get back number"); XCTAssertTrue([now doubleValue] - [timestamp doubleValue] < 2000, @"Number should be no more than 2 seconds ago"); } - (void)testServerIncrementOverwritesExistingDataOnline { [self checkServerIncrementOverwritesExistingDataWhileOnline:true]; } - (void)testServerIncrementOverwritesExistingDataOffline { [self checkServerIncrementOverwritesExistingDataWhileOnline:false]; } - (void)checkServerIncrementOverwritesExistingDataWhileOnline:(BOOL)online { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; __block NSMutableArray *found = [NSMutableArray new]; NSMutableArray *expected = [NSMutableArray new]; [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snap) { [found addObject:snap.value]; }]; // Going offline ensures that local events get queued up before server events if (!online) { [ref.repo interrupt]; } // null + incr [ref setValue:[FIRServerValue increment:@1]]; [expected addObject:@1]; // number + incr [ref setValue:@5]; [ref setValue:[FIRServerValue increment:@1]]; [expected addObject:@5]; [expected addObject:@6]; // string + incr [ref setValue:@"hello"]; [ref setValue:[FIRServerValue increment:@1]]; [expected addObject:@"hello"]; [expected addObject:@1]; // object + incr [ref setValue:@{@"hello" : @"world"}]; [ref setValue:[FIRServerValue increment:@1]]; [expected addObject:@{@"hello" : @"world"}]; [expected addObject:@1]; [self waitUntil:^BOOL { return found.count == expected.count; }]; XCTAssertEqualObjects(expected, found); if (!online) { [ref.repo resume]; } } - (void)testServerIncrementPriorityOnline { [self checkServerIncrementPriorityWhileOnline:true]; } - (void)testServerIncrementPriorityOffline { [self checkServerIncrementPriorityWhileOnline:false]; } - (void)checkServerIncrementPriorityWhileOnline:(BOOL)online { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; if (!online) { [ref.repo interrupt]; } __block NSMutableArray *found = [NSMutableArray new]; NSMutableArray *expected = [NSMutableArray new]; [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snap) { [found addObject:snap.priority]; }]; // Going offline ensures that local events get queued up before server events // Also necessary because increment may not be live yet in the server. if (!online) { [ref.repo interrupt]; } // null + incr [ref setValue:@0 andPriority:[FIRServerValue increment:@1]]; [expected addObject:@1]; [ref setValue:@0 andPriority:[FIRServerValue increment:@1.5]]; [expected addObject:@2.5]; [self waitUntil:^BOOL { return found.count == expected.count; }]; XCTAssertEqualObjects(expected, found); if (!online) { [ref.repo resume]; } } - (void)testServerIncrementOverflowAndTypeCoercion { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; __block NSMutableArray *found = [NSMutableArray new]; __block NSMutableArray *foundTypes = [NSMutableArray new]; NSMutableArray *expected = [NSMutableArray new]; NSMutableArray *expectedTypes = [NSMutableArray new]; [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snap) { [found addObject:snap.value]; [foundTypes addObject:@([(NSNumber *)snap.value objCType])]; }]; // Going offline ensures that local events get queued up before server events // Also necessary because increment may not be live yet in the server. [ref.repo interrupt]; // long + double = double [ref setValue:@1]; [ref setValue:[FIRServerValue increment:@1.0]]; [expected addObject:@1]; [expected addObject:@2.0]; [expectedTypes addObject:@(@encode(int))]; [expectedTypes addObject:@(@encode(double))]; // double + long = double [ref setValue:@1.5]; [ref setValue:[FIRServerValue increment:@1]]; [expected addObject:@1.5]; [expected addObject:@2.5]; [expectedTypes addObject:@(@encode(double))]; [expectedTypes addObject:@(@encode(double))]; // long overflow = double [ref setValue:@(1)]; [ref setValue:[FIRServerValue increment:@(LONG_MAX)]]; [expected addObject:@(1)]; [expected addObject:@(LONG_MAX + 1.0)]; [expectedTypes addObject:@(@encode(int))]; [expectedTypes addObject:@(@encode(double))]; // unsigned long long overflow = double [ref setValue:@1]; [ref setValue:[FIRServerValue increment:@((unsigned long long)ULLONG_MAX)]]; [expected addObject:@1]; [expected addObject:@((double)ULLONG_MAX + 1)]; [expectedTypes addObject:@(@encode(int))]; [expectedTypes addObject:@(@encode(double))]; // long underflow = double [ref setValue:@(-1)]; [ref setValue:[FIRServerValue increment:@(LONG_MIN)]]; [expected addObject:@(-1)]; [expected addObject:@(LONG_MIN - 1.0)]; [expectedTypes addObject:@(@encode(int))]; [expectedTypes addObject:@(@encode(double))]; [self waitUntil:^BOOL { return found.count == expected.count && foundTypes.count == expectedTypes.count; }]; XCTAssertEqualObjects(expectedTypes, foundTypes); XCTAssertEqualObjects(expected, found); [ref.repo resume]; } - (void)testUpdateAfterChildSet { FIRDatabaseReference *node = [FTestHelpers getRandomNode]; __block BOOL done = NO; __weak FIRDatabaseReference *weakRef = node; [node setValue:@{@"a" : @"a"} withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { [weakRef observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { if (snapshot.childrenCount == 3 && [snapshot hasChild:@"a"] && [snapshot hasChild:@"b"] && [snapshot hasChild:@"c"]) { done = YES; } }]; [[weakRef child:@"b"] setValue:@"b"]; [weakRef updateChildValues:@{@"c" : @"c"}]; }]; [self waitUntil:^BOOL { return done; }]; } - (void)testDeltaSyncNoDataUpdatesAfterReconnect { FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; FIRDatabaseConfig *cfg = [FTestHelpers configForName:@"test-config"]; FIRDatabaseReference *ref2 = [[FTestHelpers databaseForConfig:cfg] referenceWithPath:ref.key]; __block id data = @{@"a" : @1, @"b" : @2, @"c" : @{@".priority" : @3, @".value" : @3}, @"d" : @4}; [self waitForCompletionOf:ref setValue:data]; __block BOOL gotData = NO; [ref2 observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { XCTAssertFalse(gotData, @"event triggered twice."); gotData = YES; XCTAssertEqualObjects(snapshot.valueInExportFormat, data, @"Got wrong data."); }]; [self waitUntil:^BOOL { return gotData; }]; __block BOOL done = NO; XCTAssertEqual(ref2.repo.dataUpdateCount, 1L, @"Should have gotten one update."); // Bounce connection [FRepoManager interrupt:cfg]; [FRepoManager resume:cfg]; [[[ref2 root] child:@".info/connected"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { if ([snapshot.value boolValue]) { // We're connected. Do one more round-trip to make sure all state restoration is // done [[[ref2 root] child:@"foobar/empty/blah"] setValue:nil withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { XCTAssertEqual(ref2.repo.dataUpdateCount, 1L, @"Should have gotten one update."); done = YES; }]; } }]; [self waitUntil:^BOOL { return done; }]; // cleanup [FRepoManager interrupt:cfg]; [FRepoManager disposeRepos:cfg]; } - (void)testServerTimestampEventualConsistencyBetweenLocalAndRemote { FTupleFirebase *refs = [FTestHelpers getRandomNodePair]; FIRDatabaseReference *writer = refs.one; FIRDatabaseReference *reader = refs.two; __block FIRDataSnapshot *writerSnap = nil; __block FIRDataSnapshot *readerSnap = nil; [reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { readerSnap = snapshot; }]; [writer observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) { writerSnap = snapshot; }]; [writer setValue:[FIRServerValue timestamp] andPriority:[FIRServerValue timestamp]]; [self waitUntil:^BOOL { if (readerSnap && writerSnap && [[readerSnap value] isKindOfClass:[NSNumber class]] && [[writerSnap value] isKindOfClass:[NSNumber class]]) { if ([[readerSnap value] doubleValue] == [[writerSnap value] doubleValue]) { return YES; } } return NO; }]; } // Listens at a location and then creates a bunch of children, waiting for them all to complete. - (void)testChildAddedPerf1 { if (!runPerfTests) return; FIRDatabaseReference *ref = [FTestHelpers getRandomNode]; [ref observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot){ }]; NSDate *start = [NSDate date]; int COUNT = 1000; __block BOOL done = NO; __block NSDate *finished = nil; for (int i = 0; i < COUNT; i++) { [[ref childByAutoId] setValue:@"01234567890123456789012345678901234567890123456789" withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { if (i == (COUNT - 1)) { finished = [NSDate date]; done = YES; } }]; } [self waitUntil:^BOOL { return done; } timeout:300]; NSTimeInterval elapsed = [finished timeIntervalSinceDate:start]; NSLog(@"Elapsed: %f", elapsed); } // Listens at a location, then adds a bunch of grandchildren under a single child. - (void)testDeepChildAddedPerf1 { if (!runPerfTests) return; FIRDatabaseReference *ref = [FTestHelpers getRandomNode], *childRef = [ref child:@"child"]; [ref observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot){ }]; NSDate *start = [NSDate date]; int COUNT = 1000; __block BOOL done = NO; __block NSDate *finished = nil; for (int i = 0; i < COUNT; i++) { [[childRef childByAutoId] setValue:@"01234567890123456789012345678901234567890123456789" withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { if (i == (COUNT - 1)) { finished = [NSDate date]; done = YES; } }]; } [self waitUntil:^BOOL { return done; } timeout:300]; NSTimeInterval elapsed = [finished timeIntervalSinceDate:start]; NSLog(@"Elapsed: %f", elapsed); } // Listens at a location, then adds a bunch of grandchildren under a single child, but does it with // merges. NOTE[2015-07-14]: This test is still pretty slow, because [FWriteTree removeWriteId] ends // up rebuilding the tree after every ack. - (void)testDeepChildAddedPerfViaMerge1 { if (!runPerfTests) return; FIRDatabaseReference *ref = [FTestHelpers getRandomNode], *childRef = [ref child:@"child"]; [ref observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot){ }]; NSDate *start = [NSDate date]; int COUNT = 250; __block BOOL done = NO; __block NSDate *finished = nil; for (int i = 0; i < COUNT; i++) { NSString *childName = [childRef childByAutoId].key; [childRef updateChildValues:@{childName : @"01234567890123456789012345678901234567890123456789"} withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) { if (i == (COUNT - 1)) { finished = [NSDate date]; done = YES; } }]; } [self waitUntil:^BOOL { return done; } timeout:300]; NSTimeInterval elapsed = [finished timeIntervalSinceDate:start]; NSLog(@"Elapsed: %f", elapsed); } @end