Implemented queryWithBypassCache that is not returning data from cache when persistenceEnabled.

Author: kostassite

Example/Database/Tests/Integration/FPersist.m

@@ -221,6 +221,109 @@ - (void) testServerDataCompleteness2 {
     [device dispose];
 }
 
+- (void)testServerDataNotReturnedWhenQueryWithBypassCacheWhenOnline {
+    FIRDatabaseReference *writerRef = [FTestHelpers getRandomNode];
+    FDevice *device = [[FDevice alloc] initOnlineWithUrl:[writerRef description] ];
+    id data = @{@"a": @1, @"b": @2};
+    [device do:^(FIRDatabaseReference *ref) {
+        [self waitForCompletionOf:ref setValue:data];
+    }];
+    
+    // Wait for the data to get it cached.
+    [device do:^(FIRDatabaseReference *ref) {
+        [self waitForValueOf:ref toBe:data];
+    }];
+    
+    // Write new data using different device so not cached
+    id newData = @{@"a": @1, @"b": @2, @"c": @3};
+    
+    FDevice *secondDevice = [[FDevice alloc] initOnlineWithUrl:[writerRef description] ];
+    [secondDevice waitForIdleUsingWaiter:self];
+    [secondDevice do:^(FIRDatabaseReference *ref) {
+        [self waitForCompletionOf:ref setValue:newData];
+    }];
+    [secondDevice dispose];
+    
+    //Normal observe should return previous data
+    __block BOOL done = NO;
+    done = NO;
+    [device do:^(FIRDatabaseReference *ref) {
+        [ref observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
+            XCTAssertEqualObjects(data, [snapshot value], @"Properly saw node value");
+            done = YES;
+        }];
+    }];
+    WAIT_FOR(done);
+    
+    //queryWithBypassCache observe should return new data from server
+    done = NO;
+    [device do:^(FIRDatabaseReference *ref) {
+        [ref.queryWithBypassCache observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
+            XCTAssertEqualObjects(newData, [snapshot value], @"Properly saw node value");
+            done = YES;
+        }];
+    }];
+    WAIT_FOR(done);
+    
+    [device dispose];
+}
+
+- (void)testServerDataNotReturnedWhenQueryWithBypassCacheWhenOffline {
+    FIRDatabaseReference *writerRef = [FTestHelpers getRandomNode];
+    FDevice *device = [[FDevice alloc] initOnlineWithUrl:[writerRef description] ];
+    __block BOOL done = NO;
+    id data = @{@"a": @1, @"b": @2};
+    [writerRef setValue:data withCompletionBlock:^(NSError *error, FIRDatabaseReference *ref) {
+        done = YES;
+    }];
+    WAIT_FOR(done);
+
+    // Wait for the data to get it cached.
+    [device do:^(FIRDatabaseReference *ref) {
+        [self waitForValueOf:ref toBe:data];
+    }];
+
+    // Write new data using different device so not cached
+    id newData = @{@"a": @1, @"b": @2, @"c": @3};
+
+    FDevice *secondDevice = [[FDevice alloc] initOnlineWithUrl:[writerRef description] ];
+    [secondDevice do:^(FIRDatabaseReference *ref) {
+        [self waitForCompletionOf:ref setValue:newData];
+    }];
+    [secondDevice dispose];
+
+
+    [device goOffline];
+
+    //Normal observe should return previous cached data
+    done = NO;
+    [device do:^(FIRDatabaseReference *ref) {
+        [ref observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
+            XCTAssertEqualObjects(data, [snapshot value], @"Properly saw node value");
+            done = YES;
+        }];
+    }];
+    WAIT_FOR(done);
+
+    //queryWithBypassCache observe should not return data
+    XCTestExpectation *timeoutExpectation = [self expectationWithDescription:@"Should not be fulfilled"];
+    [timeoutExpectation setInverted:YES];
+
+    __block FIRDatabaseHandle handle;
+    __block FIRDatabaseQuery *handleRef;
+    [device do:^(FIRDatabaseReference *ref) {
+        handleRef = ref.queryWithBypassCache;
+        handle = [handleRef observeEventType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
+            [timeoutExpectation fulfill];
+        }];
+    }];
+
+    [self waitForExpectationsWithTimeout:kFirebaseTestWaitUntilTimeout handler:nil];
+    [handleRef removeObserverWithHandle:handle];
+
+    [device dispose];
+}
+
 - (void)testServerDataLimit {
     FIRDatabaseReference *writerRef = [FTestHelpers getRandomNode];
     FDevice *device = [[FDevice alloc] initOnlineWithUrl:[writerRef description] ];

Firebase/Database/Api/FIRDatabaseQuery.m

@@ -247,6 +247,15 @@ - (FIRDatabaseQuery *)queryEqualToInternal:(id)value
                              priorityMethodCalled:priorityMethod || self.priorityMethodCalled];
 }
 
+- (FIRDatabaseQuery *)queryWithBypassCache {
+    FQueryParams* params = [self.queryParams enableBypassCache];
+    return [[FIRDatabaseQuery alloc] initWithRepo:self.repo
+                                             path:self.path
+                                           params:params
+                                    orderByCalled:self.orderByCalled
+                             priorityMethodCalled:self.priorityMethodCalled];;
+}
+
 - (void)validateLimitRange:(NSUInteger)limit
 {
     // No need to check for negative ranges, since limit is unsigned

Firebase/Database/Core/FQueryParams.h

@@ -31,6 +31,8 @@
 
 @property (nonatomic, strong, readonly) id<FIndex> index;
 
+@property (nonatomic, readonly) BOOL bypassCache;
+
 - (BOOL)loadsAllData;
 - (BOOL)isDefault;
 - (BOOL)isValid;
@@ -47,6 +49,8 @@
 
 - (FQueryParams *) orderBy:(id<FIndex>) index;
 
+- (FQueryParams *) enableBypassCache;
+
 + (FQueryParams *) defaultInstance;
 + (FQueryParams *) fromQueryObject:(NSDictionary *)dict;
 

Firebase/Database/Core/FQueryParams.m

@@ -73,6 +73,8 @@ - (id)init {
         self->_indexEndKey = nil;
 
         self->_index = [FPriorityIndex priorityIndex];
+        
+        self->_bypassCache = NO;
     }
     return self;
 }
@@ -158,6 +160,8 @@ - (id) mutableCopy {
     other->_indexEndKey = _indexEndKey;
     other->_viewFrom = _viewFrom;
     other->_index = _index;
+    other->_bypassCache = _bypassCache;
+    
     return other;
 }
 
@@ -215,6 +219,12 @@ - (FQueryParams *) orderBy:(id)newIndex {
     return newParams;
 }
 
+- (FQueryParams *) enableBypassCache {
+    FQueryParams *newParams = [self mutableCopy];
+    newParams->_bypassCache = YES;
+    return newParams;
+}
+
 - (NSDictionary *) wireProtocolParams {
     NSMutableDictionary* dict = [[NSMutableDictionary alloc] init];
     if ([self hasStart]) {
@@ -353,6 +363,7 @@ - (BOOL) isEqual:(id)obj {
     if ((self->_indexStartValue != other->_indexStartValue) && ![self->_indexStartValue isEqual:other->_indexStartValue]) return NO;
     if ((self->_indexEndKey != other->_indexEndKey) && ![self->_indexEndKey isEqualToString:other->_indexEndKey]) return NO;
     if ((self->_indexEndValue != other->_indexEndValue) && ![self->_indexEndValue isEqual:other->_indexEndValue]) return NO;
+    if (self->_bypassCache != other->_bypassCache) return NO;
     if ([self isViewFromLeft] != [other isViewFromLeft]) return NO;
 
     return YES;
@@ -366,6 +377,8 @@ - (NSUInteger) hash {
     result = 31 * result + [_indexEndKey hash];
     result = 31 * result + [_indexEndValue hash];
     result = 31 * result + [_index hash];
+    result = 31 * result + (_bypassCache ? 1232 : 1238);
+    
     return result;
 }
 

Firebase/Database/FIRDatabaseReference.m

@@ -374,6 +374,9 @@ - (FIRDatabaseQuery *)queryEqualToValue:(id)value childKey:(NSString *)childKey
     return [super queryEqualToValue:value childKey:childKey];
 }
 
+- (FIRDatabaseQuery *)queryWithBypassCache {
+    return [super queryWithBypassCache];
+}
 
 #pragma mark -
 #pragma mark Transaction methods

Firebase/Database/Persistence/FPersistenceManager.m

@@ -24,6 +24,7 @@
 #import "FUtilities.h"
 #import "FPruneForest.h"
 #import "FClock.h"
+#import "FSnapshotUtilities.h"
 
 @interface FPersistenceManager ()
 
@@ -77,24 +78,29 @@ - (FCacheNode *)serverCacheForQuery:(FQuerySpec *)query {
     NSSet *trackedKeys;
     BOOL complete;
     // TODO[offline]: Should we use trackedKeys to find out if this location is a child of a complete query?
-    if ([self.trackedQueryManager isQueryComplete:query]) {
-        complete = YES;
-        FTrackedQuery *trackedQuery = [self.trackedQueryManager findTrackedQuery:query];
-        if (!query.loadsAllData && trackedQuery.isComplete) {
-            trackedKeys = [self.storageEngine trackedQueryKeysForQuery:trackedQuery.queryId];
+    id<FNode> node;
+    if (query.params.bypassCache) {
+        complete = NO;
+        node = [FSnapshotUtilities nodeFrom:nil];
+    }else{
+        if ([self.trackedQueryManager isQueryComplete:query]) {
+            complete = YES;
+            FTrackedQuery *trackedQuery = [self.trackedQueryManager findTrackedQuery:query];
+            if (!query.loadsAllData && trackedQuery.isComplete) {
+                trackedKeys = [self.storageEngine trackedQueryKeysForQuery:trackedQuery.queryId];
+            } else {
+                trackedKeys = nil;
+            }
         } else {
-            trackedKeys = nil;
+            complete = NO;
+            trackedKeys = [self.trackedQueryManager knownCompleteChildrenAtPath:query.path];
+        }
+        
+        if (trackedKeys != nil) {
+            node = [self.storageEngine serverCacheForKeys:trackedKeys atPath:query.path];
+        } else {
+            node = [self.storageEngine serverCacheAtPath:query.path];
         }
-    } else {
-        complete = NO;
-        trackedKeys = [self.trackedQueryManager knownCompleteChildrenAtPath:query.path];
-    }
-
-    id<FNode> node;
-    if (trackedKeys != nil) {
-        node = [self.storageEngine serverCacheForKeys:trackedKeys atPath:query.path];
-    } else {
-        node = [self.storageEngine serverCacheAtPath:query.path];
     }
 
     FIndexedNode *indexedNode = [FIndexedNode indexedNodeWithNode:node index:query.index];

Firebase/Database/Public/FIRDatabaseQuery.h

@@ -299,6 +299,12 @@ NS_SWIFT_NAME(DatabaseQuery)
  */
 - (FIRDatabaseQuery *)queryEqualToValue:(nullable id)value childKey:(nullable NSString *)childKey;
 
+/**
+ * queryWithBypassCache is used to generate a query that will not return cachedData.
+ *
+ * @return A FIRDatabaseQuery instance, that will not return cached data.
+ */
+- (FIRDatabaseQuery *)queryWithBypassCache;
 
 #pragma mark - Properties
 

Firebase/Database/Public/FIRDatabaseReference.h

@@ -450,6 +450,13 @@ is meant to be preserved, you should use setValue:andPriority: instead.
  */
 - (FIRDatabaseQuery *)queryEqualToValue:(nullable id)value childKey:(nullable NSString *)childKey;
 
+/**
+ * queryWithBypassCache is used to generate a query that will not return cachedData
+ *
+ * @return A FIRDatabaseQuery instance, that will not return cached data.
+ */
+- (FIRDatabaseQuery *)queryWithBypassCache;
+
 #pragma mark - Managing presence
 
 /**