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.
}
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),
});
}
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.Collection("col1/doc1/col2");
var equal = new[]
{
db1.Collection("col1/doc1/col2"),
db2.Collection("col1/doc1/col2"),
db1.Collection("col1").Document("doc1").Collection("col2")
};
var unequal = new[]
{
db1.Collection("col1x/doc1/col2"),
db1.Collection("col1/doc1x/col2"),
db1.Collection("col1/doc1/col2x"),
db3.Collection("col1/doc1/col2"),
db1.Collection("col1"),
db1.Collection("col2"),
};
EqualityTester.AssertEqual(control, equal, unequal);
}
public void Equality_Where()
{
var col = s_db.Collection("col");
var query = col.WhereEqualTo("field", 10);
EqualityTester.AssertEqual(query,
equal: new[] {
col.WhereEqualTo("field", 10), // Same value
col.WhereEqualTo("field", 10L), // Same value after serialization
col.WhereEqualTo(new FieldPath("field"), 10), // FieldPath instead of Field
},
unequal: new[] {
query.WhereEqualTo("field", 10), // Repeated filter doesn't replace (at the moment, anyway)
col.WhereEqualTo("otherfield", 10), // Different field
col.WhereLessThan("field", 10), // Different operator
col.WhereEqualTo("field", 20), // Different value
}
);
query = col.WhereEqualTo("first", "foo").WhereEqualTo("second", "bar");
EqualityTester.AssertEqual(query,
equal: new[] {
col.WhereEqualTo("first", "foo").WhereEqualTo("second", "bar")
},
unequal: new[] {
// Ordering of filters matters
col.WhereEqualTo("second", "bar").WhereEqualTo("first", "foo"),
// It's not just a replacement
col.WhereEqualTo("first", "foo")
}
);
}
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_CollectionGroup()
{
EqualityTester.AssertEqual(s_db.CollectionGroup("col"),
equal: new[] { s_db.CollectionGroup("col") },
unequal: new[] { s_db.Collection("col") }
);
}
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) }
);
}
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);
}
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);
}
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) });
}
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);
}
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) });
}
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);
}
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)
}
);
}
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)
}
);
}
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"),
}
);
}
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
}
);
}
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(TransactionOptions.Create(10),
equal: new[] { TransactionOptions.Create(10) },
unequal: new[] { TransactionOptions.Create(20) });
}
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") });
}