mirror of
https://github.com/firebase/firebase-ios-sdk
synced 2026-11-10 22:45:59 +05:45
2688 lines
98 KiB
Objective-C
2688 lines
98 KiB
Objective-C
/*
|
|
* 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 "FData.h"
|
|
#import "FTestHelpers.h"
|
|
#import "FEventTester.h"
|
|
#import "FTupleEventTypeString.h"
|
|
#import <FirebaseCore/FIRApp.h>
|
|
#import "FIRDatabaseQuery_Private.h"
|
|
#import "FIRDatabaseConfig_Private.h"
|
|
#import <FirebaseCore/FIROptions.h>
|
|
#import "FRepo_Private.h"
|
|
#import <limits.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 = [[FIRDatabase database] referenceFromURL:[self.databaseURL uppercaseString]];
|
|
FIRDatabaseReference * ref2 = [[FIRDatabase database] 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 = [[[FIRDatabase database] 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];
|
|
}
|
|
|
|
- (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;
|
|
}];
|
|
}
|
|
|
|
- (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 observeEventType: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;
|
|
}];
|
|
}
|
|
|
|
- (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;
|
|
}];
|
|
}
|
|
|
|
- (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");
|
|
}
|
|
|
|
- (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;
|
|
}];
|
|
}
|
|
|
|
- (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];
|
|
|
|
XCTAssertTrue([[parent description] isEqualToString:self.databaseURL], @"Expect domain");
|
|
FIRDatabaseReference * child = [parent child:@"a/b/c"];
|
|
NSString* expected = [NSString stringWithFormat:@"%@/a/b/c", self.databaseURL];
|
|
XCTAssertTrue([[child description] isEqualToString:expected], @"Expected path");
|
|
}
|
|
|
|
- (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 = [[FIRDatabase database] 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 = [[FIRDatabase database] 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 = [[FIRDatabase database] 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 = [[FIRDatabase database] 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 = 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");
|
|
}
|
|
|
|
- (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);
|
|
}
|
|
|
|
- (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) testLocalServerValuesEventuallyButNotImmediatelyMatchServer {
|
|
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) testServerValuesSetWithPriorityRemoteEvents {
|
|
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) testServerValuesSetPriorityRemoteEvents {
|
|
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) testServerValuesUpdateRemoteEvents {
|
|
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) testServerValuesSetWithPriorityLocalEvents {
|
|
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) testServerValuesSetPriorityLocalEvents {
|
|
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) testServerValuesUpdateLocalEvents {
|
|
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) testServerValuesTransactionLocalEvents {
|
|
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) 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 = [FIRDatabaseConfig configForName:@"test-config"];
|
|
FIRDatabaseReference * ref2 = [[[FIRDatabaseReference alloc] initWithConfig:cfg] child: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) testServerValuesEventualConsistencyBetweenLocalAndRemote {
|
|
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
|