spm/firebase-ios-sdk
1
0 Fork 0
mirror of https://github.com/firebase/firebase-ios-sdk synced 2026-11-09 22:36:01 +05:45
Code Issues Packages Projects Releases Wiki Activity
Files
ffedaed448bcd2ba9a721527644dfcf198294017
firebase-ios-sdk/FirebaseDatabase/Tests/Integration/FData.m
T

3284 lines
118 KiB
Objective-C
Raw Blame History

/*
* 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 <limits.h>
#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
Reference in new issue View Git Blame Copy Permalink