fix(issues): Fix issue search single page count inaccuracy (#103865)

Our issues search pagination uses some heuristics to give the total
results number, but this breaks for single page results sometimes which
makes no sense. Added exception for the single page case to just use the
number of results and avoid this.

Author: yuvmen

src/sentry/issues/endpoints/organization_group_index.py

@@ -389,6 +389,18 @@ def get(self, request: Request, organization: Organization) -> Response:
             status_labels = {QUERY_STATUS_LOOKUP[s] for s in status[0].value.raw_value}
             context = [r for r in context if "status" not in r or r["status"] in status_labels]
 
+        # Sanity check: if we're on the first and last page with no more results,
+        # the estimated hits from sampling may be too high due to Snuba/Postgres
+        # data inconsistency. Cap hits to match the actual number of results.
+        if (
+            cursor_result.hits is not None
+            and cursor_result.next.has_results is False
+            and not request.GET.get("cursor")
+        ):
+            actual_count = len(context)
+            if cursor_result.hits > actual_count:
+                cursor_result.hits = actual_count
+
         response = Response(context)
 
         self.add_cursor_headers(request, response, cursor_result)

tests/sentry/issues/endpoints/test_organization_group_index.py

@@ -946,6 +946,45 @@ def _my_patched_params(
 
         assert options.set("snuba.search.hits-sample-size", old_sample_size)
 
+    @patch("sentry.search.snuba.executors.PostgresSnubaQueryExecutor.calculate_hits")
+    def test_hits_capped_when_overestimated(self, mock_calculate_hits: MagicMock) -> None:
+        """
+        Test that when sampling overestimates the hit count and all results fit on one page,
+        the X-Hits header is capped to the actual number of results returned.
+
+        This prevents UI bugs like showing "(6-11) of 11" when there are only 6 results.
+        """
+        self.login_as(user=self.user)
+
+        # Create 6 groups
+        groups = []
+        for i in range(6):
+            event = self.store_event(
+                data={
+                    "timestamp": before_now(days=i).isoformat(),
+                    "fingerprint": [f"group-{i}"],
+                },
+                project_id=self.project.id,
+            )
+            groups.append(event.group)
+
+        # Mock calculate_hits to return an overestimate (simulating sampling inaccuracy)
+        # This would happen when Snuba thinks there are 11 groups but Postgres only has 6
+        mock_calculate_hits.return_value = 11
+
+        # Make a request that returns all 6 groups on one page
+        response = self.get_success_response(limit=25, query="is:unresolved")
+
+        # Should return all 6 groups
+        assert len(response.data) == 6
+
+        # X-Hits should be corrected to 6, not the overestimated 11
+        assert response["X-Hits"] == "6"
+
+        # Verify no next page exists (we have all results)
+        links = self._parse_links(response["Link"])
+        assert links["next"]["results"] == "false"
+
     def test_assigned_me_none(self) -> None:
         self.login_as(user=self.user)
         groups = []