MAJOR: POSIX compliant, argument check, unit tests

Dimos082 · web-flow · commit a3ff2ddee4c0 · 2025-02-10T14:48:59.000+02:00
- Updated command execution to be POSIX compliant, no longer requiring quotes around commands.
- Added checks for arguments to ensure validity.
- Enhanced unit tests to cover new argument handling and POSIX-compliant execution.
- Improved error handling for invalid frequency values.
- Working test and release cycling
- Automatic version bumping
diff --git a/cli_monitor.py b/cli_monitor.py
@@ -4,7 +4,7 @@
 from datetime import datetime
 # A script that runs a command at a specified frequency and optionally triggers another command based on regex matches
 # ReadMe: https://github.com/Dimos082/cli-monitor/
-__version__ = "0.9.0"
+__version__ = "0.9.0"
 # Constants:
 MIN_FREQUENCY = 0.1          # Minimum allowed frequency (seconds)
 MAX_FREQUENCY = 100000       # Maximum allowed frequency (seconds)
@@ -14,16 +14,31 @@ class CLIArgumentParser:
     """Parses command-line arguments."""
     @staticmethod
     def parse_args():
-        p = argparse.ArgumentParser(description="CLI monitor with optional regex-based triggers.")
+        class CustomFormatter(argparse.RawTextHelpFormatter, argparse.ArgumentDefaultsHelpFormatter):
+            pass
+        p = argparse.ArgumentParser(
+            description="CLI monitor with optional regex-based triggers.",
+            formatter_class=CustomFormatter
+        )
         p.add_argument("-v", "--version", action="version", version=f"CLI Monitor {__version__}")
-        p.add_argument("--command", required=True, help="Main command to run repeatedly.")
         p.add_argument("--output-file", help="Log file path; console only if omitted.")
         p.add_argument("--frequency", type=float, default=1.0, help="Seconds between each execution.")
-        p.add_argument("--max-log-size", type=int, default=1024, help="Max log file size in KB.")
+        p.add_argument("--max-log-size", type=int, default="1024", help="Max log file size in KB.")
         p.add_argument("--timer", type=float, default=0, help="Stop after N seconds (0 => infinite).")
         p.add_argument("--regex", help="Regex pattern to watch for in output.")
-        p.add_argument("--regex-execute", help="Command to run once per iteration if regex matches.")
-        return p.parse_args()
+        p.add_argument("--command", nargs="+", metavar=("CMD", "ARGS"), required=True,
+                       help="Main command to run.\nExample: --command ls -la /")
+        p.add_argument("--regex-execute", metavar=("CMD"), default=[],
+                       help="Command to execute when regex matches.\nExample: --regex-execute echo 'Match found'")
+        args = p.parse_args()
+        if args.max_log_size <= 0: # Ensure `--max-log-size` is valid
+            p.error("--max-log-size must be greater than 0 KB")
+        if "--max-log-size" in sys.argv and not args.output_file: # Ensure `--max-log-size` is ignored if `--output-file` is not set
+            print("Warning: --max-log-size is ignored since --output-file is not set.")
+        if not (MIN_FREQUENCY <= args.frequency <= MAX_FREQUENCY): # Ensure frequency is within the allowed range
+            p.error(f"Error: Frequency must be between {MIN_FREQUENCY} and {MAX_FREQUENCY}.")
+            exit(1)
+        return args
 
 class ErrorHandler:
     """Logs command/script errors and increments exception counts."""
@@ -227,11 +242,8 @@ def _finalize_summary(self):
 
 def main():
     cfg = CLIArgumentParser.parse_args()
-    if not (MIN_FREQUENCY <= cfg.frequency <= MAX_FREQUENCY): 
-        print(f"Error: Frequency must be between {MIN_FREQUENCY} and {MAX_FREQUENCY}.")
-        sys.exit(1)
     controller = CliMonitorController(cfg)
     controller.run()
 
 if __name__ == "__main__":
-    main()
+    main()
diff --git a/tests/test_cli_monitor_basic.py b/tests/test_cli_monitor_basic.py
@@ -1,31 +1,61 @@
-import unittest
-import subprocess
-
-class TestCliMonitorBasic(unittest.TestCase):
-    """Tests the most basic functionality of cli_monitor.py."""
-
-    def test_echo_command(self):
-        """Verify 'echo Hello' runs without errors and prints 'Hello'."""
-        cmd = [
-            "python", "cli_monitor.py",
-            "--command", "echo Hello",
-            "--timer", "2"  # short run
-        ]
-        result = subprocess.run(cmd, capture_output=True, text=True)
-        self.assertEqual(result.returncode, 0)
-        self.assertIn("Hello", result.stdout)
-
-    def test_invalid_frequency(self):
-        """Frequency outside allowed range should cause an error exit."""
-        cmd = [
-            "python", "cli_monitor.py",
-            "--command", "echo Hello",
-            "--frequency", "999999999"  # way too large
-        ]
-        result = subprocess.run(cmd, capture_output=True, text=True)
-        # Expecting a non-zero exit code due to frequency validation
-        self.assertNotEqual(result.returncode, 0)
-        self.assertIn("Error: Frequency must be between", result.stdout)
-
-if __name__ == "__main__":
-    unittest.main()
+import unittest
+import subprocess
+import cli_monitor
+import platform
+
+class TestCliMonitorBasic(unittest.TestCase):
+    """Tests the most basic functionality of cli_monitor.py."""
+
+    def test_command_parsing(self):
+        """Fixed version correctly passes the command as a list of arguments."""
+        cmd = ["echo", "hello", "world"]
+        result = cli_monitor.CommandExecutor.execute_command(cmd)
+        # The command should be correctly split into arguments and executed as expected
+        self.assertEqual(result[1].strip(), "hello world", "Fixed version should correctly pass arguments!")
+
+    def test_echo_command(self):
+        """Verify 'echo Hello' runs without errors and prints 'Hello'."""
+        cmd = [
+            "python", "cli_monitor.py",
+            "--command", "echo", "Hello",
+            "--timer", "2"
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        self.assertEqual(result.returncode, 0)
+        self.assertIn("Hello", result.stdout)
+
+    def test_invalid_frequency(self):
+        """Frequency outside allowed range should cause an error exit."""
+        cmd = [
+            "python", "cli_monitor.py",
+            "--command", "echo", "Hello",
+            "--frequency", "999999999"  # way too large
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        self.assertNotEqual(result.returncode, 0) # Expecting a non-zero exit code due to frequency validation
+        self.assertIn("Frequency must be between", result.stderr)  # Check stderr instead of stdout
+
+    def test_complex_command(self):
+        """Ensure complex commands with multiple arguments work correctly."""
+        cmd = ["dir"] if platform.system() == "Windows" else ["ls", "-la", "/"]
+
+        result = subprocess.run(
+            ["python", "cli_monitor.py", "--timer", "2", "--command"] + cmd,
+            capture_output=True, text=True
+        )
+        self.assertEqual(result.returncode, 0)
+        self.assertIn("total" if platform.system() != "Windows" else "Directory", result.stdout)
+
+    def test_command_with_quotes(self):
+        """Ensure commands with quotes are properly handled."""
+        cmd = [
+            "python", "cli_monitor.py",
+            "--command", "echo", "'Hello World'",
+            "--timer", "2"
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        self.assertEqual(result.returncode, 0)
+        self.assertIn("Hello World", result.stdout)
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_cli_monitor_logging.py b/tests/test_cli_monitor_logging.py
@@ -1,36 +1,151 @@
-import unittest
-import subprocess
-import os
-
-class TestCliMonitorLogging(unittest.TestCase):
-    """Tests output-file logging and log pruning."""
-
-    def setUp(self):
-        self.log_file = "test_log_output.txt"
-        # Remove log file if it exists
-        if os.path.exists(self.log_file):
-            os.remove(self.log_file)
-
-    def tearDown(self):
-        # Clean up log file
-        if os.path.exists(self.log_file):
-            os.remove(self.log_file)
-
-    def test_log_pruning(self):
-        """Check that log file pruning occurs once it exceeds max size."""
-        cmd = [
-            "python", "cli_monitor.py",
-            "--command", "echo TestLogLine",
-            "--output-file", self.log_file,
-            "--max-log-size", "1",  # 1KB to force quick pruning
-            "--timer", "3"          # run a few iterations
-        ]
-        result = subprocess.run(cmd, capture_output=True, text=True)
-        self.assertEqual(result.returncode, 0)
-        # We expect the log file to exist, but be under or ~1KB
-        self.assertTrue(os.path.exists(self.log_file))
-        file_size = os.path.getsize(self.log_file)
-        self.assertLessEqual(file_size, 1024, "Log file should be pruned to <= 1KB")
-
-if __name__ == "__main__":
-    unittest.main()
+import unittest
+import os
+import subprocess
+
+class TestLogPruning(unittest.TestCase):
+    """Tests log pruning logic for different max-log-size values."""
+
+    def setUp(self):
+        """Create a temporary log file for testing."""
+        self.log_file = "test_log.txt"
+
+    def tearDown(self):
+        """Clean up the test log file after each test."""
+        if os.path.exists(self.log_file):
+            os.remove(self.log_file)
+
+    def test_log_pruning_1KB(self):
+        """Ensure pruning works correctly when max-log-size is 1KB."""
+        cmd = [
+            "python", "cli_monitor.py",
+            "--command", "echo", "TestLogLine",
+            "--output-file", self.log_file,
+            "--max-log-size", "1",  # 1 KB
+            "--timer", "2",
+            "--frequency", "0.1"
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        self.assertEqual(result.returncode, 0)
+
+        # Ensure log file is pruned correctly
+        self.assertTrue(os.path.exists(self.log_file))
+        file_size = os.path.getsize(self.log_file)
+        self.assertLessEqual(file_size, 1024, f"Log file exceeded 1KB, actual: {file_size} bytes")
+
+    def test_log_pruning_10KB(self):
+        """Ensure pruning works correctly when max-log-size is 10KB."""
+        cmd = [
+            "python", "cli_monitor.py",
+            "--command", "echo", "TestLogLine",
+            "--output-file", self.log_file,
+            "--max-log-size", "10",  # 10 KB
+            "--timer", "3",
+            "--frequency", "0.1"
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        self.assertEqual(result.returncode, 0)
+
+        # Ensure log file is pruned correctly
+        self.assertTrue(os.path.exists(self.log_file))
+        file_size = os.path.getsize(self.log_file)
+        self.assertLessEqual(file_size, 10 * 1024, f"Log file exceeded 10KB, actual: {file_size} bytes")
+
+    def test_log_pruning_100KB(self):
+        """Ensure pruning works correctly when max-log-size is 100KB."""
+        cmd = [
+            "python", "cli_monitor.py",
+            "--command", "echo", "TestLogLine",
+            "--output-file", self.log_file,
+            "--max-log-size", "100",  # 100 KB
+            "--timer", "5",
+            "--frequency", "0.1"
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        self.assertEqual(result.returncode, 0)
+
+        # Ensure log file is pruned correctly
+        self.assertTrue(os.path.exists(self.log_file))
+        file_size = os.path.getsize(self.log_file)
+        self.assertLessEqual(file_size, 100 * 1024, f"Log file exceeded 100KB, actual: {file_size} bytes")
+
+    def test_log_pruning_min_size(self):
+        """Test with the smallest allowed log size (1KB)."""
+        cmd = [
+            "python", "cli_monitor.py",
+            "--command", "echo", "TestLogLine",
+            "--output-file", self.log_file,
+            "--max-log-size", "1",  # 1 KB (Minimum)
+            "--timer", "2"
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        self.assertEqual(result.returncode, 0)
+        self.assertTrue(os.path.exists(self.log_file))
+        file_size = os.path.getsize(self.log_file)
+        self.assertLessEqual(file_size, 1024, f"Log file exceeded 1KB, actual: {file_size} bytes")
+
+    def test_log_pruning_large_size(self):
+        """Test with a very large log size (10MB) to check if it still works."""
+        cmd = [
+            "python", "cli_monitor.py",
+            "--command", "echo", "TestLogLine",
+            "--output-file", self.log_file,
+            "--max-log-size", "10240",  # 10MB
+            "--timer", "2"
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        self.assertEqual(result.returncode, 0)
+        self.assertTrue(os.path.exists(self.log_file))
+        file_size = os.path.getsize(self.log_file)
+        self.assertLessEqual(file_size, 10 * 1024 * 1024, f"Log file exceeded 10MB, actual: {file_size} bytes")
+
+    def test_negative_log_size(self):
+        """Ensure negative log size is rejected."""
+        cmd = [
+            "python", "cli_monitor.py",
+            "--command", "echo", "TestLogLine",
+            "--output-file", self.log_file,
+            "--max-log-size", "-5"  # Negative values should not be allowed
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        self.assertNotEqual(result.returncode, 0)  # Should fail
+        self.assertIn("error", result.stderr.lower())  # Expect an error message
+
+    def test_zero_log_size(self):
+        """Ensure zero log size is rejected."""
+        cmd = [
+            "python", "cli_monitor.py",
+            "--command", "echo", "TestLogLine",
+            "--output-file", self.log_file,
+            "--max-log-size", "0"  # Zero is invalid
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        self.assertNotEqual(result.returncode, 0)  # Should fail
+        self.assertIn("error", result.stderr.lower())  # Expect an error message
+
+    def test_non_integer_log_size(self):
+        """Ensure non-integer values for max-log-size are rejected."""
+        cmd = [
+            "python", "cli_monitor.py",
+            "--command", "echo", "TestLogLine",
+            "--output-file", self.log_file,
+            "--max-log-size", "ABC"  # Invalid string
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        self.assertNotEqual(result.returncode, 0)  # Should fail
+        self.assertIn("invalid", result.stderr.lower())  # Expect an error message
+
+    def test_max_log_size_without_output_file(self):
+        """Ensure using --max-log-size without --output-file prints a warning but does not fail."""
+        cmd = [
+            "python", "cli_monitor.py",
+            "--command", "echo", "TestLogLine",
+            "--max-log-size", "10",  # ✅ Should trigger a warning but not an error
+            "--timer", "1"
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        self.assertEqual(result.returncode, 0)
+        warning_message = "Warning: --max-log-size is ignored since --output-file is not set.".lower()
+        self.assertTrue( # Check for the warning in both stdout and stderr
+            warning_message in result.stderr.lower() or warning_message in result.stdout.lower(),
+            f"Expected warning not found. Output received:\nSTDOUT: {result.stdout}\nSTDERR: {result.stderr}"
+        )
diff --git a/tests/test_cli_monitor_regex.py b/tests/test_cli_monitor_regex.py
