fix: broken test and new test

Author: miparnisari

internal/datastore/memdb/memdb.go

@@ -71,7 +71,10 @@ func NewMemdbDatastore(
 			{
 				revision:   nowRevision(),
 				schemaHash: "",
-				db:         db,
+				// A snapshot of the empty database rather than the database
+				// itself: reads at this revision must see the datastore as it
+				// was when it was created, not as it is now.
+				db: db.Snapshot(),
 			},
 		},
 
@@ -122,7 +125,7 @@ func (mdb *memdbDatastore) UniqueID(_ context.Context) (string, error) {
 }
 
 // SnapshotReader returns a reader for the snapshot visible at the given
-// revision: the first entry in mdb.revisions at or after it, located by
+// revision: the most recent entry in mdb.revisions at or before it, located by
 // binary search.
 func (mdb *memdbDatastore) SnapshotReader(dr datastore.Revision) datastore.Reader {
 	mdb.RLock()
@@ -140,13 +143,17 @@ func (mdb *memdbDatastore) SnapshotReader(dr datastore.Revision) datastore.Reade
 		return &memdbReader{nil, nil, err, time.Now()}
 	}
 
+	// sort.Search finds the first snapshot newer than the requested revision,
+	// so the one visible at it is the entry before that.
 	revIndex := sort.Search(len(mdb.revisions), func(i int) bool {
-		return mdb.revisions[i].revision.GreaterThan(dr) || mdb.revisions[i].revision.Equal(dr)
+		return mdb.revisions[i].revision.GreaterThan(dr)
 	})
 
-	// handle the case when there is no revision snapshot newer than the requested revision
-	if revIndex == len(mdb.revisions) {
-		revIndex = len(mdb.revisions) - 1
+	// Handle the case where every snapshot is newer than the requested
+	// revision, i.e. it predates the datastore itself: the oldest snapshot is
+	// the closest thing to the state at that revision.
+	if revIndex > 0 {
+		revIndex--
 	}
 
 	rev := mdb.revisions[revIndex]

internal/datastore/memdb/revisions.go

@@ -82,6 +82,16 @@ func (mdb *memdbDatastore) OptimizedRevision(_ context.Context) (datastore.Revis
 		optimized = now
 	}
 
+	// Quantization rounds downward, so a datastore created moments ago would
+	// otherwise advertise a boundary from before it held any snapshot at all.
+	// No snapshot can serve that revision, so advertise the head revision
+	// instead: the same fallback Postgres makes when the bucket it rounded back
+	// to contains no transaction. This can only happen within one quantization
+	// window of the datastore being created.
+	if optimized.LessThan(mdb.revisions[0].revision) {
+		optimized = mdb.headRevisionNoLock()
+	}
+
 	// Find the schema hash visible at the optimized revision: walk the
 	// revisions list backward for the most recent snapshot whose revision
 	// is at or before `optimized`.

pkg/datastore/datastore.go

@@ -727,6 +727,29 @@ type ReadOnlyDatastore interface {
 
 	// SnapshotReader creates a read-only handle that reads the datastore at the specified revision.
 	// Any errors establishing the reader will be returned by subsequent calls.
+	//
+	// Reads through the handle behave like a snapshot: they are repeatable, and
+	// they never observe a write committed after the given revision.
+	// Each engine reaches that guarantee differently:
+	//
+	//   - Postgres and MySQL treat the revision as a transaction snapshot and
+	//     filter each row against it, keeping only rows created at or before
+	//     the revision and not yet deleted as of it. Postgres in strict read
+	//     mode additionally asserts that the revision is present on the
+	//     instance being read, so a lagging replica fails the query with a
+	//     RevisionUnavailableError instead of answering from older data.
+	//   - CockroachDB and Spanner treat the revision as an MVCC timestamp and
+	//     leave the filtering to the database, in both cases pinned to exactly
+	//     that timestamp rather than to the nearest one at or after it:
+	//     CockroachDB appends AS OF SYSTEM TIME <revision> to each query, and
+	//     Spanner bounds a read-only transaction with ReadTimestamp. A
+	//     revision the database no longer retains, or one in the future, fails
+	//     at query time rather than when the handle is created.
+	//   - memdb keeps one in-memory snapshot per write and reads from the most
+	//     recent snapshot at or before the revision, falling back to its
+	//     oldest snapshot for a revision that predates the datastore itself.
+	//     It is also the only implementation that validates the revision when
+	//     the handle is created, rather than when it is first read.
 	SnapshotReader(Revision) Reader
 
 	// OptimizedRevision gets a revision that will likely already be replicated