Reverting unittests to the previous state

Author: Dimos082

tests/test_cli_monitor_basic.py

@@ -1,60 +1,31 @@
-import unittest
-import subprocess
-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 = subprocess.run(cmd, capture_output=True, text=True, shell=True)
-        # The command should be correctly split into arguments and executed as expected
-        self.assertEqual(result.stdout.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, shell=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, shell=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, shell=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, shell=True)
-        self.assertEqual(result.returncode, 0)
-        self.assertIn("Hello World", result.stdout)
-
-if __name__ == "__main__":
-    unittest.main()
+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()

tests/test_cli_monitor_logging.py

@@ -1,151 +1,36 @@
-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}"
-        )
+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()

tests/test_cli_monitor_regex.py

@@ -1,36 +1,35 @@
-import unittest
-import subprocess
-
-class TestCliMonitorRegex(unittest.TestCase):
-    """Tests regex matching and triggered command execution."""
-
-    def test_regex_trigger(self):
-        """Should detect 'ERROR' and run the triggered command."""
-        cmd = [
-            "python", "cli_monitor.py",
-            "--regex", "ERROR",
-            "--timer", "2",
-            "--command", "echo ERROR OCCURRED",
-            "--regex-execute", "echo 'Trigger ran!'"
-            
-        ]
-        result = subprocess.run(cmd, capture_output=True, text=True)
-        self.assertEqual(result.returncode, 0)
-        self.assertIn("ERROR OCCURRED", result.stdout)      # Main command output
-        self.assertIn("Trigger ran!", result.stdout)        # Triggered command output
-
-    def test_no_regex_no_trigger(self):
-        """No triggered command should run if no regex is provided."""
-        cmd = [
-            "python", "cli_monitor.py",
-            "--command", "echo Hello Again",
-            "--timer", "2"
-        ]
-        result = subprocess.run(cmd, capture_output=True, text=True)
-        self.assertEqual(result.returncode, 0)
-        self.assertIn("Hello Again", result.stdout)
-        # Ensure we DON'T see "Trigger ran!"
-        self.assertNotIn("Trigger ran!", result.stdout)
-
-if __name__ == "__main__":
-    unittest.main()
+import unittest
+import subprocess
+
+class TestCliMonitorRegex(unittest.TestCase):
+    """Tests regex matching and triggered command execution."""
+
+    def test_regex_trigger(self):
+        """Should detect 'ERROR' and run the triggered command."""
+        cmd = [
+            "python", "cli_monitor.py",
+            "--command", "echo ERROR OCCURRED",
+            "--regex", "ERROR",
+            "--regex-execute", "echo 'Trigger ran!'",
+            "--timer", "2"
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        self.assertEqual(result.returncode, 0)
+        self.assertIn("ERROR OCCURRED", result.stdout)      # Main command output
+        self.assertIn("Trigger ran!", result.stdout)        # Triggered command output
+
+    def test_no_regex_no_trigger(self):
+        """No triggered command should run if no regex is provided."""
+        cmd = [
+            "python", "cli_monitor.py",
+            "--command", "echo Hello Again",
+            "--timer", "2"
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        self.assertEqual(result.returncode, 0)
+        self.assertIn("Hello Again", result.stdout)
+        # Ensure we DON'T see "Trigger ran!"
+        self.assertNotIn("Trigger ran!", result.stdout)
+
+if __name__ == "__main__":
+    unittest.main()