test_default_policy_is_tablet_aware: Better tablet info filling

This commit switches from using double loop with 100 executions in each
iter, to sending statement everywhere for each tablet.
Why?
- It is easier to understand, so no more wall of text
- It is faster (~1.2 seconds faster).
- It is more resilient, because we have 100% confidence that
  each statement reached non-replica.
One thing we lose is that test no longer checks receiving feedbacks
when using DefaultPolicy, but this is not really useful. The important
part is checking that we receive no feedbacks when we have info. The
only way for the removed part to fail (apart from migrations and other
stuff Scylla inflicts on us) is if driver can magically predict tablet
info. I'd be happy if it gets magical powers, so I'm not worried about
the removed part.

Author: Lorak-mmk

scylla/tests/integration/load_balancing/tablets.rs

@@ -205,42 +205,21 @@ async fn populate_internal_driver_tablet_info(
     value_per_tablet: &[(i32, i32)],
     feedback_rxs: &mut [UnboundedReceiver<(ResponseFrame, Option<u16>)>],
 ) -> Result<(), String> {
-    // When the driver never received tablet info for any tablet in a given table,
-    // then it will not be aware that the table is tablet-based and fall back
-    // to token-ring routing for this table.
-    // After it receives any tablet for this table:
-    // - tablet-aware routing will be used for tablets that the driver has locally
-    // - non-token-aware routing will be used for other tablets (which basically means
-    //   sending the requests to random nodes)
-    // In the following code I want to make sure that the driver fetches info
-    // about all the tablets in the table.
-    // Obvious way to do this would be to, for each tablet, send some requests (here some == 100)
-    // and expect that at least one will land on non-replica and return tablet feedback.
-    // This mostly works, but there is a problem: initially driver has no
-    // tablet information at all for this table so it will fall back to token-ring routing.
-    // It is possible that token-ring replicas and tablet replicas are the same
-    // for some tokens. If it happens for the first token that we use in this loop,
-    // then no matter how many requests we send we are not going to receive any tablet feedback.
-    // The solution is to iterate over tablets twice.
-    //
-    // First iteration guarantees that the driver will receive at least one tablet
-    // for this table (it is statistically improbable for all tokens used here to have the same
-    // set of replicas for tablets and token-ring). In practice it will receive all or almost all of the tablets.
-    //
-    // Second iteration will not use token-ring routing (because the driver has some tablets
-    // for this table, so it is aware that the table is tablet based),
-    // which means that for unknown tablets it will send requests to random nodes,
-    // and definitely fetch the rest of the tablets.
     let mut total_tablets_with_feedback = 0;
-    for values in value_per_tablet.iter().chain(value_per_tablet.iter()) {
+    for values in value_per_tablet.iter() {
         info!(
             "First loop, trying key {:?}, token: {}",
             values,
             prepared.calculate_token(&values).unwrap().unwrap().value()
         );
-        try_join_all((0..100).map(|_| async { session.execute_unpaged(&prepared, values).await }))
-            .await
-            .unwrap();
+        execute_prepared_statement_everywhere(
+            session,
+            &session.get_cluster_state(),
+            prepared,
+            values,
+        )
+        .await
+        .unwrap();
         let feedbacks: usize = feedback_rxs.iter_mut().map(count_tablet_feedbacks).sum();
         if feedbacks > 0 {
             total_tablets_with_feedback += 1;
@@ -297,15 +276,16 @@ async fn run_test_default_policy_is_tablet_aware_attempt(
         .await
 }
 
-/// Tests that, when using DefaultPolicy with TokenAwareness and querying table
-/// that uses tablets:
-/// 1. When querying data that belongs to tablet we didn't receive yet we will
-///    receive this tablet at some point.
-/// 2. When we have all tablets info locally then we'll never receive tablet info.
+/// Tests that, when:
+/// - Using DefaultPolicy with TokenAwareness
+/// - Querying table that uses tablets
+/// - Driver has all driver info fetched locally
+/// Then we'll never receive tablet info.
 ///
-/// The test first sends 100 queries per tablet and expects to receive tablet info.
-/// After that we know we have all the info. The test sends the statements again
-/// and expects to not receive any tablet info.
+/// The test first sends, to each possible target, one insert request per tablet.
+/// It expects to get tablet feedback for each tablet.
+/// After that we know we have all the info. The test sends the same insert request
+/// per tablet, this time using DefaultPolicy, and expects to not get any feedbacks.
 #[cfg_attr(scylla_cloud_tests, ignore)]
 #[tokio::test]
 #[ntest::timeout(30000)]