Implement QueryCache interface and port QueryCache tests (#2209)

* Implement QueryCache interface and port tests

* Port production usages of QueryCache (#2211)

* Remove FSTQueryCache and implementations

* Switch size() to size_t

Author: Greg Soltis

Firestore/Example/Tests/Local/FSTLRUGarbageCollectorTests.mm

@@ -25,12 +25,12 @@
 #import "Firestore/Source/Local/FSTLRUGarbageCollector.h"
 #import "Firestore/Source/Local/FSTMutationQueue.h"
 #import "Firestore/Source/Local/FSTPersistence.h"
-#import "Firestore/Source/Local/FSTQueryCache.h"
 #import "Firestore/Source/Model/FSTDocument.h"
 #import "Firestore/Source/Model/FSTFieldValue.h"
 #import "Firestore/Source/Model/FSTMutation.h"
 #import "Firestore/Source/Util/FSTClasses.h"
 #include "Firestore/core/src/firebase/firestore/auth/user.h"
+#include "Firestore/core/src/firebase/firestore/local/query_cache.h"
 #include "Firestore/core/src/firebase/firestore/local/reference_set.h"
 #include "Firestore/core/src/firebase/firestore/local/remote_document_cache.h"
 #include "Firestore/core/src/firebase/firestore/model/document_key_set.h"
@@ -43,6 +43,7 @@
 using firebase::firestore::auth::User;
 using firebase::firestore::local::LruParams;
 using firebase::firestore::local::LruResults;
+using firebase::firestore::local::QueryCache;
 using firebase::firestore::local::ReferenceSet;
 using firebase::firestore::local::RemoteDocumentCache;
 using firebase::firestore::model::DocumentKey;
@@ -60,7 +61,7 @@ @implementation FSTLRUGarbageCollectorTests {
   FSTObjectValue *_testValue;
   FSTObjectValue *_bigObjectValue;
   id<FSTPersistence> _persistence;
-  id<FSTQueryCache> _queryCache;
+  QueryCache *_queryCache;
   RemoteDocumentCache *_documentCache;
   id<FSTMutationQueue> _mutationQueue;
   id<FSTLRUDelegate> _lruDelegate;
@@ -155,7 +156,7 @@ - (FSTQueryData *)nextTestQuery {
 
 - (FSTQueryData *)addNextQueryInTransaction {
   FSTQueryData *queryData = [self nextTestQuery];
-  [_queryCache addQueryData:queryData];
+  _queryCache->AddTarget(queryData);
   return queryData;
 }
 
@@ -165,7 +166,7 @@ - (void)updateTargetInTransaction:(FSTQueryData *)queryData {
       [queryData queryDataByReplacingSnapshotVersion:queryData.snapshotVersion
                                          resumeToken:token
                                       sequenceNumber:_persistence.currentSequenceNumber];
-  [_queryCache updateQueryData:updated];
+  _queryCache->UpdateTarget(updated);
 }
 
 - (FSTQueryData *)addNextQuery {
@@ -199,11 +200,11 @@ - (void)markDocumentEligibleForGCInTransaction:(const DocumentKey &)docKey {
 }
 
 - (void)addDocument:(const DocumentKey &)docKey toTarget:(TargetId)targetId {
-  [_queryCache addMatchingKeys:DocumentKeySet{docKey} forTargetID:targetId];
+  _queryCache->AddMatchingKeys(DocumentKeySet{docKey}, targetId);
 }
 
 - (void)removeDocument:(const DocumentKey &)docKey fromTarget:(TargetId)targetId {
-  [_queryCache removeMatchingKeys:DocumentKeySet{docKey} forTargetID:targetId];
+  _queryCache->RemoveMatchingKeys(DocumentKeySet{docKey}, targetId);
 }
 
 /**
@@ -392,9 +393,9 @@ - (void)testRemoveQueriesUpThroughSequenceNumber {
   XCTAssertEqual(10, removed);
   // Make sure we removed the even targets with targetID <= 20.
   _persistence.run("verify remaining targets are > 20 or odd", [&]() {
-    [_queryCache enumerateTargetsUsingBlock:^(FSTQueryData *queryData, BOOL *stop) {
+    _queryCache->EnumerateTargets(^(FSTQueryData *queryData, BOOL *stop) {
       XCTAssertTrue(queryData.targetID > 20 || queryData.targetID % 2 == 1);
-    }];
+    });
   });
   [_persistence shutdown];
 }
@@ -467,7 +468,7 @@ - (void)testRemoveOrphanedDocuments {
   _persistence.run("verify", [&]() {
     for (const DocumentKey &key : toBeRemoved) {
       XCTAssertNil(_documentCache->Get(key));
-      XCTAssertFalse([_queryCache containsKey:key]);
+      XCTAssertFalse(_queryCache->Contains(key));
     }
     for (const DocumentKey &key : expectedRetained) {
       XCTAssertNotNil(_documentCache->Get(key), @"Missing document %s", key.ToString().c_str());
@@ -649,7 +650,7 @@ - (void)testRemoveTargetsThenGC {
     for (const DocumentKey &key : expectedRemoved) {
       XCTAssertNil(_documentCache->Get(key), @"Did not expect to find %s in document cache",
                    key.ToString().c_str());
-      XCTAssertFalse([_queryCache containsKey:key], @"Did not expect to find %s in queryCache",
+      XCTAssertFalse(_queryCache->Contains(key), @"Did not expect to find %s in queryCache",
                      key.ToString().c_str());
       [self expectSentinelRemoved:key];
     }

Firestore/Example/Tests/Local/FSTLevelDBMigrationsTests.mm

@@ -24,10 +24,10 @@
 #import "Firestore/Protos/objc/firestore/local/Target.pbobjc.h"
 #import "Firestore/Source/Local/FSTLevelDB.h"
 #import "Firestore/Source/Local/FSTLevelDBMutationQueue.h"
-#import "Firestore/Source/Local/FSTLevelDBQueryCache.h"
 
 #include "Firestore/core/src/firebase/firestore/local/leveldb_key.h"
 #include "Firestore/core/src/firebase/firestore/local/leveldb_migrations.h"
+#include "Firestore/core/src/firebase/firestore/local/leveldb_query_cache.h"
 #include "Firestore/core/src/firebase/firestore/util/ordered_code.h"
 #include "Firestore/core/test/firebase/firestore/testutil/testutil.h"
 #include "absl/strings/match.h"
@@ -43,6 +43,7 @@
 using firebase::firestore::local::LevelDbMigrations;
 using firebase::firestore::local::LevelDbMutationKey;
 using firebase::firestore::local::LevelDbMutationQueueKey;
+using firebase::firestore::local::LevelDbQueryCache;
 using firebase::firestore::local::LevelDbQueryTargetKey;
 using firebase::firestore::local::LevelDbRemoteDocumentKey;
 using firebase::firestore::local::LevelDbTargetDocumentKey;
@@ -86,11 +87,11 @@ - (void)tearDown {
 }
 
 - (void)testAddsTargetGlobal {
-  FSTPBTargetGlobal *metadata = [FSTLevelDBQueryCache readTargetMetadataFromDB:_db.get()];
+  FSTPBTargetGlobal *metadata = LevelDbQueryCache::ReadMetadata(_db.get());
   XCTAssertNil(metadata, @"Not expecting metadata yet, we should have an empty db");
   LevelDbMigrations::RunMigrations(_db.get());
 
-  metadata = [FSTLevelDBQueryCache readTargetMetadataFromDB:_db.get()];
+  metadata = LevelDbQueryCache::ReadMetadata(_db.get());
   XCTAssertNotNil(metadata, @"Migrations should have added the metadata");
 }
 
@@ -166,7 +167,7 @@ - (void)testDropsTheQueryCache {
       ASSERT_FOUND(transaction, key);
     }
 
-    FSTPBTargetGlobal *metadata = [FSTLevelDBQueryCache readTargetMetadataFromDB:_db.get()];
+    FSTPBTargetGlobal *metadata = LevelDbQueryCache::ReadMetadata(_db.get());
     XCTAssertNotNil(metadata, @"Metadata should have been added");
     XCTAssertEqual(metadata.targetCount, 0);
   }
@@ -209,7 +210,7 @@ - (void)testAddsSentinelRows {
     LevelDbTransaction transaction(_db.get(), "Setup");
 
     // Set up target global
-    FSTPBTargetGlobal *metadata = [FSTLevelDBQueryCache readTargetMetadataFromDB:_db.get()];
+    FSTPBTargetGlobal *metadata = LevelDbQueryCache::ReadMetadata(_db.get());
     // Expect that documents missing a row will get the new number
     metadata.highestListenSequenceNumber = new_sequence_number;
     transaction.Put(LevelDbTargetGlobalKey::Key(), metadata);

Firestore/Example/Tests/Local/FSTLevelDBQueryCacheTests.mm

@@ -14,26 +14,28 @@
  * limitations under the License.
  */
 
-#import "Firestore/Source/Local/FSTLevelDBQueryCache.h"
-
 #import "Firestore/Source/Core/FSTQuery.h"
 #import "Firestore/Source/Local/FSTLevelDB.h"
-#import "Firestore/Source/Local/FSTLocalSerializer.h"
 #import "Firestore/Source/Local/FSTQueryData.h"
-#import "Firestore/Source/Remote/FSTSerializerBeta.h"
 
 #import "Firestore/Example/Tests/Local/FSTPersistenceTestHelpers.h"
 #import "Firestore/Example/Tests/Local/FSTQueryCacheTests.h"
 
 #include "Firestore/core/include/firebase/firestore/timestamp.h"
+#include "Firestore/core/src/firebase/firestore/local/leveldb_query_cache.h"
 #include "Firestore/core/src/firebase/firestore/local/reference_set.h"
 #include "Firestore/core/src/firebase/firestore/model/database_id.h"
+#include "Firestore/core/src/firebase/firestore/model/document_key.h"
 #include "Firestore/core/src/firebase/firestore/model/resource_path.h"
 #include "Firestore/core/src/firebase/firestore/model/snapshot_version.h"
+#include "Firestore/core/test/firebase/firestore/testutil/testutil.h"
 
+namespace testutil = firebase::firestore::testutil;
 using firebase::Timestamp;
+using firebase::firestore::local::LevelDbQueryCache;
 using firebase::firestore::local::ReferenceSet;
 using firebase::firestore::model::DatabaseId;
+using firebase::firestore::model::DocumentKey;
 using firebase::firestore::model::ListenSequenceNumber;
 using firebase::firestore::model::ResourcePath;
 using firebase::firestore::model::SnapshotVersion;
@@ -54,11 +56,15 @@ @implementation FSTLevelDBQueryCacheTests {
   ReferenceSet _additionalReferences;
 }
 
+- (LevelDbQueryCache *)getCache:(id<FSTPersistence>)persistence {
+  return static_cast<LevelDbQueryCache *>(persistence.queryCache);
+}
+
 - (void)setUp {
   [super setUp];
 
   self.persistence = [FSTPersistenceTestHelpers levelDBPersistence];
-  self.queryCache = [self.persistence queryCache];
+  self.queryCache = [self getCache:self.persistence];
   [self.persistence.referenceDelegate addInMemoryPins:&_additionalReferences];
 }
 
@@ -75,12 +81,12 @@ - (void)testMetadataPersistedAcrossRestarts {
   Path dir = [FSTPersistenceTestHelpers levelDBDir];
 
   FSTLevelDB *db1 = [FSTPersistenceTestHelpers levelDBPersistenceWithDir:dir];
-  FSTLevelDBQueryCache *queryCache = [db1 queryCache];
+  LevelDbQueryCache *queryCache = [self getCache:db1];
 
-  XCTAssertEqual(0, queryCache.highestListenSequenceNumber);
-  XCTAssertEqual(0, queryCache.highestTargetID);
+  XCTAssertEqual(0, queryCache->highest_listen_sequence_number());
+  XCTAssertEqual(0, queryCache->highest_target_id());
   SnapshotVersion versionZero;
-  XCTAssertEqual(versionZero, queryCache.lastRemoteSnapshotVersion);
+  XCTAssertEqual(versionZero, queryCache->GetLastRemoteSnapshotVersion());
 
   ListenSequenceNumber minimumSequenceNumber = 1234;
   TargetId lastTargetId = 5;
@@ -92,8 +98,8 @@ - (void)testMetadataPersistedAcrossRestarts {
                                                          targetID:lastTargetId
                                              listenSequenceNumber:minimumSequenceNumber
                                                           purpose:FSTQueryPurposeListen];
-    [queryCache addQueryData:queryData];
-    [queryCache setLastRemoteSnapshotVersion:lastVersion];
+    queryCache->AddTarget(queryData);
+    queryCache->SetLastRemoteSnapshotVersion(lastVersion);
   });
 
   [db1 shutdown];
@@ -106,14 +112,40 @@ - (void)testMetadataPersistedAcrossRestarts {
     XCTAssertGreaterThan(db2.currentSequenceNumber, minimumSequenceNumber);
   });
 
-  FSTLevelDBQueryCache *queryCache2 = [db2 queryCache];
-  XCTAssertEqual(lastTargetId, queryCache2.highestTargetID);
-  XCTAssertEqual(lastVersion, queryCache2.lastRemoteSnapshotVersion);
+  LevelDbQueryCache *queryCache2 = [self getCache:db2];
+  XCTAssertEqual(lastTargetId, queryCache2->highest_target_id());
+  XCTAssertEqual(lastVersion, queryCache2->GetLastRemoteSnapshotVersion());
 
   [db2 shutdown];
   db2 = nil;
 }
 
+- (void)testRemoveMatchingKeysForTargetID {
+  self.persistence.run("testRemoveMatchingKeysForTargetID", [&]() {
+    DocumentKey key1 = testutil::Key("foo/bar");
+    DocumentKey key2 = testutil::Key("foo/baz");
+    DocumentKey key3 = testutil::Key("foo/blah");
+
+    LevelDbQueryCache *cache = [self getCache:self.persistence];
+    [self addMatchingKey:key1 forTargetID:1];
+    [self addMatchingKey:key2 forTargetID:1];
+    [self addMatchingKey:key3 forTargetID:2];
+    XCTAssertTrue(cache->Contains(key1));
+    XCTAssertTrue(cache->Contains(key2));
+    XCTAssertTrue(cache->Contains(key3));
+
+    cache->RemoveAllKeysForTarget(1);
+    XCTAssertFalse(self.queryCache->Contains(key1));
+    XCTAssertFalse(self.queryCache->Contains(key2));
+    XCTAssertTrue(self.queryCache->Contains(key3));
+
+    cache->RemoveAllKeysForTarget(2);
+    XCTAssertFalse(self.queryCache->Contains(key1));
+    XCTAssertFalse(self.queryCache->Contains(key2));
+    XCTAssertFalse(self.queryCache->Contains(key3));
+  });
+}
+
 @end
 
 NS_ASSUME_NONNULL_END

Firestore/Example/Tests/Local/FSTLocalStoreTests.mm

@@ -22,7 +22,6 @@
 #import "Firestore/Source/Core/FSTQuery.h"
 #import "Firestore/Source/Local/FSTLocalWriteResult.h"
 #import "Firestore/Source/Local/FSTPersistence.h"
-#import "Firestore/Source/Local/FSTQueryCache.h"
 #import "Firestore/Source/Local/FSTQueryData.h"
 #import "Firestore/Source/Model/FSTDocument.h"
 #import "Firestore/Source/Model/FSTDocumentSet.h"

Firestore/Example/Tests/Local/FSTMemoryQueryCacheTests.mm

@@ -14,8 +14,6 @@
  * limitations under the License.
  */
 
-#import "Firestore/Source/Local/FSTMemoryQueryCache.h"
-
 #import "Firestore/Source/Local/FSTMemoryPersistence.h"
 
 #import "Firestore/Example/Tests/Local/FSTPersistenceTestHelpers.h"
@@ -43,7 +41,7 @@ - (void)setUp {
   [super setUp];
 
   self.persistence = [FSTPersistenceTestHelpers eagerGCMemoryPersistence];
-  self.queryCache = [self.persistence queryCache];
+  self.queryCache = self.persistence.queryCache;
   [self.persistence.referenceDelegate addInMemoryPins:&_additionalReferences];
 }
 

Firestore/Example/Tests/Local/FSTQueryCacheTests.h

@@ -14,27 +14,33 @@
  * limitations under the License.
  */
 
-#import "Firestore/Source/Local/FSTQueryCache.h"
-
 #import <XCTest/XCTest.h>
 
+#include "Firestore/core/src/firebase/firestore/local/query_cache.h"
+#include "Firestore/core/src/firebase/firestore/model/document_key.h"
+#include "Firestore/core/src/firebase/firestore/model/types.h"
+
 @protocol FSTPersistence;
 
 NS_ASSUME_NONNULL_BEGIN
 
 /**
- * These are tests for any implementation of the FSTQueryCache protocol.
+ * These are tests for any implementation of the QueryCache interface.
  *
- * To test a specific implementation of FSTQueryCache:
+ * To test a specific implementation of QueryCache:
  *
  * + Subclass FSTQueryCacheTests
  * + override -setUp, assigning to queryCache and persistence
  * + override -tearDown, cleaning up queryCache and persistence
  */
 @interface FSTQueryCacheTests : XCTestCase
 
+/** Helper method to add a single document key to target association */
+- (void)addMatchingKey:(const firebase::firestore::model::DocumentKey&)key
+           forTargetID:(firebase::firestore::model::TargetId)targetID;
+
 /** The implementation of the query cache to test. */
-@property(nonatomic, strong, nullable) id<FSTQueryCache> queryCache;
+@property(nonatomic, nullable) firebase::firestore::local::QueryCache* queryCache;
 
 /**
  * The persistence implementation to use while testing the queryCache (e.g. for committing write