mirror of
https://github.com/firebase/firebase-ios-sdk
synced 2026-11-10 22:45:59 +05:45
2784 lines
99 KiB
Objective-C
2784 lines
99 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 "FIRDatabaseQueryTests.h"
|
|
#import "FIRDatabaseQuery_Private.h"
|
|
#import "FQuerySpec.h"
|
|
#import "FTestExpectations.h"
|
|
|
|
@implementation FIRDatabaseQueryTests
|
|
|
|
- (void) testCanCreateBasicQueries {
|
|
// Just make sure none of these throw anything
|
|
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
[ref queryLimitedToFirst:10];
|
|
[ref queryLimitedToLast:10];
|
|
|
|
[[ref queryOrderedByKey] queryStartingAtValue:@"foo"];
|
|
[[ref queryOrderedByKey] queryEndingAtValue:@"foo"];
|
|
[[ref queryOrderedByKey] queryEqualToValue:@"foo"];
|
|
|
|
[[ref queryOrderedByChild:@"index"] queryStartingAtValue:@YES];
|
|
[[ref queryOrderedByChild:@"index"] queryStartingAtValue:@1];
|
|
[[ref queryOrderedByChild:@"index"] queryStartingAtValue:@"foo"];
|
|
[[ref queryOrderedByChild:@"index"] queryStartingAtValue:nil];
|
|
[[ref queryOrderedByChild:@"index"] queryEndingAtValue:@YES];
|
|
[[ref queryOrderedByChild:@"index"] queryEndingAtValue:@1];
|
|
[[ref queryOrderedByChild:@"index"] queryEndingAtValue:@"foo"];
|
|
[[ref queryOrderedByChild:@"index"] queryEndingAtValue:nil];
|
|
[[ref queryOrderedByChild:@"index"] queryEqualToValue:@YES];
|
|
[[ref queryOrderedByChild:@"index"] queryEqualToValue:@1];
|
|
[[ref queryOrderedByChild:@"index"] queryEqualToValue:@"foo"];
|
|
[[ref queryOrderedByChild:@"index"] queryEqualToValue:nil];
|
|
|
|
[[ref queryOrderedByPriority] queryStartingAtValue:@1];
|
|
[[ref queryOrderedByPriority] queryStartingAtValue:@"foo"];
|
|
[[ref queryOrderedByPriority] queryStartingAtValue:nil];
|
|
[[ref queryOrderedByPriority] queryEndingAtValue:@1];
|
|
[[ref queryOrderedByPriority] queryEndingAtValue:@"foo"];
|
|
[[ref queryOrderedByPriority] queryEndingAtValue:nil];
|
|
[[ref queryOrderedByPriority] queryEqualToValue:@1];
|
|
[[ref queryOrderedByPriority] queryEqualToValue:@"foo"];
|
|
[[ref queryOrderedByPriority] queryEqualToValue:nil];
|
|
}
|
|
|
|
- (void) testInvalidQueryParams {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
XCTAssertThrows([[ref queryLimitedToFirst:100] queryLimitedToFirst:100]);
|
|
XCTAssertThrows([[ref queryLimitedToFirst:100] queryLimitedToLast:100]);
|
|
XCTAssertThrows([[ref queryLimitedToLast:100] queryLimitedToFirst:100]);
|
|
XCTAssertThrows([[ref queryLimitedToLast:100] queryLimitedToLast:100]);
|
|
XCTAssertThrows([[ref queryOrderedByPriority] queryOrderedByPriority]);
|
|
XCTAssertThrows([[ref queryOrderedByPriority] queryOrderedByKey]);
|
|
XCTAssertThrows([[ref queryOrderedByPriority] queryOrderedByChild:@"foo"]);
|
|
XCTAssertThrows([[ref queryOrderedByPriority] queryOrderedByValue]);
|
|
XCTAssertThrows([[ref queryOrderedByKey] queryOrderedByPriority]);
|
|
XCTAssertThrows([[ref queryOrderedByKey] queryOrderedByKey]);
|
|
XCTAssertThrows([[ref queryOrderedByKey] queryOrderedByChild:@"foo"]);
|
|
XCTAssertThrows([[ref queryOrderedByKey] queryOrderedByValue]);
|
|
XCTAssertThrows([[ref queryOrderedByChild:@"foo"] queryOrderedByPriority]);
|
|
XCTAssertThrows([[ref queryOrderedByChild:@"foo"] queryOrderedByKey]);
|
|
XCTAssertThrows([[ref queryOrderedByChild:@"foo"] queryOrderedByChild:@"foo"]);
|
|
XCTAssertThrows([[ref queryOrderedByChild:@"foo"] queryOrderedByValue]);
|
|
XCTAssertThrows([[ref queryOrderedByValue] queryOrderedByPriority]);
|
|
XCTAssertThrows([[ref queryOrderedByValue] queryOrderedByKey]);
|
|
XCTAssertThrows([[ref queryOrderedByValue] queryOrderedByChild:@"foo"]);
|
|
XCTAssertThrows([[ref queryOrderedByValue] queryOrderedByValue]);
|
|
XCTAssertThrows([[ref queryStartingAtValue:@"foo"] queryStartingAtValue:@"foo"]);
|
|
XCTAssertThrows([[ref queryStartingAtValue:@"foo"] queryEqualToValue:@"foo"]);
|
|
XCTAssertThrows([[ref queryEndingAtValue:@"foo"] queryEndingAtValue:@"foo"]);
|
|
XCTAssertThrows([[ref queryEndingAtValue:@"foo"] queryEqualToValue:@"foo"]);
|
|
XCTAssertThrows([[ref queryEqualToValue:@"foo"] queryStartingAtValue:@"foo"]);
|
|
XCTAssertThrows([[ref queryEqualToValue:@"foo"] queryEndingAtValue:@"foo"]);
|
|
XCTAssertThrows([[ref queryEqualToValue:@"foo"] queryEqualToValue:@"foo"]);
|
|
XCTAssertThrows([[ref queryOrderedByKey] queryStartingAtValue:@"foo" childKey:@"foo"]);
|
|
XCTAssertThrows([[ref queryOrderedByKey] queryEndingAtValue:@"foo" childKey:@"foo"]);
|
|
XCTAssertThrows([[ref queryOrderedByKey] queryEqualToValue:@"foo" childKey:@"foo"]);
|
|
XCTAssertThrows([[ref queryOrderedByKey] queryStartingAtValue:@1 childKey:@"foo"]);
|
|
XCTAssertThrows([[ref queryOrderedByKey] queryStartingAtValue:@YES]);
|
|
XCTAssertThrows([[ref queryOrderedByKey] queryEndingAtValue:@1]);
|
|
XCTAssertThrows([[ref queryOrderedByKey] queryEndingAtValue:@YES]);
|
|
XCTAssertThrows([[ref queryOrderedByKey] queryStartingAtValue:nil]);
|
|
XCTAssertThrows([[ref queryOrderedByKey] queryEndingAtValue:nil]);
|
|
XCTAssertThrows([[ref queryOrderedByKey] queryEqualToValue:nil]);
|
|
XCTAssertThrows([[ref queryStartingAtValue:@"foo" childKey:@"foo"] queryOrderedByKey]);
|
|
XCTAssertThrows([[ref queryEndingAtValue:@"foo" childKey:@"foo"] queryOrderedByKey]);
|
|
XCTAssertThrows([[ref queryEqualToValue:@"foo" childKey:@"foo"] queryOrderedByKey]);
|
|
XCTAssertThrows([[ref queryStartingAtValue:@1] queryOrderedByKey]);
|
|
XCTAssertThrows([[ref queryStartingAtValue:@YES] queryOrderedByKey]);
|
|
XCTAssertThrows([[ref queryEndingAtValue:@1] queryOrderedByKey]);
|
|
XCTAssertThrows([[ref queryEndingAtValue:@YES] queryOrderedByKey]);
|
|
XCTAssertThrows([ref queryStartingAtValue:@[]]);
|
|
XCTAssertThrows([ref queryStartingAtValue:@{}]);
|
|
XCTAssertThrows([ref queryEndingAtValue:@[]]);
|
|
XCTAssertThrows([ref queryEndingAtValue:@{}]);
|
|
XCTAssertThrows([ref queryEqualToValue:@[]]);
|
|
XCTAssertThrows([ref queryEqualToValue:@{}]);
|
|
|
|
XCTAssertThrows([[ref queryOrderedByKey] queryOrderedByPriority], @"Cannot call orderBy multiple times");
|
|
XCTAssertThrows([[ref queryOrderedByChild:@"foo"] queryOrderedByPriority], @"Cannot call orderBy multiple times");
|
|
XCTAssertThrows([[ref queryOrderedByKey] queryOrderedByKey], @"Cannot call orderBy multiple times");
|
|
XCTAssertThrows([[ref queryOrderedByChild:@"foo"] queryOrderedByKey], @"Cannot call orderBy multiple times");
|
|
XCTAssertThrows([[ref queryOrderedByKey] queryOrderedByChild:@"foo"], @"Cannot call orderBy multiple times");
|
|
XCTAssertThrows([[ref queryOrderedByChild:@"foo"] queryOrderedByChild:@"foo"], @"Cannot call orderBy multiple times");
|
|
|
|
XCTAssertThrows([[ref queryOrderedByKey] queryStartingAtValue:@"a" childKey:@"b"], @"Cannot specify starting child name when ordering by key.");
|
|
XCTAssertThrows([[ref queryOrderedByKey] queryEndingAtValue:@"a" childKey:@"b"], @"Cannot specify ending child name when ordering by key.");
|
|
XCTAssertThrows([[ref queryOrderedByKey] queryEqualToValue:@"a" childKey:@"b"], @"Cannot specify equalTo child name when ordering by key.");
|
|
|
|
XCTAssertThrows([[ref queryOrderedByPriority] queryStartingAtValue:@YES], @"Can't pass booleans as start/end when using priority index.");
|
|
XCTAssertThrows([[ref queryOrderedByPriority] queryEndingAtValue:@NO], @"Can't pass booleans as start/end when using priority index.");
|
|
XCTAssertThrows([[ref queryOrderedByPriority] queryEqualToValue:@YES], @"Can't pass booleans as start/end when using priority index.");
|
|
}
|
|
|
|
- (void) testLimitRanges
|
|
{
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
XCTAssertThrows([ref queryLimitedToLast:0], @"Can't pass zero as limit");
|
|
XCTAssertThrows([ref queryLimitedToFirst:0], @"Can't pass zero as limit");
|
|
XCTAssertThrows([ref queryLimitedToLast:0], @"Can't pass zero as limit");
|
|
uint64_t MAX_ALLOWED_VALUE = (uint64_t)(1l << 31) - 1;
|
|
[ref queryLimitedToFirst:(NSUInteger)MAX_ALLOWED_VALUE];
|
|
[ref queryLimitedToLast:(NSUInteger)MAX_ALLOWED_VALUE];
|
|
XCTAssertThrows([ref queryLimitedToFirst:(NSUInteger)(MAX_ALLOWED_VALUE+1)],
|
|
@"Can't pass limits that don't fit into 32 bit signed integer range");
|
|
XCTAssertThrows([ref queryLimitedToLast:(NSUInteger)(MAX_ALLOWED_VALUE+1)],
|
|
@"Can't pass limits that don't fit into 32 bit signed integer range");
|
|
}
|
|
|
|
- (void) testInvalidKeys {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
NSArray* badKeys = @[ @".test", @"test.", @"fo$o", @"[what", @"ever]", @"ha#sh", @"/thing", @"th/ing", @"thing/"];
|
|
|
|
for (NSString* badKey in badKeys) {
|
|
XCTAssertThrows([[ref queryOrderedByPriority] queryStartingAtValue:nil childKey:badKey], @"Setting bad key");
|
|
XCTAssertThrows([[ref queryOrderedByPriority] queryEndingAtValue:nil childKey:badKey], @"Setting bad key");
|
|
}
|
|
}
|
|
|
|
- (void) testOffCanBeCalledOnDefault {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
__block BOOL called = NO;
|
|
FIRDatabaseQuery * query = [ref queryLimitedToLast:5];
|
|
[query observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
if (called) {
|
|
XCTFail(@"Should not be called twice");
|
|
} else {
|
|
called = YES;
|
|
}
|
|
}];
|
|
|
|
[ref setValue:@{@"a": @5, @"b": @6}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return called;
|
|
}];
|
|
|
|
called = NO;
|
|
|
|
[ref removeAllObservers];
|
|
|
|
__block BOOL complete = NO;
|
|
[ref setValue:@{@"a": @6, @"b": @7} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
complete = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return complete;
|
|
}];
|
|
|
|
XCTAssertFalse(called, @"Should not have been called again");
|
|
}
|
|
|
|
- (void) testOffCanBeCalledOnHandle {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
__block BOOL called = NO;
|
|
FIRDatabaseQuery * query = [ref queryLimitedToLast:5];
|
|
FIRDatabaseHandle handle = [query observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
if (called) {
|
|
XCTFail(@"Should not be called twice");
|
|
} else {
|
|
called = YES;
|
|
}
|
|
}];
|
|
|
|
[ref setValue:@{@"a": @5, @"b": @6}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return called;
|
|
}];
|
|
|
|
called = NO;
|
|
|
|
[ref removeObserverWithHandle:handle];
|
|
|
|
__block BOOL complete = NO;
|
|
[ref setValue:@{@"a": @6, @"b": @7} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
complete = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return complete;
|
|
}];
|
|
|
|
XCTAssertFalse(called, @"Should not have been called again");
|
|
}
|
|
|
|
- (void) testOffCanBeCalledOnSpecificQuery {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
__block BOOL called = NO;
|
|
FIRDatabaseQuery * query = [ref queryLimitedToLast:5];
|
|
FIRDatabaseHandle handle = [query observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
if (called) {
|
|
XCTFail(@"Should not be called twice");
|
|
} else {
|
|
called = YES;
|
|
}
|
|
}];
|
|
|
|
[ref setValue:@{@"a": @5, @"b": @6}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return called;
|
|
}];
|
|
|
|
called = NO;
|
|
|
|
[query removeObserverWithHandle:handle];
|
|
|
|
__block BOOL complete = NO;
|
|
[ref setValue:@{@"a": @6, @"b": @7} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
complete = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return complete;
|
|
}];
|
|
|
|
XCTAssertFalse(called, @"Should not have been called again");
|
|
}
|
|
|
|
- (void) testOffCanBeCalledOnMultipleQueries {
|
|
FIRDatabaseQuery *query = [[FTestHelpers getRandomNode] queryLimitedToFirst:10];
|
|
FIRDatabaseHandle handle1 = [query observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
}];
|
|
FIRDatabaseHandle handle2 = [query observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
}];
|
|
[query removeObserverWithHandle:handle1];
|
|
[query removeObserverWithHandle:handle2];
|
|
}
|
|
|
|
- (void) testOffCanBeCalledWithoutHandle {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
__block BOOL called1 = NO;
|
|
__block BOOL called2 = NO;
|
|
FIRDatabaseQuery * query = [ref queryLimitedToLast:5];
|
|
[ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
called1 = YES;
|
|
}];
|
|
[query observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
called2 = YES;
|
|
}];
|
|
|
|
[ref setValue:@{@"a": @5, @"b": @6}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return called1 && called2;
|
|
}];
|
|
|
|
called1 = NO;
|
|
called2 = NO;
|
|
|
|
[ref removeAllObservers];
|
|
|
|
__block BOOL complete = NO;
|
|
[ref setValue:@{@"a": @6, @"b": @7} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
complete = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return complete;
|
|
}];
|
|
|
|
XCTAssertFalse(called1 || called2, @"Should not have called either callback");
|
|
}
|
|
|
|
- (void) testEnsureOnly5ItemsAreKept {
|
|
__block FIRDataSnapshot * snap = nil;
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
FIRDatabaseQuery * query = [ref queryLimitedToLast:5];
|
|
__block int count = 0;
|
|
[query observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
snap = snapshot;
|
|
count++;
|
|
}];
|
|
|
|
[ref setValue:nil];
|
|
for (int i = 0; i < 10; ++i) {
|
|
[[ref childByAutoId] setValue:[NSNumber numberWithInt:i]];
|
|
}
|
|
|
|
[self waitUntil:^BOOL{
|
|
// The initial set triggers the callback, so we need to wait for 11 events
|
|
return count == 11;
|
|
}];
|
|
|
|
count = 5;
|
|
for (FIRDataSnapshot * snapshot in snap.children) {
|
|
NSNumber* num = [snapshot value];
|
|
NSNumber* current = [NSNumber numberWithInt:count];
|
|
XCTAssertTrue([num isEqualToNumber:current], @"Expect children in order");
|
|
count++;
|
|
}
|
|
|
|
XCTAssertTrue(count == 10, @"Expected 5 children");
|
|
}
|
|
|
|
- (void) testOnlyLast5SentFromServer {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
__block int count = 0;
|
|
|
|
[ref setValue:nil];
|
|
|
|
for (int i = 0; i < 10; ++i) {
|
|
[[ref childByAutoId] setValue:[NSNumber numberWithInt:i] withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
count++;
|
|
}];
|
|
}
|
|
|
|
[self waitUntil:^BOOL{
|
|
return count == 10;
|
|
}];
|
|
|
|
FIRDatabaseQuery * query = [ref queryLimitedToLast:5];
|
|
count = 5;
|
|
[query observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
for (FIRDataSnapshot *child in snapshot.children) {
|
|
NSNumber *num = [child value];
|
|
NSNumber *current = [NSNumber numberWithInt:count];
|
|
XCTAssertTrue([num isEqualToNumber:current], @"Expect children to be in order");
|
|
count++;
|
|
}
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return count == 10;
|
|
}];
|
|
}
|
|
|
|
- (void) testVariousLimits {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
FTestExpectations* expectations = [[FTestExpectations alloc] initFrom:self];
|
|
|
|
[expectations addQuery:[ref queryLimitedToLast:1] withExpectation:@{@"c": @3}];
|
|
[expectations addQuery:[[[ref queryOrderedByPriority] queryEndingAtValue:nil] queryLimitedToLast:1] withExpectation:@{@"c": @3}];
|
|
[expectations addQuery:[[[ref queryOrderedByPriority] queryEndingAtValue:nil] queryLimitedToLast:2] withExpectation:@{@"b": @2, @"c": @3}];
|
|
[expectations addQuery:[[[ref queryOrderedByPriority] queryEndingAtValue:nil] queryLimitedToLast:3] withExpectation:@{@"a": @1, @"b": @2, @"c": @3}];
|
|
[expectations addQuery:[[[ref queryOrderedByPriority] queryEndingAtValue:nil] queryLimitedToLast:4] withExpectation:@{@"a": @1, @"b": @2, @"c": @3}];
|
|
|
|
|
|
__block BOOL ready = NO;
|
|
[ref setValue:@{@"a": @1, @"b": @2, @"c": @3} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
[expectations validate];
|
|
}
|
|
|
|
- (void) testSetLimitsWithStartAt {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
FTestExpectations* expectations = [[FTestExpectations alloc] initFrom:self];
|
|
|
|
[expectations addQuery:[[[ref queryOrderedByPriority] queryStartingAtValue:nil] queryLimitedToFirst:1] withExpectation:@{@"a": @1}];
|
|
[expectations addQuery:[[[ref queryOrderedByPriority] queryStartingAtValue:nil childKey:@"c"] queryLimitedToFirst:1] withExpectation:@{@"c": @3}];
|
|
[expectations addQuery:[[[ref queryOrderedByPriority] queryStartingAtValue:nil childKey:@"b"] queryLimitedToFirst:1] withExpectation:@{@"b": @2}];
|
|
[expectations addQuery:[[[ref queryOrderedByPriority] queryStartingAtValue:nil childKey:@"b"] queryLimitedToFirst:2] withExpectation:@{@"b": @2, @"c": @3}];
|
|
[expectations addQuery:[[[ref queryOrderedByPriority] queryStartingAtValue:nil childKey:@"b"] queryLimitedToFirst:3] withExpectation:@{@"b": @2, @"c": @3}];
|
|
|
|
|
|
__block BOOL ready = NO;
|
|
[ref setValue:@{@"a": @1, @"b": @2, @"c": @3} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
[expectations validate];
|
|
}
|
|
|
|
- (void) testLimitsAndStartAtWithServerData {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
__block BOOL ready = NO;
|
|
[ref setValue:@{@"a": @1, @"b": @2, @"c": @3} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
FTestExpectations* expectations = [[FTestExpectations alloc] initFrom:self];
|
|
|
|
[expectations addQuery:[[[ref queryOrderedByPriority] queryStartingAtValue:nil] queryLimitedToFirst:1] withExpectation:@{@"a": @1}];
|
|
|
|
/*params = [[FQueryParams alloc] init];
|
|
params = [params setStartPriority:nil andName:@"c"];
|
|
params = [params limitTo:1];
|
|
[expectations addQuery:[ref queryWithParams:params] withExpectation:@{@"c": @3}];
|
|
|
|
params = [[FQueryParams alloc] init];
|
|
params = [params setStartPriority:nil andName:@"b"];
|
|
params = [params limitTo:1];
|
|
[expectations addQuery:[ref queryWithParams:params] withExpectation:@{@"b": @2}];
|
|
|
|
params = [[FQueryParams alloc] init];
|
|
params = [params setStartPriority:nil andName:@"b"];
|
|
params = [params limitTo:2];
|
|
[expectations addQuery:[ref queryWithParams:params] withExpectation:@{@"b": @2, @"c": @3}];
|
|
|
|
params = [[FQueryParams alloc] init];
|
|
params = [params setStartPriority:nil andName:@"b"];
|
|
params = [params limitTo:3];
|
|
[expectations addQuery:[ref queryWithParams:params] withExpectation:@{@"b": @2, @"c": @3}];*/
|
|
|
|
[self waitUntil:^BOOL{
|
|
return expectations.isReady;
|
|
}];
|
|
[expectations validate];
|
|
[ref removeAllObservers];
|
|
}
|
|
|
|
- (void) testChildEventsAreFiredWhenLimitIsHit {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
NSMutableArray* added = [[NSMutableArray alloc] init];
|
|
NSMutableArray* removed = [[NSMutableArray alloc] init];
|
|
[[ref queryLimitedToLast:2] observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
|
|
|
|
[added addObject:[snapshot key]];
|
|
}];
|
|
[[ref queryLimitedToLast:2] observeEventType:FIRDataEventTypeChildRemoved withBlock:^(FIRDataSnapshot *snapshot) {
|
|
|
|
[removed addObject:[snapshot key]];
|
|
}];
|
|
|
|
__block BOOL ready = NO;
|
|
[ref setValue:@{@"a": @1, @"b": @2, @"c": @3} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
XCTAssertTrue([removed count] == 0, @"Nothing should be removed from our window");
|
|
NSArray* expected = @[@"b", @"c"];
|
|
XCTAssertTrue([added isEqualToArray:expected], @"Should have two items");
|
|
|
|
[added removeAllObjects];
|
|
ready = NO;
|
|
[[ref child:@"d"] setValue:@4 withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
expected = @[@"b"];
|
|
XCTAssertTrue([removed isEqualToArray:expected], @"Expected to remove b");
|
|
expected = @[@"d"];
|
|
XCTAssertTrue([added isEqualToArray:expected], @"Expected to add d");
|
|
[ref removeAllObservers];
|
|
}
|
|
|
|
- (void) testChildEventsAreFiredWhenLimitIsHitWithServerData {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
__block BOOL ready = NO;
|
|
[ref setValue:@{@"a": @1, @"b": @2, @"c": @3} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
NSMutableArray* added = [[NSMutableArray alloc] init];
|
|
NSMutableArray* removed = [[NSMutableArray alloc] init];
|
|
FIRDatabaseQuery * query = [ref queryLimitedToLast:2];
|
|
[query observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
|
|
|
|
[added addObject:[snapshot key]];
|
|
}];
|
|
[query observeEventType:FIRDataEventTypeChildRemoved withBlock:^(FIRDataSnapshot *snapshot) {
|
|
|
|
[removed addObject:[snapshot key]];
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return [added count] == 2;
|
|
}];
|
|
|
|
XCTAssertTrue([removed count] == 0, @"Nothing should be removed from our window");
|
|
NSArray* expected = @[@"b", @"c"];
|
|
XCTAssertTrue([added isEqualToArray:expected], @"Should have two items");
|
|
|
|
[added removeAllObjects];
|
|
ready = NO;
|
|
[[ref child:@"d"] setValue:@4 withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
expected = @[@"b"];
|
|
XCTAssertTrue([removed isEqualToArray:expected], @"Expected to remove b");
|
|
expected = @[@"d"];
|
|
XCTAssertTrue([added isEqualToArray:expected], @"Expected to add d");
|
|
[ref removeAllObservers];
|
|
}
|
|
|
|
- (void) testChildEventsAreFiredWhenLimitIsHitWithStart {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
FIRDatabaseQuery * query = [[[ref queryOrderedByPriority] queryStartingAtValue:nil childKey:@"a"] queryLimitedToFirst:2];
|
|
|
|
NSMutableArray* added = [[NSMutableArray alloc] init];
|
|
NSMutableArray* removed = [[NSMutableArray alloc] init];
|
|
[query observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
|
|
|
|
[added addObject:[snapshot key]];
|
|
}];
|
|
[query observeEventType:FIRDataEventTypeChildRemoved withBlock:^(FIRDataSnapshot *snapshot) {
|
|
|
|
[removed addObject:[snapshot key]];
|
|
}];
|
|
|
|
__block BOOL ready = NO;
|
|
[ref setValue:@{@"a": @1, @"b": @2, @"c": @3} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
XCTAssertTrue([removed count] == 0, @"Nothing should be removed from our window");
|
|
NSArray* expected = @[@"a", @"b"];
|
|
XCTAssertTrue([added isEqualToArray:expected], @"Should have two items");
|
|
|
|
[added removeAllObjects];
|
|
ready = NO;
|
|
[[ref child:@"aa"] setValue:@4 withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
expected = @[@"b"];
|
|
XCTAssertTrue([removed isEqualToArray:expected], @"Expected to remove b");
|
|
expected = @[@"aa"];
|
|
XCTAssertTrue([added isEqualToArray:expected], @"Expected to add aa");
|
|
[ref removeAllObservers];
|
|
}
|
|
|
|
- (void) testChildEventsAreFiredWhenLimitIsHitWithStartAndServerData {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
__block BOOL ready = NO;
|
|
[ref setValue:@{@"a": @1, @"b": @2, @"c": @3} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
FIRDatabaseQuery * query = [[[ref queryOrderedByPriority] queryStartingAtValue:nil childKey:@"a"] queryLimitedToFirst:2];
|
|
NSMutableArray* added = [[NSMutableArray alloc] init];
|
|
NSMutableArray* removed = [[NSMutableArray alloc] init];
|
|
[query observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
|
|
|
|
[added addObject:[snapshot key]];
|
|
}];
|
|
[query observeEventType:FIRDataEventTypeChildRemoved withBlock:^(FIRDataSnapshot *snapshot) {
|
|
|
|
[removed addObject:[snapshot key]];
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return [added count] == 2;
|
|
}];
|
|
|
|
XCTAssertTrue([removed count] == 0, @"Nothing should be removed from our window");
|
|
NSArray* expected = @[@"a", @"b"];
|
|
XCTAssertTrue([added isEqualToArray:expected], @"Should have two items");
|
|
|
|
[added removeAllObjects];
|
|
ready = NO;
|
|
[[ref child:@"aa"] setValue:@4 withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
expected = @[@"b"];
|
|
XCTAssertTrue([removed isEqualToArray:expected], @"Expected to remove b");
|
|
expected = @[@"aa"];
|
|
XCTAssertTrue([added isEqualToArray:expected], @"Expected to add aa");
|
|
[ref removeAllObservers];
|
|
}
|
|
|
|
- (void) testStartAndLimitWithIncompleteWindow {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
FIRDatabaseQuery * query = [[[ref queryOrderedByPriority] queryStartingAtValue:nil childKey:@"a"] queryLimitedToFirst:2];
|
|
NSMutableArray* added = [[NSMutableArray alloc] init];
|
|
NSMutableArray* removed = [[NSMutableArray alloc] init];
|
|
[query observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
|
|
[added addObject:[snapshot key]];
|
|
}];
|
|
[query observeEventType:FIRDataEventTypeChildRemoved withBlock:^(FIRDataSnapshot *snapshot) {
|
|
|
|
[removed addObject:[snapshot key]];
|
|
}];
|
|
|
|
__block BOOL ready = NO;
|
|
[ref setValue:@{@"c": @3} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready && [added count] >= 1;
|
|
}];
|
|
|
|
XCTAssertTrue([removed count] == 0, @"Nothing should be removed from our window");
|
|
NSArray* expected = @[@"c"];
|
|
XCTAssertTrue([added isEqualToArray:expected], @"Should have one item");
|
|
|
|
[added removeAllObjects];
|
|
ready = NO;
|
|
[[ref child:@"b"] setValue:@4 withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
XCTAssertTrue([removed count] == 0, @"Expected to remove nothing");
|
|
expected = @[@"b"];
|
|
XCTAssertTrue([added isEqualToArray:expected], @"Expected to add b");
|
|
[ref removeAllObservers];
|
|
}
|
|
|
|
- (void) testStartAndLimitWithIncompleteWindowAndServerData {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
__block BOOL ready = NO;
|
|
[ref setValue:@{@"c": @3} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
FIRDatabaseQuery * query = [[[ref queryOrderedByPriority] queryStartingAtValue:nil childKey:@"a"] queryLimitedToFirst:2];
|
|
|
|
NSMutableArray* added = [[NSMutableArray alloc] init];
|
|
NSMutableArray* removed = [[NSMutableArray alloc] init];
|
|
[query observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
|
|
|
|
[added addObject:[snapshot key]];
|
|
}];
|
|
[query observeEventType:FIRDataEventTypeChildRemoved withBlock:^(FIRDataSnapshot *snapshot) {
|
|
|
|
[removed addObject:[snapshot key]];
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return [added count] == 1;
|
|
}];
|
|
|
|
XCTAssertTrue([removed count] == 0, @"Nothing should be removed from our window");
|
|
NSArray* expected = @[@"c"];
|
|
XCTAssertTrue([added isEqualToArray:expected], @"Should have one item");
|
|
|
|
[added removeAllObjects];
|
|
ready = NO;
|
|
[[ref child:@"b"] setValue:@4 withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
XCTAssertTrue([removed count] == 0, @"Expected to remove nothing");
|
|
expected = @[@"b"];
|
|
XCTAssertTrue([added isEqualToArray:expected], @"Expected to add b");
|
|
[ref removeAllObservers];
|
|
}
|
|
|
|
- (void) testChildEventsFiredWhenItemDeleted {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
FIRDatabaseQuery * query = [ref queryLimitedToLast:2];
|
|
|
|
NSMutableArray* added = [[NSMutableArray alloc] init];
|
|
NSMutableArray* removed = [[NSMutableArray alloc] init];
|
|
[query observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
|
|
[added addObject:[snapshot key]];
|
|
}];
|
|
[query observeEventType:FIRDataEventTypeChildRemoved withBlock:^(FIRDataSnapshot *snapshot) {
|
|
|
|
[removed addObject:[snapshot key]];
|
|
}];
|
|
|
|
__block BOOL ready = NO;
|
|
[ref setValue:@{@"a": @1, @"b": @2, @"c": @3} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready && [added count] >= 1;
|
|
}];
|
|
|
|
XCTAssertTrue([removed count] == 0, @"Nothing should be removed from our window");
|
|
NSArray* expected = @[@"b", @"c"];
|
|
XCTAssertTrue([added isEqualToArray:expected], @"Should have one item");
|
|
|
|
[added removeAllObjects];
|
|
ready = NO;
|
|
[[ref child:@"b"] removeValueWithCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
expected = @[@"b"];
|
|
XCTAssertTrue([removed isEqualToArray:expected], @"Expected to remove b");
|
|
expected = @[@"a"];
|
|
XCTAssertTrue([added isEqualToArray:expected], @"Expected to add a");
|
|
[ref removeAllObservers];
|
|
}
|
|
|
|
-(void) testChildEventsAreFiredWhenItemDeletedAtServer {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNodeWithoutPersistence];
|
|
|
|
__block BOOL ready = NO;
|
|
[ref setValue:@{@"a": @1, @"b": @2, @"c": @3} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
FIRDatabaseQuery * query = [ref queryLimitedToLast:2];
|
|
|
|
NSMutableArray* added = [[NSMutableArray alloc] init];
|
|
NSMutableArray* removed = [[NSMutableArray alloc] init];
|
|
[query observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
|
|
|
|
[added addObject:[snapshot key]];
|
|
}];
|
|
[query observeEventType:FIRDataEventTypeChildRemoved withBlock:^(FIRDataSnapshot *snapshot) {
|
|
|
|
[removed addObject:[snapshot key]];
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return [added count] == 2;
|
|
}];
|
|
|
|
XCTAssertTrue([removed count] == 0, @"Nothing should be removed from our window");
|
|
NSArray* expected = @[@"b", @"c"];
|
|
XCTAssertTrue([added isEqualToArray:expected], @"Should have two items");
|
|
|
|
[added removeAllObjects];
|
|
ready = NO;
|
|
[[ref child:@"b"] removeValueWithCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
XCTAssertEqualObjects(removed, (@[@"b"]), @"Expected to remove b");
|
|
XCTAssertEqualObjects(added, (@[@"a"]), @"Expected to add a");
|
|
[ref removeAllObservers];
|
|
}
|
|
|
|
- (void) testRemoveFiredWhenItemDeleted {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
FIRDatabaseQuery * query = [ref queryLimitedToLast:2];
|
|
NSMutableArray* added = [[NSMutableArray alloc] init];
|
|
NSMutableArray* removed = [[NSMutableArray alloc] init];
|
|
[query observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
|
|
[added addObject:[snapshot key]];
|
|
}];
|
|
[query observeEventType:FIRDataEventTypeChildRemoved withBlock:^(FIRDataSnapshot *snapshot) {
|
|
|
|
[removed addObject:[snapshot key]];
|
|
}];
|
|
|
|
__block BOOL ready = NO;
|
|
[ref setValue:@{@"b": @2, @"c": @3} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready && [added count] >= 1;
|
|
}];
|
|
|
|
XCTAssertTrue([removed count] == 0, @"Nothing should be removed from our window");
|
|
NSArray* expected = @[@"b", @"c"];
|
|
XCTAssertTrue([added isEqualToArray:expected], @"Should have one item");
|
|
|
|
[added removeAllObjects];
|
|
ready = NO;
|
|
[[ref child:@"b"] removeValueWithCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
expected = @[@"b"];
|
|
XCTAssertTrue([removed isEqualToArray:expected], @"Expected to remove b");
|
|
XCTAssertTrue([added count] == 0, @"Expected to add nothing");
|
|
[ref removeAllObservers];
|
|
}
|
|
|
|
-(void) testRemoveFiredWhenItemDeletedAtServer {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
__block BOOL ready = NO;
|
|
[ref setValue:@{@"b": @2, @"c": @3} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
FIRDatabaseQuery * query = [ref queryLimitedToLast:2];
|
|
|
|
NSMutableArray* added = [[NSMutableArray alloc] init];
|
|
NSMutableArray* removed = [[NSMutableArray alloc] init];
|
|
[query observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
|
|
|
|
[added addObject:[snapshot key]];
|
|
}];
|
|
[query observeEventType:FIRDataEventTypeChildRemoved withBlock:^(FIRDataSnapshot *snapshot) {
|
|
|
|
[removed addObject:[snapshot key]];
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return [added count] == 2;
|
|
}];
|
|
|
|
XCTAssertTrue([removed count] == 0, @"Nothing should be removed from our window");
|
|
NSArray* expected = @[@"b", @"c"];
|
|
XCTAssertTrue([added isEqualToArray:expected], @"Should have two items");
|
|
|
|
[added removeAllObjects];
|
|
ready = NO;
|
|
[[ref child:@"b"] removeValueWithCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
expected = @[@"b"];
|
|
XCTAssertTrue([removed isEqualToArray:expected], @"Expected to remove b");
|
|
XCTAssertTrue([added count] == 0, @"Expected to add nothing");
|
|
[ref removeAllObservers];
|
|
}
|
|
|
|
- (void) testStartAtPriorityAndEndAtPriorityWork {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
FTestExpectations* expectations = [[FTestExpectations alloc] initFrom:self];
|
|
|
|
[expectations addQuery:[[[ref queryOrderedByPriority] queryStartingAtValue:@"w"] queryEndingAtValue:@"y"] withExpectation:@{@"b": @2, @"c": @3, @"d": @4}];
|
|
[expectations addQuery:[[[ref queryOrderedByPriority] queryStartingAtValue:@"w"] queryEndingAtValue:@"w"] withExpectation:@{@"d": @4}];
|
|
|
|
__block id nullSnap = @"dummy";
|
|
[[[[ref queryOrderedByPriority] queryStartingAtValue:@"a"] queryEndingAtValue:@"c"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
nullSnap = [snapshot value];
|
|
}];
|
|
|
|
[ref setValue:@{
|
|
@"a": @{@".value": @1, @".priority": @"z"},
|
|
@"b": @{@".value": @2, @".priority": @"y"},
|
|
@"c": @{@".value": @3, @".priority": @"x"},
|
|
@"d": @{@".value": @4, @".priority": @"w"}
|
|
}];
|
|
|
|
WAIT_FOR(expectations.isReady && [nullSnap isEqual:[NSNull null]]);
|
|
|
|
[expectations validate];
|
|
}
|
|
|
|
- (void) testStartAtPriorityAndEndAtPriorityWorkWithServerData {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
__block BOOL ready = NO;
|
|
[ref setValue:@{
|
|
@"a": @{@".value": @1, @".priority": @"z"},
|
|
@"b": @{@".value": @2, @".priority": @"y"},
|
|
@"c": @{@".value": @3, @".priority": @"x"},
|
|
@"d": @{@".value": @4, @".priority": @"w"}
|
|
} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
WAIT_FOR(ready);
|
|
|
|
FTestExpectations* expectations = [[FTestExpectations alloc] initFrom:self];
|
|
|
|
[expectations addQuery:[[[ref queryOrderedByPriority] queryStartingAtValue:@"w"] queryEndingAtValue:@"y"] withExpectation:@{@"b": @2, @"c": @3, @"d": @4}];
|
|
[expectations addQuery:[[[ref queryOrderedByPriority] queryStartingAtValue:@"w"] queryEndingAtValue:@"w"] withExpectation:@{@"d": @4}];
|
|
|
|
__block id nullSnap = @"dummy";
|
|
[[[[ref queryOrderedByPriority] queryStartingAtValue:@"a"] queryEndingAtValue:@"c"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
nullSnap = [snapshot value];
|
|
}];
|
|
|
|
WAIT_FOR(expectations.isReady && [nullSnap isEqual:[NSNull null]]);
|
|
|
|
[expectations validate];
|
|
}
|
|
|
|
- (void) testStartAtAndEndAtPriorityAndNameWork {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
FTestExpectations* expectations = [[FTestExpectations alloc] initFrom:self];
|
|
|
|
FIRDatabaseQuery * query = [[[ref queryOrderedByPriority] queryStartingAtValue:@1 childKey:@"a"] queryEndingAtValue:@2 childKey:@"d"];
|
|
[expectations addQuery:query withExpectation:@{@"a": @1, @"b": @2, @"c": @3, @"d": @4}];
|
|
|
|
query = [[[ref queryOrderedByPriority] queryStartingAtValue:@1 childKey:@"b"] queryEndingAtValue:@2 childKey:@"c"];
|
|
[expectations addQuery:query withExpectation:@{@"b": @2, @"c": @3}];
|
|
|
|
query = [[[ref queryOrderedByPriority] queryStartingAtValue:@1 childKey:@"c"] queryEndingAtValue:@2];
|
|
[expectations addQuery:query withExpectation:@{@"c": @3, @"d": @4}];
|
|
|
|
[ref setValue:@{
|
|
@"a": @{@".value": @1, @".priority": @1},
|
|
@"b": @{@".value": @2, @".priority": @1},
|
|
@"c": @{@".value": @3, @".priority": @2},
|
|
@"d": @{@".value": @4, @".priority": @2}
|
|
}];
|
|
|
|
WAIT_FOR(expectations.isReady);
|
|
|
|
[expectations validate];
|
|
}
|
|
|
|
- (void) testStartAtAndEndAtPriorityAndNameWorkWithServerData {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
__block BOOL ready = NO;
|
|
[ref setValue:@{
|
|
@"a": @{@".value": @1, @".priority": @1},
|
|
@"b": @{@".value": @2, @".priority": @1},
|
|
@"c": @{@".value": @3, @".priority": @2},
|
|
@"d": @{@".value": @4, @".priority": @2}
|
|
} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
WAIT_FOR(ready);
|
|
|
|
FTestExpectations* expectations = [[FTestExpectations alloc] initFrom:self];
|
|
|
|
FIRDatabaseQuery * query = [[[ref queryOrderedByPriority] queryStartingAtValue:@1 childKey:@"a"] queryEndingAtValue:@2 childKey:@"d"];
|
|
[expectations addQuery:query withExpectation:@{@"a": @1, @"b": @2, @"c": @3, @"d": @4}];
|
|
|
|
query = [[[ref queryOrderedByPriority] queryStartingAtValue:@1 childKey:@"b"] queryEndingAtValue:@2 childKey:@"c"];
|
|
[expectations addQuery:query withExpectation:@{@"b": @2, @"c": @3}];
|
|
|
|
query = [[[ref queryOrderedByPriority] queryStartingAtValue:@1 childKey:@"c"] queryEndingAtValue:@2];
|
|
[expectations addQuery:query withExpectation:@{@"c": @3, @"d": @4}];
|
|
|
|
WAIT_FOR(expectations.isReady);
|
|
|
|
[expectations validate];
|
|
}
|
|
|
|
- (void) testStartAtAndEndAtPriorityAndNameWork2 {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
FTestExpectations* expectations = [[FTestExpectations alloc] initFrom:self];
|
|
|
|
FIRDatabaseQuery * query = [[[ref queryOrderedByPriority] queryStartingAtValue:@1 childKey:@"c"] queryEndingAtValue:@2 childKey:@"b"];
|
|
[expectations addQuery:query withExpectation:@{@"a": @1, @"b": @2, @"c": @3, @"d": @4}];
|
|
|
|
query = [[[ref queryOrderedByPriority] queryStartingAtValue:@1 childKey:@"d"] queryEndingAtValue:@2 childKey:@"a"];
|
|
[expectations addQuery:query withExpectation:@{@"d": @4, @"a": @1}];
|
|
|
|
query = [[[ref queryOrderedByPriority] queryStartingAtValue:@1 childKey:@"e"] queryEndingAtValue:@2];
|
|
[expectations addQuery:query withExpectation:@{@"a": @1, @"b": @2}];
|
|
|
|
[ref setValue:@{
|
|
@"c": @{@".value": @3, @".priority": @1},
|
|
@"d": @{@".value": @4, @".priority": @1},
|
|
@"a": @{@".value": @1, @".priority": @2},
|
|
@"b": @{@".value": @2, @".priority": @2}
|
|
}];
|
|
|
|
WAIT_FOR(expectations.isReady);
|
|
|
|
[expectations validate];
|
|
}
|
|
|
|
- (void) testStartAtAndEndAtPriorityAndNameWorkWithServerData2 {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
__block BOOL ready = NO;
|
|
[ref setValue:@{
|
|
@"c": @{@".value": @3, @".priority": @1},
|
|
@"d": @{@".value": @4, @".priority": @1},
|
|
@"a": @{@".value": @1, @".priority": @2},
|
|
@"b": @{@".value": @2, @".priority": @2}
|
|
} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
WAIT_FOR(ready);
|
|
|
|
FTestExpectations* expectations = [[FTestExpectations alloc] initFrom:self];
|
|
|
|
FIRDatabaseQuery * query = [[[ref queryOrderedByPriority] queryStartingAtValue:@1 childKey:@"c"] queryEndingAtValue:@2 childKey:@"b"];
|
|
[expectations addQuery:query withExpectation:@{@"a": @1, @"b": @2, @"c": @3, @"d": @4}];
|
|
|
|
query = [[[ref queryOrderedByPriority] queryStartingAtValue:@1 childKey:@"d"] queryEndingAtValue:@2 childKey:@"a"];
|
|
[expectations addQuery:query withExpectation:@{@"d": @4, @"a": @1}];
|
|
|
|
query = [[[ref queryOrderedByPriority] queryStartingAtValue:@1 childKey:@"e"] queryEndingAtValue:@2];
|
|
[expectations addQuery:query withExpectation:@{@"a": @1, @"b": @2}];
|
|
|
|
WAIT_FOR(expectations.isReady);
|
|
|
|
[expectations validate];
|
|
}
|
|
|
|
- (void) testEqualToPriorityWorks {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
FTestExpectations* expectations = [[FTestExpectations alloc] initFrom:self];
|
|
|
|
[expectations addQuery:[[ref queryOrderedByPriority] queryEqualToValue:@"w"] withExpectation:@{@"d": @4}];
|
|
|
|
__block id nullSnap = @"dummy";
|
|
[[[ref queryOrderedByPriority] queryEqualToValue:@"c"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
nullSnap = [snapshot value];
|
|
}];
|
|
|
|
[ref setValue:@{
|
|
@"a": @{@".value": @1, @".priority": @"z"},
|
|
@"b": @{@".value": @2, @".priority": @"y"},
|
|
@"c": @{@".value": @3, @".priority": @"x"},
|
|
@"d": @{@".value": @4, @".priority": @"w"}
|
|
}];
|
|
|
|
WAIT_FOR(expectations.isReady && [nullSnap isEqual:[NSNull null]]);
|
|
|
|
[expectations validate];
|
|
}
|
|
|
|
- (void) testEqualToPriorityWorksWithServerData {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
__block BOOL ready = NO;
|
|
[ref setValue:@{
|
|
@"a": @{@".value": @1, @".priority": @"z"},
|
|
@"b": @{@".value": @2, @".priority": @"y"},
|
|
@"c": @{@".value": @3, @".priority": @"x"},
|
|
@"d": @{@".value": @4, @".priority": @"w"}
|
|
} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
WAIT_FOR(ready);
|
|
|
|
FTestExpectations* expectations = [[FTestExpectations alloc] initFrom:self];
|
|
|
|
[expectations addQuery:[[ref queryOrderedByPriority] queryEqualToValue:@"w"] withExpectation:@{@"d": @4}];
|
|
|
|
__block id nullSnap = @"dummy";
|
|
[[[ref queryOrderedByPriority] queryEqualToValue:@"c"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
nullSnap = [snapshot value];
|
|
}];
|
|
|
|
WAIT_FOR(expectations.isReady && [nullSnap isEqual:[NSNull null]]);
|
|
|
|
[expectations validate];
|
|
}
|
|
|
|
- (void) testEqualToPriorityAndNameWorks {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
FTestExpectations* expectations = [[FTestExpectations alloc] initFrom:self];
|
|
|
|
FIRDatabaseQuery * query = [[ref queryOrderedByPriority] queryEqualToValue:@1 childKey:@"a"];
|
|
[expectations addQuery:query withExpectation:@{@"a": @1}];
|
|
|
|
__block id nullSnap = @"dummy";
|
|
[[[ref queryOrderedByPriority] queryEqualToValue:@"1" childKey:@"z"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
nullSnap = [snapshot value];
|
|
}];
|
|
|
|
[ref setValue:@{
|
|
@"a": @{@".value": @1, @".priority": @1},
|
|
@"b": @{@".value": @2, @".priority": @1},
|
|
@"c": @{@".value": @3, @".priority": @2},
|
|
@"d": @{@".value": @4, @".priority": @2}
|
|
}];
|
|
|
|
WAIT_FOR(expectations.isReady && [nullSnap isEqual:[NSNull null]]);
|
|
|
|
[expectations validate];
|
|
}
|
|
|
|
- (void) testEqualToPriorityAndNameWorksWithServerData {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
__block BOOL ready = NO;
|
|
[ref setValue:@{
|
|
@"a": @{@".value": @1, @".priority": @1},
|
|
@"b": @{@".value": @2, @".priority": @1},
|
|
@"c": @{@".value": @3, @".priority": @2},
|
|
@"d": @{@".value": @4, @".priority": @2}
|
|
} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
WAIT_FOR(ready);
|
|
|
|
FTestExpectations* expectations = [[FTestExpectations alloc] initFrom:self];
|
|
|
|
FIRDatabaseQuery * query = [[ref queryOrderedByPriority] queryEqualToValue:@1 childKey:@"a"];
|
|
[expectations addQuery:query withExpectation:@{@"a": @1}];
|
|
|
|
__block id nullSnap = @"dummy";
|
|
[[[ref queryOrderedByPriority] queryEqualToValue:@"1" childKey:@"z"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
nullSnap = [snapshot value];
|
|
}];
|
|
|
|
WAIT_FOR(expectations.isReady && [nullSnap isEqual:[NSNull null]]);
|
|
|
|
[expectations validate];
|
|
}
|
|
|
|
- (void) testPrevNameWorks {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
NSMutableArray* added = [[NSMutableArray alloc] init];
|
|
|
|
[[ref queryLimitedToLast:2] observeEventType:FIRDataEventTypeChildAdded andPreviousSiblingKeyWithBlock:^(FIRDataSnapshot *snapshot, NSString *prevName) {
|
|
[added addObject:snapshot.key];
|
|
if (prevName) {
|
|
[added addObject:prevName];
|
|
} else {
|
|
[added addObject:@"null"];
|
|
}
|
|
|
|
}];
|
|
|
|
[[ref child:@"a"] setValue:@1];
|
|
[self waitUntil:^BOOL{
|
|
NSArray* expected = @[@"a", @"null"];
|
|
return [added isEqualToArray:expected];
|
|
}];
|
|
|
|
[added removeAllObjects];
|
|
|
|
[[ref child:@"c"] setValue:@3];
|
|
[self waitUntil:^BOOL{
|
|
NSArray* expected = @[@"c", @"a"];
|
|
return [added isEqualToArray:expected];
|
|
}];
|
|
|
|
[added removeAllObjects];
|
|
|
|
[[ref child:@"b"] setValue:@2];
|
|
[self waitUntil:^BOOL{
|
|
NSArray* expected = @[@"b", @"null"];
|
|
return [added isEqualToArray:expected];
|
|
}];
|
|
|
|
[added removeAllObjects];
|
|
|
|
[[ref child:@"d"] setValue:@3];
|
|
[self waitUntil:^BOOL{
|
|
NSArray* expected = @[@"d", @"c"];
|
|
return [added isEqualToArray:expected];
|
|
}];
|
|
}
|
|
|
|
// Dropping some of the server data tests here, around prevName. They don't really test anything new, and mostly don't even test server data
|
|
|
|
- (void) testPrevNameWorksWithMoves {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
NSMutableArray* moved = [[NSMutableArray alloc] init];
|
|
|
|
[[ref queryLimitedToLast:2] observeEventType:FIRDataEventTypeChildMoved andPreviousSiblingKeyWithBlock:^(FIRDataSnapshot *snapshot, NSString *prevName) {
|
|
[moved addObject:snapshot.key];
|
|
if (prevName) {
|
|
[moved addObject:prevName];
|
|
} else {
|
|
[moved addObject:@"null"];
|
|
}
|
|
}];
|
|
|
|
[ref setValue:@{
|
|
@"a": @{@".value": @"a", @".priority": @10},
|
|
@"b": @{@".value": @"b", @".priority": @20},
|
|
@"c": @{@".value": @"c", @".priority": @30},
|
|
@"d": @{@".value": @"d", @".priority": @40}
|
|
}];
|
|
|
|
__block BOOL ready = NO;
|
|
[[ref child:@"c"] setPriority:@50 withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
NSArray* expected = @[@"c", @"d"];
|
|
XCTAssertTrue([moved isEqualToArray:expected], @"Expected changed node and prevChild");
|
|
|
|
[moved removeAllObjects];
|
|
ready = NO;
|
|
[[ref child:@"c"] setPriority:@35 withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
expected = @[@"c", @"null"];
|
|
XCTAssertTrue([moved isEqualToArray:expected], @"Expected changed node and prevChild");
|
|
|
|
[moved removeAllObjects];
|
|
ready = NO;
|
|
[[ref child:@"b"] setPriority:@33 withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
expected = @[];
|
|
XCTAssertTrue([moved isEqualToArray:expected], @"Expected changed node and prevChild to be empty");
|
|
}
|
|
|
|
- (void) testLocalEvents {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
NSMutableArray* events = [[NSMutableArray alloc] init];
|
|
[[ref queryLimitedToLast:2] observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
|
|
NSString *eventString = [NSString stringWithFormat:@"%@ added", [snapshot value]];
|
|
[events addObject:eventString];
|
|
}];
|
|
|
|
[[ref queryLimitedToLast:2] observeEventType:FIRDataEventTypeChildRemoved withBlock:^(FIRDataSnapshot *snapshot) {
|
|
NSString *eventString = [NSString stringWithFormat:@"%@ removed", [snapshot value]];
|
|
[events addObject:eventString];
|
|
}];
|
|
|
|
__block BOOL ready = NO;
|
|
for (int i = 0; i < 5; ++i) {
|
|
[[ref childByAutoId] setValue:[NSNumber numberWithInt:i] withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
if (i == 4) {
|
|
ready = YES;
|
|
}
|
|
}];
|
|
}
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
NSArray* expected = @[@"0 added", @"1 added", @"0 removed", @"2 added", @"1 removed", @"3 added", @"2 removed", @"4 added"];
|
|
XCTAssertTrue([events isEqualToArray:expected], @"Expecting window to stay at two nodes");
|
|
}
|
|
|
|
- (void) testRemoteEvents {
|
|
FTupleFirebase* pair = [FTestHelpers getRandomNodePair];
|
|
FIRDatabaseReference * writer = pair.one;
|
|
FIRDatabaseReference * reader = pair.two;
|
|
|
|
NSMutableArray* events = [[NSMutableArray alloc] init];
|
|
|
|
[[reader queryLimitedToLast:2] observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
|
|
NSString *eventString = [NSString stringWithFormat:@"%@ added", [snapshot value]];
|
|
[events addObject:eventString];
|
|
}];
|
|
|
|
[[reader queryLimitedToLast:2] observeEventType:FIRDataEventTypeChildRemoved withBlock:^(FIRDataSnapshot *snapshot) {
|
|
NSString *oldEventString = [NSString stringWithFormat:@"%@ added", [snapshot value]];
|
|
[events removeObject:oldEventString];
|
|
}];
|
|
|
|
for (int i = 0; i < 5; ++i) {
|
|
[[writer childByAutoId] setValue:[NSNumber numberWithInt:i]];
|
|
}
|
|
|
|
NSArray* expected = @[@"3 added", @"4 added"];
|
|
[self waitUntil:^BOOL{
|
|
return [events isEqualToArray:expected];
|
|
}];
|
|
}
|
|
|
|
- (void) testLimitOnEmptyNodeFiresValue {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
__block BOOL ready = NO;
|
|
[[ref queryLimitedToLast:1] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
}
|
|
|
|
- (void) testFilteringToNullPriorities {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
// Note: cannot set nil in a dictionary, just leave out priority
|
|
[ref setValue:@{
|
|
@"a": @0,
|
|
@"b": @1,
|
|
@"c": @{@".priority": @2, @".value": @2},
|
|
@"d": @{@".priority": @3, @".value": @3},
|
|
@"e": @{@".priority": @"hi", @".value": @4}
|
|
}];
|
|
|
|
__block BOOL ready = NO;
|
|
[[[[ref queryOrderedByPriority] queryStartingAtValue:nil] queryEndingAtValue:nil] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
NSDictionary *expected = @{@"a" : @0, @"b" : @1};
|
|
NSDictionary *val = [snapshot value];
|
|
XCTAssertTrue([val isEqualToDictionary:expected], @"Expected only null priority keys");
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
}
|
|
|
|
- (void) testNullPrioritiesIncludedInEndAt {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
// Note: cannot set nil in a dictionary, just leave out priority
|
|
[ref setValue:@{
|
|
@"a": @0,
|
|
@"b": @1,
|
|
@"c": @{@".priority": @2, @".value": @2},
|
|
@"d": @{@".priority": @3, @".value": @3},
|
|
@"e": @{@".priority": @"hi", @".value": @4}
|
|
}];
|
|
|
|
__block BOOL ready = NO;
|
|
[[[ref queryOrderedByPriority] queryEndingAtValue:@2] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
NSDictionary *expected = @{@"a" : @0, @"b" : @1, @"c" : @2};
|
|
NSDictionary *val = [snapshot value];
|
|
XCTAssertTrue([val isEqualToDictionary:expected], @"Expected up to priority 2");
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
}
|
|
|
|
- (NSSet *) dumpListensForRef:(FIRDatabaseReference *)ref {
|
|
NSMutableSet* dumpPieces = [[NSMutableSet alloc] init];
|
|
NSDictionary* listens = [ref.repo dumpListens];
|
|
|
|
FPath* nodePath = ref.path;
|
|
[listens enumerateKeysAndObjectsUsingBlock:^(FQuerySpec *spec, id obj, BOOL *stop) {
|
|
if ([nodePath contains:spec.path]) {
|
|
FPath *relative = [FPath relativePathFrom:nodePath to:spec.path];
|
|
[dumpPieces addObject:[[FQuerySpec alloc] initWithPath:relative params:spec.params]];
|
|
}
|
|
}];
|
|
|
|
return dumpPieces;
|
|
}
|
|
|
|
- (NSSet *) expectDefaultListenerAtPath:(FPath *)path {
|
|
return [self expectParams:[FQueryParams defaultInstance] atPath:path];
|
|
}
|
|
|
|
- (NSSet *) expectParamssetValue:(NSSet *)paramsSet atPath:(FPath *)path {
|
|
NSMutableSet *all = [NSMutableSet set];
|
|
[paramsSet enumerateObjectsUsingBlock:^(FQueryParams *params, BOOL *stop) {
|
|
[all addObject:[[FQuerySpec alloc] initWithPath:path params:params]];
|
|
}];
|
|
return all;
|
|
}
|
|
|
|
- (NSSet *) expectParams:(FQueryParams *)params atPath:(FPath *)path {
|
|
return [self expectParamssetValue:[NSSet setWithObject:params] atPath:path];
|
|
}
|
|
|
|
- (void) testDedupesListensOnChild {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
__block NSSet* listens = [self dumpListensForRef:ref];
|
|
XCTAssertTrue(listens.count == 0, @"No Listens yet");
|
|
|
|
[[ref child:@"a"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
}];
|
|
__block BOOL ready = NO;
|
|
dispatch_async([FIRDatabaseQuery sharedQueue], ^{
|
|
listens = [self dumpListensForRef:ref];
|
|
NSSet* expected = [NSSet setWithObject:[FQuerySpec defaultQueryAtPath:PATH(@"a")]];
|
|
XCTAssertTrue([expected isEqualToSet:listens], @"Expected child listener");
|
|
ready = YES;
|
|
});
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
[ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
}];
|
|
ready = NO;
|
|
dispatch_async([FIRDatabaseQuery sharedQueue], ^{
|
|
listens = [self dumpListensForRef:ref];
|
|
NSSet* expected = [NSSet setWithObject:[FQuerySpec defaultQueryAtPath:PATH(@"")]];
|
|
XCTAssertTrue([expected isEqualToSet:listens], @"Expected parent listener");
|
|
ready = YES;
|
|
});
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
[ref removeAllObservers];
|
|
ready = NO;
|
|
dispatch_async([FIRDatabaseQuery sharedQueue], ^{
|
|
listens = [self dumpListensForRef:ref];
|
|
NSSet* expected = [NSSet setWithObject:[FQuerySpec defaultQueryAtPath:PATH(@"a")]];
|
|
XCTAssertTrue([expected isEqualToSet:listens], @"Child listener should be back");
|
|
ready = YES;
|
|
});
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
[[ref child:@"a"] removeAllObservers];
|
|
ready = NO;
|
|
dispatch_async([FIRDatabaseQuery sharedQueue], ^{
|
|
listens = [self dumpListensForRef:ref];
|
|
XCTAssertTrue(listens.count == 0, @"No more listeners");
|
|
ready = YES;
|
|
});
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
}
|
|
|
|
- (void) testDedupeListensOnGrandchild {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
__block NSSet* listens;
|
|
__block BOOL ready = NO;
|
|
dispatch_async([FIRDatabaseQuery sharedQueue], ^{
|
|
listens = [self dumpListensForRef:ref];
|
|
XCTAssertTrue(listens.count == 0, @"No Listens yet");
|
|
ready = YES;
|
|
});
|
|
WAIT_FOR(ready);
|
|
|
|
[ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
}];
|
|
|
|
dispatch_async([FIRDatabaseQuery sharedQueue], ^{
|
|
listens = [self dumpListensForRef:ref];
|
|
NSSet* expected = [self expectDefaultListenerAtPath:[FPath empty]];
|
|
XCTAssertTrue([expected isEqualToSet:listens], @"Expected one listener");
|
|
ready = YES;
|
|
});
|
|
WAIT_FOR(ready);
|
|
|
|
[[ref child:@"a/aa"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
}];
|
|
ready = NO;
|
|
dispatch_async([FIRDatabaseQuery sharedQueue], ^{
|
|
listens = [self dumpListensForRef:ref];
|
|
NSSet* expected = [self expectDefaultListenerAtPath:[FPath empty]];
|
|
XCTAssertTrue([expected isEqualToSet:listens], @"Expected parent listener to override");
|
|
ready = YES;
|
|
});
|
|
WAIT_FOR(ready);
|
|
|
|
[ref removeAllObservers];
|
|
[[ref child:@"a/aa"] removeAllObservers];
|
|
ready = NO;
|
|
dispatch_async([FIRDatabaseQuery sharedQueue], ^{
|
|
listens = [self dumpListensForRef:ref];
|
|
XCTAssertTrue(listens.count == 0, @"No more listeners");
|
|
ready = YES;
|
|
});
|
|
WAIT_FOR(ready);
|
|
}
|
|
|
|
- (void) testListenOnGrandparentOfTwoChildren {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
__block NSSet* listens = [self dumpListensForRef:ref];
|
|
XCTAssertTrue(listens.count == 0, @"No Listens yet");
|
|
|
|
[[ref child:@"a/aa"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
}];
|
|
__block BOOL ready = NO;
|
|
dispatch_async([FIRDatabaseQuery sharedQueue], ^{
|
|
listens = [self dumpListensForRef:ref];
|
|
NSSet* expected = [self expectDefaultListenerAtPath:[FPath pathWithString:@"/a/aa"]];
|
|
XCTAssertTrue([expected isEqualToSet:listens], @"Expected grandchild");
|
|
ready = YES;
|
|
});
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
[[ref child:@"a/bb"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
}];
|
|
ready = NO;
|
|
dispatch_async([FIRDatabaseQuery sharedQueue], ^{
|
|
listens = [self dumpListensForRef:ref];
|
|
NSSet* expecteda = [self expectDefaultListenerAtPath:[FPath pathWithString:@"/a/aa"]];
|
|
NSSet* expectedb = [self expectDefaultListenerAtPath:[FPath pathWithString:@"/a/bb"]];
|
|
NSMutableSet* expected = [NSMutableSet setWithSet:expecteda];
|
|
[expected unionSet:expectedb];
|
|
XCTAssertTrue([expected isEqualToSet:listens], @"Expected two grandchildren");
|
|
ready = YES;
|
|
});
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
[ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
}];
|
|
ready = NO;
|
|
dispatch_async([FIRDatabaseQuery sharedQueue], ^{
|
|
listens = [self dumpListensForRef:ref];
|
|
NSSet* expected = [self expectDefaultListenerAtPath:[FPath empty]];
|
|
XCTAssertTrue([expected isEqualToSet:listens], @"Expected parent listener to override");
|
|
ready = YES;
|
|
});
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
[ref removeAllObservers];
|
|
ready = NO;
|
|
dispatch_async([FIRDatabaseQuery sharedQueue], ^{
|
|
listens = [self dumpListensForRef:ref];
|
|
NSSet* expecteda = [self expectDefaultListenerAtPath:[FPath pathWithString:@"/a/aa"]];
|
|
NSSet* expectedb = [self expectDefaultListenerAtPath:[FPath pathWithString:@"/a/bb"]];
|
|
NSMutableSet* expected = [NSMutableSet setWithSet:expecteda];
|
|
[expected unionSet:expectedb];
|
|
XCTAssertTrue([expected isEqualToSet:listens], @"Expected grandchild listeners to return");
|
|
ready = YES;
|
|
});
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
[[ref child:@"a/aa"] removeAllObservers];
|
|
ready = NO;
|
|
dispatch_async([FIRDatabaseQuery sharedQueue], ^{
|
|
listens = [self dumpListensForRef:ref];
|
|
NSSet* expected = [self expectDefaultListenerAtPath:[FPath pathWithString:@"/a/bb"]];
|
|
XCTAssertTrue([expected isEqualToSet:listens], @"Expected one listener");
|
|
ready = YES;
|
|
});
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
[[ref child:@"a/bb"] removeAllObservers];
|
|
ready = NO;
|
|
dispatch_async([FIRDatabaseQuery sharedQueue], ^{
|
|
listens = [self dumpListensForRef:ref];
|
|
XCTAssertTrue(listens.count == 0, @"No more listeners");
|
|
ready = YES;
|
|
});
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
}
|
|
|
|
- (void) testDedupingMultipleListenQueries {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
__block NSSet* listens = [self dumpListensForRef:ref];
|
|
XCTAssertTrue(listens.count == 0, @"No Listens yet");
|
|
|
|
__block BOOL ready = NO;
|
|
FIRDatabaseQuery * aLim1 = [[ref child:@"a"] queryLimitedToLast:1];
|
|
FIRDatabaseHandle handle1 = [aLim1 observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
}];
|
|
dispatch_async([FIRDatabaseQuery sharedQueue], ^{
|
|
listens = [self dumpListensForRef:ref];
|
|
FQueryParams* expectedParams = [[FQueryParams alloc] init];
|
|
expectedParams = [expectedParams limitTo:1];
|
|
NSSet* expected = [self expectParams:expectedParams atPath:[FPath pathWithString:@"/a"]];
|
|
XCTAssertTrue([expected isEqualToSet:listens], @"Single query");
|
|
ready = YES;
|
|
});
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
ready = NO;
|
|
FIRDatabaseQuery * rootLim1 = [ref queryLimitedToLast:1];
|
|
FIRDatabaseHandle handle2 = [rootLim1 observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
}];
|
|
dispatch_async([FIRDatabaseQuery sharedQueue], ^{
|
|
listens = [self dumpListensForRef:ref];
|
|
FQueryParams* expectedParams = [[FQueryParams alloc] init];
|
|
expectedParams = [expectedParams limitTo:1];
|
|
NSSet* rootExpected = [self expectParams:expectedParams atPath:[FPath empty]];
|
|
NSSet* childExpected = [self expectParams:expectedParams atPath:[FPath pathWithString:@"/a"]];
|
|
NSMutableSet* expected = [NSMutableSet setWithSet:rootExpected];
|
|
[expected unionSet:childExpected];
|
|
XCTAssertTrue([expected isEqualToSet:listens], @"Two queries");
|
|
ready = YES;
|
|
});
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
ready = NO;
|
|
FIRDatabaseQuery * aLim5 = [[ref child:@"a"] queryLimitedToLast:5];
|
|
FIRDatabaseHandle handle3 = [aLim5 observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
}];
|
|
dispatch_async([FIRDatabaseQuery sharedQueue], ^{
|
|
listens = [self dumpListensForRef:ref];
|
|
FQueryParams* expectedParams1 = [[FQueryParams alloc] init];
|
|
expectedParams1 = [expectedParams1 limitTo:1];
|
|
NSSet* rootExpected = [self expectParams:expectedParams1 atPath:[FPath empty]];
|
|
|
|
FQueryParams* expectedParams2 = [[FQueryParams alloc] init];
|
|
expectedParams2 = [expectedParams2 limitTo:5];
|
|
NSSet* childExpected = [self expectParamssetValue:[NSSet setWithObjects:expectedParams1, expectedParams2, nil] atPath:[FPath pathWithString:@"/a"]];
|
|
NSMutableSet* expected = [NSMutableSet setWithSet:childExpected];
|
|
[expected unionSet:rootExpected];
|
|
XCTAssertTrue([expected isEqualToSet:listens], @"Three queries");
|
|
ready = YES;
|
|
});
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
[ref removeObserverWithHandle:handle2];
|
|
ready = NO;
|
|
dispatch_async([FIRDatabaseQuery sharedQueue], ^{
|
|
listens = [self dumpListensForRef:ref];
|
|
FQueryParams* expectedParams1 = [[FQueryParams alloc] init];
|
|
expectedParams1 = [expectedParams1 limitTo:1];
|
|
FQueryParams* expectedParams2 = [[FQueryParams alloc] init];
|
|
expectedParams2= [expectedParams2 limitTo:5];
|
|
NSSet* expected = [self expectParamssetValue:[NSSet setWithObjects:expectedParams1, expectedParams2, nil] atPath:[FPath pathWithString:@"/a"]];
|
|
XCTAssertTrue([expected isEqualToSet:listens], @"Two queries");
|
|
ready = YES;
|
|
});
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
[aLim1 removeObserverWithHandle:handle1];
|
|
[aLim5 removeObserverWithHandle:handle3];
|
|
ready = NO;
|
|
dispatch_async([FIRDatabaseQuery sharedQueue], ^{
|
|
listens = [self dumpListensForRef:ref];
|
|
XCTAssertTrue(listens.count == 0, @"No more listeners");
|
|
ready = YES;
|
|
});
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
}
|
|
|
|
- (void) testListenOnParentOfQueriedChildren {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
__block NSSet* listens = [self dumpListensForRef:ref];
|
|
XCTAssertTrue(listens.count == 0, @"No Listens yet");
|
|
|
|
__block BOOL ready = NO;
|
|
FIRDatabaseQuery * aLim1 = [[ref child:@"a"] queryLimitedToLast:1];
|
|
FIRDatabaseHandle handle1 = [aLim1 observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
}];
|
|
dispatch_async([FIRDatabaseQuery sharedQueue], ^{
|
|
listens = [self dumpListensForRef:ref];
|
|
FQueryParams* expectedParams = [[FQueryParams alloc] init];
|
|
expectedParams = [expectedParams limitTo:1];
|
|
NSSet* expected = [self expectParams:expectedParams atPath:[FPath pathWithString:@"/a"]];
|
|
XCTAssertTrue([expected isEqualToSet:listens], @"Single query");
|
|
ready = YES;
|
|
});
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
ready = NO;
|
|
FIRDatabaseQuery * bLim1 = [[ref child:@"b"] queryLimitedToLast:1];
|
|
FIRDatabaseHandle handle2 = [bLim1 observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
}];
|
|
dispatch_async([FIRDatabaseQuery sharedQueue], ^{
|
|
listens = [self dumpListensForRef:ref];
|
|
FQueryParams* expectedParams = [[FQueryParams alloc] init];
|
|
expectedParams = [expectedParams limitTo:1];
|
|
NSSet* expecteda = [self expectParams:expectedParams atPath:[FPath pathWithString:@"/a"]];
|
|
NSSet* expectedb = [self expectParams:expectedParams atPath:[FPath pathWithString:@"/b"]];
|
|
NSMutableSet* expected = [NSMutableSet setWithSet:expecteda];
|
|
[expected unionSet:expectedb];
|
|
XCTAssertTrue([expected isEqualToSet:listens], @"Two queries");
|
|
ready = YES;
|
|
});
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
ready = NO;
|
|
FIRDatabaseHandle handle3 = [ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
}];
|
|
dispatch_async([FIRDatabaseQuery sharedQueue], ^{
|
|
listens = [self dumpListensForRef:ref];
|
|
NSSet* expected = [self expectDefaultListenerAtPath:[FPath empty]];
|
|
XCTAssertTrue([expected isEqualToSet:listens], @"Parent should override");
|
|
ready = YES;
|
|
});
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
// remove in slightly random order
|
|
[aLim1 removeObserverWithHandle:handle1];
|
|
ready = NO;
|
|
dispatch_async([FIRDatabaseQuery sharedQueue], ^{
|
|
listens = [self dumpListensForRef:ref];
|
|
NSSet* expected = [self expectDefaultListenerAtPath:[FPath empty]];
|
|
XCTAssertTrue([expected isEqualToSet:listens], @"Parent should override");
|
|
ready = YES;
|
|
});
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
[ref removeObserverWithHandle:handle3];
|
|
ready = NO;
|
|
dispatch_async([FIRDatabaseQuery sharedQueue], ^{
|
|
listens = [self dumpListensForRef:ref];
|
|
FQueryParams* expectedParams = [[FQueryParams alloc] init];
|
|
expectedParams = [expectedParams limitTo:1];
|
|
NSSet* expected = [self expectParams:expectedParams atPath:[FPath pathWithString:@"/b"]];
|
|
XCTAssertTrue([expected isEqualToSet:listens], @"Single query");
|
|
ready = YES;
|
|
});
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
ready = NO;
|
|
[bLim1 removeObserverWithHandle:handle2];
|
|
dispatch_async([FIRDatabaseQuery sharedQueue], ^{
|
|
listens = [self dumpListensForRef:ref];
|
|
XCTAssertTrue(listens.count == 0, @"No more listeners");
|
|
ready = YES;
|
|
});
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
}
|
|
|
|
-(void) testLimitWithMixOfNullAndNonNullPriorities {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
NSMutableArray* children = [[NSMutableArray alloc] init];
|
|
|
|
[[ref queryLimitedToLast:5] observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
|
|
[children addObject:[snapshot key]];
|
|
}];
|
|
|
|
__block BOOL ready = NO;
|
|
NSDictionary* toSet = @{
|
|
@"Vikrum": @{@".priority": @1000, @"score": @1000, @"name": @"Vikrum"},
|
|
@"Mike": @{@".priority": @500, @"score": @500, @"name": @"Mike"},
|
|
@"Andrew": @{@".priority": @50, @"score": @50, @"name": @"Andrew"},
|
|
@"James": @{@".priority": @7, @"score": @7, @"name": @"James"},
|
|
@"Sally": @{@".priority": @-7, @"score": @-7, @"name": @"Sally"},
|
|
@"Fred": @{@"score": @0, @"name": @"Fred"}
|
|
};
|
|
|
|
[ref setValue:toSet withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
NSArray* expected = @[@"Sally", @"James", @"Andrew", @"Mike", @"Vikrum"];
|
|
XCTAssertTrue([children isEqualToArray:expected], @"Null priority should be left out");
|
|
|
|
}
|
|
|
|
-(void) testLimitWithMixOfNullAndNonNullPrioritiesOnServerData {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
__block BOOL ready = NO;
|
|
NSDictionary* toSet = @{
|
|
@"Vikrum": @{@".priority": @1000, @"score": @1000, @"name": @"Vikrum"},
|
|
@"Mike": @{@".priority": @500, @"score": @500, @"name": @"Mike"},
|
|
@"Andrew": @{@".priority": @50, @"score": @50, @"name": @"Andrew"},
|
|
@"James": @{@".priority": @7, @"score": @7, @"name": @"James"},
|
|
@"Sally": @{@".priority": @-7, @"score": @-7, @"name": @"Sally"},
|
|
@"Fred": @{@"score": @0, @"name": @"Fred"}
|
|
};
|
|
|
|
[ref setValue:toSet withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
__block int count = 0;
|
|
NSMutableArray* children = [[NSMutableArray alloc] init];
|
|
|
|
[[ref queryLimitedToLast:5] observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
|
|
[children addObject:[snapshot key]];
|
|
count++;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return count == 5;
|
|
}];
|
|
|
|
|
|
NSArray* expected = @[@"Sally", @"James", @"Andrew", @"Mike", @"Vikrum"];
|
|
XCTAssertTrue([children isEqualToArray:expected], @"Null priority should be left out");
|
|
|
|
}
|
|
|
|
// Skipping context tests. Context is not implemented on iOS
|
|
|
|
/* DISABLING for now, since I'm not 100% sure what the right behavior is.
|
|
Perhaps a merge at /foo should shadow server updates at /foo instead of
|
|
just the modified children? Not sure.
|
|
- (void) testHandleUpdateThatDeletesEntireWindow {
|
|
Firebase* ref = [FTestHelpers getRandomNode];
|
|
|
|
NSMutableArray* snaps = [[NSMutableArray alloc] init];
|
|
|
|
[[ref queryLimitedToLast:2] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
id val = [snapshot value];
|
|
if (val == nil) {
|
|
[snaps addObject:[NSNull null]];
|
|
} else {
|
|
[snaps addObject:val];
|
|
}
|
|
}];
|
|
|
|
NSDictionary* toSet = @{
|
|
@"a": @{@".priority": @1, @".value": @1},
|
|
@"b": @{@".priority": @2, @".value": @2},
|
|
@"c": @{@".priority": @3, @".value": @3}
|
|
};
|
|
|
|
[ref setValue:toSet];
|
|
|
|
__block BOOL ready = NO;
|
|
toSet = @{@"b": [NSNull null], @"c": [NSNull null]};
|
|
[ref updateChildValues:toSet withCompletionBlock:^(NSError* err, Firebase* ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
NSArray* expected = @[@{@"b": @2, @"c": @3}, [NSNull null], @{@"a": @1}];
|
|
STAssertTrue([snaps isEqualToArray:expected], @"Expected %@ to equal %@", snaps, expected);
|
|
}
|
|
*/
|
|
|
|
- (void) testHandlesAnOutOfViewQueryOnAChild {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
__block NSDictionary* parent = nil;
|
|
[[ref queryLimitedToLast:1] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
parent = [snapshot value];
|
|
}];
|
|
|
|
__block NSNumber* child = nil;
|
|
[[ref child:@"a"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
child = [snapshot value];
|
|
}];
|
|
|
|
__block BOOL ready = NO;
|
|
NSDictionary* toSet = @{@"a": @1, @"b": @2};
|
|
[ref setValue:toSet withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
NSDictionary* parentExpected = @{@"b": @2};
|
|
NSNumber* childExpected = [NSNumber numberWithInt:1];
|
|
XCTAssertTrue([parent isEqualToDictionary:parentExpected], @"Expected last element");
|
|
XCTAssertTrue([child isEqualToNumber:childExpected], @"Expected value of a");
|
|
|
|
ready = NO;
|
|
[ref updateChildValues:@{@"c": @3} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
parentExpected = @{@"c": @3};
|
|
XCTAssertTrue([parent isEqualToDictionary:parentExpected], @"Expected last element");
|
|
XCTAssertTrue([child isEqualToNumber:childExpected], @"Expected value of a");
|
|
}
|
|
|
|
- (void) testHandlesAChildQueryGoingOutOfViewOfTheParent {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
__block NSDictionary* parent = nil;
|
|
[[ref queryLimitedToLast:1] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
parent = [snapshot value];
|
|
}];
|
|
|
|
__block NSNumber* child = nil;
|
|
[[ref child:@"a"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
child = [snapshot value];
|
|
}];
|
|
|
|
__block BOOL ready = NO;
|
|
NSDictionary* toSet = @{@"a": @1};
|
|
[ref setValue:toSet withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
WAIT_FOR(ready);
|
|
|
|
NSDictionary* parentExpected = @{@"a": @1};
|
|
NSNumber* childExpected = [NSNumber numberWithInt:1];
|
|
XCTAssertTrue([parent isEqualToDictionary:parentExpected], @"Expected last element");
|
|
XCTAssertTrue([child isEqualToNumber:childExpected], @"Expected value of a");
|
|
|
|
ready = NO;
|
|
[[ref child:@"b"] setValue:@2 withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
WAIT_FOR(ready);
|
|
|
|
parentExpected = @{@"b": @2};
|
|
XCTAssertTrue([parent isEqualToDictionary:parentExpected], @"Expected last element");
|
|
XCTAssertTrue([child isEqualToNumber:childExpected], @"Expected value of a");
|
|
|
|
ready = NO;
|
|
[[ref child:@"b"] removeValueWithCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
parentExpected = @{@"a": @1};
|
|
XCTAssertTrue([parent isEqualToDictionary:parentExpected], @"Expected last element");
|
|
XCTAssertTrue([child isEqualToNumber:childExpected], @"Expected value of a");
|
|
}
|
|
|
|
- (void) testHandlesDivergingViews {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
__block NSDictionary* cVal = nil;
|
|
FIRDatabaseQuery * query = [[[ref queryOrderedByPriority] queryEndingAtValue:nil childKey:@"c"] queryLimitedToLast:1];
|
|
[query observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
cVal = [snapshot value];
|
|
}];
|
|
|
|
__block NSDictionary* dVal = nil;
|
|
query = [[[ref queryOrderedByPriority] queryEndingAtValue:nil childKey:@"d"] queryLimitedToLast:1];
|
|
[query observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
dVal = [snapshot value];
|
|
}];
|
|
|
|
__block BOOL ready = NO;
|
|
NSDictionary* toSet = @{@"a": @1, @"b": @2, @"c": @3};
|
|
[ref setValue:toSet withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
NSDictionary* expected = @{@"c": @3};
|
|
XCTAssertTrue([cVal isEqualToDictionary:expected], @"should be c");
|
|
XCTAssertTrue([dVal isEqualToDictionary:expected], @"should be c");
|
|
|
|
ready = NO;
|
|
[[ref child:@"d"] setValue:@4 withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
XCTAssertTrue([cVal isEqualToDictionary:expected], @"should be c");
|
|
expected = @{@"d": @4};
|
|
XCTAssertTrue([dVal isEqualToDictionary:expected], @"should be d");
|
|
}
|
|
|
|
- (void) testHandlesRemovingAQueriedElement {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
__block NSNumber* val = nil;
|
|
[[ref queryLimitedToLast:1] observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
|
|
id newVal = [snapshot value];
|
|
if (newVal != nil) {
|
|
val = [snapshot value];
|
|
}
|
|
}];
|
|
|
|
__block BOOL ready = NO;
|
|
[ref setValue:@{@"a": @1, @"b": @2} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
XCTAssertTrue([val isEqualToNumber:@2], @"Expected last element in window");
|
|
|
|
ready = NO;
|
|
[[ref child:@"b"] removeValueWithCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
XCTAssertTrue([val isEqualToNumber:@1], @"Should now be the next element in the window");
|
|
}
|
|
|
|
- (void) testStartAtAndLimit1Works {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
__block NSNumber* val = nil;
|
|
FIRDatabaseQuery * query = [[[ref queryOrderedByPriority] queryStartingAtValue:nil] queryLimitedToFirst:1];
|
|
[query observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
|
|
id newVal = [snapshot value];
|
|
if (newVal != nil) {
|
|
val = [snapshot value];
|
|
}
|
|
}];
|
|
|
|
__block BOOL ready = NO;
|
|
[ref setValue:@{@"a": @1, @"b": @2} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
XCTAssertTrue([val isEqualToNumber:@1], @"Expected first element in window");
|
|
}
|
|
|
|
// See case 1664
|
|
- (void) testStartAtAndLimit1AndRemoveFirstChild {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
__block NSNumber* val = nil;
|
|
FIRDatabaseQuery * query = [[[ref queryOrderedByPriority] queryStartingAtValue:nil] queryLimitedToFirst:1];
|
|
[query observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
|
|
id newVal = [snapshot value];
|
|
if (newVal != nil) {
|
|
val = [snapshot value];
|
|
}
|
|
}];
|
|
|
|
__block BOOL ready = NO;
|
|
[ref setValue:@{@"a": @1, @"b": @2} withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
XCTAssertTrue([val isEqualToNumber:@1], @"Expected first element in window");
|
|
|
|
ready = NO;
|
|
[[ref child:@"a"] removeValueWithCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
XCTAssertTrue([val isEqualToNumber:@2], @"Expected next element in window");
|
|
}
|
|
|
|
// See case 1169
|
|
- (void) testStartAtWithTwoArgumentsWorks {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
__block BOOL ready = NO;
|
|
NSMutableArray* children = [[NSMutableArray alloc] init];
|
|
|
|
NSDictionary* toSet = @{
|
|
@"Walker": @{@"name": @"Walker", @"score": @20, @".priority": @20},
|
|
@"Michael": @{@"name": @"Michael", @"score": @100, @".priority": @100}
|
|
};
|
|
|
|
[ref setValue:toSet withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
ready = NO;
|
|
FIRDatabaseQuery * query = [[[ref queryOrderedByPriority] queryStartingAtValue:@20 childKey:@"Walker"] queryLimitedToFirst:2];
|
|
[query observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
|
|
for (FIRDataSnapshot *child in snapshot.children) {
|
|
[children addObject:child.key];
|
|
}
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
NSArray* expected = @[@"Walker", @"Michael"];
|
|
XCTAssertTrue([children isEqualToArray:expected], @"Expected both children");
|
|
}
|
|
|
|
- (void) testHandlesMultipleQueriesOnSameNode {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
__block BOOL ready = NO;
|
|
|
|
NSDictionary* toSet = @{
|
|
@"a": @1, @"b": @2, @"c": @3, @"d": @4, @"e": @5, @"f": @6
|
|
};
|
|
|
|
[ref setValue:toSet withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
ready = NO;
|
|
__block BOOL called = NO;
|
|
[[ref queryLimitedToLast:2] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
// we got the initial data
|
|
XCTAssertFalse(called, @"This should only get called once, we don't update data after this");
|
|
called = YES;
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
ready = NO;
|
|
__block NSDictionary* snap = nil;
|
|
// now do nested once calls
|
|
[[ref queryLimitedToLast:1] observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
[[ref queryLimitedToLast:1] observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
|
|
snap = [snapshot value];
|
|
ready = YES;
|
|
}];
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
NSDictionary* expected = @{@"f": @6};
|
|
XCTAssertTrue([snap isEqualToDictionary:expected], @"Expected the correct data");
|
|
}
|
|
|
|
- (void) testHandlesOnceCalledOnNodeWithDefaultListener {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
__block BOOL ready = NO;
|
|
|
|
NSDictionary* toSet = @{
|
|
@"a": @1, @"b": @2, @"c": @3, @"d": @4, @"e": @5, @"f": @6
|
|
};
|
|
|
|
[ref setValue:toSet withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
ready = NO;
|
|
|
|
[ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
// we got the initial data
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
ready = NO;
|
|
|
|
__block NSNumber* snap = nil;
|
|
[[ref queryLimitedToLast:1] observeSingleEventOfType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
|
|
snap = [snapshot value];
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
XCTAssertTrue([snap isEqualToNumber:@6], @"Got once response");
|
|
}
|
|
|
|
- (void) testHandlesOnceCalledOnNodeWithDefaultListenerAndNonCompleteLimit {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
__block BOOL ready = NO;
|
|
|
|
NSDictionary* toSet = @{@"a": @1, @"b": @2, @"c": @3};
|
|
|
|
[ref setValue:toSet withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
ready = NO;
|
|
// do first listen
|
|
[ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
ready = NO;
|
|
|
|
__block NSDictionary* snap = nil;
|
|
[[ref queryLimitedToLast:5] observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
snap = [snapshot value];
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
NSDictionary* expected = @{@"a": @1, @"b": @2, @"c": @3};
|
|
XCTAssertTrue([snap isEqualToDictionary:expected], @"Got once response");
|
|
}
|
|
|
|
- (void) testRemoveTriggersRemoteEvents {
|
|
FTupleFirebase* tuple = [FTestHelpers getRandomNodePair];
|
|
FIRDatabaseReference * writer = tuple.one;
|
|
FIRDatabaseReference * reader = tuple.two;
|
|
|
|
__block BOOL ready = NO;
|
|
|
|
NSDictionary* toSet = @{@"a": @"a", @"b": @"b", @"c": @"c", @"d": @"d", @"e": @"e"};
|
|
|
|
[writer setValue:toSet withCompletionBlock:^(NSError* err, FIRDatabaseReference * ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
|
|
ready = NO;
|
|
__block int count = 0;
|
|
|
|
[[reader queryLimitedToLast:5] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
count++;
|
|
if (count == 1) {
|
|
NSDictionary *val = [snapshot value];
|
|
NSDictionary *expected = @{@"a" : @"a", @"b" : @"b", @"c" : @"c", @"d" : @"d", @"e" : @"e"};
|
|
XCTAssertTrue([val isEqualToDictionary:expected], @"First callback, expect all the data");
|
|
[[writer child:@"c"] removeValue];
|
|
} else {
|
|
XCTAssertTrue(count == 2, @"Should only get called twice");
|
|
NSDictionary *val = [snapshot value];
|
|
NSDictionary *expected = @{@"a" : @"a", @"b" : @"b", @"d" : @"d", @"e" : @"e"};
|
|
XCTAssertTrue([val isEqualToDictionary:expected], @"Second callback, expect all the remaining data");
|
|
ready = YES;
|
|
}
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return ready;
|
|
}];
|
|
}
|
|
|
|
- (void) testEndingAtNameReturnsCorrectChildren {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
NSDictionary* toSet = @{
|
|
@"a": @"a",
|
|
@"b": @"b",
|
|
@"c": @"c",
|
|
@"d": @"d",
|
|
@"e": @"e",
|
|
@"f": @"f",
|
|
@"g": @"g",
|
|
@"h": @"h"
|
|
};
|
|
|
|
[self waitForCompletionOf:ref setValue:toSet];
|
|
|
|
__block NSDictionary* snap = nil;
|
|
__block BOOL done = NO;
|
|
FIRDatabaseQuery * query = [[[ref queryOrderedByPriority] queryEndingAtValue:nil childKey:@"f"] queryLimitedToLast:5];
|
|
[query observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
snap = [snapshot value];
|
|
done = YES;
|
|
}];
|
|
|
|
[self waitUntil:^BOOL{
|
|
return done;
|
|
}];
|
|
|
|
NSDictionary* expected = @{
|
|
@"b": @"b",
|
|
@"c": @"c",
|
|
@"d": @"d",
|
|
@"e": @"e",
|
|
@"f": @"f"
|
|
};
|
|
XCTAssertTrue([snap isEqualToDictionary:expected], @"Expected 5 elements, ending at f");
|
|
}
|
|
|
|
- (void) testListenForChildAddedWithLimitEnsureEventsFireProperly {
|
|
FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
|
|
FIRDatabaseReference * writer = refs.one;
|
|
FIRDatabaseReference * reader = refs.two;
|
|
|
|
__block BOOL done = NO;
|
|
|
|
NSDictionary* toSet = @{@"a": @1, @"b": @"b", @"c": @{@"deep": @"path", @"of": @{@"stuff": @YES}}};
|
|
[writer setValue:toSet withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
|
|
done = YES;
|
|
}];
|
|
|
|
WAIT_FOR(done);
|
|
|
|
__block int count = 0;
|
|
[[reader queryLimitedToLast:3] observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
|
|
count++;
|
|
if (count == 1) {
|
|
XCTAssertTrue([snapshot.key isEqualToString:@"a"], @"Got first child");
|
|
XCTAssertTrue([snapshot.value isEqualToNumber:@1], @"Got correct value");
|
|
} else if (count == 2) {
|
|
XCTAssertTrue([snapshot.key isEqualToString:@"b"], @"Got second child");
|
|
XCTAssertTrue([snapshot.value isEqualToString:@"b"], @"got correct value");
|
|
} else if (count == 3) {
|
|
XCTAssertTrue([snapshot.key isEqualToString:@"c"], @"Got third child");
|
|
NSDictionary *expected = @{@"deep" : @"path", @"of" : @{@"stuff" : @YES}};
|
|
XCTAssertTrue([snapshot.value isEqualToDictionary:expected], @"Got deep object");
|
|
} else {
|
|
XCTFail(@"wrong event count");
|
|
}
|
|
}];
|
|
|
|
WAIT_FOR(count == 3);
|
|
}
|
|
|
|
#ifdef FLAKY_TEST
|
|
- (void) testListenForChildChangedWithLimitEnsureEventsFireProperly {
|
|
FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
|
|
FIRDatabaseReference * writer = refs.one;
|
|
FIRDatabaseReference * reader = refs.two;
|
|
|
|
__block BOOL done = NO;
|
|
|
|
NSDictionary* toSet = @{@"a": @"something", @"b": @"we'll", @"c": @"overwrite"};
|
|
[writer setValue:toSet withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
|
|
done = YES;
|
|
}];
|
|
|
|
WAIT_FOR(done);
|
|
|
|
__block int count = 0;
|
|
[reader observeEventType:FIRDataEventTypeChildChanged withBlock:^(FIRDataSnapshot *snapshot) {
|
|
count++;
|
|
if (count == 1) {
|
|
XCTAssertTrue([snapshot.key isEqualToString:@"a"], @"Got first child");
|
|
XCTAssertTrue([snapshot.value isEqualToNumber:@1], @"Got correct value");
|
|
} else if (count == 2) {
|
|
XCTAssertTrue([snapshot.key isEqualToString:@"b"], @"Got second child");
|
|
XCTAssertTrue([snapshot.value isEqualToString:@"b"], @"got correct value");
|
|
} else if (count == 3) {
|
|
XCTAssertTrue([snapshot.key isEqualToString:@"c"], @"Got third child");
|
|
NSDictionary *expected = @{@"deep" : @"path", @"of" : @{@"stuff" : @YES}};
|
|
XCTAssertTrue([snapshot.value isEqualToDictionary:expected], @"Got deep object");
|
|
} else {
|
|
XCTFail(@"wrong event count");
|
|
}
|
|
}];
|
|
toSet = @{@"a": @1, @"b": @"b", @"c": @{@"deep": @"path", @"of": @{@"stuff": @YES}}};
|
|
[writer setValue:toSet];
|
|
|
|
WAIT_FOR(count == 3);
|
|
}
|
|
#endif
|
|
|
|
- (void) testListenForChildRemovedWithLimitEnsureEventsFireProperly {
|
|
FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
|
|
FIRDatabaseReference * writer = refs.one;
|
|
FIRDatabaseReference * reader = refs.two;
|
|
|
|
__block BOOL done = NO;
|
|
|
|
NSDictionary* toSet = @{@"a": @1, @"b": @"b", @"c": @{@"deep": @"path", @"of": @{@"stuff": @YES}}};
|
|
[writer setValue:toSet withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
|
|
done = YES;
|
|
}];
|
|
|
|
WAIT_FOR(done);
|
|
|
|
__block int count = 0;
|
|
[reader observeEventType:FIRDataEventTypeChildRemoved withBlock:^(FIRDataSnapshot *snapshot) {
|
|
count++;
|
|
if (count == 1) {
|
|
XCTAssertTrue([snapshot.key isEqualToString:@"a"], @"Got first child");
|
|
XCTAssertTrue([snapshot.value isEqualToNumber:@1], @"Got correct value");
|
|
} else if (count == 2) {
|
|
XCTAssertTrue([snapshot.key isEqualToString:@"b"], @"Got second child");
|
|
XCTAssertTrue([snapshot.value isEqualToString:@"b"], @"got correct value");
|
|
} else if (count == 3) {
|
|
XCTAssertTrue([snapshot.key isEqualToString:@"c"], @"Got third child");
|
|
NSDictionary *expected = @{@"deep" : @"path", @"of" : @{@"stuff" : @YES}};
|
|
XCTAssertTrue([snapshot.value isEqualToDictionary:expected], @"Got deep object");
|
|
} else {
|
|
XCTFail(@"wrong event count");
|
|
}
|
|
}];
|
|
|
|
done = NO;
|
|
[reader observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
// Load the data first
|
|
done = snapshot.value != [NSNull null] && [snapshot.value isEqualToDictionary:toSet];
|
|
}];
|
|
|
|
WAIT_FOR(done);
|
|
|
|
// Now do the removes
|
|
[[writer child:@"a"] removeValue];
|
|
[[writer child:@"b"] removeValue];
|
|
[[writer child:@"c"] removeValue];
|
|
|
|
WAIT_FOR(count == 3);
|
|
}
|
|
|
|
- (void) testQueriesBehaveProperlyAfterOnceCall {
|
|
FTupleFirebase* refs = [FTestHelpers getRandomNodePair];
|
|
FIRDatabaseReference * writer = refs.one;
|
|
FIRDatabaseReference * reader = refs.two;
|
|
|
|
__block BOOL done = NO;
|
|
NSDictionary* toSet = @{@"a": @1, @"b": @2, @"c": @3, @"d": @4};
|
|
[writer setValue:toSet withCompletionBlock:^(NSError* error, FIRDatabaseReference * ref) {
|
|
done = YES;
|
|
}];
|
|
|
|
WAIT_FOR(done);
|
|
|
|
done = NO;
|
|
[reader observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
done = YES;
|
|
}];
|
|
|
|
WAIT_FOR(done);
|
|
|
|
// Ok, now do some queries
|
|
__block int startCount = 0;
|
|
__block int defaultCount = 0;
|
|
[[[reader queryOrderedByPriority] queryStartingAtValue:nil childKey:@"d"] observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
|
|
startCount++;
|
|
}];
|
|
|
|
[reader observeEventType:FIRDataEventTypeChildAdded withBlock:^(FIRDataSnapshot *snapshot) {
|
|
defaultCount++;
|
|
}];
|
|
|
|
[reader observeEventType:FIRDataEventTypeChildRemoved withBlock:^(FIRDataSnapshot *snapshot) {
|
|
XCTFail(@"Should not remove any children");
|
|
}];
|
|
|
|
WAIT_FOR(startCount == 1 && defaultCount == 4);
|
|
}
|
|
|
|
- (void) testIntegerKeysBehaveNumerically1 {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
NSDictionary* toSet = @{@"1": @YES, @"50": @YES, @"550": @YES, @"6": @YES, @"600": @YES, @"70": @YES, @"8": @YES, @"80": @YES };
|
|
__block BOOL done = NO;
|
|
[ref setValue:toSet withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) {
|
|
[[[ref queryOrderedByPriority] queryStartingAtValue:nil childKey:@"80"] observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
NSDictionary *expected = @{@"80" : @YES, @"550" : @YES, @"600" : @YES};
|
|
XCTAssertTrue([snapshot.value isEqualToDictionary:expected], @"Got correct result.");
|
|
done = YES;
|
|
}];
|
|
}];
|
|
WAIT_FOR(done);
|
|
}
|
|
|
|
- (void) testIntegerKeysBehaveNumerically2 {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
NSDictionary* toSet = @{@"1": @YES, @"50": @YES, @"550": @YES, @"6": @YES, @"600": @YES, @"70": @YES, @"8": @YES, @"80": @YES };
|
|
__block BOOL done = NO;
|
|
[ref setValue:toSet withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) {
|
|
[[[ref queryOrderedByPriority] queryEndingAtValue:nil childKey:@"50"] observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
NSDictionary *expected = @{@"1" : @YES, @"6" : @YES, @"8" : @YES, @"50" : @YES};
|
|
XCTAssertTrue([snapshot.value isEqualToDictionary:expected], @"Got correct result.");
|
|
done = YES;
|
|
}];
|
|
}];
|
|
WAIT_FOR(done);
|
|
}
|
|
|
|
- (void) testIntegerKeysBehaveNumerically3 {
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
NSDictionary* toSet = @{@"1": @YES, @"50": @YES, @"550": @YES, @"6": @YES, @"600": @YES, @"70": @YES, @"8": @YES, @"80": @YES };
|
|
__block BOOL done = NO;
|
|
[ref setValue:toSet withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) {
|
|
[[[[ref queryOrderedByPriority] queryStartingAtValue:nil childKey:@"50"] queryEndingAtValue:nil childKey:@"80"] observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
NSDictionary *expected = @{@"50" : @YES, @"70" : @YES, @"80" : @YES};
|
|
XCTAssertTrue([snapshot.value isEqualToDictionary:expected], @"Got correct result.");
|
|
done = YES;
|
|
}];
|
|
}];
|
|
WAIT_FOR(done);
|
|
}
|
|
|
|
- (void) testItemsPulledIntoLimitCorrectly {
|
|
FIRDatabaseReference *ref = [FTestHelpers getRandomNode];
|
|
|
|
NSMutableArray* snaps = [[NSMutableArray alloc] init];
|
|
|
|
// Just so everything is cached locally.
|
|
[ref observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
|
|
}];
|
|
|
|
[[ref queryLimitedToLast:2] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
id val = [snapshot value];
|
|
[snaps addObject:val];
|
|
}];
|
|
|
|
[ref setValue:@{
|
|
@"a": @{@".value": @1, @".priority": @1},
|
|
@"b": @{@".value": @2, @".priority": @2},
|
|
@"c": @{@".value": @3, @".priority": @3}
|
|
}];
|
|
|
|
__block BOOL ready = NO;
|
|
[[ref child:@"b"] setValue:[NSNull null] withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) {
|
|
ready = YES;
|
|
}];
|
|
|
|
WAIT_FOR(ready);
|
|
|
|
NSArray* expected = @[@{@"b": @2, @"c": @3}, @{@"a": @1, @"c": @3}];
|
|
XCTAssertEqualObjects(snaps, expected, @"Incorrect snapshots.");
|
|
}
|
|
|
|
- (void)testChildChangedCausesChildRemovedEvent
|
|
{
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
[[ref child:@"l/a"] setValue:@"1" andPriority:@"a"];
|
|
[[ref child:@"l/b"] setValue:@"2" andPriority:@"b"];
|
|
FIRDatabaseQuery *query = [[[[ref child:@"l"] queryOrderedByPriority] queryStartingAtValue:@"b"] queryEndingAtValue:@"d"];
|
|
__block BOOL removed = NO;
|
|
[query observeEventType:FIRDataEventTypeChildRemoved withBlock:^(FIRDataSnapshot *snapshot) {
|
|
XCTAssertEqualObjects(snapshot.value, @"2", @"Incorrect snapshot");
|
|
removed = YES;
|
|
}];
|
|
|
|
[[ref child:@"l/b"] setValue:@"4" andPriority:@"a"];
|
|
|
|
WAIT_FOR(removed);
|
|
}
|
|
|
|
- (void) testQueryHasRef {
|
|
FIRDatabaseReference *ref = [FTestHelpers getRandomNode];
|
|
FIRDatabaseQuery *query = [ref queryOrderedByKey];
|
|
XCTAssertEqualObjects([query.ref path], [ref path], @"Should have same path");
|
|
}
|
|
|
|
- (void) testQuerySnapshotChildrenRespectDefaultOrdering {
|
|
FTupleFirebase* pair = [FTestHelpers getRandomNodePair];
|
|
FIRDatabaseReference * writer = pair.one;
|
|
FIRDatabaseReference * reader = pair.two;
|
|
__block BOOL done = NO;
|
|
|
|
NSDictionary* list = @{
|
|
@"a": @{
|
|
@"thisvaluefirst": @{ @".value": @true, @".priority": @1 },
|
|
@"name": @{ @".value": @"Michael", @".priority": @2 },
|
|
@"thisvaluelast": @{ @".value": @true, @".priority": @3 },
|
|
},
|
|
@"b": @{
|
|
@"thisvaluefirst": @{ @".value": @true },
|
|
@"name": @{ @".value": @"Rob", @".priority": @2 },
|
|
@"thisvaluelast": @{ @".value": @true, @".priority": @3 },
|
|
},
|
|
@"c": @{
|
|
@"thisvaluefirst": @{ @".value": @true, @".priority": @1 },
|
|
@"name": @{ @".value": @"Jonny", @".priority": @2 },
|
|
@"thisvaluelast": @{ @".value": @true, @".priority": @"somestring" },
|
|
}
|
|
};
|
|
|
|
[writer setValue:list withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) {
|
|
done = YES;
|
|
}];
|
|
WAIT_FOR(done);
|
|
|
|
done = NO;
|
|
[[reader queryOrderedByChild:@"name"] observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
NSArray *expectedKeys = @[@"thisvaluefirst", @"name", @"thisvaluelast"];
|
|
NSArray *expectedNames = @[@"Jonny", @"Michael", @"Rob"];
|
|
|
|
// Validate that snap.child() resets order to default for child snaps
|
|
NSMutableArray *orderedKeys = [[NSMutableArray alloc] init];
|
|
for (FIRDataSnapshot *childSnap in [snapshot childSnapshotForPath:@"b"].children) {
|
|
[orderedKeys addObject:childSnap.key];
|
|
}
|
|
XCTAssertEqualObjects(expectedKeys, orderedKeys, @"Should have matching ordered lists of keys");
|
|
|
|
// Validate that snap.forEach() resets ordering to default for child snaps
|
|
NSMutableArray *orderedNames = [[NSMutableArray alloc] init];
|
|
for (FIRDataSnapshot *childSnap in snapshot.children) {
|
|
[orderedNames addObject:[childSnap childSnapshotForPath:@"name"].value];
|
|
[orderedKeys removeAllObjects];
|
|
for (FIRDataSnapshot *grandchildSnap in childSnap.children) {
|
|
[orderedKeys addObject:grandchildSnap.key];
|
|
}
|
|
XCTAssertEqualObjects(expectedKeys, orderedKeys, @"Should have matching ordered lists of keys");
|
|
}
|
|
XCTAssertEqualObjects(expectedNames, orderedNames, @"Should have matching ordered lists of names");
|
|
|
|
done = YES;
|
|
}];
|
|
WAIT_FOR(done);
|
|
}
|
|
|
|
- (void) testAddingListensForTheSamePathDoesNotCheckFail {
|
|
// This bug manifests itself if there's a hierarchy of query listener, default listener and one-time listener
|
|
// underneath.
|
|
// In Java implementation, during one-time listener registration, sync-tree traversal stopped as soon as it found
|
|
// a complete server cache (this is the case for not indexed query view). The problem is that the same traversal was
|
|
// looking for a ancestor default view, and the early exit prevented from finding the default listener above the
|
|
// one-time listener. Event removal code path wasn't removing the listener because it stopped as soon as it
|
|
// found the default view. This left the zombie one-time listener and check failed on the second attempt to
|
|
// create a listener for the same path (asana#61028598952586).
|
|
|
|
FIRDatabaseReference * ref = [FTestHelpers getRandomNode];
|
|
|
|
__block BOOL done = NO;
|
|
|
|
[[ref child:@"child"] setValue:@{@"name": @"John"}];
|
|
[[[ref queryOrderedByChild:@"name"] queryEqualToValue:@"John"] observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
done = YES;
|
|
}];
|
|
WAIT_FOR(done);
|
|
|
|
done = NO;
|
|
[[[ref child:@"child"] child:@"favoriteToy"] observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
done = YES;
|
|
}];
|
|
WAIT_FOR(done);
|
|
|
|
done = NO;
|
|
[[[ref child:@"child"] child:@"favoriteToy"] observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
|
|
done = YES;
|
|
}];
|
|
WAIT_FOR(done);
|
|
}
|
|
|
|
@end
|