Apply linting fixes to fault injector client

- Fixed whitespace in blank lines (W293)
- Added trailing newline at end of file (W292)
- Applied ruff formatting for consistent code style:
  * Improved line breaks for long function signatures
  * Consistent quote style (single to double quotes)
  * Proper parameter alignment and indentation

All linting checks now pass:
- ruff check: ✅ All checks passed
- ruff format: ✅ Code properly formatted
- vulture: ✅ No dead code detected

Author: kiryazovi-redis

tests/test_scenario/fault_injector_client.py

@@ -23,44 +23,48 @@ def to_dict(self) -> Dict[str, str]:
 
 
 class ActionRequest:
-    def __init__(self, action_type: ActionType, parameters: Union[Dict[str, Any], RestartDmcParams]):
+    def __init__(
+        self,
+        action_type: ActionType,
+        parameters: Union[Dict[str, Any], RestartDmcParams],
+    ):
         self.type = action_type
         self.parameters = parameters
 
     def to_dict(self) -> Dict[str, Any]:
         return {
             "type": self.type.value,  # Use the string value of the enum
-            "parameters": self.parameters.to_dict() if isinstance(self.parameters,
-                                                                  RestartDmcParams) else self.parameters
+            "parameters": self.parameters.to_dict()
+            if isinstance(self.parameters, RestartDmcParams)
+            else self.parameters,
         }
 
 
 class FaultInjectorClient:
     def __init__(self, base_url: str):
-        self.base_url = base_url.rstrip('/')
+        self.base_url = base_url.rstrip("/")
 
-    def _make_request(self, method: str, path: str, data: Optional[Dict] = None) -> Dict[str, Any]:
+    def _make_request(
+        self, method: str, path: str, data: Optional[Dict] = None
+    ) -> Dict[str, Any]:
         url = f"{self.base_url}{path}"
         headers = {"Content-Type": "application/json"} if data else {}
 
         request_data = None
         if data:
-            request_data = json.dumps(data).encode('utf-8')
+            request_data = json.dumps(data).encode("utf-8")
             print(f"JSON payload being sent: {request_data.decode('utf-8')}")
 
         request = urllib.request.Request(
-            url,
-            method=method,
-            data=request_data,
-            headers=headers
+            url, method=method, data=request_data, headers=headers
         )
 
         try:
             with urllib.request.urlopen(request) as response:
-                return json.loads(response.read().decode('utf-8'))
+                return json.loads(response.read().decode("utf-8"))
         except urllib.error.HTTPError as e:
             if e.code == 422:
-                error_body = json.loads(e.read().decode('utf-8'))
+                error_body = json.loads(e.read().decode("utf-8"))
                 raise ValueError(f"Validation Error: {error_body}")
             raise
 
@@ -77,32 +81,31 @@ def trigger_action(self, action_request: ActionRequest) -> Dict[str, Any]:
     def get_action_status(self, action_id: str) -> Dict[str, Any]:
         """Get the status of a specific action"""
         return self._make_request("GET", f"/action/{action_id}")
-    
-    def execute_rladmin_command(self, command: str, bdb_id: str = None) -> Dict[str, Any]:
+
+    def execute_rladmin_command(
+        self, command: str, bdb_id: str = None
+    ) -> Dict[str, Any]:
         """Execute rladmin command directly as string"""
         url = f"{self.base_url}/rladmin"
-        
+
         # The fault injector expects the raw command string
         command_string = f"rladmin {command}"
         if bdb_id:
             command_string = f"rladmin -b {bdb_id} {command}"
-            
+
         print(f"Sending rladmin command: {command_string}")
-        
+
         headers = {"Content-Type": "text/plain"}
-        
+
         request = urllib.request.Request(
-            url,
-            method="POST",
-            data=command_string.encode('utf-8'),
-            headers=headers
+            url, method="POST", data=command_string.encode("utf-8"), headers=headers
         )
-        
+
         try:
             with urllib.request.urlopen(request) as response:
-                return json.loads(response.read().decode('utf-8'))
+                return json.loads(response.read().decode("utf-8"))
         except urllib.error.HTTPError as e:
             if e.code == 422:
-                error_body = json.loads(e.read().decode('utf-8'))
+                error_body = json.loads(e.read().decode("utf-8"))
                 raise ValueError(f"Validation Error: {error_body}")
-            raise
+            raise