appium_failure_helper 1.8.1 → 1.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5fe4f4dcf579db89e79b789c9915b51adab896a9d9586220d0162d65ddbba55c
-  data.tar.gz: b988c6bbd9571393c371449804e4b37b1b5962273dfd275a1d703324734cb8d5
+  metadata.gz: a56eb0f75acb977e0d8e066b31593613b5ef167675cddb797fd474c152965cc3
+  data.tar.gz: 2c3bf1de88d8976d9fd49622c4c1ae3523dd16f4afe6c0fef764a443edb255a7
 SHA512:
-  metadata.gz: 9e34cabdb17a71b586374f5aca2e086dd0bf060eb56ad250d3594fc2c5d02bf4594d2648d356564027997f66f230dcf2a48ee7bb4ffe0fc362798baac3ef13f9
-  data.tar.gz: 39435fd489a0fc28719499533d372b46a60b82bdd4df202c9fa84054172bd89ea3a8c9f0920d26c327dedd04bb225d8d10dcd278548d7c2c1732026d0d9d2238
+  metadata.gz: 645ec5e70207e9345350ea66f64524db344c65cee481ec3aa189c8133557433bd504eca618eeba8aa56c7bb7517cc36170493c56631d5efc3dadc6c6725e99b6
+  data.tar.gz: 3ee2904b1aae5428e5eec0edccdf9565284f147da00206ef6c74a7a2d1b79c0764fc51385ca29c5e63b31f205566c0c9ffb8452bf76afbe24559bf09981b3032

data/lib/appium_failure_helper/handler.rb

@@ -13,67 +13,113 @@ module AppiumFailureHelper
 
     def call
       begin
-        unless @driver && @driver.session_id
+        unless @driver && @driver.respond_to?(:session_id) && @driver.session_id
           Utils.logger.error("Helper não executado: driver nulo ou sessão encerrada.")
           return
         end
 
         FileUtils.mkdir_p(@output_folder)
 
-        triage_result = Analyzer.triage_error(@exception)
-        platform_value = @driver.capabilities[:platform_name] || @driver.capabilities['platformName']
+        triage_result = Analyzer.triage_error(@exception) rescue :unknown
+        platform_value = (@driver.capabilities[:platform_name] rescue nil) || (@driver.capabilities['platformName'] rescue nil)
         platform = platform_value&.downcase || 'unknown'
 
         report_data = {
-          exception: @exception, triage_result: triage_result,
-          timestamp: @timestamp, platform: platform,
-          screenshot_base_64: @driver.screenshot_as(:base64)
+          exception: @exception,
+          triage_result: triage_result,
+          timestamp: @timestamp,
+          platform: platform,
+          screenshot_base_64: safe_screenshot_base64
         }
 
         if triage_result == :locator_issue
-          page_source = @driver.page_source
-          failed_info = Analyzer.extract_failure_details(@exception)
+          page_source = safe_page_source
+          # tenta extrair detalhes do Analyzer (se existir), senão usa fetch_failed_element
+          failed_info = {}
+          begin
+            failed_info = Analyzer.extract_failure_details(@exception) if Analyzer.respond_to?(:extract_failure_details)
+          rescue
+            failed_info = {}
+          end
 
           if failed_info.nil? || failed_info.empty?
-            failed_info = SourceCodeAnalyzer.extract_from_exception(@exception) || {}
+            # tenta extrair do próprio handler (regex mais robusta)
+            failed_info = fetch_failed_element || {}
           end
 
-          if failed_info.empty?
-            report_data[:triage_result] = :unidentified_locator_issue
-          else
-            doc = Nokogiri::XML(page_source)
-            page_analyzer = PageAnalyzer.new(page_source, platform)
-            all_page_elements = page_analyzer.analyze || []
-
-            best_candidate_analysis = Analyzer.perform_advanced_analysis(failed_info, all_page_elements, platform)
+          # fallback para extrair do código-fonte (se existir)
+          if (failed_info.nil? || failed_info.empty?) && SourceCodeAnalyzer.respond_to?(:extract_from_exception)
+            begin
+              failed_info = SourceCodeAnalyzer.extract_from_exception(@exception) || {}
+            rescue
+              failed_info = {}
+            end
+          end
 
-            alternative_xpaths = []
-            target_node = nil
+          # garante que exista ao menos um objeto failed_element
+          if failed_info.nil? || failed_info.empty?
+            failed_info = { selector_type: 'unknown', selector_value: @exception&.message.to_s }
+            report_data[:triage_result] = :unidentified_locator_issue
+          end
 
-            if best_candidate_analysis
-              if best_candidate_analysis[:attributes] && (path = best_candidate_analysis[:attributes][:path])
-                target_node = doc.at_xpath(path)
-              end
-            else
-              failed_attrs = Analyzer.send(:parse_locator, failed_info[:selector_type], failed_info[:selector_value], platform)
+          all_page_elements = []
+          best_candidate_analysis = nil
+          alternative_xpaths = []
+
+          if page_source
+            begin
+              doc = Nokogiri::XML(page_source)
+              page_analyzer = PageAnalyzer.new(page_source, platform)
+              all_page_elements = page_analyzer.analyze || []
+              best_candidate_analysis = Analyzer.perform_advanced_analysis(failed_info, all_page_elements, platform) rescue nil
+            rescue => e
+              Utils.logger.warn("Erro analisando page_source: #{e.message}")
+            end
+          end
 
-              unless failed_attrs.empty?
-                temp_doc = Nokogiri::XML::Document.new
-                target_node = Nokogiri::XML::Node.new(failed_attrs['tag'] || 'element', temp_doc)
-                failed_attrs.each { |k, v| target_node[k] = v unless k == 'tag' }
+          # se não encontrou candidato, gera alternativas a partir do locator bruto
+          if best_candidate_analysis.nil?
+            # tenta parse por Analyzer (se exposto), senão regex fallback
+            failed_attrs = {}
+            begin
+              if Analyzer.respond_to?(:parse_locator) || Analyzer.private_methods.include?(:parse_locator)
+                failed_attrs = Analyzer.send(:parse_locator, failed_info[:selector_type], failed_info[:selector_value], platform) rescue {}
               end
+            rescue
+              failed_attrs = {}
             end
 
-            alternative_xpaths = XPathFactory.generate_for_node(target_node) if target_node
+            if failed_attrs.nil? || failed_attrs.empty?
+              failed_attrs = parse_attrs_from_locator_string(failed_info[:selector_value] || '')
+            end
 
-            report_data.merge!({
-                                 page_source: page_source,
-                                 failed_element: failed_info,
-                                 best_candidate_analysis: best_candidate_analysis,
-                                 alternative_xpaths: alternative_xpaths,
-                                 all_page_elements: all_page_elements
-                               })
+            if failed_attrs && !failed_attrs.empty?
+              temp_doc = Nokogiri::XML::Document.new
+              tag = (failed_attrs.delete('tag') || failed_attrs.delete(:tag) || 'element').to_s
+              target_node = Nokogiri::XML::Node.new(tag, temp_doc)
+              failed_attrs.each { |k, v| target_node[k.to_s] = v.to_s unless k.to_s == 'tag' }
+              alternative_xpaths = XPathFactory.generate_for_node(target_node) || []
+            end
+          else
+            # se encontrou candidato, tenta gerar alternativas a partir do node encontrado
+            if best_candidate_analysis[:attributes] && (path = best_candidate_analysis[:attributes][:path])
+              begin
+                doc = Nokogiri::XML(page_source) unless defined?(doc) && doc
+                target_node = doc.at_xpath(path) rescue nil
+                alternative_xpaths = XPathFactory.generate_for_node(target_node) if target_node
+              rescue
+                # ignore, já temos best_candidate_analysis
+              end
+            end
           end
+
+          report_data.merge!({
+                               page_source: page_source,
+                               failed_element: failed_info,
+                               best_candidate_analysis: best_candidate_analysis,
+                               alternative_xpaths: alternative_xpaths,
+                               all_page_elements: all_page_elements
+                             })
         end
 
         ReportGenerator.new(@output_folder, report_data).generate_all
@@ -86,93 +132,73 @@ module AppiumFailureHelper
 
     private
 
+    def safe_screenshot_base64
+      @driver.respond_to?(:screenshot_as) ? @driver.screenshot_as(:base64) : nil
+    rescue => _
+      nil
+    end
+
+    def safe_page_source
+      return nil unless @driver.respond_to?(:page_source)
+      @driver.page_source
+    rescue => _
+      nil
+    end
+
     def fetch_failed_element
       msg = @exception&.message.to_s
 
-      if (m = msg.match(/using\s+["']?([^"']+)["']?\s+with\s+value\s+["']([^"']+)["']/i))
-        return { selector_type: m[1], selector_value: m[2] }
+      # 1) tentativa de parse clássico com aspas (mais restritivo)
+      if (m = msg.match(/using\s+['"](?<type>[^'"]+)['"]\s+with\s+value\s+['"](?<value>.*?)['"]/m))
+        return { selector_type: m[:type], selector_value: m[:value] }
+      end
+
+      # 2) fallback: pega anything após 'with value' até o final da linha (remove quotes extras)
+      if (m = msg.match(/with\s+value\s+(?<value>.+)$/mi))
+        raw = m[:value].strip
+        # remove quotes de borda apenas se existirem
+        raw = raw[1..-2] if raw.start_with?('"', "'") && raw.end_with?('"', "'")
+        # tenta detectar o tipo (xpath, id, accessibility id, css)
+        guessed_type = if raw =~ %r{^//|^/}i
+                         'xpath'
+                       elsif raw =~ /^[a-zA-Z0-9\-_:.]+:/
+                         'id'
+                       else
+                         (msg[/\b(xpath|id|accessibility id|css)\b/i] || 'unknown').downcase
+                       end
+        return { selector_type: guessed_type, selector_value: raw }
       end
 
+      # 3) outros formatos JSON-like
       if (m = msg.match(/"method"\s*:\s*"([^"]+)"[\s,}].*"selector"\s*:\s*"([^"]+)"/i))
         return { selector_type: m[1], selector_value: m[2] }
       end
 
+      # 4) tentativa simples: pegar primeira ocorrência entre aspas
       if (m = msg.match(/["']([^"']+)["']/))
         maybe_value = m[1]
-        unified_map = ElementRepository.load_all rescue {}
-        found = find_in_element_repository_by_value(maybe_value, unified_map)
-        if found
-          return found
-        end
-
         guessed_type = msg[/\b(xpath|id|accessibility id|css)\b/i] ? $&.downcase : nil
         return { selector_type: guessed_type || 'unknown', selector_value: maybe_value }
       end
 
-      begin
-        code_info = SourceCodeAnalyzer.extract_from_exception(@exception) rescue {}
-        unless code_info.nil? || code_info.empty?
-          return code_info
-        end
-      rescue => _; end
-
-      unified_map = ElementRepository.load_all rescue {}
-      unified_map.each do |k, v|
-        k_str = k.to_s.downcase
-        if msg.downcase.include?(k_str)
-          return normalize_repo_element(v)
-        end
-        vals = []
-        if v.is_a?(Hash)
-          vals << v['valor'] if v.key?('valor')
-          vals << v['value'] if v.key?('value')
-          vals << v[:valor] if v.key?(:valor)
-          vals << v[:value] if v.key?(:value)
-        end
-        vals.compact!
-        vals.each do |vv|
-          if vv.to_s.downcase == vv.to_s.downcase && msg.downcase.include?(vv.to_s.downcase)
-            return normalize_repo_element(v)
-          end
-        end
-      end
-
-      # final fallback
-      debug_log("fetch_failed_element: fallback unknown")
-      { selector_type: 'unknown', selector_value: 'unknown' }
+      {}
     end
 
-    def find_in_element_repository_by_value(value, map = {})
-      return nil if value.nil? || value.to_s.strip.empty?
-      normalized_value = value.to_s.downcase.strip
-      map.each do |k, v|
-        entry = v.is_a?(Hash) ? v : (v.respond_to?(:to_h) ? v.to_h : nil)
-        next unless entry
-        entry_val = entry['valor'] || entry['value'] || entry[:valor] || entry[:value] || entry['locator'] || entry[:locator]
-        next unless entry_val
-        return normalize_repo_element(entry) if entry_val.to_s.downcase.strip == normalized_value
-      end
-      nil
-    end
+    def parse_attrs_from_locator_string(selector_value)
+      attrs = {}
+      return attrs unless selector_value.is_a?(String) && !selector_value.empty?
 
-    def normalize_repo_element(entry)
-      return nil unless entry.is_a?(Hash)
-      tipo = entry['tipoBusca'] || entry[:tipoBusca] || entry['type'] || entry[:type] || entry['search_type'] || entry[:search]
-      valor = entry['valor'] || entry[:value] || entry[:locator] || entry[:valor_final] || entry[:value_final]
-      return nil unless valor
-      { selector_type: (tipo || 'unknown'), selector_value: valor.to_s }
-    end
+      selector_value.scan(/@([a-zA-Z0-9\-\:]+)\s*=\s*['"]([^'"]+)['"]/).each do |k, v|
+        attrs[k] = v
+      end
 
-    def generate_alternative_xpaths(similar_elements, doc)
-      alternative_xpaths = []
-      if !similar_elements.empty?
-        target_suggestion = similar_elements.first
-        if target_suggestion[:attributes] && (target_path = target_suggestion[:attributes][:path])
-          target_node = doc.at_xpath(target_path) rescue nil
-          alternative_xpaths = XPathFactory.generate_for_node(target_node) if target_node
-        end
+      if selector_value =~ %r{//\s*([a-zA-Z0-9_\-:]+)}
+        attrs['tag'] = $1
+      elsif selector_value =~ /^([a-zA-Z0-9_\-:]+)\[/
+        attrs['tag'] = $1
       end
-      alternative_xpaths
+
+      attrs
     end
   end
 end

data/lib/appium_failure_helper/report_generator.rb

@@ -24,7 +24,8 @@ module AppiumFailureHelper
         exception_class: @data[:exception].class.to_s,
         exception_message: @data[:exception].message,
         failed_element: @data[:failed_element],
-        best_candidate_analysis: @data[:best_candidate_analysis]
+        best_candidate_analysis: @data[:best_candidate_analysis],
+        alternative_xpaths: @data[:alternative_xpaths] || []
       }
       File.open("#{@output_folder}/failure_analysis_#{@data[:timestamp]}.yaml", 'w') { |f| f.write(YAML.dump(analysis_report)) }
 

data/lib/appium_failure_helper/version.rb

@@ -1,3 +1,3 @@
 module AppiumFailureHelper
-  VERSION = "1.8.1"
+  VERSION = "1.9.0"
 end

data/lib/appium_failure_helper/xpath_factory.rb

@@ -4,8 +4,18 @@ module AppiumFailureHelper
 
     def self.generate_for_node(node)
       return [] unless node
+
+      # Se vier um Document, usa o root element
+      if defined?(Nokogiri) && node.is_a?(Nokogiri::XML::Document)
+        node = node.root
+      end
+
+      # Só continua se for um elemento que suporta atributos
+      return [] unless node && node.respond_to?(:attributes) && node.element?
+
       tag = node.name
-      attrs = node.attributes.transform_values(&:value) || {}
+      attrs = (node.attributes || {}).transform_values { |a| a.respond_to?(:value) ? a.value : a }
+
       strategies = []
 
       add_direct_attribute_strategies(strategies, tag, attrs)
@@ -15,7 +25,12 @@ module AppiumFailureHelper
       add_partial_text_strategies(strategies, tag, attrs)
       add_boolean_strategies(strategies, tag, attrs)
       add_positional_strategies(strategies, node)
-      
+
+      # fallback: se nenhuma estratégia foi criada, garante ao menos o caminho absoluto
+      if strategies.empty?
+        strategies << { name: "Caminho Absoluto (fallback)", strategy: 'xpath', locator: node.path.to_s, reliability: :baixa }
+      end
+
       strategies.uniq { |s| s[:locator] }.first(MAX_STRATEGIES)
     end
 
@@ -46,32 +61,40 @@ module AppiumFailureHelper
 
     def self.add_parent_based_strategies(strategies, tag, node)
       parent = node.parent
-      return unless parent && parent.name != 'hierarchy'
+      return unless parent
+      return if parent.name == 'hierarchy' rescue false
 
-      parent_attrs = parent.respond_to?(:attributes) ? parent.attributes.transform_values(&:value) : {}
+      parent_attrs = {}
+      if parent.respond_to?(:attributes) && parent.element?
+        parent_attrs = (parent.attributes || {}).transform_values { |a| a.respond_to?(:value) ? a.value : a }
+      end
 
       if (id = parent_attrs['resource-id']) && !id.empty?
         strategies << { name: "Filho de Pai com ID", strategy: 'xpath', locator: "//*[@resource-id='#{id}']//#{tag}", reliability: :alta }
       else
         parent_attrs.each do |k, v|
-          next if v.empty?
+          next if v.to_s.strip.empty?
           strategies << { name: "Filho de Pai com #{k}", strategy: 'xpath', locator: "//*[@#{k}='#{v}']//#{tag}", reliability: :media }
         end
       end
     end
-    
+
     def self.add_relational_strategies(strategies, node)
-      if (prev_sibling = node.previous_sibling) && (text = prev_sibling['text']) && !text.empty?
-        strategies << { name: "Relativo ao Irmão Anterior", strategy: 'xpath', locator: "//#{prev_sibling.name}[@text='#{text}']/following-sibling::#{node.name}[1]", reliability: :media }
+      prev = node.previous_sibling
+      if prev && prev.respond_to?(:attributes) && prev.element?
+        prev_attrs = (prev.attributes || {}).transform_values { |a| a.respond_to?(:value) ? a.value : a }
+        if (text = prev_attrs['text']) && !text.empty?
+          strategies << { name: "Relativo ao Irmão Anterior", strategy: 'xpath', locator: "//#{prev.name}[@text='#{text}']/following-sibling::#{node.name}[1]", reliability: :media }
+        end
       end
     end
-    
+
     def self.add_partial_text_strategies(strategies, tag, attrs)
       if (text = attrs['text']) && !text.empty? && text.split.size > 1
         strategies << { name: "Texto Parcial (contains)", strategy: 'xpath', locator: "//#{tag}[contains(@text, '#{text.split.first}')]", reliability: :media }
       end
     end
-    
+
     def self.add_boolean_strategies(strategies, tag, attrs)
       %w[enabled checked selected].each do |attr|
         if attrs[attr] == 'true'
@@ -81,9 +104,14 @@ module AppiumFailureHelper
     end
 
     def self.add_positional_strategies(strategies, node)
-      index = node.xpath('preceding-sibling::' + node.name).count + 1
+      index = 1
+      begin
+        index = node.xpath('preceding-sibling::' + node.name).count + 1
+      rescue
+        index = 1
+      end
       strategies << { name: "Índice na Tela (Frágil)", strategy: 'xpath', locator: "(//#{node.name})[#{index}]", reliability: :baixa }
-      strategies << { name: "Caminho Absoluto (Não Recomendado)", strategy: 'xpath', locator: node.path, reliability: :baixa }
+      strategies << { name: "Caminho Absoluto (Não Recomendado)", strategy: 'xpath', locator: node.path.to_s, reliability: :baixa }
     end
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appium_failure_helper
 version: !ruby/object:Gem::Version
-  version: 1.8.1
+  version: 1.9.0
 platform: ruby
 authors:
 - David Nascimento