appium_failure_helper 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b1148ccbdea9b7b8446bf489a8f325e6dd4255cbeeba75ed58469f21169a126
-  data.tar.gz: 646ef386ee881d2f9cccf4ca3e85f8a79bd3cd132221c537e6db3f07c719f91f
+  metadata.gz: 43096445c0c64d280ed41cc96d50ddd088c660bfac0441b8ff4e9ddc34e9107d
+  data.tar.gz: a2b4d0c6ebe03d445ae1e39d5dd35da188b01b4835b1a9a16055709b201f0864
 SHA512:
-  metadata.gz: f345294b82fad66aa0b47e3455a85063caef1f292225f9954d5bd10a0370f29e9ba51c15d7caeed219c4e587b84f115e4e762e7b16f9408bacdc91dbce8aaf55
-  data.tar.gz: 505c2e690da3d723c5afb43a7afb1f219bca682e45e1c8c14068c98072c1331c90fecbe764312fe4ad3071d95df57106068b4feea5c4ca68c736b5fcbcd647dd
+  metadata.gz: f27c3e50dbef777ef84b756738e32ca50779a970e01e8cbd086a13c5a65a15d6c22c3f27e51e357b78555d3ae8cf5619b9e9fa36131c5f6761d54707b3fe8d93
+  data.tar.gz: a1dc3d6684a2d5afc79c6a7c956075fdeb5a90afd6d5ac4b02ae8a1129e16c18fcdae7cfd2f66794cab9e86ec65880ff7c5cb0edfddbef0b8ab6326ff163e445

data/lib/appium_failure_helper/element_repository.rb

@@ -1,6 +1,7 @@
 # lib/appium_failure_helper/element_repository.rb
 module AppiumFailureHelper
   module ElementRepository
+    ELEMENTS = {}
     def self.load_all
       config = AppiumFailureHelper.configuration
       base_path = config.elements_path
@@ -38,48 +39,26 @@ module AppiumFailureHelper
       map
     end
     
-    def self.load_all_from_yaml(base_path)
-      elements_map = {}
-      glob_path = File.join(base_path, '**', '*.yaml')
-      files_found = Dir.glob(glob_path)
-      files_found.each do |file|
-        next if file.include?('reports_failure')
+    def self.load_all_from_yaml(dir_path = 'features/elements')
+      Dir.glob("#{dir_path}/*.yaml").each do |file|
         begin
-          data = YAML.load_file(file)
-          if data.is_a?(Hash)
-            data.each do |k, v|
-              data[k] = normalize_element(v)
-            end
-            elements_map.merge!(data)
+          yaml_data = YAML.load_file(file)
+          yaml_data.each do |key, value|
+            ELEMENTS[key.to_sym] = normalize_element(value)
           end
         rescue => e
           Utils.logger.warn("Aviso: Erro ao carregar o arquivo YAML #{file}: #{e.message}")
         end
       end
-      elements_map
+      Utils.logger.info("Número de elementos carregados: #{ELEMENTS.size}")
+      ELEMENTS
     end
 
-    def self.normalize_yaml_hash_keys(obj)
-      case obj
-      when Hash
-        result = {}
-        obj.each do |k, v|
-          k_s = k.to_s
-          v_n = normalize_yaml_hash_keys(v)
-          # Se v_n é um Hash com chaves :value ou 'valor' -> faça unificação para 'value'
-          if v_n.is_a?(Hash)
-            if v_n.key?('valor') && !v_n.key?('value')
-              v_n['value'] = v_n.delete('valor')
-            end
-            # também converte :tipoBusca para 'tipoBusca' (string)
-          end
-          result[k_s] = v_n
-        end
-        result
-      when Array
-        obj.map { |el| normalize_yaml_hash_keys(el) }
-      else
-        obj
+    def self.normalize_element(element_hash)
+      # Ajuste para garantir keys simbólicas e paths padrão
+      element_hash.transform_keys(&:to_sym).tap do |h|
+        h[:selector_type] ||= h[:type] || 'unknown'
+        h[:selector_value] ||= h[:value] || 'unknown'
       end
     end
   end

data/lib/appium_failure_helper/handler.rb

@@ -12,54 +12,44 @@ module AppiumFailureHelper
     end
 
     def call
+      report_data = {}
       begin
         unless @driver && @driver.session_id
           Utils.logger.error("Helper não executado: driver nulo ou sessão encerrada.")
-          return
+          return {}
         end
 
         FileUtils.mkdir_p(@output_folder)
-        
 
         triage_result = Analyzer.triage_error(@exception)
-        
+        screenshot_b64 = begin
+          @driver.screenshot_as(:base64)
+        rescue
+          nil
+        end
         report_data = {
           exception: @exception,
           triage_result: triage_result,
           timestamp: @timestamp,
-          platform: @driver.capabilities['platformName'] || @driver.capabilities[:platform_name] || 'unknown',
-          screenshot_base64: @driver.screenshot_as(:base64)
+          platform: (@driver.capabilities['platformName'] rescue @driver.capabilities[:platform_name]) || 'unknown',
+          screenshot_base64: screenshot_b64
         }
 
         if triage_result == :locator_issue
           page_source = @driver.page_source rescue nil
-          doc = Nokogiri::XML(page_source)
+          doc = Nokogiri::XML(page_source) rescue nil
 
-          # Inicializa failed_info primeiro
-          failed_info = Analyzer.extract_failure_details(@exception) || {}
-          failed_info = SourceCodeAnalyzer.extract_from_exception(@exception) || {} if failed_info.empty?
-          failed_info = { selector_type: 'unknown', selector_value: 'unknown' } if failed_info.empty?
+          failed_info = fetch_failed_element
 
-          # Monta o report_data
           report_data[:page_source] = page_source
           report_data[:failed_element] = failed_info
 
-          # Analisa elementos similares, alternative xpaths, de_para, code search etc
-          unless failed_info.empty?
-            page_analyzer = PageAnalyzer.new(page_source, report_data[:platform].to_s)
-            all_page_elements = page_analyzer.analyze || []
+          unless failed_info.nil? || failed_info.empty?
+            page_analyzer = PageAnalyzer.new(page_source, report_data[:platform].to_s) rescue nil
+            all_page_elements = page_analyzer ? (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
+            alternative_xpaths = generate_alternative_xpaths(similar_elements, doc)
+            unified_element_map = ElementRepository.load_all rescue {}
             de_para_result = Analyzer.find_de_para_match(failed_info, unified_element_map)
             code_search_results = CodeSearcher.find_similar_locators(failed_info) || []
 
@@ -72,16 +62,116 @@ module AppiumFailureHelper
             )
           end
 
-          # Gera o relatório
           ReportGenerator.new(@output_folder, report_data).generate_all
           Utils.logger.info("Relatórios gerados com sucesso em: #{@output_folder}")
-
-          report_data
-          return
         end
+
       rescue => e
         Utils.logger.error("Erro fatal na GEM de diagnóstico: #{e.message}\n#{e.backtrace.join("\n")}")
+        report_data = { exception: @exception, triage_result: :error } if report_data.nil? || report_data.empty?
+      ensure
+        return report_data
+      end
+    end
+
+    private
+
+    def fetch_failed_element
+      msg = @exception&.message.to_s
+
+      # 1) pattern: using "type" with value "value"
+      if (m = msg.match(/using\s+["']?([^"']+)["']?\s+with\s+value\s+["']([^"']+)["']/i))
+        return { selector_type: m[1], selector_value: m[2] }
+      end
+
+      # 2) JSON-like: {"method":"id","selector":"btn"}
+      if (m = msg.match(/"method"\s*:\s*"([^"]+)"[\s,}].*"selector"\s*:\s*"([^"]+)"/i))
+        return { selector_type: m[1], selector_value: m[2] }
+      end
+
+      # 3) generic quoted token "value" or 'value'
+      if (m = msg.match(/["']([^"']+)["']/))
+        maybe_value = m[1]
+        # try lookup in repo by that value
+        unified_map = ElementRepository.load_all rescue {}
+        found = find_in_element_repository_by_value(maybe_value, unified_map)
+        if found
+          return found
+        end
+
+        # guess type from message heuristics
+        guessed_type = msg[/\b(xpath|id|accessibility id|css)\b/i] ? $&.downcase : nil
+        return { selector_type: guessed_type || 'unknown', selector_value: maybe_value }
+      end
+
+      # 4) try SourceCodeAnalyzer
+      begin
+        code_info = SourceCodeAnalyzer.extract_from_exception(@exception) rescue {}
+        unless code_info.nil? || code_info.empty?
+          return code_info
+        end
+      rescue => _; end
+
+      # 5) fallback: try to inspect unified map for likely candidates (keys or inner values)
+      unified_map = ElementRepository.load_all rescue {}
+      # try to match any key that looks like an identifier present in the message
+      unified_map.each do |k, v|
+        k_str = k.to_s.downcase
+        if msg.downcase.include?(k_str)
+          return normalize_repo_element(v)
+        end
+        # inspect value fields
+        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 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
+
+    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
       end
+      alternative_xpaths
     end
   end
-end
+end

data/lib/appium_failure_helper/version.rb

@@ -1,3 +1,3 @@
 module AppiumFailureHelper
-  VERSION = "1.4.0"
+  VERSION = "1.5.0"
 end

data/release_gem.rb

@@ -60,6 +60,7 @@ def git_commit_and_tag(new_version)
   `git add .`
   `git commit -m "Bump version to #{new_version.join('.')}"` 
   `git tag v#{new_version.join('.')}`
+  `git push && git push --tags`
 end
 
 # Publicar a GEM

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appium_failure_helper
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - David Nascimento
@@ -94,6 +94,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- appium_failure_helper-1.4.0.gem
 - elements/cadastro.yaml
 - elements/login.yaml
 - img/fluxo_appium_failure_helper.png