pickles 0.1.0

data/lib/cucumber/pickles/fill_in.rb

@@ -0,0 +1,10 @@
+module FillIN
+
+  _dir = 'cucumber/pickles/steps/fill_in/'
+
+  autoload :Factory, _dir + 'factory'
+  autoload :Input, _dir + 'input'
+  autoload :Select, _dir + 'select'
+  autoload :ComplexInput, _dir + 'complex_input'
+
+end

data/lib/cucumber/pickles/helpers.rb

@@ -0,0 +1,40 @@
+unless defined?(SUPPORT_DIR)
+  in_features_dir = caller.select { |path| path =~ /features/ }.first
+
+  if in_features_dir
+    features_dir = in_features_dir.split('/')
+
+    2.times { features_dir.pop }
+
+    SUPPORT_DIR = File.join(features_dir,'support')
+  end
+end
+
+require_relative 'refinements'
+require_relative 'config'
+require_relative 'errors/ambigious'
+
+module Locator
+
+  _dir = 'cucumber/pickles/locator/'
+
+  autoload :Index, _dir + 'index'
+  autoload :Equal, _dir + 'equal'
+
+end
+
+module Helpers
+
+  _dir = 'cucumber/pickles/helpers/'
+
+  autoload :Main, _dir + 'main'
+  autoload :Regex, _dir + 'regex'
+
+end
+
+module Pickles
+
+  extend  Helpers::Main
+  include Helpers::Main
+
+end

data/lib/cucumber/pickles/helpers/extensions/chrome/compiled.crx.base64

@@ -0,0 +1 @@
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

data/lib/cucumber/pickles/helpers/extensions/chrome/manifest.json

@@ -0,0 +1,15 @@
+{
+  "name": "Chrome driver Ajax shim",
+  "version": "0.0.1",
+  "manifest_version": 2,
+  "description": "Chrome driver testing vars to preserve Ajax requests sent status",
+  "content_scripts": [
+    {
+      "matches": ["<all_urls>"],
+      "js": [
+        "src/inject/inject.js"
+      ],
+      "run_at":    "document_start"
+    }
+  ]
+}

data/lib/cucumber/pickles/helpers/extensions/chrome/src/inject/inject.js

@@ -0,0 +1,35 @@
+chrome.extension.sendMessage({}, function(response) {
+
+  var elt = document.createElement("script");
+
+  elt.innerHTML = "var oldOpen=XMLHttpRequest.prototype.open;window.activeRequests=0,XMLHttpRequest.prototype.open=function(a,b,c,d,e){window.activeRequests++,this.addEventListener(\"readystatechange\",function(){4==this.readyState&&window.activeRequests--},!1),oldOpen.call(this,a,b,c,d,e)};";
+
+
+  document.head.appendChild(elt);
+
+      var style = document.createElement('style');
+      style.type = 'text/css';
+      style.innerHTML = '* {' +
+      '/*CSS transitions*/' +
+      ' -o-transition-property: none !important;' +
+      ' -moz-transition-property: none !important;' +
+      ' -ms-transition-property: none !important;' +
+      ' -webkit-transition-property: none !important;' +
+      '  transition-property: none !important;' +
+      // '/*CSS transforms*/' +
+      // '  -o-transform: none !important;' +
+      // ' -moz-transform: none !important;' +
+      // '   -ms-transform: none !important;' +
+      // '  -webkit-transform: none !important;' +
+      // '   transform: none !important;' +
+      '  /*CSS animations*/' +
+      '   -webkit-animation: none !important;' +
+      '   -moz-animation: none !important;' +
+      '   -o-animation: none !important;' +
+      '   -ms-animation: none !important;' +
+      '   animation: none !important;}';
+
+         document.head.appendChild(style);
+
+
+});

data/lib/cucumber/pickles/helpers/main.rb

@@ -0,0 +1,88 @@
+require_relative 'node_finders'
+require_relative 'waiter'
+
+module Helpers::Main
+
+  include NodeFinders
+  include Waiter
+
+  #
+  # parent node of given
+  #
+  # @node - Capybara node
+  #
+  # returns Capybara node
+  #
+  def parent_node(node)
+    node.find(:xpath, '..', wait: 0, visible: false)
+  end
+
+  #
+  # trigger blur event on given node
+  #
+  # @node - Capybara node
+  #
+  def blur(node)
+    trigger(node, 'blur')
+
+    Capybara.current_session.execute_script("document.body.click()")
+  end
+
+  #
+  # Select checkbox | radio input
+  #
+  # @input -            Capybara node with <input type="checkbox|radio">
+  # @value - optional - value to set to input, Defaults to input state switch
+  #
+  # returns: [void]
+  #
+  def select_input(input, value = nil)
+    case value
+    when "true", true
+      value = true
+    when "false", false
+      value = false
+    else
+      value = !input.checked?
+    end
+
+    #
+    # Hack:
+    #   cant use input.set(#{value})
+    #   because element can be hidden or covered by other eement
+    #   in which case Selenium raises error
+    #
+    trigger(parent_node(input), 'click')
+
+    Capybara.current_session.execute_script("arguments[0].checked = #{value}", input)
+  end
+
+  #
+  # Attach file from features/support/attachments/* to given file input
+  #
+  # @input - Capybara node with <input type="file">
+  # @file  - file path relative to features/support/attachments/*
+  #
+  # returns [void]
+  #
+  def attach_file(input, file)
+    path = File.expand_path(File.join(SUPPORT_DIR,"attachments/#{file}"))
+
+    raise RuntimeError, "file '#{path}' does not exists" unless File.exists?(path)
+
+    input.set(path)
+  end
+
+  #
+  # Triggers event on node
+  # Usefull when Capybara raises error about element being covered by another
+  #
+  # @node - Capybara node
+  # @event - event to trigger
+  #
+  # returns: [void]
+  def trigger(node, event)
+    Capybara.current_session.execute_script("arguments[0].#{event}()", node)
+  end
+
+end

data/lib/cucumber/pickles/helpers/node_finders.rb

@@ -0,0 +1,125 @@
+module NodeFinders
+
+  using BlankMethod
+
+  #
+  # Finds text node by text locator
+  #
+  # @text - locator ( see locator docs in #Artifact )
+  # @within: - within block to limit search to
+  #
+  # returns Capybara node
+  #
+  def find_node(locator, within: nil)
+    within ||= Capybara.current_session
+
+    locator, index = Locator::Index.execute(locator)
+    locator, xpath = Locator::Equal.execute(locator)
+
+    if index
+      xpath = "(#{xpath})[#{index}]"
+    end
+
+    _rescued_find([:xpath, xpath, wait: 0, visible: false], locator, within: within, message: "find_node") do
+      raise Capybara::ElementNotFound,
+            "Unable to find node by locator #{locator}",
+            caller
+    end
+  end
+
+  #
+  # Does lookup based on provided in config maps
+  #
+  def detect_node(el_alias, locator = nil, within: nil)
+    return find_node(locator, within: within) if el_alias.blank?
+
+    within ||= Capybara.current_session
+
+    locator, index = Locator::Index.execute(locator)
+
+    if index.nil?
+      el_alias, index = Locator::Index.execute(el_alias.to_s)
+    end
+
+    el_alias = el_alias.to_sym
+
+    if xpath = Pickles.config.xpath_node_map[el_alias]
+      xpath = xpath.respond_to?(:call) ? xpath.call(locator) : xpath
+
+      search_params = [:xpath, xpath, wait: 0]
+    elsif css = Pickles.config.css_node_map[el_alias] || el_alias
+      css = css.respond_to?(:call) ? css.call(locator) : css
+
+      search_params = [:css, css, text: locator, wait: 0]
+    end
+
+    if index
+      within.all(*search_params)[index - 1]
+    else
+      _rescued_find(search_params, locator || el_alias, within: within, message: "Detecting by #{xpath || css}") do
+        raise Capybara::ElementNotFound,
+              "Unable to detect node by locator #{locator}",
+              caller
+      end
+    end
+  end
+
+  #
+  # Similar to find_node, but looking for fillable fields for this cases:
+  #  1. label or span(as label) with input hint for input || textarea || @contenteditable
+  #  2. capybara lookup by label || plcaeholder || id || name || etc
+  #  3. @contenteditable with @placeholder = @locator
+  #
+  # @input_locator - string to identify input field by
+  #
+  # returns: Capybara node
+  #
+  def find_input(input_locator, within: nil, options: {})
+    within ||= Capybara.current_session
+    options[:wait] = 0
+    options[:visible] = false
+
+    locator, index = Locator::Index.execute(input_locator)
+
+    if index
+      index_xpath = "[#{index}]"
+    end
+
+    xpath = ".//*[@contenteditable and (@placeholder='#{locator}' or name='#{locator}')]#{index_xpath}"
+
+    # case 3
+    _rescued_find([:xpath, xpath, options], locator, within: within, message: "@contenteditable with placeholder = #{locator}") do
+
+      locator, label_xpath = Locator::Equal.execute(input_locator)
+
+      inputtable_field_xpath = "*[self::input or self::textarea or @contenteditable]"
+
+      xpath = "(#{label_xpath})#{index_xpath}/ancestor::*[.//#{inputtable_field_xpath}][position()=1]//#{inputtable_field_xpath}"
+
+      # case 1
+      _rescued_find([:xpath, xpath, options], locator, within: within, message: "find_node(#{locator}) => look for closest fillable field") do
+
+        # case 2
+        _rescued_find([:fillable_field, locator, options], locator, within: within, message: 'Capybara#fillable_input') do
+
+          # all cases failed => raise
+          raise Capybara::ElementNotFound,
+                "Unable to find fillable field by locator #{locator}",
+                caller
+
+        end
+
+      end
+
+    end
+  end
+
+  def _rescued_find(params, locator, within:, message:)
+    within.find(*params)
+  rescue Capybara::Ambiguous => err # Capybara::Ambiguous < Capybara::ElementNotFound == true
+    raise Pickles::Ambiguous.new(locator, within, params, message), nil, caller
+  rescue Capybara::ElementNotFound
+    yield
+  end
+
+end

data/lib/cucumber/pickles/helpers/regex.rb

@@ -0,0 +1,6 @@
+# :nodoc:
+module Helpers::Regex
+
+  WITHIN = /\A\s*(.*)?\s*(?:["|'](.*?)["|'])?\s*\Z/
+
+end

data/lib/cucumber/pickles/helpers/waiter.rb

@@ -0,0 +1,152 @@
+# original code:
+#
+# (function() {
+#   var oldOpen = XMLHttpRequest.prototype.open;
+#   window.openHTTPs = 0;
+#   XMLHttpRequest.prototype.open = function(method, url, async, user, pass) {
+#     window.openHTTPs++;
+#     this.addEventListener("readystatechange", function() {
+#         if(this.readyState == 4) {
+#           window.openHTTPs--;
+#         }
+#       }, false);
+#     oldOpen.call(this, method, url, async, user, pass);
+#   }
+# })(XMLHttpRequest);
+#
+# module Capybara
+#   module Selenium
+#     class Driver
+#
+#       class << self
+#         alias __pickles_redefined__new new
+#
+#         #
+#         # Monkey patch initializer to load custom chrome extension in extensions/chrome
+#         #
+#         # It will add window.activeRequests to keep track of active AJAX requests in tests
+#         #
+#         # For source code of extension see extensions/chrome/src/inject/inject.js
+#         #
+#         # TODO: support all major browser drivers
+#         #
+#         def new(app, options={})
+#           if options[:browser].to_s == "chrome"
+#             options[:desired_capabilities] ||= {}
+#             options[:desired_capabilities]["chromeOptions"] ||= {}
+#             options[:desired_capabilities]["chromeOptions"]["extensions"] ||= []
+#
+#             extension_path = File.expand_path('extensions/chrome/compiled.crx.base64', __dir__)
+#
+#             options[:desired_capabilities]["chromeOptions"]["extensions"].unshift(File.read(extension_path))
+#           end
+#
+#           __pickles_redefined__new(app, options)
+#         end
+#       end
+#
+#     end
+#
+#   end
+# end
+
+def stub_xml_http_request(page)
+  page.evaluate_script <<-JAVASCRIPT
+    (function() {
+
+      if (window.ajaxRequestIsSet) { return; };
+      window.ajaxRequestIsSet = true;
+
+      var oldOpen = XMLHttpRequest.prototype.open;
+      window.activeRequests =  0;
+      XMLHttpRequest.prototype.open = function(method, url, async, user, pass) {
+        window.activeRequests++;
+        this.addEventListener("readystatechange", function() {
+            if (this.readyState == 4) {
+              window.activeRequests--;
+
+              #{
+                if Pickles.config.log_xhr_response
+                  <<-LOG
+                  if (parseInt(this.status, 10) >= 400) {
+                    console.error("############## ERRRO RESPONSE START ################");
+                    console.error(this.response);
+                    console.error("############## ERRRO RESPONSE END   ################");
+                  }
+                  LOG
+                end
+              }
+
+            }
+          }, false);
+        oldOpen.call(this, method, url, async, user, pass);
+      };
+
+
+      var style = document.createElement('style');
+      style.type = 'text/css';
+      style.innerHTML = '* {' +
+      '/*CSS transitions*/' +
+      ' -o-transition-property: none !important;' +
+      ' -moz-transition-property: none !important;' +
+      ' -ms-transition-property: none !important;' +
+      ' -webkit-transition-property: none !important;' +
+      '  transition-property: none !important;' +
+      '  /*CSS animations*/' +
+      '   -webkit-animation: none !important;' +
+      '   -moz-animation: none !important;' +
+      '   -o-animation: none !important;' +
+      '   -ms-animation: none !important;' +
+      '   animation: none !important;}';
+         document.getElementsByTagName('head')[0].appendChild(style);
+
+    })();
+  JAVASCRIPT
+end
+
+module Capybara
+  class Session
+
+    alias __pickles_redefined__old_visit visit
+
+    def visit(*args)
+      __pickles_redefined__old_visit(*args)
+
+      stub_xml_http_request(Capybara.current_session)
+    end
+
+  end
+end
+
+module Waiter
+
+  module_function
+
+  def wait
+    wait_for_ajax
+
+    return unless block_given?
+
+    page.document.synchronize do
+      yield
+    end
+  end
+
+  def page
+    Capybara.current_session
+  end
+
+  #
+  # waits for all Ajax requests to finish
+  #
+  def wait_for_ajax
+    page.document.synchronize do
+      pending_ajax_requests_num.zero? || raise(Capybara::ElementNotFound)
+    end
+  end
+
+  def pending_ajax_requests_num
+    page.evaluate_script("window.activeRequests")
+  end
+
+end