Relaxing in restrictions.

packages/firestore/test/integration/api/query.test.ts

@@ -1549,7 +1549,7 @@ apiDescribe('Queries', (persistence: boolean) => {
 
   // TODO(orquery): Enable this test when prod supports OR queries.
   // eslint-disable-next-line no-restricted-properties
-  it.skip('supports multiple in ops', () => {
+  it('supports multiple in ops', () => {
     const testDocs = {
       doc1: { a: 1, b: 0 },
       doc2: { b: 1 },
@@ -1663,9 +1663,7 @@ apiDescribe('Queries', (persistence: boolean) => {
         'doc4',
         'doc6'
       );
-    });
 
-    return withTestCollection(persistence, testDocs, async coll => {
       await checkOnlineAndOfflineResultsMatch(
         query(
           coll,
@@ -1676,31 +1674,26 @@ apiDescribe('Queries', (persistence: boolean) => {
         ),
         'doc3'
       );
-    });
 
-    return withTestCollection(persistence, testDocs, async coll => {
       await checkOnlineAndOfflineResultsMatch(
         query(
           coll,
           or(
-            where('a', 'in', [2, 3]),
-            where('c', '==', 10),
+            and(where('a', 'in', [2, 3]), where('c', '==', 10)),
             where('b', 'array-contains-any', [0, 7])
           )
         ),
         'doc1',
         'doc3',
         'doc4'
       );
-    });
 
-    return withTestCollection(persistence, testDocs, async coll => {
       await checkOnlineAndOfflineResultsMatch(
         query(
           coll,
           and(
             where('a', 'in', [2, 3]),
-            or(where('b', 'array-contains-any', [0, 7]), where('c', '==', 10))
+            or(where('b', 'array-contains-any', [0, 7]), where('c', '==', 20))
           )
         ),
         'doc3',
@@ -1731,34 +1724,28 @@ apiDescribe('Queries', (persistence: boolean) => {
         'doc4',
         'doc6'
       );
-    });
 
-    return withTestCollection(persistence, testDocs, async coll => {
       await checkOnlineAndOfflineResultsMatch(
         query(
           coll,
           and(where('a', 'in', [2, 3]), where('b', 'array-contains', 7))
         ),
         'doc3'
       );
-    });
 
-    return withTestCollection(persistence, testDocs, async coll => {
       await checkOnlineAndOfflineResultsMatch(
         query(
           coll,
           or(
             where('a', 'in', [2, 3]),
-            and(where('b', 'array-contains', 3), where('b', '==', 1))
+            and(where('b', 'array-contains', 3), where('a', '==', 1))
           )
         ),
         'doc3',
         'doc4',
         'doc6'
       );
-    });
 
-    return withTestCollection(persistence, testDocs, async coll => {
       await checkOnlineAndOfflineResultsMatch(
         query(
           coll,
@@ -1791,6 +1778,12 @@ apiDescribe('Queries', (persistence: boolean) => {
         'doc4',
         'doc5'
       );
+
+      await checkOnlineAndOfflineResultsMatch(
+        query(coll, where('a', 'in', [2, 3]), orderBy('a')),
+        'doc6',
+        'doc3'
+      );
     });
   });
 });

packages/firestore/test/integration/api/validation.test.ts

@@ -961,106 +961,123 @@ apiDescribe('Validation:', (persistence: boolean) => {
       );
     });
 
-    validationIt(persistence, 'with multiple disjunctive filters fail', db => {
-      expect(() =>
-        query(
-          collection(db, 'test'),
-          where('foo', 'not-in', [1, 2]),
-          where('foo', 'not-in', [2, 3])
-        )
-      ).to.throw(
-        "Invalid query. You cannot use more than one 'not-in' filter."
-      );
+    validationIt.only(
+      persistence,
+      'with multiple disjunctive filters fail',
+      db => {
+        expect(() =>
+          query(
+            collection(db, 'test'),
+            where('foo', 'not-in', [1, 2]),
+            where('foo', 'not-in', [2, 3])
+          )
+        ).to.throw(
+          "Invalid query. You cannot use more than one 'not-in' filter."
+        );
 
-      expect(() =>
-        query(
-          collection(db, 'test'),
-          where('foo', 'array-contains-any', [1, 2]),
-          where('foo', 'array-contains-any', [2, 3])
-        )
-      ).to.throw(
-        "Invalid query. You cannot use more than one 'array-contains-any'" +
-          ' filter.'
-      );
+        expect(() =>
+          query(
+            collection(db, 'test'),
+            where('foo', 'array-contains-any', [1, 2]),
+            where('foo', 'array-contains-any', [2, 3])
+          )
+        ).to.throw(
+          "Invalid query. You cannot use more than one 'array-contains-any'" +
+            ' filter.'
+        );
 
-      expect(() =>
-        query(
-          collection(db, 'test'),
-          where('foo', 'not-in', [2, 3]),
-          where('foo', 'array-contains-any', [2, 3])
-        )
-      ).to.throw(
-        "Invalid query. You cannot use 'array-contains-any' filters with " +
-          "'not-in' filters."
-      );
+        expect(() =>
+          query(
+            collection(db, 'test'),
+            where('foo', 'not-in', [2, 3]),
+            where('foo', 'array-contains-any', [2, 3])
+          )
+        ).to.throw(
+          "Invalid query. You cannot use 'array-contains-any' filters with " +
+            "'not-in' filters."
+        );
 
-      expect(() =>
-        query(
-          collection(db, 'test'),
-          where('foo', 'array-contains-any', [2, 3]),
-          where('foo', 'not-in', [2, 3])
-        )
-      ).to.throw(
-        "Invalid query. You cannot use 'not-in' filters with " +
-          "'array-contains-any' filters."
-      );
+        expect(() =>
+          query(
+            collection(db, 'test'),
+            where('foo', 'array-contains-any', [2, 3]),
+            where('foo', 'not-in', [2, 3])
+          )
+        ).to.throw(
+          "Invalid query. You cannot use 'not-in' filters with " +
+            "'array-contains-any' filters."
+        );
 
-      expect(() =>
-        query(
-          collection(db, 'test'),
-          where('foo', 'not-in', [2, 3]),
-          where('foo', 'in', [2, 3])
-        )
-      ).to.throw(
-        "Invalid query. You cannot use 'in' filters with 'not-in' filters."
-      );
+        expect(() =>
+          query(
+            collection(db, 'test'),
+            where('foo', 'not-in', [2, 3]),
+            where('foo', 'in', [2, 3])
+          )
+        ).to.throw(
+          "Invalid query. You cannot use 'in' filters with 'not-in' filters."
+        );
 
-      expect(() =>
-        query(
-          collection(db, 'test'),
-          where('foo', 'in', [2, 3]),
-          where('foo', 'not-in', [2, 3])
-        )
-      ).to.throw(
-        "Invalid query. You cannot use 'not-in' filters with 'in' filters."
-      );
+        expect(() =>
+          query(
+            collection(db, 'test'),
+            where('foo', 'in', [2, 3]),
+            where('foo', 'not-in', [2, 3])
+          )
+        ).to.throw(
+          "Invalid query. You cannot use 'not-in' filters with 'in' filters."
+        );
 
-      expect(() =>
-        query(
-          collection(db, 'test'),
-          where('foo', 'array-contains', 1),
-          where('foo', 'in', [2, 3]),
-          where('foo', 'array-contains-any', [2])
-        )
-      ).to.throw(
-        "Invalid query. You cannot use 'array-contains-any' filters with " +
-          "'array-contains' filters."
-      );
+        // This is redundant with the above tests, but makes sure our validation
+        // doesn't get confused.
+        expect(() =>
+          query(
+            collection(db, 'test'),
+            where('foo', 'in', [2, 3]),
+            where('foo', 'array-contains', 1),
+            where('foo', 'array-contains-any', [2])
+          )
+        ).to.throw(
+          "Invalid query. You cannot use 'array-contains-any' filters with 'array-contains' filters."
+        );
 
-      expect(() =>
-        query(
-          collection(db, 'test'),
-          where('foo', 'not-in', [2, 3]),
-          where('foo', 'array-contains', 2),
-          where('foo', 'array-contains-any', [2])
-        )
-      ).to.throw(
-        "Invalid query. You cannot use 'array-contains' filters with " +
-          "'not-in' filters."
-      );
+        expect(() =>
+          query(
+            collection(db, 'test'),
+            where('foo', 'array-contains', 1),
+            where('foo', 'in', [2, 3]),
+            where('foo', 'array-contains-any', [2])
+          )
+        ).to.throw(
+          "Invalid query. You cannot use 'array-contains-any' filters with " +
+            "'array-contains' filters."
+        );
 
-      expect(() =>
-        query(
-          collection(db, 'test'),
-          where('foo', 'array-contains', 2),
-          where('foo', 'in', [2]),
-          where('foo', 'not-in', [2, 3])
-        )
-      ).to.throw(
-        "Invalid query. You cannot use 'not-in' filters with " +
-          "'array-contains' filters."
-      );
-    });
+        expect(() =>
+          query(
+            collection(db, 'test'),
+            where('foo', 'not-in', [2, 3]),
+            where('foo', 'array-contains', 2),
+            where('foo', 'array-contains-any', [2])
+          )
+        ).to.throw(
+          "Invalid query. You cannot use 'array-contains' filters with " +
+            "'not-in' filters."
+        );
+
+        expect(() =>
+          query(
+            collection(db, 'test'),
+            where('foo', 'array-contains', 2),
+            where('foo', 'in', [2]),
+            where('foo', 'not-in', [2, 3])
+          )
+        ).to.throw(
+          "Invalid query. You cannot use 'not-in' filters with " +
+            "'array-contains' filters."
+        );
+      }
+    );
 
     validationIt(
       persistence,