appium_failure_helper 1.1.5 → 1.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3ecea0ef4f0ef9f44f103bbe8c03108cbbf2200c1b3c72c27c14f41c598e463
-  data.tar.gz: 58b26c45f12392193baf2963a829f63504db35b8acb017774a65d8fb98e15b52
+  metadata.gz: 78e35ec0789690a1c581b094e7f1a1bc8cf87ffd7b5775b58805bc3d0954e2c0
+  data.tar.gz: 62f6e3a7a2338ec85b6f5c37064509d45534cf55197e0a791048763aac85e044
 SHA512:
-  metadata.gz: 553620c60e1306d4bbdac5340556b69712343f8736697cc1f08a278ae4d60768e098021a562424e4bf0664ed77237bd1979b3e0c3a33f652178d5bbda012bf4d
-  data.tar.gz: 165d91270f4f0ce695d565c5c8943c5c41c8aff49337d37ea1d2e78640509b6d878d2700ed9ffa8ac6050a6aab229e85fe01a65c8de07fdb0cf2a2a83374b027
+  metadata.gz: 3f57d410bc16465a452693cd5c2211fcc159def18c39b58d6de140be38e37c78f64b625f31844f77e566b5c222fbcd1d5c79b64408fad427038f360f75a4a07a
+  data.tar.gz: e7322ab59bde3d4fa00551573ef5fadb6e8091f7b374b9170dc1fddac247908393b442be3c0b72ef3fb144e2d680547631a946d4711cea03d3ff7029d2536a42

data/lib/appium_failure_helper/analyzer.rb

@@ -1,30 +1,55 @@
 module AppiumFailureHelper
   module Analyzer
     def self.triage_error(exception)
-      # Simples e direto: se for um desses erros, é um problema de seletor.
-      if exception.is_a?(Selenium::WebDriver::Error::NoSuchElementError) || exception.is_a?(Selenium::WebDriver::Error::TimeoutError)
+      case exception
+      when Selenium::WebDriver::Error::NoSuchElementError, 
+           Selenium::WebDriver::Error::TimeoutError,
+           Selenium::WebDriver::Error::UnknownCommandError
         :locator_issue
+      when Selenium::WebDriver::Error::ElementNotInteractableError
+        :visibility_issue
+      when Selenium::WebDriver::Error::StaleElementReferenceError
+        :stale_element_issue
+      when defined?(RSpec::Expectations::ExpectationNotMetError) ? RSpec::Expectations::ExpectationNotMetError : Class.new
+        :assertion_failure
+      when NoMethodError, NameError, ArgumentError, TypeError
+        :ruby_code_issue
+      when Selenium::WebDriver::Error::SessionNotCreatedError, Errno::ECONNREFUSED
+        :session_startup_issue
+      when Selenium::WebDriver::Error::WebDriverError
+        return :app_crash_issue if exception.message.include?('session deleted because of page crash')
+        :unknown_appium_issue
       else
-        :generic_issue # Para todos os outros casos
+        :unknown_issue
       end
     end
 
     def self.extract_failure_details(exception)
-      message = exception.message
+      message = exception.message.to_s
       info = {}
-      # único padrão que precisa, para ler a mensagem enriquecida
-      pattern = /using "([^"]+)" with value "([^"]+)"/
-      
-      match = message.match(pattern)
-      if match
-        info[:selector_type] = match.captures[0]
-        info[:selector_value] = match.captures[1]
+      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,
+      ]
+      patterns.each do |pattern|
+        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)
@@ -32,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
@@ -46,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

@@ -1,4 +1,3 @@
-# lib/appium_failure_helper/handler.rb
 module AppiumFailureHelper
   class Handler
     def self.call(driver, exception)
@@ -6,7 +5,10 @@ module AppiumFailureHelper
     end
 
     def initialize(driver, exception)
-      @driver = driver; @exception = exception; @timestamp = Time.now.strftime('%Y%m%d_%H%M%S'); @output_folder = "reports_failure/failure_#{@timestamp}"
+      @driver = driver
+      @exception = exception
+      @timestamp = Time.now.strftime('%Y%m%d_%H%M%S')
+      @output_folder = "reports_failure/failure_#{@timestamp}"
     end
 
     def call
@@ -17,26 +19,53 @@ module AppiumFailureHelper
         end
 
         FileUtils.mkdir_p(@output_folder)
+        
         triage_result = Analyzer.triage_error(@exception)
         
-        report_data = { exception: @exception, triage_result: triage_result, timestamp: @timestamp, platform: @driver.capabilities[:platformName], screenshot_base64: @driver.screenshot_as(:base64) }
+        report_data = {
+          exception: @exception,
+          triage_result: triage_result,
+          timestamp: @timestamp,
+          platform: @driver.capabilities['platformName'] || @driver.capabilities[:platformName] || 'unknown',
+          screenshot_base64: @driver.screenshot_as(:base64)
+        }
 
         if triage_result == :locator_issue
           page_source = @driver.page_source
-          failed_info = Analyzer.extract_failure_details(@exception)
+          doc = Nokogiri::XML(page_source)
 
-          # Se a extração da mensagem falhou, geramos o relatório simples
+          failed_info = Analyzer.extract_failure_details(@exception) || {}
+          if failed_info.empty?
+            failed_info = SourceCodeAnalyzer.extract_from_exception(@exception) || {}
+          end
+          
           if failed_info.empty?
-             report_data[:triage_result] = :unidentified_locator_issue
+            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
-            best_candidate_analysis = Analyzer.perform_advanced_analysis(failed_info, all_page_elements)
+            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
+
+            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) || []
 
             report_data.merge!({
               page_source: page_source,
               failed_element: failed_info,
-              best_candidate_analysis: best_candidate_analysis,
+              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
@@ -44,8 +73,9 @@ module AppiumFailureHelper
 
         ReportGenerator.new(@output_folder, report_data).generate_all
         Utils.logger.info("Relatórios gerados com sucesso em: #{@output_folder}")
+        
       rescue => e
-        Utils.logger.error("Erro fatal na GEM: #{e.message}\n#{e.backtrace.join("\n")}")
+        Utils.logger.error("Erro fatal na GEM de diagnóstico: #{e.message}\n#{e.backtrace.join("\n")}")
       end
     end
   end

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.5"
+  VERSION = "1.1.6"
 end

metadata

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