appium_failure_helper 1.1.4 → 1.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 422c6af375ea6308ceaadf40036c7e1ff5187ed660830c4a403abcea94553551
-  data.tar.gz: 19ffb9d6d32d70274087584bce03005694fc75c6ea17d1abf2cc4c938c448d25
+  metadata.gz: 78e35ec0789690a1c581b094e7f1a1bc8cf87ffd7b5775b58805bc3d0954e2c0
+  data.tar.gz: 62f6e3a7a2338ec85b6f5c37064509d45534cf55197e0a791048763aac85e044
 SHA512:
-  metadata.gz: d0ed3e523bcf4ee55edf522c4a93dbca4d1c60be1654ab87fbb625bce741dbb9df9eadd2458f33d6b9df8405cf9a8a775431982d46bb1a8d45b40983b995657b
-  data.tar.gz: b903344bf3dbc2176f3cf21c217082e8c5a739bd7e2ff8cd9a7dda4a7b066a0a75cd74ead27e7a4a4b7a6fe557ba86f02aa6e8fdd1fd633af8b2e31396b45999
+  metadata.gz: 3f57d410bc16465a452693cd5c2211fcc159def18c39b58d6de140be38e37c78f64b625f31844f77e566b5c222fbcd1d5c79b64408fad427038f360f75a4a07a
+  data.tar.gz: e7322ab59bde3d4fa00551573ef5fadb6e8091f7b374b9170dc1fddac247908393b442be3c0b72ef3fb144e2d680547631a946d4711cea03d3ff7029d2536a42

data/lib/appium_failure_helper/analyzer.rb

@@ -1,8 +1,10 @@
 module AppiumFailureHelper
   module Analyzer
-        def self.triage_error(exception)
+    def self.triage_error(exception)
       case exception
-      when Selenium::WebDriver::Error::NoSuchElementError, Selenium::WebDriver::Error::TimeoutError
+      when Selenium::WebDriver::Error::NoSuchElementError, 
+           Selenium::WebDriver::Error::TimeoutError,
+           Selenium::WebDriver::Error::UnknownCommandError
         :locator_issue
       when Selenium::WebDriver::Error::ElementNotInteractableError
         :visibility_issue
@@ -23,33 +25,31 @@ module AppiumFailureHelper
     end
 
     def self.extract_failure_details(exception)
-      message = exception.message
+      message = exception.message.to_s
       info = {}
       patterns = [
+        /using "([^"]+)" with value "([^"]+)"/,
         /element with locator ['"]?(#?\w+)['"]?/i,
         /(?:could not be found|cannot find element) using (.+?)=['"]?([^'"]+)['"]?/i,
         /no such element: Unable to locate element: {"method":"([^"]+)","selector":"([^"]+)"}/i,
-        /(?:with the resource-id|with the accessibility-id) ['"]?(.+?)['"]?/i,
-         /using "([^"]+)" with value "([^"]+)"/
       ]
       patterns.each do |pattern|
-          match = message.match(pattern)
-          if match
-              if match.captures.size == 2
-                info[:selector_type] = match.captures[0].strip.gsub(/['"]/, '')
-                info[:selector_value] = match.captures[1].strip.gsub(/['"]/, '')
-              else
-                info[:selector_value] = match.captures.last.strip.gsub(/['"]/, '')
-                info[:selector_type] = 'id' # Padrão para regex com 1 captura
-              end
-              return info
+        match = message.match(pattern)
+        if match
+          if match.captures.size == 2
+            info[:selector_type], info[:selector_value] = match.captures.map(&:strip)
+          else
+            info[:selector_value] = match.captures.first.strip
+            info[:selector_type] = 'logical_name'
           end
+          return info
+        end
       end
       info
     end
-
+    
     def self.find_de_para_match(failed_info, element_map)
-      failed_value = failed_info[:selector_value].to_s
+      failed_value = (failed_info || {})[:selector_value].to_s
       return nil if failed_value.empty?
       logical_name_key = failed_value.gsub(/^#/, '')
       if element_map.key?(logical_name_key)
@@ -57,7 +57,7 @@ module AppiumFailureHelper
       end
       cleaned_failed_locator = failed_value.gsub(/[:\-\/@=\[\]'"()]/, ' ').gsub(/\s+/, ' ').downcase.strip
       element_map.each do |name, locator_info|
-        mapped_locator = locator_info['valor'].to_s || locator_info['value'].to_s
+        mapped_locator = (locator_info || {})['valor'].to_s
         cleaned_mapped_locator = mapped_locator.gsub(/[:\-\/@=\[\]'"()]/, ' ').gsub(/\s+/, ' ').downcase.strip
         distance = DidYouMean::Levenshtein.distance(cleaned_failed_locator, cleaned_mapped_locator)
         max_len = [cleaned_failed_locator.length, cleaned_mapped_locator.length].max
@@ -71,14 +71,14 @@ module AppiumFailureHelper
     end
 
     def self.find_similar_elements(failed_info, all_page_suggestions)
-      failed_locator_value = failed_info[:selector_value]
-      failed_locator_type = failed_info[:selector_type]
+      failed_locator_value = (failed_info || {})[:selector_value]
+      failed_locator_type = (failed_info || {})[:selector_type]
       return [] unless failed_locator_value && failed_locator_type
       normalized_failed_type = failed_locator_type.to_s.downcase.include?('id') ? 'id' : failed_locator_type.to_s
       cleaned_failed_locator = failed_locator_value.to_s.gsub(/[:\-\/@=\[\]'"()]/, ' ').gsub(/\s+/, ' ').downcase.strip
       similarities = []
       all_page_suggestions.each do |suggestion|
-        candidate_locator = suggestion[:locators].find { |loc| loc[:strategy] == normalized_failed_type }
+        candidate_locator = (suggestion[:locators] || []).find { |loc| loc[:strategy] == normalized_failed_type }
         next unless candidate_locator
         cleaned_candidate_locator = candidate_locator[:locator].gsub(/[:\-\/@=\[\]'"()]/, ' ').gsub(/\s+/, ' ').downcase.strip
         distance = DidYouMean::Levenshtein.distance(cleaned_failed_locator, cleaned_candidate_locator)

data/lib/appium_failure_helper/element_repository.rb

@@ -1,50 +1,42 @@
+# lib/appium_failure_helper/element_repository.rb
 module AppiumFailureHelper
   module ElementRepository
-  
     def self.load_all
-      elements_map = load_from_ruby_file
-      elements_map.merge!(load_all_from_yaml)
+      config = AppiumFailureHelper.configuration
+      base_path = config.elements_path
+      elements_map = load_from_ruby_file(base_path, config.elements_ruby_file)
+      elements_map.merge!(load_all_from_yaml(base_path))
+      Utils.logger.info("Mapa de elementos carregado da pasta '#{base_path}'. Total: #{elements_map.size}.")
       elements_map
     end
 
     private
 
-    def self.load_from_ruby_file
+    def self.load_from_ruby_file(base_path, filename)
       map = {}
-      config = AppiumFailureHelper.configuration
-      file_path = File.join(Dir.pwd, config.elements_path, config.elements_ruby_file)
-      
+      file_path = File.join(base_path, filename)
       return map unless File.exist?(file_path)
-
       begin
-        require file_path
+        require File.expand_path(file_path)
         instance = OnboardingElementLists.new
         unless instance.respond_to?(:elements)
-          Utils.logger.warn("AVISO: A classe OnboardingElementLists não expõe um `attr_reader :elements`.")
+          Utils.logger.warn("AVISO: A classe #{instance.class} não expõe um `attr_reader :elements`.")
           return map
         end
         instance.elements.each do |key, value|
-          valor = value[1]
-          if valor.is_a?(Hash)
-            valor_final = valor['valor'] || valor['value'] || valor
-          else
-            valor_final = valor
-          end
-          map[key.to_s] = { 'tipoBusca' => value[0], 'valor' => valor_final }
+          map[key.to_s] = { 'tipoBusca' => value[0], 'valor' => value[1] }
         end
       rescue => e
-        Utils.logger.warn("AVISO: Erro ao processar o arquivo #{file_path}: #{e.message}")
+        Utils.logger.warn("AVISO: Erro ao processar o arquivo Ruby #{file_path}: #{e.message}")
       end
-      
       map
     end
     
-    def self.load_all_from_yaml
+    def self.load_all_from_yaml(base_path)
       elements_map = {}
-      config = AppiumFailureHelper.configuration
-      glob_path = File.join(Dir.pwd, config.elements_path, '**', '*.yaml')
-      
-      Dir.glob(glob_path).each do |file|
+      glob_path = File.join(base_path, '**', '*.yaml')
+      files_found = Dir.glob(glob_path)
+      files_found.each do |file|
         next if file.include?('reports_failure')
         begin
           data = YAML.load_file(file)

data/lib/appium_failure_helper/handler.rb

@@ -7,7 +7,7 @@ module AppiumFailureHelper
     def initialize(driver, exception)
       @driver = driver
       @exception = exception
-      @timestamp = Time.now.strftime('%Ym%d_%H%M%S')
+      @timestamp = Time.now.strftime('%Y%m%d_%H%M%S')
       @output_folder = "reports_failure/failure_#{@timestamp}"
     end
 
@@ -30,44 +30,45 @@ module AppiumFailureHelper
           screenshot_base64: @driver.screenshot_as(:base64)
         }
 
-        # A análise profunda agora é executada para QUALQUER :locator_issue.
         if triage_result == :locator_issue
           page_source = @driver.page_source
           doc = Nokogiri::XML(page_source)
 
-          # Tenta Plano A e Plano B sem reclassificar o erro.
           failed_info = Analyzer.extract_failure_details(@exception) || {}
           if failed_info.empty?
             failed_info = SourceCodeAnalyzer.extract_from_exception(@exception) || {}
           end
           
-          page_analyzer = PageAnalyzer.new(page_source, report_data[:platform].to_s)
-          all_page_elements = page_analyzer.analyze || []
-          similar_elements = Analyzer.find_similar_elements(failed_info, all_page_elements) || []
-          
-          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)
-              alternative_xpaths = XPathFactory.generate_for_node(target_node) if target_node
+          if failed_info.empty?
+            report_data[:triage_result] = :unidentified_locator_issue
+          else
+            page_analyzer = PageAnalyzer.new(page_source, report_data[:platform].to_s)
+            all_page_elements = page_analyzer.analyze || []
+            similar_elements = Analyzer.find_similar_elements(failed_info, all_page_elements) || []
+            
+            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)
+                alternative_xpaths = XPathFactory.generate_for_node(target_node) if target_node
+              end
             end
-          end
 
-          unified_element_map = ElementRepository.load_all
-          de_para_result = Analyzer.find_de_para_match(failed_info, unified_element_map)
-          code_search_results = CodeSearcher.find_similar_locators(failed_info) || []
+            unified_element_map = ElementRepository.load_all
+            de_para_result = Analyzer.find_de_para_match(failed_info, unified_element_map)
+            code_search_results = CodeSearcher.find_similar_locators(failed_info) || []
 
-          # Adiciona os dados (mesmo que vazios) ao pacote.
-          report_data.merge!({
-            page_source: page_source,
-            failed_element: failed_info,
-            similar_elements: similar_elements,
-            alternative_xpaths: alternative_xpaths,
-            de_para_analysis: de_para_result,
-            code_search_results: code_search_results,
-            all_page_elements: all_page_elements
-          })
+            report_data.merge!({
+              page_source: page_source,
+              failed_element: failed_info,
+              similar_elements: similar_elements,
+              alternative_xpaths: alternative_xpaths,
+              de_para_analysis: de_para_result,
+              code_search_results: code_search_results,
+              all_page_elements: all_page_elements
+            })
+          end
         end
 
         ReportGenerator.new(@output_folder, report_data).generate_all

data/lib/appium_failure_helper/report_generator.rb

@@ -18,72 +18,31 @@ module AppiumFailureHelper
       File.write("#{@output_folder}/page_source_#{@data[:timestamp]}.xml", @page_source)
     end
 
-    def generate_yaml_reports
-      # Gera um YAML simplificado se não for um problema de seletor
+     def generate_yaml_reports
       analysis_report = {
         triage_result: @data[:triage_result],
         exception_class: @data[:exception].class.to_s,
         exception_message: @data[:exception].message,
         failed_element: @data[:failed_element],
-        similar_elements: @data[:similar_elements],
-        de_para_analysis: @data[:de_para_analysis],
-        code_search_results: @data[:code_search_results]
+        best_candidate_analysis: @data[:best_candidate_analysis]
       }
       File.open("#{@output_folder}/failure_analysis_#{@data[:timestamp]}.yaml", 'w') { |f| f.write(YAML.dump(analysis_report)) }
       
-      # Só gera o dump de elementos se a análise completa tiver sido feita
       if @data[:all_page_elements]
         File.open("#{@output_folder}/all_elements_dump_#{@data[:timestamp]}.yaml", 'w') { |f| f.write(YAML.dump(@data[:all_page_elements])) }
       end
     end
 
     def generate_html_report
-      if @data[:triage_result] == :locator_issue && @data[:failed_element].empty?
-        html_content = build_simple_diagnosis_report(
-          title: "Falha na Análise do Seletor",
-          message: "A GEM identificou um erro de 'elemento não encontrado', mas não conseguiu extrair o seletor da mensagem de erro ou do código-fonte. Isso pode ocorrer com métodos de busca customizados ou seletores dinâmicos. Verifique o stack trace para encontrar a linha exata do erro e o método responsável."
-        )
-      else
-        html_content = case @data[:triage_result]
-                        when :locator_issue
-                          build_full_report
-                        when :unidentified_locator_issue, :unidentified_timeout_issue
-                          build_simple_diagnosis_report(
-                            title: "Seletor Não Identificado",
-                            message: "A falha ocorreu porque um elemento não foi encontrado, mas a GEM não conseguiu extrair o seletor exato da mensagem de erro ou do código-fonte. Isso geralmente acontece quando o seletor é construído dinamicamente ou está dentro de um método helper complexo. Verifique o stack trace para encontrar o método responsável (ex: 'tap_by_text')."
-                          )
-                        when :assertion_failure
-                          build_simple_diagnosis_report(
-                            title: "Falha de Asserção (Bug Funcional)",
-                            message: "A automação executou os passos corretamente, mas o resultado final verificado na tela não foi o esperado. Isso geralmente indica um bug funcional na aplicação, e não um problema com o seletor."
-                          )
-                        when :visibility_issue
-                          build_simple_diagnosis_report(
-                            title: "Elemento Oculto ou Não-Interagível",
-                            message: "O seletor encontrou o elemento no XML da página, mas ele não está visível ou habilitado para interação. Verifique se há outros elementos sobrepondo-o, se ele está desabilitado (disabled/enabled='false'), ou se é necessário aguardar uma animação."
-                          )
-                        when :stale_element_issue
-                          build_simple_diagnosis_report(
-                            title: "Referência de Elemento Antiga (Stale)",
-                            message: "O elemento foi encontrado, mas a página foi atualizada antes que a interação pudesse ocorrer. Isso é um problema de timing. A solução é encontrar o elemento novamente logo antes de interagir com ele."
-                          )
-                        when :session_startup_issue
-                          build_simple_diagnosis_report(
-                            title: "Falha na Conexão com o Servidor Appium",
-                            message: "Não foi possível criar uma sessão com o servidor. Verifique se o servidor Appium está rodando, se as 'capabilities' (incluindo prefixos 'appium:') e a URL de conexão estão corretas."
-                          )
-                        when :app_crash_issue
-                          build_simple_diagnosis_report(
-                            title: "Crash do Aplicativo",
-                            message: "A sessão foi encerrada inesperadamente, o que indica que o aplicativo travou. A causa raiz deve ser investigada nos logs do dispositivo (Logcat para Android, Console para iOS)."
-                          )
-                        else # :ruby_code_issue, :unknown_issue
-                          build_simple_diagnosis_report(
-                              title: "Erro Inesperado",
-                              message: "Ocorreu um erro não catalogado. Verifique o stack trace para mais detalhes."
-                            )
-                        end
-      end
+      html_content = case @data[:triage_result]
+                     when :locator_issue
+                       build_full_report
+                     else
+                       build_simple_diagnosis_report(
+                         title: "Diagnóstico Rápido de Falha",
+                         message: "A falha não foi causada por um seletor não encontrado ou a análise do seletor falhou. Verifique a mensagem de erro original e o stack trace para a causa raiz."
+                       )
+                     end
       
       File.write("#{@output_folder}/report_#{@data[:timestamp]}.html", html_content)
     end

data/lib/appium_failure_helper/source_code_analyzer.rb

@@ -1,28 +1,20 @@
 # lib/appium_failure_helper/source_code_analyzer.rb
 module AppiumFailureHelper
   module SourceCodeAnalyzer
-    # VERSÃO 3.0: Padrões de Regex mais flexíveis que aceitam um "receptor" opcional (como $driver).
     PATTERNS = [
       { type: 'id',               regex: /(?:\$driver\.)?find_element\((?:id:|:id\s*=>)\s*['"]([^'"]+)['"]\)/ },
       { type: 'xpath',            regex: /(?:\$driver\.)?find_element\((?:xpath:|:xpath\s*=>)\s*['"]([^'"]+)['"]\)/ },
-      { type: 'accessibility_id', regex: /(?:\$driver\.)?find_element\((?:accessibility_id:|:accessibility_id\s*=>)\s*['"]([^'"]+)['"]\)/ },
-      { type: 'class_name',       regex: /(?:\$driver\.)?find_element\((?:class_name:|:class_name\s*=>)\s*['"]([^'"]+)['"]\)/ },
-      { type: 'xpath',            regex: /(?:\$driver\.)?find_element\(:xpath,\s*['"]([^'"]+)['"]\)/ },
       { type: 'id',               regex: /(?:\$driver\.)?\s*id\s*\(?['"]([^'"]+)['"]\)?/ },
       { type: 'xpath',            regex: /(?:\$driver\.)?\s*xpath\s*\(?['"]([^'"]+)['"]\)?/ }
     ].freeze
 
     def self.extract_from_exception(exception)
-      # Busca a primeira linha do backtrace que seja um arquivo .rb do projeto
       location = exception.backtrace.find { |line| line.include?('.rb') && !line.include?('gems') }
       return {} unless location
-
       path_match = location.match(/^(.*?):(\d+)(?::in.*)?$/)
       return {} unless path_match
-
       file_path, line_number = path_match.captures
       return {} unless File.exist?(file_path)
-
       begin
         error_line = File.readlines(file_path)[line_number.to_i - 1]
         return parse_line_for_locator(error_line)

data/lib/appium_failure_helper/version.rb

@@ -1,3 +1,3 @@
 module AppiumFailureHelper
-  VERSION = "1.1.4"
+  VERSION = "1.1.6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: appium_failure_helper
 version: !ruby/object:Gem::Version
-  version: 1.1.4
+  version: 1.1.6
 platform: ruby
 authors:
 - David Nascimento
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-09-30 00:00:00.000000000 Z
+date: 2025-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri