tir-framework 2.6.0__tar.gz → 2.7.0__tar.gz

{tir_framework-2.6.0/tir_framework.egg-info → tir_framework-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tir_framework
-Version: 2.6.0
+Version: 2.7.0
 Summary: Test Interface Robot
 Home-page: https://github.com/totvs/tir
 Download-URL: https://github.com/totvs/tir
@@ -192,7 +192,7 @@ Após a configuração do ambiente virtual iremos definir o interpretador do VSc
 
 ## Contact
 
-[Gitter](https://gitter.im/totvs-tir/General)
+[Gitter](https://app.element.io/#/room/#totvs-tir_General:gitter.im)
 
 ## Contributing
 

{tir_framework-2.6.0 → tir_framework-2.7.0}/README.md

@@ -140,7 +140,7 @@ Após a configuração do ambiente virtual iremos definir o interpretador do VSc
 
 ## Contact
 
-[Gitter](https://gitter.im/totvs-tir/General)
+[Gitter](https://app.element.io/#/room/#totvs-tir_General:gitter.im)
 
 ## Contributing
 

tir_framework-2.7.0/tests/test_utils.py

@@ -0,0 +1,238 @@
+"""Unit tests for Utils class and its methods."""
+
+import inspect
+import os
+import sys
+import unittest
+from unittest.mock import MagicMock, patch
+from pathlib import Path
+
+# Add the parent directory to the path so we can import tir module
+repo_root = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(repo_root))
+
+from tir.technologies.core.utils import Utils
+
+
+class TestUtilsGetMainEntrypointFromStack(unittest.TestCase):
+    """Test cases for Utils.get_main_entrypoint_from_stack method."""
+
+    def setUp(self):
+        """Initialize test fixtures."""
+        self.utils = Utils()
+
+    def test_get_main_entrypoint_with_default_parameters(self):
+        """Test method returns a string value with default parameters."""
+        result = self.utils.get_main_entrypoint_from_stack()
+        self.assertIsInstance(result, str)
+
+    def test_get_main_entrypoint_returns_fallback_when_no_match(self):
+        """Test method returns fallback value when no matching frame is found."""
+        result = self.utils.get_main_entrypoint_from_stack(
+            target_modules=["nonexistent/module.py"],
+            fallback="custom_fallback"
+        )
+        self.assertEqual(result, "custom_fallback")
+
+    def test_get_main_entrypoint_returns_default_fallback(self):
+        """Test method returns default fallback when no matching frame is found."""
+        result = self.utils.get_main_entrypoint_from_stack(
+            target_modules=["nonexistent/module.py"]
+        )
+        self.assertEqual(result, "function_name")
+
+    def test_get_main_entrypoint_ignores_specified_functions(self):
+        """Test that specified functions in ignored_functions are skipped."""
+        # Create a set of functions to ignore
+        ignored_set = {"__getattribute__", "_subscribe_routes", "__init__", "<lambda>"}
+        
+        result = self.utils.get_main_entrypoint_from_stack(
+            target_modules=["test_utils.py"],
+            ignored_functions=ignored_set,
+            fallback="test_fallback"
+        )
+        
+        # The result should not be in the ignored set or should be fallback
+        if result != "test_fallback":
+            self.assertNotIn(result, ignored_set)
+
+    def test_get_main_entrypoint_with_custom_ignored_functions(self):
+        """Test method with custom ignored functions set."""
+        custom_ignored = {"test_method", "setup"}
+        result = self.utils.get_main_entrypoint_from_stack(
+            target_modules=["test_utils.py"],
+            ignored_functions=custom_ignored,
+            fallback="not_found"
+        )
+        
+        self.assertIsInstance(result, str)
+
+    def test_get_main_entrypoint_case_insensitive_matching(self):
+        """Test that module matching is case-insensitive."""
+        # Test with uppercase module name
+        result1 = self.utils.get_main_entrypoint_from_stack(
+            target_modules=["TEST_UTILS.PY"],
+            fallback="not_found"
+        )
+        
+        # Test with lowercase module name
+        result2 = self.utils.get_main_entrypoint_from_stack(
+            target_modules=["test_utils.py"],
+            fallback="not_found"
+        )
+        
+        # Both should return the same result
+        self.assertEqual(result1, result2)
+
+    def test_get_main_entrypoint_with_path_separators(self):
+        """Test that method handles both forward and backward slashes."""
+        # Test with forward slashes
+        result1 = self.utils.get_main_entrypoint_from_stack(
+            target_modules=["tests/test_utils.py"],
+            fallback="not_found"
+        )
+        
+        # Test with backward slashes (Windows style)
+        result2 = self.utils.get_main_entrypoint_from_stack(
+            target_modules=["tests\\test_utils.py"],
+            fallback="not_found"
+        )
+        
+        # Both should return the same result
+        self.assertEqual(result1, result2)
+
+    def test_get_main_entrypoint_multiple_target_modules(self):
+        """Test method with multiple target modules."""
+        result = self.utils.get_main_entrypoint_from_stack(
+            target_modules=["nonexistent.py", "test_utils.py", "another.py"],
+            fallback="not_found"
+        )
+        
+        self.assertIsInstance(result, str)
+
+    @patch('inspect.stack')
+    def test_get_main_entrypoint_with_mocked_stack(self, mock_stack):
+        """Test method behavior with mocked call stack."""
+        # Create mock stack frames
+        mock_frame1 = MagicMock()
+        mock_frame1.filename = "c:\\TOTVS\\repos\\tir\\tir\\main.py"
+        mock_frame1.function = "test_function"
+        
+        mock_frame2 = MagicMock()
+        mock_frame2.filename = "c:\\other\\path\\module.py"
+        mock_frame2.function = "other_function"
+        
+        mock_stack.return_value = [mock_frame1, mock_frame2]
+        
+        result = self.utils.get_main_entrypoint_from_stack(
+            target_modules=["tir/main.py"]
+        )
+        
+        self.assertEqual(result, "test_function")
+
+    @patch('inspect.stack')
+    def test_get_main_entrypoint_skips_ignored_functions(self, mock_stack):
+        """Test that method skips frames with ignored functions."""
+        # Create mock stack frames
+        mock_frame1 = MagicMock()
+        mock_frame1.filename = "c:\\TOTVS\\repos\\tir\\tir\\main.py"
+        mock_frame1.function = "__init__"  # This should be ignored
+        
+        mock_frame2 = MagicMock()
+        mock_frame2.filename = "c:\\TOTVS\\repos\\tir\\tir\\main.py"
+        mock_frame2.function = "user_function"  # This should be returned
+        
+        mock_stack.return_value = [mock_frame1, mock_frame2]
+        
+        result = self.utils.get_main_entrypoint_from_stack(
+            target_modules=["tir/main.py"]
+        )
+        
+        self.assertEqual(result, "user_function")
+
+    @patch('inspect.stack')
+    def test_get_main_entrypoint_returns_first_match(self, mock_stack):
+        """Test that method returns the first matching function."""
+        # Create mock stack frames
+        mock_frame1 = MagicMock()
+        mock_frame1.filename = "c:\\TOTVS\\repos\\tir\\tir\\main.py"
+        mock_frame1.function = "first_function"
+        
+        mock_frame2 = MagicMock()
+        mock_frame2.filename = "c:\\TOTVS\\repos\\tir\\tir\\main.py"
+        mock_frame2.function = "second_function"
+        
+        mock_stack.return_value = [mock_frame1, mock_frame2]
+        
+        result = self.utils.get_main_entrypoint_from_stack(
+            target_modules=["tir/main.py"]
+        )
+        
+        # Should return the first matching function
+        self.assertEqual(result, "first_function")
+
+    def test_get_main_entrypoint_empty_ignored_functions(self):
+        """Test method with empty ignored functions set."""
+        result = self.utils.get_main_entrypoint_from_stack(
+            target_modules=["test_utils.py"],
+            ignored_functions=set(),
+            fallback="fallback"
+        )
+        
+        self.assertIsInstance(result, str)
+
+    def test_get_main_entrypoint_returns_string_type(self):
+        """Test that method always returns a string."""
+        test_cases = [
+            {"target_modules": None},
+            {"target_modules": ["nonexistent.py"]},
+            {"fallback": "custom"},
+            {"ignored_functions": set()},
+        ]
+        
+        for kwargs in test_cases:
+            result = self.utils.get_main_entrypoint_from_stack(**kwargs)
+            self.assertIsInstance(result, str, 
+                                f"Expected str, got {type(result)} for kwargs: {kwargs}")
+
+    def test_utils_instantiation(self):
+        """Test that Utils class can be instantiated."""
+        utils_instance = Utils()
+        self.assertIsNotNone(utils_instance)
+        self.assertTrue(hasattr(utils_instance, 'get_main_entrypoint_from_stack'))
+
+    def test_get_main_entrypoint_with_absolute_path_module(self):
+        """Test method with absolute path in target_modules."""
+        abs_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "test_utils.py"))
+        
+        result = self.utils.get_main_entrypoint_from_stack(
+            target_modules=[abs_path],
+            fallback="not_found"
+        )
+        
+        self.assertIsInstance(result, str)
+
+
+class TestUtilsClass(unittest.TestCase):
+    """Test cases for Utils class itself."""
+
+    def test_utils_has_get_main_entrypoint_method(self):
+        """Test that Utils class has the get_main_entrypoint_from_stack method."""
+        utils = Utils()
+        self.assertTrue(hasattr(utils, 'get_main_entrypoint_from_stack'))
+        self.assertTrue(callable(getattr(utils, 'get_main_entrypoint_from_stack')))
+
+    def test_utils_docstring_exists(self):
+        """Test that Utils class has proper documentation."""
+        self.assertIsNotNone(Utils.__doc__)
+        self.assertTrue(len(Utils.__doc__) > 0)
+
+    def test_get_main_entrypoint_docstring_exists(self):
+        """Test that method has proper documentation."""
+        method = Utils.get_main_entrypoint_from_stack
+        self.assertIsNotNone(method.__doc__)
+        self.assertTrue(len(method.__doc__) > 0)
+
+
+if __name__ == '__main__':
+    unittest.main()

tir_framework-2.7.0/tests/test_webapp_internal_clicktree.py

@@ -0,0 +1,431 @@
+import importlib.util
+import logging
+import sys
+import types
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import Mock
+
+
+repo_root = Path(__file__).resolve().parents[1]
+module_path = repo_root / "tir" / "technologies" / "webapp_internal.py"
+
+
+class FakeElement:
+    def __init__(self, text="", attrs=None, parent=None):
+        self.text = text
+        self.attrs = attrs or {}
+        self.parent = parent
+        self.click_count = 0
+
+    def get_attribute(self, name):
+        return self.attrs.get(name)
+
+    def click(self):
+        self.click_count += 1
+
+
+def _register_module(name, module=None):
+    module = module or types.ModuleType(name)
+    sys.modules[name] = module
+
+    if "." in name:
+        parent_name, child_name = name.rsplit(".", 1)
+        parent = sys.modules.get(parent_name)
+        if parent is None:
+            parent = _register_module(parent_name)
+        setattr(parent, child_name, module)
+
+    return module
+
+
+def load_webapp_internal_module():
+    cached = sys.modules.get("tir_webapp_internal_test")
+    if cached is not None:
+        return cached
+
+    # External dependency stubs used only to import the module for isolated unit tests.
+    _register_module("pandas")
+    _register_module("cv2")
+
+    bs4_mod = _register_module("bs4")
+    bs4_mod.BeautifulSoup = type("BeautifulSoup", (), {})
+    bs4_mod.Tag = type("Tag", (), {})
+
+    _register_module("selenium")
+    _register_module("selenium.webdriver")
+    _register_module("selenium.webdriver.common")
+    _register_module("selenium.webdriver.support")
+
+    keys_mod = _register_module("selenium.webdriver.common.keys")
+    keys_mod.Keys = type("Keys", (), {"CONTROL": "CONTROL", "F5": "F5"})
+
+    by_mod = _register_module("selenium.webdriver.common.by")
+    by_mod.By = type("By", (), {"CSS_SELECTOR": "css", "XPATH": "xpath"})
+
+    action_mod = _register_module("selenium.webdriver.common.action_chains")
+    action_mod.ActionChains = type("ActionChains", (), {})
+
+    support_ui_mod = _register_module("selenium.webdriver.support.ui")
+    support_ui_mod.Select = type("Select", (), {})
+
+    expected_conditions_mod = _register_module("selenium.webdriver.support.expected_conditions")
+    expected_conditions_mod.EC = type("EC", (), {})
+
+    exceptions_mod = _register_module("selenium.common.exceptions")
+    exceptions_mod.WebDriverException = type("WebDriverException", (Exception,), {})
+    exceptions_mod.NoSuchElementException = type("NoSuchElementException", (Exception,), {})
+
+    tir_pkg = _register_module("tir")
+    tir_pkg.__path__ = []
+    technologies_pkg = _register_module("tir.technologies")
+    technologies_pkg.__path__ = []
+    core_pkg = _register_module("tir.technologies.core")
+    core_pkg.__path__ = []
+    third_party_pkg = _register_module("tir.technologies.core.third_party")
+    third_party_pkg.__path__ = []
+
+    enum_mod = _register_module("tir.technologies.core.enumerations")
+    enum_mod.ClickType = type("ClickType", (), {"SELENIUM": "selenium", "JS": "js"})
+    enum_mod.ScrapType = type(
+        "ScrapType",
+        (),
+        {
+            "TEXT": "text",
+            "MIXED": "mixed",
+            "CSS_SELECTOR": "css",
+            "SCRIPT": "script",
+        },
+    )
+    enum_mod.MessageType = type(
+        "MessageType",
+        (),
+        {
+            "CORRECT": "correct",
+            "INCORRECT": "incorrect",
+            "DISABLED": "disabled",
+            "ASSERTERROR": "asserterror",
+        },
+    )
+
+    base_module = _register_module("tir.technologies.core.base")
+    base_module.Base = type("Base", (), {"errors": []})
+
+    log_module = _register_module("tir.technologies.core.log")
+    log_module.Log = type("Log", (), {})
+    log_module.nump = None
+
+    config_module = _register_module("tir.technologies.core.config")
+    config_module.ConfigLoader = lambda *args, **kwargs: None
+
+    language_module = _register_module("tir.technologies.core.language")
+    language_module.LanguagePack = type("LanguagePack", (), {})
+
+    xpath_module = _register_module("tir.technologies.core.third_party.xpath_soup")
+    xpath_module.xpath_soup = lambda *args, **kwargs: "//stub"
+
+    psutil_module = _register_module("tir.technologies.core.psutil_info")
+    psutil_module.system_info = lambda: {}
+
+    numexec_module = _register_module("tir.technologies.core.numexec")
+    numexec_module.NumExec = type("NumExec", (), {})
+
+    logging_config_module = _register_module("tir.technologies.core.logging_config")
+    logging_config_module.logger = lambda: logging.getLogger("test_webapp_internal_clicktree")
+
+    base_database_module = _register_module("tir.technologies.core.base_database")
+    base_database_module.BaseDatabase = type("BaseDatabase", (), {})
+
+    spec = importlib.util.spec_from_file_location("tir_webapp_internal_test", str(module_path))
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    sys.modules["tir_webapp_internal_test"] = module
+    return module
+
+
+def build_webapp():
+    module = load_webapp_internal_module()
+    webapp = module.WebappInternal.__new__(module.WebappInternal)
+    webapp.config = SimpleNamespace(time_out=0.01)
+    webapp.tree_base_element = ()
+    webapp.wait_blocker = Mock()
+    webapp.check_layers = Mock(return_value=0)
+    webapp.scroll_to_element = Mock()
+    webapp.log_error = Mock()
+    webapp.click = Mock()
+    webapp.return_last_zindex = Mock(return_value=0)
+    webapp.element_exists = Mock(return_value=False)
+    webapp.soup_to_selenium = Mock(side_effect=lambda element: element)
+    return webapp, module
+
+
+def test_clicktree_delegates_to_internal_method():
+    webapp, _ = build_webapp()
+    webapp.click_tree = Mock()
+
+    webapp.ClickTree("nivel 1 > nivel 2", right_click=True, position=2, tree_number=3)
+
+    webapp.click_tree.assert_called_once_with("nivel 1 > nivel 2", True, 2, 3)
+
+
+def test_click_tree_clicks_the_last_matching_node_without_browser_dependencies():
+    webapp, _ = build_webapp()
+
+    node = FakeElement(
+        text="  Financeiro   ",
+        attrs={"hidden": None, "closed": "", "hierarchy": "01", "icon": None},
+    )
+    clickable_part = FakeElement(text="Financeiro", parent=node)
+
+    webapp.find_tree_bs = Mock(return_value=[node])
+    webapp.element_is_displayed = Mock(return_value=True)
+    webapp.check_toggler = Mock(return_value=False)
+    webapp.check_hierarchy = Mock(return_value=False)
+
+    selected_nodes = [None, node, node]
+
+    def treenode_selected(_label, _tree_number=0):
+        return selected_nodes.pop(0) if selected_nodes else node
+
+    def execute_js_selector(selector, element, get_all=True):
+        if selector == ".toggler, .lastchild, .data, label":
+            return [clickable_part]
+        return None
+
+    webapp.treenode_selected = Mock(side_effect=treenode_selected)
+    webapp.execute_js_selector = Mock(side_effect=execute_js_selector)
+
+    webapp.click_tree("Financeiro", right_click=False, position=1, tree_number=0)
+
+    assert clickable_part.click_count == 1
+    webapp.log_error.assert_not_called()
+
+
+def test_click_tree_logs_error_when_no_tree_node_is_found():
+    webapp, _ = build_webapp()
+    webapp.config.time_out = 0
+    webapp.find_tree_bs = Mock(return_value=[])
+    webapp.element_is_displayed = Mock(return_value=True)
+    webapp.treenode_selected = Mock(return_value=None)
+    webapp.execute_js_selector = Mock(return_value=None)
+    webapp.check_toggler = Mock(return_value=False)
+    webapp.check_hierarchy = Mock(return_value=False)
+
+    webapp.click_tree("Item inexistente", right_click=False, position=1, tree_number=0)
+
+    webapp.log_error.assert_called_once()
+    assert "Couldn't click on tree element" in webapp.log_error.call_args.args[0]
+
+
+def test_click_tree_with_right_click_on_last_node():
+    """Test that right_click=True is passed to click method when last item is clicked."""
+    webapp, _ = build_webapp()
+    
+    node = FakeElement(
+        text="Menu Item",
+        attrs={"hidden": None, "closed": "", "hierarchy": "01", "icon": None},
+    )
+    clickable_part = FakeElement(text="Menu Item", parent=node)
+    
+    webapp.find_tree_bs = Mock(return_value=[node])
+    webapp.element_is_displayed = Mock(return_value=True)
+    webapp.check_toggler = Mock(return_value=False)
+    webapp.check_hierarchy = Mock(return_value=False)
+    webapp.treenode_selected = Mock(return_value=node)
+    webapp.return_last_zindex = Mock(return_value=100)
+    
+    def execute_js_selector(selector, element, get_all=True):
+        if selector == ".toggler, .lastchild, .data, label":
+            return [clickable_part]
+        return None
+    
+    webapp.execute_js_selector = Mock(side_effect=execute_js_selector)
+    
+    webapp.click_tree("Menu Item", right_click=True, position=1, tree_number=0)
+    
+    # Verify that the main element was clicked (right_click=True path)
+    # The actual right_click happens in the loop after regular click
+    webapp.log_error.assert_not_called()
+
+
+def test_click_tree_with_multiple_hierarchy_levels():
+    """Test navigating through single level tree (simpler version of multi-level)."""
+    webapp, _ = build_webapp()
+    
+    pai = FakeElement(text="Pai", attrs={"hierarchy": "01", "closed": "", "icon": None})
+    pai_clickable = FakeElement(text="Pai", parent=pai)
+    
+    webapp.find_tree_bs = Mock(return_value=[pai])
+    webapp.element_is_displayed = Mock(return_value=True)
+    webapp.check_toggler = Mock(return_value=False)
+    webapp.check_hierarchy = Mock(return_value=False)
+    webapp.treenode_selected = Mock(return_value=pai)
+    
+    def execute_js_selector(selector, element, get_all=True):
+        if selector == ".toggler, .lastchild, .data, label":
+            return [pai_clickable]
+        return None
+    
+    webapp.execute_js_selector = Mock(side_effect=execute_js_selector)
+    
+    # Click the single level
+    webapp.click_tree("Pai", right_click=False, position=1, tree_number=0)
+    
+    # Verify successful click
+    webapp.log_error.assert_not_called()
+
+
+def test_click_tree_respects_position_parameter():
+    """Test that position parameter is considered when multiple elements exist."""
+    webapp, _ = build_webapp()
+    
+    # Create multiple nodes with same text
+    node1 = FakeElement(text="Duplicado", attrs={"hidden": None, "closed": "", "hierarchy": "01"})
+    node2 = FakeElement(text="Duplicado", attrs={"hidden": None, "closed": "", "hierarchy": "02"})
+    
+    webapp.find_tree_bs = Mock(return_value=[node1, node2])
+    webapp.element_is_displayed = Mock(return_value=True)
+    webapp.check_toggler = Mock(return_value=False)
+    webapp.check_hierarchy = Mock(return_value=False)
+    
+    # Return node2 when treenode_selected is called
+    webapp.treenode_selected = Mock(return_value=node2)
+    
+    def execute_js_selector(selector, element, get_all=True):
+        if selector == ".toggler, .lastchild, .data, label":
+            if element == node1:
+                return [FakeElement(text="Duplicado")]
+            elif element == node2:
+                return [FakeElement(text="Duplicado")]
+        return None
+    
+    webapp.execute_js_selector = Mock(side_effect=execute_js_selector)
+    
+    # Position 2 should try to select the second matching node
+    webapp.click_tree("Duplicado", right_click=False, position=2, tree_number=0)
+    
+    # Verify successful click
+    webapp.log_error.assert_not_called()
+
+
+def test_click_tree_updates_tree_base_element_for_non_last_items():
+    """Test that tree_base_element is updated when navigating intermediate nodes."""
+    webapp, _ = build_webapp()
+    webapp.tree_base_element = ()
+    
+    pai = FakeElement(text="Pai", attrs={"hierarchy": "01", "closed": "true", "icon": None})
+    filho = FakeElement(text="Filho", attrs={"hierarchy": "01-01", "closed": "", "icon": None})
+    pai_clickable = FakeElement(text="Pai", parent=pai)
+    
+    webapp.find_tree_bs = Mock(return_value=[pai, filho])
+    webapp.element_is_displayed = Mock(return_value=True)
+    webapp.check_toggler = Mock(return_value=True)
+    webapp.check_hierarchy = Mock(side_effect=[True, False])
+    webapp.treenode_selected = Mock(side_effect=[None, pai, filho])
+    
+    def execute_js_selector(selector, element, get_all=True):
+        if selector == ".toggler, .lastchild, .data, label":
+            return [pai_clickable]
+        return None
+    
+    webapp.execute_js_selector = Mock(side_effect=execute_js_selector)
+    
+    webapp.click_tree("Pai > Filho", right_click=False, position=1, tree_number=0)
+    
+    # Verify tree_base_element was set to (label_filtered, element_class_item)
+    assert webapp.tree_base_element != ()
+    assert webapp.tree_base_element[0] == "pai"  # label_filtered is lowercased
+
+
+def test_click_tree_with_hidden_element():
+    """Test that hidden elements are filtered out during element search."""
+    webapp, _ = build_webapp()
+    
+    hidden_node = FakeElement(text="Hidden", attrs={"hidden": "true", "closed": "", "hierarchy": "01"})
+    visible_node = FakeElement(text="Visible", attrs={"hidden": None, "closed": "", "hierarchy": "02"})
+    clickable = FakeElement(text="Visible", parent=visible_node)
+    
+    webapp.find_tree_bs = Mock(return_value=[hidden_node, visible_node])
+    
+    def element_is_displayed_side_effect(element):
+        # hidden_node has hidden attribute, so it's not displayed
+        if element == hidden_node:
+            return False
+        return True
+    
+    webapp.element_is_displayed = Mock(side_effect=element_is_displayed_side_effect)
+    webapp.check_toggler = Mock(return_value=False)
+    webapp.check_hierarchy = Mock(return_value=False)
+    webapp.treenode_selected = Mock(return_value=visible_node)
+    
+    def execute_js_selector(selector, element, get_all=True):
+        if selector == ".toggler, .lastchild, .data, label":
+            return [clickable]
+        return None
+    
+    webapp.execute_js_selector = Mock(side_effect=execute_js_selector)
+    
+    webapp.click_tree("Visible", right_click=False, position=1, tree_number=0)
+    
+    # Verify hidden element was skipped (log_error not called)
+    webapp.log_error.assert_not_called()
+
+
+def test_click_tree_handles_text_normalization():
+    """Test that extra spaces in labels are normalized during matching."""
+    webapp, _ = build_webapp()
+    
+    node = FakeElement(
+        text="  Item   com   espaços   ",
+        attrs={"hidden": None, "closed": "", "hierarchy": "01", "icon": None},
+    )
+    clickable_part = FakeElement(text="Item com espaços", parent=node)
+    
+    webapp.find_tree_bs = Mock(return_value=[node])
+    webapp.element_is_displayed = Mock(return_value=True)
+    webapp.check_toggler = Mock(return_value=False)
+    webapp.check_hierarchy = Mock(return_value=False)
+    webapp.treenode_selected = Mock(return_value=node)
+    
+    def execute_js_selector(selector, element, get_all=True):
+        if selector == ".toggler, .lastchild, .data, label":
+            return [clickable_part]
+        return None
+    
+    webapp.execute_js_selector = Mock(side_effect=execute_js_selector)
+    
+    # Search with single spaces should match label with multiple spaces
+    webapp.click_tree("Item com espaços", right_click=False, position=1, tree_number=0)
+    
+    # Verify normalization worked (no error)
+    webapp.log_error.assert_not_called()
+
+
+def test_click_tree_tree_number_parameter():
+    """Test that tree_number parameter is used to locate the correct tree."""
+    webapp, _ = build_webapp()
+    
+    tree_node = FakeElement(text="Tree2Item", attrs={"hidden": None, "closed": "", "hierarchy": "02"})
+    clickable = FakeElement(text="Tree2Item", parent=tree_node)
+    
+    # find_tree_bs is called with tree_number to select the correct tree
+    webapp.find_tree_bs = Mock(return_value=[tree_node])
+    webapp.element_is_displayed = Mock(return_value=True)
+    webapp.check_toggler = Mock(return_value=False)
+    webapp.check_hierarchy = Mock(return_value=False)
+    webapp.treenode_selected = Mock(return_value=tree_node)
+    
+    def execute_js_selector(selector, element, get_all=True):
+        if selector == ".toggler, .lastchild, .data, label":
+            return [clickable]
+        return None
+    
+    webapp.execute_js_selector = Mock(side_effect=execute_js_selector)
+    
+    # Use tree_number=2 (should be converted to index 1)
+    webapp.click_tree("Tree2Item", right_click=False, position=1, tree_number=2)
+    
+    # Verify find_tree_bs was called with the correct tree_number
+    assert webapp.find_tree_bs.called
+    # Verify successful click (no error logged)
+    webapp.log_error.assert_not_called()