fix(scyllaclient_test): skip TestClientActiveRepairsIntegration for tablets

When SM uses tablet repair API, Scylla registers a request to repair
a tablet table. Later on, Scylla creates repair jobs for given tablets
according to its own internal scheduler. Because of that, we have no guarantee
that Scylla will start any repair jobs right after SM used tablet repair API.
For example, they might be delayed due to a table migration/merge/split.
The API for checking active repairs and killing repairs works on the repair job
level, not the tablet repair API request level. Task manager API should be used
for handling those requests.

Fixes #4334

Author: Michal-Leszczynski

Diff for: pkg/scyllaclient/client_scylla_integration_test.go

@@ -169,11 +169,7 @@ func TestClientActiveRepairsIntegration(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	ni, err := client.AnyNodeInfo(context.Background())
-	if err != nil {
-		t.Fatal(err)
-	}
-	tabletAPI, err := ni.SupportsTabletRepair()
+	hosts, err := client.Hosts(context.Background())
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -184,46 +180,45 @@ func TestClientActiveRepairsIntegration(t *testing.T) {
 	db.WriteData(t, s, ks, 1)
 
 	rd := scyllaclient.NewRingDescriber(context.Background(), client)
-	asyncRepair := func(ctx context.Context, ks, tab, master string) {
-		if _, err := client.RawRepair(ctx, ks, tab, master); err != nil {
-			t.Error(err)
-		}
-	}
-	if rd.IsTabletKeyspace(ks) && tabletAPI {
-		asyncRepair = func(ctx context.Context, ks, tab, master string) {
-			if _, err := client.TabletRepair(ctx, ks, tab, master, nil, nil); err != nil {
-				t.Error(err)
-			}
-		}
+	if rd.IsTabletKeyspace(ks) {
+		// When SM uses tablet repair API, Scylla registers a request to repair
+		// a tablet table. Later on, Scylla creates repair jobs for given tablets
+		// according to its own internal scheduler. Because of that, we have no guarantee
+		// that Scylla will start any repair jobs right after SM used tablet repair API.
+		// For example, they might be delayed due to a table migration/merge/split.
+		// The API for checking active repairs and killing repairs works on the repair job
+		// level, not the tablet repair API request level. Task manager API should be used
+		// for handling those requests.
+		t.Skip("Checking active repairs and killing repairs is flaky with tablets")
 	}
 
 	Print("When: cluster is idle")
 	Print("Then: no repairs are running")
-	active, err := client.ActiveRepairs(context.Background(), ManagedClusterHosts())
+	active, err := client.ActiveRepairs(context.Background(), hosts)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if len(active) != 0 {
 		t.Fatal(active)
 	}
 
+	Print("When: repair is running on host 0")
+	go func() {
+		ExecOnHost(hosts[0], "nodetool repair -pr")
+	}()
 	defer func() {
-		// Make sure that repairs don't spill to other tests
-		if err := client.KillAllRepairs(context.Background(), ManagedClusterHosts()...); err != nil {
+		if err := client.KillAllRepairs(context.Background(), hosts[0]); err != nil {
 			t.Fatal(err)
 		}
 	}()
 
-	Print("When: repairs are running")
-	Print("Then: repairs are reported as active")
+	Print("Then: active repairs reports host 0")
 	WaitCond(t, func() bool {
-		// Multiple repair requests in order to reduce flakiness
-		asyncRepair(context.Background(), ks, db.BigTableName, ManagedClusterHost())
-		active, err = client.ActiveRepairs(context.Background(), ManagedClusterHosts())
+		active, err = client.ActiveRepairs(context.Background(), hosts)
 		if err != nil {
 			t.Fatal(err)
 		}
-		return len(active) > 0
+		return cmp.Diff(active, hosts[0:1]) == ""
 	}, 500*time.Millisecond, 4*time.Second)
 }