public void Equality()
        {
            var query    = s_db.Collection("col1");
            var readTime = new Timestamp(10, 2);
            var doc1     = GetSampleSnapshot(s_db, "doc1");
            var doc2     = GetSampleSnapshot(s_db, "doc2");
            var doc3     = GetSampleSnapshot(s_db, "doc3");

            var docs    = new[] { doc1, doc2 };
            var control = QuerySnapshot.ForDocuments(query, docs, readTime);

            EqualityTester.AssertEqual(control,
                                       // Distinct but equal values for query and snapshots, but a different timestamp
                                       equal: new[] { QuerySnapshot.ForDocuments(s_db.Collection("col1"), new[] { GetSampleSnapshot(s_db, "doc1"), doc2 }, new Timestamp(12, 13)) },
                                       unequal: new[] {
                // Unequal query
                QuerySnapshot.ForDocuments(query.Offset(0), docs, readTime),
                // No doc2
                QuerySnapshot.ForDocuments(query, new[] { doc1 }, readTime),
                // Extra doc3
                QuerySnapshot.ForDocuments(query, new[] { doc1, doc2, doc3 }, readTime),
                // Order matters
                QuerySnapshot.ForDocuments(query, new[] { doc2, doc1 }, readTime),
            });

            // Note: no test for the changes being compared. It would be overkill at the moment.
        }
Example #2
0
 public void Equality_CollectionGroup()
 {
     EqualityTester.AssertEqual(s_db.CollectionGroup("col"),
                                equal: new[] { s_db.CollectionGroup("col") },
                                unequal: new[] { s_db.Collection("col") }
                                );
 }
        public void Equality()
        {
            var snapshot = GetSampleSnapshot("doc1");

            var control = new DocumentChange(snapshot, DocumentChange.Type.Modified, 3, 2);

            EqualityTester.AssertEqual(control,
                                       // Distinct but equal document snapshots
                                       equal: new[] { new DocumentChange(GetSampleSnapshot("doc1"), DocumentChange.Type.Modified, 3, 2) },
                                       unequal: new[] {
                // Different document
                new DocumentChange(GetSampleSnapshot("doc2"), DocumentChange.Type.Modified, 3, 2),
                // These indexes don't actually make sense for added, but it's simplest to change things independently
                new DocumentChange(snapshot, DocumentChange.Type.Added, 3, 2),
                new DocumentChange(snapshot, DocumentChange.Type.Modified, 4, 2),
                new DocumentChange(snapshot, DocumentChange.Type.Modified, 3, 1),
                new DocumentChange(snapshot, DocumentChange.Type.Modified, null, 2),
                new DocumentChange(snapshot, DocumentChange.Type.Modified, 3, null),
            });

            // Null matching checks
            EqualityTester.AssertEqual(new DocumentChange(snapshot, DocumentChange.Type.Added, null, 2),
                                       equal: new[] { new DocumentChange(snapshot, DocumentChange.Type.Added, null, 2) },
                                       unequal: new[] { new DocumentChange(snapshot, DocumentChange.Type.Added, 0, 2) });
            EqualityTester.AssertEqual(new DocumentChange(snapshot, DocumentChange.Type.Removed, 1, null),
                                       equal: new[] { new DocumentChange(snapshot, DocumentChange.Type.Removed, 1, null) },
                                       unequal: new[] { new DocumentChange(snapshot, DocumentChange.Type.Removed, 1, 1) });
        }
        public void Equality()
        {
            var client = new FakeFirestoreClient();
            var db1    = FirestoreDb.Create("proj", "db", client);
            var db2    = FirestoreDb.Create("proj", "db", client);
            var db3    = FirestoreDb.Create("proj", "otherdb", client);

            var control = db1.Document("col1/doc1/col2/doc2");
            var equal   = new[]
            {
                db1.Document("col1/doc1/col2/doc2"),
                db2.Document("col1/doc1/col2/doc2"),
                db1.Collection("col1").Document("doc1").Collection("col2").Document("doc2")
            };
            var unequal = new[]
            {
                db1.Document("col1x/doc1/col2/doc2"),
                db1.Document("col1/doc1x/col2/doc2"),
                db1.Document("col1/doc1/col2x/doc2"),
                db1.Document("col1/doc1/col2/doc2x"),
                db3.Document("col1/doc1/col2/doc2"),
                db1.Document("col1/doc1"),
                db1.Document("col2/doc2"),
            };

            EqualityTester.AssertEqual(control, equal, unequal);
        }
        public void Equality()
        {
            var control = GetSampleSnapshot();
            var equalDb = FirestoreDb.Create("proj", "db", new FakeFirestoreClient());

            // Equal (but distinct) everything
            var doc1   = control.Document.Clone();
            var equal1 = DocumentSnapshot.ForDocument(equalDb, doc1, control.ReadTime);

            var doc2 = control.Document.Clone();

            doc2.CreateTime = null;
            doc2.UpdateTime = null;
            // Different create/update times
            var equal2 = DocumentSnapshot.ForDocument(equalDb, doc2, control.ReadTime);

            // Different read time
            var equal3 = DocumentSnapshot.ForDocument(equalDb, doc2, new Timestamp(10, 3));

            // Different fields
            var doc4 = doc1.Clone();

            doc4.Fields["other"] = new Value {
                StringValue = "different"
            };
            var unequal1 = DocumentSnapshot.ForDocument(equalDb, doc4, control.ReadTime);

            // Different name
            var doc5 = doc1.Clone();

            doc5.Name += "x";
            var unequal2 = DocumentSnapshot.ForDocument(equalDb, doc5, control.ReadTime);

            EqualityTester.AssertEqual(control, new[] { equal1, equal2, equal3 }, new[] { unequal1, unequal2 });
        }
        public void Equality_Complex()
        {
            // It doesn't matter what order the query calls are made in, other than for ordering + start etc.
            var col   = s_db.Collection("col");
            var query = col
                        .OrderBy("foo")
                        .StartAfter(20)
                        .EndBefore(30)
                        .Select("foo")
                        .WhereGreaterThan("bar", 20)
                        .Limit(20)
                        .Offset(3);

            EqualityTester.AssertEqual(query,
                                       equal: new[] {
                col.WhereGreaterThan("bar", 20)
                .Select("foo")
                .Offset(3)
                .OrderBy("foo")
                .EndBefore(30)
                .Limit(20)
                .StartAfter(20)
            },
                                       unequal: new[] {
                // Just one change here - the EndBefore argument
                col.WhereGreaterThan("bar", 20)
                .Select("foo")
                .Offset(3)
                .OrderBy("foo")
                .EndBefore(40)
                .Limit(20)
                .StartAfter(20)
            }
                                       );
        }
        public void Equality_Where()
        {
            var col   = s_db.Collection("col");
            var query = col.Where("field", QueryOperator.Equal, 10);

            EqualityTester.AssertEqual(query,
                                       equal: new[] {
                col.Where("field", QueryOperator.Equal, 10),                // Same value
                col.Where("field", QueryOperator.Equal, 10L),               // Same value after serialization
                col.Where(new FieldPath("field"), QueryOperator.Equal, 10), // FieldPath instead of Field
            },
                                       unequal: new[] {
                query.Where("field", QueryOperator.Equal, 10),    // Repeated filter doesn't replace (at the moment, anyway)
                col.Where("otherfield", QueryOperator.Equal, 10), // Different field
                col.Where("field", QueryOperator.LessThan, 10),   // Different operator
                col.Where("field", QueryOperator.Equal, 20),      // Different value
            }
                                       );

            query = col.Where("first", QueryOperator.Equal, "foo").Where("second", QueryOperator.Equal, "bar");
            EqualityTester.AssertEqual(query,
                                       equal: new[] {
                col.Where("first", QueryOperator.Equal, "foo").Where("second", QueryOperator.Equal, "bar")
            },
                                       unequal: new[] {
                // Ordering of filters matters
                col.Where("second", QueryOperator.Equal, "bar").Where("first", QueryOperator.Equal, "foo"),
                // It's not just a replacement
                col.Where("first", QueryOperator.Equal, "foo")
            }
                                       );
        }
        public void Equality()
        {
            // Note: timestamp choice can give false test failures, due to proto hash code computation.
            var timestamp1 = new Timestamp(10, 0);
            var timestamp2 = new Timestamp(10, 1);

            EqualityTester.AssertEqual(Precondition.None,
                                       equal: new[] { Precondition.None },
                                       unequal: new[] { Precondition.MustExist, Precondition.MustNotExist, Precondition.LastUpdated(timestamp1) }
                                       );

            EqualityTester.AssertEqual(Precondition.MustExist,
                                       equal: new[] { Precondition.MustExist },
                                       unequal: new[] { Precondition.MustNotExist, Precondition.LastUpdated(timestamp1) }
                                       );

            EqualityTester.AssertEqual(Precondition.MustNotExist,
                                       equal: new[] { Precondition.MustNotExist },
                                       unequal: new[] { Precondition.LastUpdated(timestamp1) }
                                       );

            EqualityTester.AssertEqual(Precondition.LastUpdated(timestamp1),
                                       equal: new[] { Precondition.LastUpdated(timestamp1) },
                                       unequal: new[] { Precondition.LastUpdated(timestamp2) }
                                       );
        }
Example #9
0
        public void Equality()
        {
            var query    = s_db.Collection("col1");
            var readTime = new Timestamp(10, 2);
            var doc1     = GetSampleSnapshot("doc1");
            var doc2     = GetSampleSnapshot("doc2");
            var doc3     = GetSampleSnapshot("doc3");

            var docs    = new[] { doc1, doc2 };
            var control = new QuerySnapshot(query, docs, readTime);

            EqualityTester.AssertEqual(control,
                                       // Distinct but equal values for query and snapshots, but a different timestamp
                                       equal: new[] { new QuerySnapshot(s_db.Collection("col1"), new[] { GetSampleSnapshot("doc1"), doc2 }, new Timestamp(12, 13)) },
                                       unequal: new[] {
                // Unequal query
                new QuerySnapshot(query.Offset(0), docs, readTime),
                // No doc2
                new QuerySnapshot(query, new[] { doc1 }, readTime),
                // Extra doc3
                new QuerySnapshot(query, new[] { doc1, doc2, doc3 }, readTime),
                // Order matters
                new QuerySnapshot(query, new[] { doc2, doc1 }, readTime),
            });
        }
Example #10
0
        public void Equality()
        {
            var control = new FieldPath("a", "b");
            var equal   = new[] { new FieldPath("a", "b"), FieldPath.FromDotSeparatedString("a.b") };
            var unequal = new[] { new FieldPath("a", "c") };

            EqualityTester.AssertEqual(control, equal, unequal);
        }
Example #11
0
        public void Equality()
        {
            var control = Blob.CopyFrom(new byte[] { 1, 2, 3, 4, 5 });
            var equal   = new[] { Blob.CopyFrom(new byte[] { 1, 2, 3, 4, 5 }) };
            var unequal = new[] { Blob.CopyFrom(new byte[] { 1, 2, 3, 4, 5, 6 }) };

            EqualityTester.AssertEqual(control, equal, unequal);
            EqualityTester.AssertEqualityOperators(control, equal, unequal);
        }
Example #12
0
        public void Equality_Limit()
        {
            var col   = s_db.Collection("col");
            var query = col.Limit(10);

            EqualityTester.AssertEqual(query,
                                       equal: new[] { col.Limit(10), query.Limit(10) },
                                       unequal: new[] { col.Limit(2), query.Limit(2) });
        }
Example #13
0
        public void Equality()
        {
            var control = new Timestamp(1, 2);
            var equal   = new[] { new Timestamp(1, 2) };
            var unequal = new[] { new Timestamp(2, 2), new Timestamp(1, 3) };

            EqualityTester.AssertEqual(control, equal, unequal);
            EqualityTester.AssertEqualityOperators(control, equal, unequal);
        }
Example #14
0
        public void Equality_Offset()
        {
            var col   = s_db.Collection("col");
            var query = col.Offset(1);

            EqualityTester.AssertEqual(query,
                                       equal: new[] { col.Offset(1), query.Offset(1) },
                                       unequal: new[] { col.Offset(2), query.Offset(2) });
        }
Example #15
0
        public void Equality_CollectionRefNotEqualToQuery()
        {
            var col1 = s_db.Collection("col1");
            var col2 = s_db.Collection("col2");

            // Collection and "a Query isn't equal to a CollectionReference"
            var query = col1.Offset(0);

            EqualityTester.AssertEqual(query, equal: new[] { col1.Offset(0), query.Offset(0) }, unequal: new[] { col1, col2.Offset(0) });
        }
        public void Equality_Missing()
        {
            var nonMissing = GetSampleSnapshot();
            var db         = nonMissing.Database;
            var doc        = nonMissing.Document;

            var control  = DocumentSnapshot.ForMissingDocument(db, doc.Name, new Timestamp(1, 2));
            var equal    = DocumentSnapshot.ForMissingDocument(db, doc.Name, new Timestamp(1, 3));
            var unequal1 = DocumentSnapshot.ForMissingDocument(db, doc.Name + "x", new Timestamp(1, 2));
            var unequal2 = DocumentSnapshot.ForDocument(db, doc, new Timestamp(1, 2));

            EqualityTester.AssertEqual(control, new[] { equal }, new[] { unequal1, unequal2 });
        }
        public void Equality()
        {
            var control = new GeoPoint(1.5, 2.5);
            // Equal
            var equal   = new[] { new GeoPoint(1.5, 2.5) };
            var unequal = new[]
            {
                new GeoPoint(2.5, 2.5), // Difference in latitude
                new GeoPoint(1.5, 3.5)  // Difference in longitude
            };

            EqualityTester.AssertEqual(control, equal, unequal);
            EqualityTester.AssertEqualityOperators(control, equal, unequal);
        }
Example #18
0
        public void Equality_End()
        {
            var col   = s_db.Collection("col");
            var query = col.OrderBy("foo").EndAt(10);

            EqualityTester.AssertEqual(query,
                                       equal: new[] {
                col.OrderBy("foo").EndAt(10L)
            },
                                       unequal: new[] {
                col.OrderBy("foo"),
                col.OrderBy("foo").EndAt(20),
                col.OrderBy("foo").EndBefore(10)
            }
                                       );
        }
Example #19
0
        public void Equality_Start()
        {
            var col   = s_db.Collection("col");
            var query = col.OrderBy("foo").StartAt(10);

            EqualityTester.AssertEqual(query,
                                       equal: new[] {
                col.OrderBy("foo").StartAt(10L),
            },
                                       unequal: new[] {
                col.OrderBy("foo"),
                col.OrderBy("foo").StartAt(20),
                col.OrderBy("foo").StartAfter(10)
            }
                                       );
        }
Example #20
0
        public void Equality_OrderBy()
        {
            var col   = s_db.Collection("col");
            var query = col.OrderBy("foo").OrderByDescending("bar");

            EqualityTester.AssertEqual(query,
                                       equal: new[] {
                col.OrderBy("foo").OrderByDescending("bar")
            },
                                       unequal: new[] {
                query.OrderBy("foo"),
                col.OrderBy("foo"),
                col.OrderByDescending("foo").OrderByDescending("bar"),
                col.OrderBy("bar").OrderByDescending("foo"),
            }
                                       );
        }
Example #21
0
        public void Equality_Select()
        {
            var col = s_db.Collection("col");
            // Each call to Select replaces previous ones
            var query = col.Select("a", "b");

            EqualityTester.AssertEqual(query,
                                       equal: new[] {
                col.Select("a", "b"),
                query.Select("a", "b"),
                col.Select("x").Select("a", "b"),
            },
                                       unequal: new[] {
                col.Select("b").Select("a"), // Order matters
                query.Select("a"),           // Projecting again adds another projection
            }
                                       );
        }
Example #22
0
        public void Equality()
        {
            EqualityTester.AssertEqual(SetOptions.MergeAll,
                                       equal: new[] { SetOptions.MergeAll },
                                       unequal: new[] { SetOptions.Overwrite, SetOptions.MergeFields("a", "b") });

            EqualityTester.AssertEqual(SetOptions.Overwrite,
                                       equal: new[] { SetOptions.Overwrite },
                                       unequal: new[] { SetOptions.MergeFields("a", "b") });

            EqualityTester.AssertEqual(SetOptions.MergeFields("a", "b.c"),
                                       equal: new[] {
                SetOptions.MergeFields("a", "b.c"),
                SetOptions.MergeFields(new FieldPath("a"), new FieldPath("b", "c"))
            },
                                       unequal: new[] {
                SetOptions.MergeFields("a"),
                SetOptions.MergeFields("b.c"),
                SetOptions.MergeFields("a", "b.c", "d"),
                SetOptions.MergeFields("x"),
                // Currently, equality is order-sensitive. This is being reviewed.
                SetOptions.MergeFields("b.c", "a")
            });
        }
 public void Equality()
 {
     EqualityTester.AssertEqual(new FieldMask("a", "b"),
                                new[] { new FieldMask("a", "b", "b"), new FieldMask(new FieldPath("a"), new FieldPath("b")) },
                                new[] { new FieldMask("a"), new FieldMask("a", "c"), new FieldMask("a", "b", "c") });
 }
Example #24
0
 public void Equality()
 {
     EqualityTester.AssertEqual(TransactionOptions.Create(10),
                                equal: new[] { TransactionOptions.Create(10) },
                                unequal: new[] { TransactionOptions.Create(20) });
 }