Reduce cyclomatic complexity by using seperate function

Signed-off-by: Raunak Madan <[email protected]>

Author: CodexRaunak

integration-tests/meshsync_as_binary_with_k8s_cluster_integration_test.go

@@ -55,9 +55,6 @@ func TestMeshsyncBinaryWithK8sClusterIntegration(t *testing.T) {
 	}
 }
 
-// need this as separate function to bring down cyclomatic complexity
-// this one itself is also already too complicated :)
-//
 // TODO fix cyclop error
 // integration-tests/k8s_cluster_integration_test.go:74:1: calculated cyclomatic complexity for function runWithMeshsyncBinaryAndk8sClusterMeshsyncBinaryTestCase is 11, max is 10 (cyclop)
 //
@@ -103,28 +100,14 @@ func runMeshsyncBinaryWithK8sClusterTestCase(
 		if err := cmd.Start(); err != nil {
 			t.Fatalf("error starting binary: %v", err)
 		}
-		errCh := make(chan error)
-		go func(cmd0 *exec.Cmd, errCh0 chan<- error) {
-			errCh0 <- cmd0.Wait()
-		}(cmd, errCh)
 
 		// intentionally big timeout to wait till the cmd execution ended
 		timeout := time.Duration(time.Hour * 24)
 		if tc.waitMeshsyncTimeout > 0 {
 			timeout = tc.waitMeshsyncTimeout
 		}
 
-		select {
-		case err := <-errCh:
-			if err != nil {
-				t.Fatalf("error running binary: %v", err)
-			}
-		case <-time.After(timeout):
-			if err := cmd.Process.Signal(syscall.SIGTERM); err != nil {
-				t.Fatalf("error terminating meshsync command: %v", err)
-			}
-			t.Logf("processing after timeout %d", timeout)
-		}
+        waitForMeshsync(t, cmd, timeout)
 
 		// Step 4: do final assertion, if any
 		if tc.finalHandler != nil {
@@ -135,7 +118,7 @@ func runMeshsyncBinaryWithK8sClusterTestCase(
 	}
 }
 
-// introduced this function to decrease cyclomatic complexity
+// introduced these below function to decrease cyclomatic complexity
 func withMeshsyncBinaryPrepareMeshsyncCMD(
 	t *testing.T,
 	tcIndex int,
@@ -166,3 +149,30 @@ func withMeshsyncBinaryPrepareMeshsyncCMD(
 
 	return cmd, deferFunc
 }
+
+func waitForMeshsync(
+    t *testing.T,
+    cmd *exec.Cmd,
+    timeout time.Duration,
+) {
+    errCh := make(chan error)
+
+	go func(cmd0 *exec.Cmd, errCh0 chan<- error) {
+			errCh0 <- cmd0.Wait()
+		}(cmd, errCh)
+
+    select {
+    case err := <-errCh:
+        if err != nil {
+            t.Fatalf("error running binary: %v", err)
+        }
+    case <-time.After(timeout):
+        if err := cmd.Process.Signal(syscall.SIGTERM); err != nil {
+            t.Fatalf("error terminating meshsync command: %v", err)
+        }
+		t.Logf("processing after timeout %d", timeout)
+
+    }
+}
+
+

integration-tests/meshsync_as_library_with_k8s_cluster_custom_broker_integration_test.go

@@ -86,47 +86,16 @@ func runWithMeshsyncLibraryAndk8sClusterCustomBrokerTestCase(
 		}
 
 		// Step 3: run meshsync library
-		go func(errCh0 chan<- error) {
-			runOptions := make([]libmeshsync.OptionsSetter, 0, len(tc.meshsyncRunOptions))
-			runOptions = append(runOptions, tc.meshsyncRunOptions...)
-			runOptions = append(runOptions, libmeshsync.WithBrokerHandler(br))
-
-			errCh0 <- libmeshsync.Run(
-				log,
-				runOptions...,
-			)
-		}(errCh)
-
+		runMeshsyncLibraryAsync(br, log, tc, errCh)
+		
 		// intentionally big timeout to wait till the run execution ended
 		timeout := time.Duration(time.Hour * 24)
 		if tc.waitMeshsyncTimeout > 0 {
 			timeout = tc.waitMeshsyncTimeout
 		}
 
-		select {
-		case err := <-errCh:
-			if err != nil {
-				if !tc.expectError {
-					t.Fatal("must not end with error", err)
-				}
-				assert.ErrorContains(t, err, tc.expectedErrorMessage, "must end with expected error")
-			} else if tc.expectError {
-				if tc.expectedErrorMessage != "" {
-					t.Fatalf("must end with expected error message %s", tc.expectedErrorMessage)
-				}
-				t.Fatalf("must end with error")
-			}
-		case <-time.After(timeout):
-			self, err := os.FindProcess(os.Getpid())
-			if err != nil {
-				t.Fatalf("could not find self process: %v", err)
-			}
-			if err := self.Signal(syscall.SIGTERM); err != nil {
-				t.Fatalf("error terminating meshsync library: %v", err)
-			}
-			t.Logf("processing after timeout %d", timeout)
-		}
-
+		handleLibraryCompletion(t, errCh, timeout, tc)
+		
 		// Step 4: do final assertion, if any
 		if tc.finalHandler != nil {
 			tc.finalHandler(t, resultData)
@@ -136,6 +105,7 @@ func runWithMeshsyncLibraryAndk8sClusterCustomBrokerTestCase(
 	}
 }
 
+// introduced these below function to decrease cyclomatic complexity
 func withMeshsyncLibraryAndk8sClusterCustomBrokerPrepareMeshsyncLoggerOptions(
 	t *testing.T,
 	tcIndex int,
@@ -165,3 +135,63 @@ func withMeshsyncLibraryAndk8sClusterCustomBrokerPrepareMeshsyncLoggerOptions(
 
 	return options, deferFunc
 }
+
+func runMeshsyncLibraryAsync(
+	br broker.Handler,
+	log logger.Handler,
+	tc meshsyncLibraryWithK8SClusterCustomBrokerTestCaseStruct,
+	errCh chan<- error,
+) {
+	go func() {
+    runOptions := make([]libmeshsync.OptionsSetter, 0, len(tc.meshsyncRunOptions))
+    runOptions = append(runOptions, tc.meshsyncRunOptions...)
+    runOptions = append(runOptions, libmeshsync.WithBrokerHandler(br))
+
+    errCh <- libmeshsync.Run(log, runOptions...)
+	}()
+}
+
+func handleLibraryCompletion(
+	t *testing.T,
+	errCh <-chan error,
+	timeout time.Duration,
+	tc meshsyncLibraryWithK8SClusterCustomBrokerTestCaseStruct,
+) {
+	select {
+	case err := <-errCh:
+		validateErrorOutcome(t, err, tc)
+	case <-time.After(timeout):
+		self, findErr := os.FindProcess(os.Getpid())
+		if findErr != nil {
+			t.Fatalf("could not find self process: %v", findErr)
+		}
+		if err := self.Signal(syscall.SIGTERM); err != nil {
+			t.Fatalf("error terminating meshsync library: %v", err)
+		}
+		t.Logf("processing after timeout %d", timeout)
+	}
+}
+
+func validateErrorOutcome(
+	t *testing.T,
+	err error,
+	tc meshsyncLibraryWithK8SClusterCustomBrokerTestCaseStruct,
+) {
+	if err != nil {
+		if !tc.expectError {
+			t.Fatal("must not end with error", err)
+		}
+		assert.ErrorContains(t, err, tc.expectedErrorMessage, "must end with expected error")
+		return
+	}
+
+	// err == nil
+	if tc.expectError {
+		if tc.expectedErrorMessage != "" {
+			t.Fatalf("must end with expected error message %s", tc.expectedErrorMessage)
+		}
+		t.Fatalf("must end with error")
+	}
+}
+
+