troubadix 25.6.1__tar.gz → 25.7.1__tar.gz

{troubadix-25.6.1 → troubadix-25.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: troubadix
-Version: 25.6.1
+Version: 25.7.1
 Summary: A linting and QA check tool for NASL files
 License: GPL-3.0-or-later
 Author: Greenbone

{troubadix-25.6.1 → troubadix-25.7.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "troubadix"
-version = "25.6.1"
+version = "25.7.1"
 description = "A linting and QA check tool for NASL files"
 authors = ["Greenbone <info@greenbone.net>"]
 license = "GPL-3.0-or-later"
@@ -73,6 +73,7 @@ version-module-file = "troubadix/__version__.py"
 
 [tool.poetry.scripts]
 troubadix = 'troubadix.troubadix:main'
+troubadix-changed-creation-date = 'troubadix.standalone_plugins.changed_creation_date:main'
 troubadix-changed-oid = 'troubadix.standalone_plugins.changed_oid:main'
 troubadix-last-modification = 'troubadix.standalone_plugins.last_modification:main'
 troubadix-version-updated = 'troubadix.standalone_plugins.version_updated:main'

troubadix-25.7.1/tests/helper/test_if_block_parser.py

@@ -0,0 +1,216 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+# SPDX-FileCopyrightText: 2025 Greenbone AG
+
+import unittest
+
+from troubadix.helper.if_block_parser import find_if_statements
+
+
+class FindIfStatementsTestCase(unittest.TestCase):
+    def test_empty_input(self):
+        result = find_if_statements("")
+        self.assertEqual(len(result), 0)
+
+    def test_inline_single_expression(self):
+        content = 'if(TRUE) display("inline");'
+        result = find_if_statements(content)
+
+        self.assertEqual(1, len(result))
+        self.assertEqual("TRUE", result[0].condition)
+        self.assertEqual('display("inline")', result[0].statement)
+        # Check that position is correct (start at 'if', end at semicolon)
+        self.assertEqual(0, result[0].if_start)
+        self.assertEqual(len(content), result[0].if_end)
+
+    def test_single_line_with_newline(self):
+        content = 'if(TRUE)\n  display("single line");'
+        result = find_if_statements(content)
+
+        self.assertEqual(1, len(result))
+        self.assertEqual("TRUE", result[0].condition)
+        self.assertEqual('display("single line")', result[0].statement)
+
+    def test_standard_block(self):
+        content = 'if(TRUE) {\n  display("block");\n}'
+        result = find_if_statements(content)
+
+        self.assertEqual(1, len(result))
+        self.assertEqual("TRUE", result[0].condition)
+        self.assertEqual('display("block");', result[0].statement)
+        # Check position spans from 'if' to the closing brace
+        self.assertEqual(0, result[0].if_start)
+        self.assertEqual(len(content), result[0].if_end)
+
+    def test_block_brace_on_newline(self):
+        content = 'if(TRUE)\n{\n  display("block");\n}'
+        result = find_if_statements(content)
+
+        self.assertEqual(1, len(result))
+        self.assertEqual("TRUE", result[0].condition)
+        self.assertEqual('display("block");', result[0].statement)
+
+    def test_empty_block(self):
+        content = "if(TRUE)\n{\n}"
+        result = find_if_statements(content)
+
+        self.assertEqual(1, len(result))
+        self.assertEqual("TRUE", result[0].condition)
+        self.assertEqual("", result[0].statement.strip())
+
+    def test_compact_block(self):
+        content = "if(TRUE){}"
+        result = find_if_statements(content)
+
+        self.assertEqual(1, len(result))
+        self.assertEqual("TRUE", result[0].condition)
+        self.assertEqual("", result[0].statement)
+
+    def test_multiple_if_statements(self):
+        content = """
+        if(cond1) display("one");
+        if(cond2) {
+            display("two");
+        }
+        if(cond3)
+            display("three");
+        """
+        result = find_if_statements(content)
+        self.assertEqual(3, len(result))
+
+        self.assertEqual("cond1", result[0].condition)
+        self.assertEqual('display("one")', result[0].statement)
+
+        self.assertEqual("cond2", result[1].condition)
+        self.assertEqual('display("two");', result[1].statement)
+
+        self.assertEqual("cond3", result[2].condition)
+        self.assertEqual('display("three")', result[2].statement)
+
+    def test_nested_if_statements(self):
+        content = """
+        if(outer) {
+            if(inner1) {
+                display("nested block");
+            }
+            if(inner2) display("nested inline");
+        }
+        """
+        result = find_if_statements(content)
+        self.assertEqual(3, len(result))
+
+        self.assertEqual("outer", result[0].condition)
+        self.assertIn("if(inner1)", result[0].statement)
+        self.assertIn("if(inner2)", result[0].statement)
+
+        self.assertEqual("inner1", result[1].condition)
+        self.assertIn('display("nested block")', result[1].statement)
+
+        self.assertEqual("inner2", result[2].condition)
+        self.assertEqual('display("nested inline")', result[2].statement)
+
+    def test_complex_condition(self):
+        content = (
+            'if (a == 1 && b > 2 || c != "string") { display("complex"); }'
+        )
+        result = find_if_statements(content)
+
+        self.assertEqual(1, len(result))
+        self.assertEqual(
+            'a == 1 && b > 2 || c != "string"', result[0].condition
+        )
+        self.assertEqual('display("complex");', result[0].statement)
+
+    def test_if_with_problematic_stuff(self):
+        # escape single quote and backslash, function call in condition
+        content = r"if(some_func('\'\\')) display('\'test\\');"
+        result = find_if_statements(content)
+
+        self.assertEqual(1, len(result))
+        self.assertEqual(r"some_func('\'\\')", result[0].condition)
+        self.assertEqual(r"display('\'test\\')", result[0].statement)
+
+    def test_unclosed_parenthesis(self):
+        content = "if(unclosed condition\ndisplay();"
+        with self.assertRaises(ValueError) as cm:
+            find_if_statements(content)
+        self.assertEqual(
+            "Unclosed parenthesis in if statement at line 1",
+            str(cm.exception),
+        )
+
+    def test_no_statement_after_condition(self):
+        content = "if(condition)"
+        with self.assertRaises(ValueError) as cm:
+            find_if_statements(content)
+        self.assertEqual(
+            "Missing statement after if condition at line 1",
+            str(cm.exception),
+        )
+
+    def test_useless_semicolon(self):
+        content = "if(condition);"
+        with self.assertRaises(ValueError) as cm:
+            find_if_statements(content)
+        self.assertEqual(
+            "Semicolon after if condition at line 1 makes following block always execute."
+            " Remove semicolon to fix.",
+            str(cm.exception),
+        )
+
+    def test_unclosed_block_brace(self):
+        content = "if(condition) {\ndisplay();\n# Missing closing brace"
+        with self.assertRaises(ValueError) as cm:
+            find_if_statements(content)
+        self.assertEqual(
+            "Unclosed brace in if statement at line 1",
+            str(cm.exception),
+        )
+
+    def test_no_semicolon_in_single_expression(self):
+        content = "if(condition) display()"  # Missing semicolon
+        with self.assertRaises(ValueError) as cm:
+            find_if_statements(content)
+        self.assertEqual(
+            "Missing expression after if condition at line 1",
+            str(cm.exception),
+        )
+
+    def test_complex_condition_with_unmatched_brace(self):
+        content = "if(func(1, 2) || check(a) { display(); }"  # Missing closing ) in condition
+        with self.assertRaises(ValueError) as cm:
+            find_if_statements(content)
+        self.assertEqual(
+            "Unclosed parenthesis in if statement at line 1",
+            str(cm.exception),
+        )
+
+    def test_position_info_in_error_message(self):
+        content = "# Some comment\nif(bad) something"  # No semicolon
+        with self.assertRaises(ValueError) as cm:
+            find_if_statements(content)
+        error_msg = str(cm.exception)
+        self.assertIn("at line 2", error_msg)
+
+    def test_condition_and_statement_positions_block(self):
+        content = 'if(TRUE) {\n  display("block");\n}'
+        result = find_if_statements(content)
+
+        self.assertEqual(1, len(result))
+        # Check condition position (inside parentheses)
+        self.assertEqual(3, result[0].condition_start)
+        self.assertEqual(7, result[0].condition_end)
+        # Check statement position (inside braces)
+        self.assertEqual(10, result[0].statement_start)
+        self.assertEqual(31, result[0].statement_end)
+
+    def test_condition_and_statement_positions_single(self):
+        content = 'if(num > 5) display("inline");'
+        result = find_if_statements(content)
+
+        self.assertEqual(1, len(result))
+        # Check condition position (inside parentheses)
+        self.assertEqual(3, result[0].condition_start)
+        self.assertEqual(10, result[0].condition_end)
+        # Check statement position (after parenthesis to semicolon)
+        self.assertEqual(12, result[0].statement_start)
+        self.assertEqual(29, result[0].statement_end)

troubadix-25.7.1/tests/helper/test_remove_comments.py

@@ -0,0 +1,81 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+# SPDX-FileCopyrightText: 2025 Greenbone AG
+
+import unittest
+
+from troubadix.helper.remove_comments import remove_comments
+
+
+class RemoveCommentsTestCase(unittest.TestCase):
+    def test_empty_string(self):
+        input_content = ""
+        expected_output = ""
+        self.assertEqual(remove_comments(input_content), expected_output)
+
+    def test_no_comments(self):
+        input_content = (
+            "function detect_archlinux(sock, port, SCRIPT_DESC, is_pfsense) {"
+        )
+        expected_output = input_content
+        self.assertEqual(remove_comments(input_content), expected_output)
+
+    def test_full_line_comments(self):
+        input_content = "# comment\nfunction hello() {\n    # Another comment\n    return 42;"
+        expected_output = "\nfunction hello() {\n\n    return 42;"
+        self.assertEqual(remove_comments(input_content), expected_output)
+
+    def test_inline_comments(self):
+        input_content = (
+            "function hello(){ # A function\n    return 42; # The answer"
+        )
+        expected_output = "function hello(){ \n    return 42; "
+        self.assertEqual(remove_comments(input_content), expected_output)
+
+    def test_hash_in_strings(self):
+        input_content = "message = 'This # is not a comment';\nurl = \"http://example.com/#anchor\";"
+        expected_output = input_content
+        self.assertEqual(remove_comments(input_content), expected_output)
+
+    def test_mixed_quotes_and_comments(self):
+        input_content = (
+            "display('Hash: #'); # Real comment\n"
+            's = "My string with # character"; # Another comment'
+        )
+        expected_output = (
+            "display('Hash: #'); \ns = \"My string with # character\"; "
+        )
+        self.assertEqual(remove_comments(input_content), expected_output)
+
+    def test_complex_scenario(self):
+        # ruff does not allow whitespace at end of lines so this looks a bit weird
+        input_content = """function hello(){
+    # Comment at start
+    if (TRUE) {# inline comment
+        display('Hello # not a comment');
+    # Full comment line
+        display("Hash: #");# end comment
+    }
+}"""
+
+        expected_output = """function hello(){
+
+    if (TRUE) {
+        display('Hello # not a comment');
+
+        display("Hash: #");
+    }
+}"""
+
+        self.assertEqual(remove_comments(input_content), expected_output)
+
+    def test_indented_comments(self):
+        input_content = (
+            "function func() {\n    # Indented comment\n    return 0;\n}"
+        )
+        expected_output = "function func() {\n\n    return 0;\n}"
+        self.assertEqual(remove_comments(input_content), expected_output)
+
+    def test_backslash_double_quotes(self):
+        input_content = r'display("\"); # This is a comment'
+        expected_output = r'display("\"); '
+        self.assertEqual(remove_comments(input_content), expected_output)

troubadix-25.7.1/tests/helper/test_text_utils.py

@@ -0,0 +1,168 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+# SPDX-FileCopyrightText: 2025 Greenbone AG
+
+import unittest
+
+from troubadix.helper.text_utils import (
+    StringState,
+    index_to_linecol,
+    is_position_in_string,
+)
+
+
+class TestStringState(unittest.TestCase):
+    def test_process_normal_char_outside_strings(self):
+        state = StringState()
+        state.process_next_char("a")
+        self.assertFalse(state.escape_next)
+        self.assertFalse(state.in_string)
+
+    def test_enter_double_quotes(self):
+        state = StringState()
+        state.process_next_char('"')
+        self.assertFalse(state.escape_next)
+        self.assertTrue(state.in_double_quote)
+        self.assertTrue(state.in_string)
+
+    def test_exit_double_quotes(self):
+        state = StringState(in_double_quote=True)
+        state.process_next_char('"')
+        self.assertFalse(state.escape_next)
+        self.assertFalse(state.in_string)
+
+    def test_enter_single_quotes(self):
+        state = StringState()
+        state.process_next_char("'")
+        self.assertFalse(state.escape_next)
+        self.assertTrue(state.in_single_quote)
+        self.assertTrue(state.in_string)
+
+    def test_exit_single_quotes(self):
+        state = StringState(in_single_quote=True)
+        state.process_next_char("'")
+        self.assertFalse(state.escape_next)
+        self.assertFalse(state.in_string)
+
+    def test_escape_in_single_quotes(self):
+        state = StringState(in_single_quote=True)
+        state.process_next_char("\\")
+        self.assertTrue(state.escape_next)
+        self.assertTrue(state.in_single_quote)
+        self.assertTrue(state.in_string)
+
+    def test_escaped_single_quote_in_single_quotes(self):
+        state = StringState(escape_next=True, in_single_quote=True)
+        state.process_next_char("'")
+        self.assertFalse(state.escape_next)
+        self.assertTrue(state.in_single_quote)
+        self.assertTrue(state.in_string)
+
+    def test_ignore_single_quotes_in_double_quotes(self):
+        state = StringState(in_double_quote=True)
+        state.process_next_char("'")
+        self.assertFalse(state.escape_next)
+        self.assertTrue(state.in_double_quote)
+        self.assertTrue(state.in_string)
+
+    def test_ignore_double_quotes_in_single_quotes(self):
+        state = StringState(in_single_quote=True)
+        state.process_next_char('"')
+        self.assertFalse(state.escape_next)
+        self.assertTrue(state.in_single_quote)
+        self.assertTrue(state.in_string)
+
+    def test_nasl_backslash_string_sequence(self):
+        # Test the sequence "\" in NASL - a valid string where escaping is ignored
+        state = StringState()
+
+        # Enter double quote
+        state.process_next_char('"')
+        self.assertFalse(state.escape_next)
+        self.assertTrue(state.in_double_quote)
+
+        # Process backslash in double quotes (should not set escape flag)
+        state.process_next_char("\\")
+        self.assertFalse(state.escape_next)
+        self.assertTrue(state.in_double_quote)
+
+        # Exit double quote
+        state.process_next_char('"')
+        self.assertFalse(state.escape_next)
+        self.assertFalse(state.in_string)
+
+
+class TestIndexToLinecol(unittest.TestCase):
+    def test_start_of_file(self):
+        line, col = index_to_linecol("hello\nworld", 0)
+        self.assertEqual((line, col), (1, 1))
+
+    def test_middle_of_first_line(self):
+        line, col = index_to_linecol("hello\nworld", 2)
+        self.assertEqual((line, col), (1, 3))
+
+    def test_end_of_first_line(self):
+        line, col = index_to_linecol("hello\nworld", 5)
+        self.assertEqual((line, col), (1, 6))
+
+    def test_start_of_second_line(self):
+        line, col = index_to_linecol("hello\nworld", 6)
+        self.assertEqual((line, col), (2, 1))
+
+    def test_end_of_file(self):
+        line, col = index_to_linecol("hello\nworld", 10)
+        self.assertEqual((line, col), (2, 5))
+
+    def test_multiline_file(self):
+        text = "line1\nline2\nline3"
+        line, col = index_to_linecol(text, 10)
+        self.assertEqual((line, col), (2, 5))
+
+    def test_empty_file(self):
+        self.assertRaises(ValueError, index_to_linecol, "", 0)
+
+
+class TestIsPositionInString(unittest.TestCase):
+    def test_no_strings(self):
+        text = "x = 5; y = 10;"
+        self.assertFalse(is_position_in_string(text, 0))
+        self.assertFalse(is_position_in_string(text, 7))
+
+    def test_position_before_string(self):
+        text = 'x = "hello";'
+        self.assertFalse(is_position_in_string(text, 0))
+        self.assertFalse(is_position_in_string(text, 3))
+
+    def test_position_inside_double_quote_string(self):
+        text = 'x = "hello";'
+        self.assertTrue(is_position_in_string(text, 5))  # inside "hello"
+        self.assertTrue(is_position_in_string(text, 9))  # inside "hello"
+
+    def test_position_inside_single_quote_string(self):
+        text = "x = 'world';"
+        self.assertTrue(is_position_in_string(text, 5))  # inside 'world'
+        self.assertTrue(is_position_in_string(text, 9))  # inside 'world'
+
+    def test_position_after_string(self):
+        text = 'x = "hello";'
+        self.assertFalse(is_position_in_string(text, 11))  # after string
+
+    def test_escaped_quote_in_single_quotes(self):
+        text = "x = 'don\\'t';"
+        self.assertTrue(is_position_in_string(text, 8))  # inside the string
+        self.assertTrue(
+            is_position_in_string(text, 10)
+        )  # after the escaped quote
+
+    def test_mixed_quotes(self):
+        text = 'a = "it\'s ok"; b = \'say "hi"\';'
+        self.assertTrue(is_position_in_string(text, 6))  # inside "it's ok"
+        self.assertTrue(is_position_in_string(text, 22))  # inside 'say "hi"'
+        self.assertFalse(is_position_in_string(text, 15))  # between strings
+
+    def test_position_at_quote_characters(self):
+        # This checks that the implementation considers only characters before the current index,
+        # so the opening quote is not inside the string,
+        # but the closing quote is still considered inside.
+        text = 'x = "hello";'
+        self.assertFalse(is_position_in_string(text, 4))  # at opening quote
+        self.assertTrue(is_position_in_string(text, 10))  # at closing quote

troubadix-25.7.1/tests/manual_tests/comment_removal_diff.py

@@ -0,0 +1,62 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+# SPDX-FileCopyrightText: 2025 Greenbone AG
+
+import sys
+
+from troubadix.helper import CURRENT_ENCODING
+from troubadix.helper.remove_comments import remove_comments
+
+
+# poetry run python tests/manual_tests/comment_removal_diff.py <path_to_nasl_file>
+def test_comment_removal(input_file):
+    """
+    Test the remove_comments function and show all lines with their status.
+
+    Args:
+        input_file: Path to the NASL file to test
+    """
+    try:
+        with open(input_file, "r", encoding=CURRENT_ENCODING) as f:
+            original_content = f.read()
+    except Exception as e:
+        print(f"Error reading file: {e}")
+        return
+
+    processed_content = remove_comments(original_content)
+
+    original_lines = original_content.splitlines()
+    processed_lines = processed_content.splitlines()
+
+    print("\nFull comparison between original and processed file:")
+    print("----------------------------------------------------")
+
+    max_len = max(len(original_lines), len(processed_lines))
+
+    for i in range(max_len):
+        if i < len(original_lines) and i < len(processed_lines):
+            if original_lines[i] == processed_lines[i]:
+                status = "  "  # Unchanged
+            else:
+                status = "! "  # Changed
+            print(f"{i + 1:4d} {status}{original_lines[i]}")
+            if status == "! ":
+                print(f"     -> {processed_lines[i]}")
+
+    print("\nSummary:")
+    print(f"Original file lines: {len(original_lines)}")
+    print(f"Processed file lines: {len(processed_lines)}")
+
+    comment_lines = 0
+    for line in original_lines:
+        stripped = line.lstrip()
+        if stripped.startswith("#"):
+            comment_lines += 1
+    print(f"Full-line comments: {comment_lines}")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        print(f"Usage: {sys.argv[0]} <nasl_file>")
+        sys.exit(1)
+
+    test_comment_removal(sys.argv[1])

{troubadix-25.6.1 → troubadix-25.7.1}/tests/plugins/test_using_display.py

@@ -38,7 +38,7 @@ class CheckUsingDisplayTestCase(PluginTestCase):
 
         results = list(plugin.run())
 
-        self.assertEqual(len(results), 0)
+        self.assertEqual(0, len(results))
 
     def test_using_display(self):
         path = Path("some/file.nasl")
@@ -55,10 +55,10 @@ class CheckUsingDisplayTestCase(PluginTestCase):
 
         results = list(plugin.run())
 
-        self.assertEqual(len(results), 1)
+        self.assertEqual(1, len(results))
         self.assertIsInstance(results[0], LinterError)
         self.assertEqual(
-            'VT/Include is using a display() function at:   display("FOO");',
+            'VT is using a display() without any if statement at line 3: display("FOO");',
             results[0].message,
         )
 
@@ -77,14 +77,13 @@ class CheckUsingDisplayTestCase(PluginTestCase):
 
         results = list(plugin.run())
 
-        self.assertEqual(len(results), 1)
+        self.assertEqual(1, len(results))
         self.assertIsInstance(results[0], LinterWarning)
-        self.assertEqual(
-            "VT is using a display() function which is "
-            "protected by a comment or an if statement at: "
-            'if (0) display("FOO");.',
+        self.assertIn(
+            "VT is using a display() inside an if statement but without debug check",
             results[0].message,
         )
+        self.assertIn('if (0) display("FOO");', results[0].message)
 
     def test_using_comment_display(self):
         path = Path("some/file.nasl")
@@ -101,11 +100,49 @@ class CheckUsingDisplayTestCase(PluginTestCase):
 
         results = list(plugin.run())
 
-        self.assertEqual(len(results), 1)
-        self.assertIsInstance(results[0], LinterWarning)
-        self.assertEqual(
-            "VT is using a display() function which is "
-            "protected by a comment or an if statement at: "
-            '# display("FOO");.',
-            results[0].message,
+        # Comments are removed, so display() won't be found
+        self.assertEqual(0, len(results))
+
+    def test_using_debug_if_display(self):
+        """Test that display() inside a debug if statement is allowed"""
+        path = Path("some/file.nasl")
+        content = (
+            '  script_tag(name:"cvss_base", value:"4.0");\n'
+            'if (debug) display("FOO");\n'
         )
+        fake_context = self.create_file_plugin_context(
+            nasl_file=path, file_content=content
+        )
+        plugin = CheckUsingDisplay(fake_context)
+
+        results = list(plugin.run())
+
+        # Should be OK because it's in a debug if
+        self.assertEqual(0, len(results))
+
+    def test_display_in_string_ignored(self):
+        path = Path("some/file.nasl")
+        content = "str = 'display(\"FOO\")';\n"
+        fake_context = self.create_file_plugin_context(
+            nasl_file=path, file_content=content
+        )
+        plugin = CheckUsingDisplay(fake_context)
+
+        results = list(plugin.run())
+
+        self.assertEqual(0, len(results))
+
+    def test_propagate_if_parser_error(self):
+        path = Path("some/file.nasl")
+        content = "if (Foo);\ndisplay('Foo');"
+        fake_context = self.create_file_plugin_context(
+            nasl_file=path, file_content=content
+        )
+        plugin = CheckUsingDisplay(fake_context)
+
+        results = list(plugin.run())
+
+        # only one result for if parser error,
+        # display call not part of result due to early exit of entire run.
+        self.assertEqual(1, len(results))
+        self.assertIn("Semicolon after if condition", results[0].message)