fix(rtdb): Preserve server-side key order in order_by_key() query results

The Realtime Database server returns order_by_key() results in Firebase key
order (integer-parseable keys first, numerically; then string keys
lexicographically). Query.get() re-sorted this payload client-side with a
pure lexicographic comparison, scrambling the server order and breaking
keyset pagination (feeding the last returned key back into start_at()
returned the same page forever).

Skip the client-side sorter for order_by_key() and return the server-ordered
payload as an OrderedDict, preserving the documented return type.

Fixes #677

Author: Sanjays2402

firebase_admin/db.py

@@ -481,8 +481,9 @@ class Query:
     is applied on the sorted data to produce the final result. Despite the ordering constraint,
     the final result is returned by the server as an unordered collection. Therefore the Query
     interface performs another round of sorting at the client-side before returning the results
-    to the caller. This client-side sorted results are returned to the user as a Python
-    OrderedDict.
+    to the caller. The only exceptions are queries ordered by key (``order_by_key()``) or by
+    priority (``order_by='$priority'``), for which the server-returned order is preserved as is.
+    This client-side sorted results are returned to the user as a Python OrderedDict.
     """
 
     def __init__(self, **kwargs):
@@ -618,6 +619,10 @@ def get(self):
           FirebaseError: If an error occurs while communicating with the remote database server.
         """
         result = self._client.body('get', self._pathurl, params=self._querystr)
+        if isinstance(result, dict) and self._order_by == '$key':
+            # The server already returns results in key order. Re-sorting them client-side
+            # with a pure lexicographic comparison would scramble that order (see issue #677).
+            return collections.OrderedDict(result)
         if isinstance(result, (dict, list)) and self._order_by != '$priority':
             return _Sorter(result, self._order_by).get()
         return result

tests/test_db.py

@@ -1044,6 +1044,43 @@ def test_invalid_query_args(self):
         with pytest.raises(ValueError):
             db.Query(order_by='$key', client=ref._client, pathurl=ref._add_suffix(), foo='bar')
 
+    @staticmethod
+    def _instrument_body(query, payload, monkeypatch):
+        """Stubs out the HTTP layer of a Query with a fixed server payload."""
+        class _StubClient:
+            def body(self, unused_method, unused_url, params=None):
+                return dict(payload)
+        monkeypatch.setattr(query, '_client', _StubClient())
+
+    def test_get_order_by_key_preserves_server_order(self, monkeypatch):
+        # Regression test for https://github.com/firebase/firebase-admin-python/issues/677
+        # The RTDB server returns children in Firebase key order (integer-parseable keys
+        # first, numerically; then string keys lexicographically). The client must not
+        # re-sort the payload with a pure lexicographic comparison, which would scramble
+        # the server order and break keyset pagination (e.g. feeding the last returned
+        # key back into start_at()).
+        query = self.ref.order_by_key().limit_to_first(4)
+        server_payload = collections.OrderedDict([
+            ('123', {'myValue': True}),
+            ('100001', {'myValue': True}),
+            ('100002', {'myValue': True}),
+            ('100003', {'myValue': True}),
+        ])
+        self._instrument_body(query, server_payload, monkeypatch)
+        result = query.get()
+        assert isinstance(result, collections.OrderedDict)
+        assert list(result.keys()) == ['123', '100001', '100002', '100003']
+
+    def test_get_order_by_child_still_sorted_client_side(self, monkeypatch):
+        # Guard against overcorrection: ordering by child must still be sorted
+        # client-side, since the server returns an unordered collection for it.
+        query = self.ref.order_by_child('myValue')
+        server_payload = {'k1': {'myValue': 2}, 'k2': {'myValue': 1}}
+        self._instrument_body(query, server_payload, monkeypatch)
+        result = query.get()
+        assert isinstance(result, collections.OrderedDict)
+        assert list(result.keys()) == ['k2', 'k1']
+
 
 class TestSorter:
     """Test cases for db._Sorter class."""