cornucopia 0.1.12

data/lib/cornucopia/capybara/finder_extensions.rb

@@ -0,0 +1,89 @@
+require ::File.expand_path("../util/configuration", File.dirname(__FILE__))
+require ::File.expand_path("finder_diagnostics", File.dirname(__FILE__))
+
+module Cornucopia
+  module Capybara
+    module FinderExtensions
+      def find(*args)
+        __cornucopia_finder_function(:find, *args)
+      end
+
+      def all(*args)
+        __cornucopia_finder_function(:all, *args)
+      end
+
+      def __cornucopia_finder_function(finder_function, *args)
+        retry_count = 0
+        result      = nil
+
+        support_options = __cornucopia__extract_support_options(*args)
+
+        begin
+          retry_count += 1
+          result      = send("__cornucopia_orig_#{finder_function}", *args)
+        rescue Selenium::WebDriver::Error::StaleElementReferenceError
+          retry if __cornucopia__retry_finder(retry_count, support_options)
+
+          result = __cornucopia__analyze_finder(finder_function, support_options, *args)
+        rescue Exception
+          result = __cornucopia__analyze_finder(finder_function, support_options, *args)
+        end
+
+        result
+      end
+
+      private
+
+      def __cornucopia__extract_support_options(*args)
+        support_options = {}
+
+        if args[-1].is_a?(Hash)
+          support_options[:__cornucopia_no_analysis]      = args[-1].delete(:__cornucopia_no_analysis)
+          support_options[:__cornucopia_retry_with_found] = args[-1].delete(:__cornucopia_retry_with_found)
+          # support_options[:__cornucopia_alternate_retry]  = args[-1].delete(:__cornucopia_alternate_retry)
+        end
+
+        support_options
+      end
+
+      def __cornucopia__analyze_finder(function_name, support_options, *args)
+        return_value = nil
+        error        = $!
+
+        if !support_options[:__cornucopia_no_analysis] &&
+            (Cornucopia::Util::Configuration.analyze_find_exceptions ||
+                support_options[:__cornucopia_retry_with_found])
+          # || support_options[:__cornucopia_alternate_retry])
+          support_options.merge!({ __cornucopia_no_analysis: true })
+
+          find_action = Cornucopia::Capybara::FinderDiagnostics::FindAction.new(self,
+                                                                                {},
+                                                                                support_options,
+                                                                                function_name,
+                                                                                *args)
+
+          if find_action.perform_analysis(Cornucopia::Util::Configuration.retry_with_found ||
+                                              support_options[:__cornucopia_retry_with_found])
+            #                                 Cornucopia::Util::Configuration.alternate_retry ||
+            #                                     support_options[:__cornucopia_alternate_retry])
+            return_value = find_action.simple_run({ __cornucopia_no_analysis: true }) rescue nil
+            return_value ||= find_action.return_value
+          else
+            raise error
+          end
+        else
+          raise error
+        end
+
+        return_value
+      end
+
+      def __cornucopia__retry_finder(retry_count, support_options)
+        retry_count <= Cornucopia::Util::Configuration.selenium_cache_retry_count &&
+            !support_options[:__cornucopia_no_analysis]
+      end
+    end
+  end
+end
+
+load ::File.expand_path("install_finder_extensions.rb", File.dirname(__FILE__))

data/lib/cornucopia/capybara/install_finder_extensions.rb

@@ -0,0 +1,105 @@
+$cornucopia_finder_extension_installed = false unless defined? $cornucopia_finder_extension_installed
+
+if Object.const_defined?("Capybara") &&
+    Capybara.const_defined?("Node") &&
+    Capybara::Node.const_defined?("Document") &&
+    !$cornucopia_finder_extension_installed
+  module Capybara
+    module Node
+      class Document
+        alias_method :__cornucopia_orig_find, :find
+        alias_method :__cornucopia_orig_all, :all
+
+        include Cornucopia::Capybara::FinderExtensions
+      end
+    end
+  end
+end
+
+if Object.const_defined?("Capybara") &&
+    Capybara.const_defined?("Node") &&
+    Capybara::Node.const_defined?("Simple") &&
+    !$cornucopia_finder_extension_installed
+  module Capybara
+    module Node
+      class Simple
+        alias_method :__cornucopia_orig_find, :find
+        alias_method :__cornucopia_orig_all, :all
+
+        include Cornucopia::Capybara::FinderExtensions
+      end
+    end
+  end
+end
+
+if Object.const_defined?("Capybara") &&
+    Capybara.const_defined?("Node") &&
+    Capybara::Node.const_defined?("Element") &&
+    !$cornucopia_finder_extension_installed
+  module Capybara
+    module Node
+      class Element
+        alias_method :__cornucopia_orig_find, :find
+        alias_method :__cornucopia_orig_all, :all
+
+        include Cornucopia::Capybara::FinderExtensions
+
+        # select_value finds the option with the value #value then calls select_option on that item.
+        #
+        # select_value only works on select boxes.
+        def select_value(values)
+          raise "select_value is only valid for select items" unless self.tag_name == "select"
+
+          if values.is_a?(Array)
+            values.each do |value|
+              html_safe_value = "".html_safe + value.to_s
+              self.find("option[value=\"#{html_safe_value}\"]", visible: false).select_option
+            end
+          else
+            html_safe_value = "".html_safe + values.to_s
+            self.find("option[value=\"#{html_safe_value}\"]", visible: false).select_option
+          end
+        end
+
+        # value_text returns the text for the selected items in the select box instead of the value(s)
+        #
+        # value_text only works on select boxes.
+        def value_text
+          raise "value_text is only valid for select items" unless self.tag_name == "select"
+
+          values = self.value
+          if values.is_a?(Array)
+            values.map do |value|
+              self.find("option[value=\"#{value}\"]", visible: false).text
+            end
+          else
+            self.find("option[value=\"#{values}\"]", visible: false).text
+          end
+        end
+      end
+    end
+  end
+end
+
+if Object.const_defined?("Capybara") &&
+    Capybara.const_defined?("Session") &&
+    !$cornucopia_finder_extension_installed
+  $cornucopia_finder_extension_installed = true
+
+  module Capybara
+    class Session
+      # alias_method :__cornucopia_orig_find, :find
+      # alias_method :__cornucopia_orig_all, :all
+      #
+      # include Cornucopia::Capybara::FinderExtensions
+
+      # This function uses Capybara's synchronize function to evaluate a block until
+      # it becomes true.
+      def synchronize_test(seconds=Capybara.default_wait_time, options = {}, &block)
+        document.synchronize(seconds, options) do
+          raise ::Capybara::ElementNotFound unless block.yield
+        end
+      end
+    end
+  end
+end

data/lib/cornucopia/capybara/install_matcher_extensions.rb

@@ -0,0 +1,39 @@
+$cornucopia_matcher_extension_installed = false unless defined? $cornucopia_matcher_extension_installed
+
+if Object.const_defined?("Capybara") &&
+    Capybara.const_defined?("Node") &&
+    Capybara::Node.const_defined?("Document") &&
+    !$cornucopia_matcher_extension_installed
+  module Capybara
+    module Node
+      class Document
+        alias_method :__cornucopia_orig_assert_selector, :assert_selector
+        alias_method :__cornucopia_orig_assert_no_selector, :assert_no_selector
+
+        include Cornucopia::Capybara::MatcherExtensions
+      end
+    end
+  end
+end
+
+if Object.const_defined?("Capybara") &&
+    Capybara.const_defined?("Node") &&
+    Capybara::Node.const_defined?("Element") &&
+    !$cornucopia_matcher_extension_installed
+  module Capybara
+    module Node
+      class Element
+        alias_method :__cornucopia_orig_assert_selector, :assert_selector
+        alias_method :__cornucopia_orig_assert_no_selector, :assert_no_selector
+
+        include Cornucopia::Capybara::MatcherExtensions
+      end
+    end
+  end
+end
+
+if Object.const_defined?("Capybara") &&
+    Capybara.const_defined?("Session") &&
+    !$cornucopia_matcher_extension_installed
+  $cornucopia_matcher_extension_installed = true
+end

data/lib/cornucopia/capybara/matcher_extensions.rb

@@ -0,0 +1,83 @@
+require ::File.expand_path("../util/configuration", File.dirname(__FILE__))
+require ::File.expand_path("finder_diagnostics", File.dirname(__FILE__))
+
+module Cornucopia
+  module Capybara
+    module MatcherExtensions
+      def assert_selector(*args)
+        __cornucopia_assert_selector_function(:assert_selector, *args)
+      end
+
+      def assert_no_selector(*args)
+        __cornucopia_assert_selector_function(:assert_no_selector, *args)
+      end
+
+      def __cornucopia_assert_selector_function(assert_selector_function, *args)
+        retry_count = 0
+        result      = nil
+
+        support_options = __cornucopia__extract_selector_support_options(*args)
+
+        begin
+          retry_count += 1
+          result      = send("__cornucopia_orig_#{assert_selector_function}", *args)
+        rescue Selenium::WebDriver::Error::StaleElementReferenceError
+          retry if __cornucopia__retry_selector(retry_count, support_options)
+
+          result = __cornucopia__analyze_selector(assert_selector_function, support_options, *args)
+        rescue Exception
+          result = __cornucopia__analyze_selector(assert_selector_function, support_options, *args)
+        end
+
+        result
+      end
+
+      private
+
+      def __cornucopia__extract_selector_support_options(*args)
+        support_options = {}
+
+        if args[-1].is_a?(Hash)
+          support_options[:__cornucopia_no_analysis]      = args[-1].delete(:__cornucopia_no_analysis)
+          support_options[:__cornucopia_retry_with_found] = args[-1].delete(:__cornucopia_retry_with_found)
+        end
+
+        support_options
+      end
+
+      def __cornucopia__analyze_selector(function_name, support_options, *args)
+        return_value = nil
+        error        = $!
+
+        if !support_options[:__cornucopia_no_analysis] &&
+            (Cornucopia::Util::Configuration.analyze_selector_exceptions ||
+                support_options[:__cornucopia_retry_with_found])
+          find_action = Cornucopia::Capybara::FinderDiagnostics::FindAction.new(self,
+                                                                                {},
+                                                                                support_options,
+                                                                                function_name,
+                                                                                *args)
+
+          if find_action.perform_analysis(Cornucopia::Util::Configuration.retry_match_with_found ||
+                                              support_options[:__cornucopia_retry_with_found])
+            return_value = find_action.simple_run rescue nil
+            return_value ||= find_action.return_value
+          else
+            raise error
+          end
+        else
+          raise error
+        end
+
+        return_value
+      end
+
+      def __cornucopia__retry_selector(retry_count, support_options)
+        retry_count <= Cornucopia::Util::Configuration.selenium_cache_retry_count &&
+            !support_options[:__cornucopia_no_analysis]
+      end
+    end
+  end
+end
+
+load ::File.expand_path("install_matcher_extensions.rb", File.dirname(__FILE__))

data/lib/cornucopia/capybara/page_diagnostics.rb

@@ -0,0 +1,228 @@
+require "digest"
+require ::File.expand_path("../util/configuration", File.dirname(__FILE__))
+require ::File.expand_path("../util/report_builder", File.dirname(__FILE__))
+require ::File.expand_path("../util/report_table", File.dirname(__FILE__))
+
+module Cornucopia
+  module Capybara
+    class PageDiagnostics
+      @@dumped_pages = []
+
+      Cornucopia::Util::ReportBuilder.on_close do
+        Cornucopia::Capybara::PageDiagnostics.clear_dumped_pages
+      end
+
+      attr_accessor :allow_other_windows
+
+      class << self
+        # This outputs the details about the current Capybara page to
+        # the current report.
+        def dump_details(options = {})
+          Cornucopia::Capybara::PageDiagnostics.new(options).dump_details
+        end
+
+        def dump_details_in_table(report, report_table, options = {})
+          Cornucopia::Capybara::PageDiagnostics.new(options.merge(report: report, table: report_table)).dump_details
+        end
+
+        def clear_dumped_pages
+          @@dumped_pages = []
+        end
+      end
+
+      def initialize(options = {})
+        @options             = options.clone
+        @report              = @options.delete(:report)
+        @table               = @options.delete(:table)
+        @unsupported_list    ||= []
+        @allow_other_windows = true
+
+        @page_url         = "use accessor"
+        @title            = "use accessor"
+        @page_width       = "use accessor"
+        @page_height      = "use accessor"
+        @response_headers = "use accessor"
+        @status_code      = "use accessor"
+        @html_source      = "use accessor"
+        @html_frame       = "use accessor"
+        @screen_shot      = "use accessor"
+        @html_file        = "use accessor"
+      end
+
+      def can_dump_details?
+        can_dump = false
+
+        if (Object.const_defined?("Capybara"))
+          my_page = ::Capybara.current_session
+
+          if (my_page && my_page.current_url.present? && my_page.current_url != "about:blank")
+            can_dump = !@@dumped_pages.include?(Digest::SHA2.hexdigest(my_page.html))
+          end
+        end
+
+        can_dump
+      end
+
+      def dump_details
+        if can_dump_details?
+          if @report && @table
+            dump_details_in_table
+          else
+            @report       = Cornucopia::Util::ReportBuilder.current_report
+            section_title = @options[:section_label] || "Page Dump:"
+
+            @report.within_section(section_title) do
+              @table = nil
+              dump_details_in_table
+            end
+          end
+        end
+      end
+
+      def dump_details_in_table
+        if can_dump_details?
+          @session = ::Capybara.current_session
+          @driver  = @session.driver
+
+          @current_window = execute_driver_function(:current_window_handle, nil)
+          @window_handles = execute_driver_function(:window_handles, [1]).clone
+
+          configured_report = Cornucopia::Util::Configuration.report_configuration(:capybara_page_diagnostics)
+
+          configured_report.add_report_objects(capybara: self)
+          configured_report.generate_report(@report, report_table: @table)
+
+          @@dumped_pages << Digest::SHA2.hexdigest(@session.html)
+        end
+      end
+
+      class WindowIterator
+        def initialize(window_handles, current_window, diagnostics)
+          @window_handles = window_handles
+          @current_window = current_window
+          @diagnostics    = diagnostics
+        end
+
+        def each(&block)
+          begin
+            @diagnostics.allow_other_windows = false
+
+            if @window_handles.length > 1
+              @window_handles.each do |window_handle|
+                unless @current_window && @current_window == window_handle
+                  switched = @diagnostics.execute_driver_function(:switch_to_window,
+                                                                  "could not switch windows",
+                                                                  window_handle)
+                  if switched != "could not switch windows"
+                    block.yield @diagnostics
+                  end
+                end
+              end
+            end
+          ensure
+            @diagnostics.allow_other_windows = true
+            @diagnostics.execute_driver_function(:switch_to_window, "could not switch windows", @current_window)
+          end
+        end
+      end
+
+      def other_windows
+        if @allow_other_windows
+          Cornucopia::Capybara::PageDiagnostics::WindowIterator.new(@window_handles, @current_window, self)
+        end
+      end
+
+      def execute_driver_function(function_symbol, unsupported_value, *args)
+        value = unsupported_value
+
+        @unsupported_list << function_symbol unless @driver.respond_to?(function_symbol)
+
+        begin
+          unless @unsupported_list.include?(function_symbol)
+            value = @driver.send(function_symbol, *args)
+          end
+        rescue ::Capybara::NotSupportedByDriverError => error
+          @unsupported_list << function_symbol
+        end
+
+        value
+      end
+
+      def page_url
+        execute_driver_function(:current_url, nil)
+      end
+
+      def title
+        execute_driver_function(:title, nil)
+      end
+
+      def page_width
+        if @current_window
+          value = execute_driver_function(:window_size, nil, @current_window)
+          value[0] if value
+        end
+      end
+
+      def page_height
+        if @current_window
+          value = execute_driver_function(:window_size, nil, @current_window)
+          value[1] if value
+        end
+      end
+
+      def response_headers
+        execute_driver_function(:response_headers, nil)
+      end
+
+      def status_code
+        execute_driver_function(:status_code, nil)
+      end
+
+      def html_source
+        value = execute_driver_function(:html, nil)
+        @report.page_text(value) if value
+      end
+
+      def html_frame
+        value = execute_driver_function(:html, nil)
+        @report.page_frame(value) if value
+      end
+
+      def screen_shot
+        dir_name = File.join(@report.report_folder_name, "temporary_folder")
+
+        begin
+          page_name = @options[:screen_shot_name] || "screen_shot"
+          page_name = page_name [Dir.pwd.length..-1] if page_name.start_with?(Dir.pwd)
+          page_name = page_name [1..-1] if page_name.start_with?("/")
+          page_name = page_name["features/".length..-1] if page_name.start_with?("features/")
+          page_name = page_name.gsub(/[^a-z0-9_]/i, "_")
+          page_name = page_name.gsub("__", "_")
+
+          page_name = File.join(dir_name, "#{page_name}.png")
+
+          FileUtils.mkdir_p dir_name
+
+          execute_driver_function(:save_screenshot, nil, page_name)
+
+          if File.exists?(page_name)
+            @report.image_link(page_name)
+          else
+            "Could not save screen_shot."
+          end
+        ensure
+          FileUtils.rm_rf dir_name
+        end
+      end
+
+      def html_file
+        dir_name = @report.unique_folder_name("html_save_file")
+        FileUtils.mkdir_p File.join(@report.report_folder_name, dir_name)
+        ::Capybara.current_session.
+            save_page(File.join(@report.report_folder_name, dir_name, "__cornucopia_save_page.html"))
+        "<a href=\"#{File.join(dir_name, "__cornucopia_save_page.html")}\" target=\"_blank\">Saved Page</a>".
+            html_safe
+      end
+    end
+  end
+end