seleniumrecord 0.0.1.beta1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e34d57392ef8365deafdf42fce9a442de4de5b5c
+  data.tar.gz: dee1cdc484930e6b3ee7553da9813cd90b728a79
+SHA512:
+  metadata.gz: 07a8ce0f127b8de9aa73531a492b18f5913e7665e02be7bd6b7b5236b8bb792461fa684030cc3a9a64df686d26c38d8618d5d788bffbdc0f7e3f93183f40a196
+  data.tar.gz: d201431d8b93319963930d5e8aea010f62ca5264118538e9fa55f06c6812513f2f88f55e9c703ec76b32ceecf8c7994ad4dff71a09122f3f49ddbcaa4becd51b

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in selenium_record.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 David Saenz Tagarro
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,65 @@
+[![Gem Version](https://badge.fury.io/rb/selenium-record.svg)](http://badge.fury.io/rb/selenium-record)
+[![Code Climate](https://codeclimate.com/github/dsaenztagarro/selenium-record/badges/gpa.svg)](https://codeclimate.com/github/dsaenztagarro/selenium-record)
+
+# SeleniumRecord
+
+Selenium Record is a DSL for easily writing acceptance tests. It is a wrapper 
+over Selenium ruby bindings to let you easily apply the well known page object 
+pattern.
+
+## Why to use
+
+Within your web app's UI there are areas that your tests interact with. A
+Selenium Record object simply models these as objects within the test code.
+This reduces the amount of duplicated code and means that if the UI changes,
+the fix need only be applied in one place.
+
+## Warning
+
+This gem is still under development! As this gem was born while I was trying to
+right acceptance tests in a more maintainable and productive way, it is not 
+already tested!! Check the roadmap for upcoming updates. All pending tasks 
+should be completed for '1.0.0' version. Keep up to date!
+
+## Roadmap
+
+[ ] Full test coverage
+[ ] Wiki Documentation
+[ ] Basic install generator
+[ ] ComponentAutoload integration in core (Currently present as a framework
+    extension)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'seleniumrecord'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install seleniumrecord
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/dsaenztagarro/selenium-record/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## References
+
+- [Selenium Wiki Page](https://code.google.com/p/selenium/wiki/PageObjects)
+- "Selenium 2 Testing Tools" by David Burns
+
+## Thanks
+
+Thanks to Hola Internet for let me right this kind of tools

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/selenium_record.rb

@@ -0,0 +1,7 @@
+Dir["#{File.dirname(__FILE__)}/selenium_record/*.rb"].each { |f| require f }
+
+# Selenium Record provides objects for interacting with browser and managing
+# the application during tests. Also joins in every object behaviour and
+# expectations
+module SeleniumRecord
+end

data/lib/selenium_record/action_builder.rb

@@ -0,0 +1,41 @@
+module SeleniumRecord
+  # Helpers for building complex actions
+  module ActionBuilder
+    # Class for storing action info
+    class Action
+      attr_reader :method, :args
+      def initialize(method, args = [])
+        @method = method
+        @args = args
+      end
+    end
+
+    # Class for building complex actions
+    class Builder
+      attr_accessor :actions
+
+      def initialize(&block)
+        @actions = []
+        @blk = block
+      end
+
+      def perform
+        @actions.each { |action| @blk.call(action.method, action.args) }
+        @actions.freeze
+      end
+
+      def method_missing(method, *args)
+        @actions << Action.new(method, *args)
+        self
+      end
+    end
+
+    # @param block [Block] the block over all actions will be performed. It
+    #   should contain two params: |method, args|
+    # @return [SeleniumRecord::Builder::ActionBuilder] a new action builder
+    #   instance
+    def action_builder(&block)
+      Builder.new(&block)
+    end
+  end
+end

data/lib/selenium_record/actions.rb

@@ -0,0 +1,80 @@
+module SeleniumRecord
+  # Contains simple actions to play from selenium objects
+  module Actions
+    def textarea_content(locator, content)
+      find(locator).clear  # gain focus on textarea
+      find(locator).send_keys content
+    end
+
+    # Clicks accept button on popup
+    def accept_popup
+      popup = browser.switch_to.alert
+      popup.accept
+    end
+
+    # Chooses an option from select enhanced by javascript
+    # @param id [String] id of the select
+    # @param text [String] the option text
+    def choose_option(id, text)
+      click_wait xpath: select_xpath(id)
+      click_wait xpath: select_option_xpath(id, text)
+    end
+
+    # Chooses a menu from dropdown enhanced by javascript
+    # @param dropdown [String] text of dropdown
+    # @param menu [String] text of menu
+    def choose_menu(dropdown, menu)
+      click_wait xpath: dropdown_xpath(trans dropdown)
+      click_wait xpath: dropdown_menu_xpath(trans menu)
+    end
+
+    # Clicks on element and wait until all jquery events are dispatched
+    # @param how [Symbol]  (:class, :class_name, :css, :id, :link_text, :link,
+    #   :partial_link_text, :name, :tag_name, :xpath)
+    # @param what [String]
+    def click_wait(locator)
+      when_present(locator).click
+      wait_js_inactive
+    end
+
+    def click(locator)
+      find(locator).click
+    end
+
+    def submit
+      click(xpath: ".//button[@type='submit']")
+      wait_page_load
+      load_dom
+    end
+
+    # @param text [String] text of the link to be clicked
+    def click_link(text)
+      finder = root_el || browser
+      finder.find_element(link_text: text).click
+    end
+
+    # Drops the model view on the bottom to the top of the model type view list
+    # @param model_type [Symbol] the type of the views to be affected
+    def pop_last(model_type)
+      elements = send("#{model_type}_elements")
+      browser.action
+        .drag_and_drop(elements.last, elements.first).perform
+    end
+
+    # @param id [Symbol] id of select element
+    # @param text [String] text of the option to be selected
+    def select_from_chosen(id, text)
+      browser.execute_script <<-script
+        var optValue = $("##{id} option:contains('#{text}')").val();
+        var value = [optValue];
+        if ($('##{id}').val()) {
+          $.merge(value, $('##{id}').val());
+        }
+        $('##{id}').val(value).trigger('chosen:updated');
+      script
+    end
+
+    # Remove once all helper references belongs to selenium objects
+    module_function :choose_option
+  end
+end

data/lib/selenium_record/axis.rb

@@ -0,0 +1,54 @@
+module SeleniumRecord
+  # Helper methods for comparing the relative position in DOM among selenium
+  # objects
+  module Axis
+    # @param view [SeleniumRecord::Base]
+    # @return [Boolean] Marks whether the current view is located in DOM
+    #   after the view passed as parameter
+    def after?(other_view)
+      preceding_sibling_elements.member? other_view.root_el
+    end
+
+    # @param view [SeleniumRecord::Base]
+    # @return [Boolean] Marks whether the current view is located in DOM
+    #   before the view passed as parameter
+    def before?(other_view)
+      following_sibling_elements.member? other_view.root_el
+    end
+
+    # @param models [Array<PORO>] list of models associated to views
+    # @return [Boolean] Marks whether the model views are ordered in the dom
+    def ordered?(*models)
+      result = []
+      models.reduce(nil) do |prev, current|
+        result << (view_for(prev).before? view_for(current)) if prev
+        current
+      end
+      result.any?
+    end
+
+    # Returns all elements belonging to preceding sibling xpath axe
+    # @return [Array<Selenium::WebDriver::Element>]
+    def preceding_sibling_elements
+      find_elements(preceding_sibling_locator)
+    end
+
+    # Returns all elements belonging to following sibling xpath axe
+    # @return [Array<Selenium::WebDriver::Element>]
+    def following_sibling_elements
+      find_elements(following_sibling_locator)
+    end
+
+    private
+
+    # @return [String] locator for finding preceding sibling dom elements
+    def preceding_sibling_locator
+      { xpath: "./preceding-sibling::#{tag_name}" }
+    end
+
+    # @return [String] locator for finding following sibling dom elements
+    def following_sibling_locator
+      { xpath: "./following-sibling::#{tag_name}" }
+    end
+  end
+end

data/lib/selenium_record/base.rb

@@ -0,0 +1,93 @@
+require_relative 'core'
+require_relative 'lookup'
+require_relative 'actions'
+require_relative 'action_builder'
+require_relative 'scopes'
+require_relative 'waits'
+require_relative 'preconditions'
+require_relative 'axis'
+require_relative 'html'
+require_relative 'theme'
+require_relative 'translations'
+
+# SeleniumRecord provides a framework based on the Selenium Page Object pattern
+#
+# ### More references:
+# - [Selenium Wiki Page](https://code.google.com/p/selenium/wiki/PageObjects)
+# - "Selenium 2 Testing Tools" by David Burns
+module SeleniumRecord
+  # @abstract Subclass and override {#run} to implement
+  #   a custom Selenium object
+  class Base
+    include Core
+    include Lookup
+    include Actions
+    include ActionBuilder
+    include Scopes
+    include Waits
+    include Preconditions
+    include Axis
+    include Html
+    include Theme
+    include Translations
+    attr_reader :browser, :parent_el, :root_el, :object
+    alias_method :__rootel__, :root_el
+
+    # @params browser [Selenium::WebDriver::Driver]
+    # @param [Hash] opts the options to create a new record
+    # @option opts [Selenium::WebDriver::Element] :parent_el The parent element
+    # @option opts [Selenium::WebDriver::Element] :root_el The root element
+    # @option opts [PORO] :object Plain Old Ruby Object contains main info
+    #   related to the record
+    def initialize(browser, opts = {})
+      @browser = browser
+      @parent_el = opts[:parent_el]
+      @root_el = opts[:root_el]
+      @object = opts[:object]
+    end
+
+    # Creates a view in the scope of current instance based on object model
+    #   passed as parameter
+    # @param object [ActiveRecord::Base] the object related to the new view
+    # @param [Hash] opts the options for the new view created
+    # @option opts [Module] :namespace The namespace in which the new view
+    #   should be created
+    # @option opts [String] :suffix The suffix to be appended to the new view
+    #   class name
+    def create_record(object, opts = {})
+      subject = opts[:subject] || object.class.name
+      klass = self.class.extract_klass(subject, opts)
+      klass.new(@browser, parent_el: root_el, object: object)
+    end
+
+    # Creates a view in the scope of current instance based on the action name
+    # @param action [Symbol]
+    # @param [Hash] opts the options for the new view created
+    # @option opts [Module] :namespace The namespace in which the new view
+    #   should be created
+    # @option opts [String] :suffix The suffix to be appended to the new view
+    #   class name
+    def create_record_for_action(action, opts = {})
+      klass = self.class.extract_klass(action.to_s.camelize, opts)
+      klass.new(@browser, parent_el: root_el)
+    end
+
+    # @return [Boolean] returns whether the view is attached to the dom
+    def exist?
+      load_dom if respond_to? :lookup_sequence
+      root_el != nil
+    end
+
+    # @param [Hash] opts the options for the new view created
+    # @option opts [Module] :namespace The namespace in which the new view
+    #   should be created
+    # @option opts [String] :suffix The suffix to be appended to the new view
+    #   class name
+    # @return [SeleniumRecord::Base]
+    def self.extract_klass(subject, opts)
+      namespace = opts[:namespace] || Object
+      suffix = opts[:suffix] || ''
+      namespace.const_get("#{subject}#{suffix}")
+    end
+  end
+end

data/lib/selenium_record/configuration.rb

@@ -0,0 +1,11 @@
+module SeleniumRecord
+  # Defines configuration options
+  class Configuration
+    @js_library = :jquery
+    @choose_option_max_retries = 10
+
+    class << self
+      attr_accessor :js_library, :choose_option_max_retries
+    end
+  end
+end

data/lib/selenium_record/core.rb

@@ -0,0 +1,38 @@
+module SeleniumRecord
+  # Core helpers to get easier access to selenium api
+  module Core
+    SUBCLASS_RESPONSABILITY = 'SubclassResponsibilityError'
+
+    def load_dom!(attrs = {})
+      @load_attributes = attrs
+      before_load_dom if respond_to? :before_load_dom
+      before_lookup if respond_to? :before_lookup
+      lookup
+      after_load_dom if respond_to? :after_load_dom
+      self
+    end
+
+    def load_dom(attrs = {})
+      load_dom! attrs
+    rescue
+      false
+    end
+
+    def click_on(locator)
+      find(locator).click
+    end
+
+    def find(locator)
+      root_el.find_element(locator)
+    end
+
+    def find_elements(locator)
+      root_el.find_elements(locator)
+    end
+
+    def first_last(list)
+      blk = ->(first, *_, last) { [first, last] }
+      blk.call(*list)
+    end
+  end
+end

data/lib/selenium_record/html.rb

@@ -0,0 +1,17 @@
+module SeleniumRecord
+  # Helpers for getting html related info to selenium objects
+  module Html
+    # @return [String] the html content for the root element
+    def to_html
+      return root_el.attribute('innerHTML') if exist?
+      nil
+    end
+
+    # @return [String] the tag name for the DOM element at the root of the
+    #   object. Used to define xpath locators.
+    # @see preceding_sibling_locator
+    def tag_name
+      @tag_name ||= root_el.attribute('tagName')
+    end
+  end
+end

data/lib/selenium_record/lookup.rb

@@ -0,0 +1,123 @@
+module SeleniumRecord
+  # Responsible methods for looking up the root element for each selenium object
+  module Lookup
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Searchs for root element of current object based on other element
+    # @return [Webdriver::Element]
+    def lookup
+      @root_el = parent_el || browser
+      lookup_sequence.each { |locator| @root_el = lookup_step(locator) }
+    rescue
+      @root_el = nil
+      raise
+    end
+
+    # Given the current root element for the view, applies a scoped search for
+    # the web element identified by the locator passed as parameter
+    #
+    # @raise [LookupMultipleElementsError] if it is found multiple web elements
+    #   in the scope of the current root element for the locator passed
+    # @raise [LookupUndefinedElementError] if it isn't found any web elements
+    #   in the scope of the current root element for the locator passed
+    #
+    # @param locator [Hash] contains unique {key: value} where the key is the
+    #   locator_type (:class, :class_name, :css, :id, :link_text, :link,
+    #   :partial_link_text, :name, :tag_name, :xpath)
+    # @return element [Selenium::WebDriver::Element]
+    def lookup_step(locator)
+      lookup_elements = find_elements(locator)
+      size = lookup_elements.size
+      fail 'LookupMultipleElementsError' if size > 1
+      fail 'LookupUndefinedElementError' if size == 0
+      lookup_elements.first
+    end
+
+    # Clasess extending SeleniumRecord::Base should overwrite this method or
+    # call to class method `lookup_strategy` defined in `SeleniumRecord::Lookup`
+    # in order to search for Selenium::WebDriver::Element used as scope for
+    # finding elements inside the instance object
+    def lookup_sequence
+      fail 'LookupUndefinedSequenceError'
+    end
+
+    # Contains class method helpers and definition of classes for lookup
+    # strategy
+    module ClassMethods
+      # @param strategy_sym [Symbol] lookup strategy corresponding with the
+      #   name of a lookup strategy locator
+      def lookup_strategy(strategy_sym, opts = {})
+        locator_klass = "Lookup#{strategy_sym.to_s.camelize}Strategy"
+        Module.nesting.shift.const_get(locator_klass).new(self, opts).run
+      end
+
+      # Base class for all lookup strategies
+      class LookupStrategy
+        attr_reader :lookup_attributes
+
+        # @param klass [SeleniumObject::Base] class on top over it is defined
+        #   the lookup strategy
+        # @param attrs [Hash] attributes used while it is the defined the
+        #   lookup sequence
+        def initialize(klass, attrs = {})
+          @klass = klass
+          @attributes_blk = -> { attrs }
+        end
+
+        # Defines for the class the instance methods required for the lookup
+        # sequence. Inside the block you have access to the "lookup_attributes"
+        # specified in the constructor call
+        # @param [Block] block defining the lookup sequence
+        def lookup_sequence(&block)
+          attributes_blk = @attributes_blk
+          before_lookup_blk = before_run if respond_to? :before_run
+          @klass.instance_eval do
+            define_method :lookup_attributes, attributes_blk
+            define_method :lookup_sequence, &block
+            define_method :before_lookup, before_lookup_blk if before_lookup_blk
+          end
+        end
+      end
+
+      # Defines a lookup sequence relative to the title xpath
+      class LookupRelativeTitleStrategy < LookupStrategy
+        def run
+          lookup_sequence do
+            [title_locator, lookup_attributes[:locator]]
+          end
+        end
+      end
+
+      # Defines a lookup sequence relative to the xpath of an element present in
+      # the selenium object
+      class LookupRelativePathStrategy < LookupStrategy
+        def run
+          lookup_sequence do
+            [send("#{lookup_attributes[:to]}_locator"),
+             lookup_attributes[:locator]]
+          end
+        end
+      end
+
+      # Defines a lookup sequence matching an element path
+      class LookupMatchingStrategy < LookupStrategy
+        def run
+          lookup_sequence { [lookup_attrs[:locator]] }
+        end
+      end
+
+      # Defines a lookup sequence matching the whole document body
+      class LookupRootStrategy < LookupStrategy
+        def run
+          lookup_sequence { [{ xpath: '//body' }] }
+        end
+
+        def before_run
+          -> { @parent_el = nil }
+        end
+      end
+    end
+  end
+end

data/lib/selenium_record/navigation_item.rb

@@ -0,0 +1,71 @@
+require_relative 'base'
+
+module SeleniumRecord
+  # Base model to be extended by all Selenium page objects
+  class NavigationItem < Base
+    lookup_strategy :root
+
+    def before_load_dom
+      before_navigate if respond_to? :before_navigate
+      navigate unless current?
+    end
+
+    def click_link(*args)
+      super
+      self
+    end
+
+    def reload
+      find(link_active_locator).click
+      wait_page_load
+      self
+    rescue => error
+      if error.is_a? Selenium::WebDriver::Error::StaleElementReferenceError
+        load_dom
+        retry
+      else
+        raise
+      end
+    end
+
+    # Class method to create the 'before_navigate' hook defining the title
+    # of the page
+    # @param key [String] key to lookup text translation for menu title of
+    #   the page
+    def self.navigate_to(key)
+      define_method :before_navigate do
+        @title = trans key
+      end
+    end
+
+    private
+
+    # Checks whether the current page corresponds to the instance page and
+    # in case of mismatch clicks on the navigation menu for loading the
+    # instance page
+    def navigate
+      when_present(link_inactive_locator).click
+      wait_displayed(link_active_locator)
+    end
+
+    # @param [String] Returns the xpath to be used to identify if the current
+    #   browser page matches this object
+    # @raise [SubclassResponsabilityError] if subclasses don't implement this
+    #   method
+    def link_inactive_locator
+      fail SUBCLASS_RESPONSABILITY
+    end
+
+    def link_active_locator
+      fail SUBCLASS_RESPONSABILITY
+    end
+
+    # @return [Boolean] Marks whether the current browser page matches the new
+    #   new instantiated page object
+    def current?
+      browser.find_element(link_active_locator)
+    rescue Selenium::WebDriver::Error::NoSuchElementError
+      false
+    end
+  end
+end

data/lib/selenium_record/preconditions.rb

@@ -0,0 +1,50 @@
+module SeleniumRecord
+  # Selenium helpers for doing an action after a precondition takes place
+  module Preconditions
+    # Returns the first element matching the given arguments once this
+    # element is displayed in the DOM
+    # @param how [Symbol]  (:class, :class_name, :css, :id, :link_text, :link,
+    #   :partial_link_text, :name, :tag_name, :xpath)
+    # @param what [String]
+    # @return element [Selenium::WebDriver::Element]
+    def when_present(locator)
+      element = wait_displayed(locator)
+      yield if block_given?
+      element
+    end
+
+    # @raise [Selenium::WebDriver::Error::TimeOutError] whether the element
+    #   stays no clickable after time out period
+    # @param locator [Hash] contains unique {key: value} where the key is the
+    #   locator_type (:class, :class_name, :css, :id, :link_text, :link,
+    #   :partial_link_text, :name, :tag_name, :xpath)
+    # @return [Selenium::WebDriver::Element] once the element is clickable
+    def when_clickable(locator)
+      element = wait_clickable(locator)
+      yield if block_given?
+      element
+    end
+
+    def when_modal_present(title, &block)
+      when_present(:xpath, modal_header_xpath(title), &block)
+    end
+
+    # @raise [Selenium::WebDriver::Error::TimeOutError] whether the element
+    #   stays visible after time out period
+    # @param locator [Hash] contains unique {key: value} where the key is the
+    #   locator_type (:class, :class_name, :css, :id, :link_text, :link,
+    #   :partial_link_text, :name, :tag_name, :xpath)
+    # @return [Selenium::WebDriver::Element] once the element is hidden
+    def when_hidden(locator)
+      self.class.wait_for do
+        begin
+          element = root_el.find_element(locator)
+          element unless element.displayed?
+        rescue => error
+          raise if error.is_a? Selenium::WebDriver::Error::TimeOutError
+          true
+        end
+      end
+    end
+  end
+end

data/lib/selenium_record/scopes.rb

@@ -0,0 +1,40 @@
+module SeleniumRecord
+  # Helpers for executing actions in custom scope
+  module Scopes
+    # Class for giving custom scope to selenium objects
+    class LocatorScope < SimpleDelegator
+      include Actions
+      attr_accessor :scoped_locator
+
+      def root_el
+        @root_el ||= __rootel__.find_element(scoped_locator)
+      end
+
+      def find(locator)
+        root_el.find_element(locator)
+      end
+
+      def find_elements(locator)
+        root_el.find_elements(locator)
+      end
+
+      def run(&block)
+        instance_eval(&block)
+      end
+
+      def class
+        __getobj__.class
+      end
+    end
+
+    # Executes the block passed as parameter in the scope associated to the
+    # locator referenced by the scope name
+    # @param name [Symbol] The name of the scope. Adding the suffix '_locator'
+    #   it should match a locator name
+    def scope(scope_name, &block)
+      scope_obj = LocatorScope.new(self)
+      scope_obj.scoped_locator = send "#{scope_name}_locator"
+      scope_obj.run(&block)
+    end
+  end
+end

data/lib/selenium_record/theme.rb

@@ -0,0 +1,40 @@
+module SeleniumRecord
+  # Helpers specific for the bootstrap theme
+  module Theme
+    def modal_header_xpath(key)
+      "//div[@class='modal-header']/h3[text()='#{trans(key)}')]"
+    end
+
+    def find_headline(text)
+      xpath = "//div[contains(@class,'headline')]//div[contains(.,'#{text}')]"
+      find(:xpath, xpath)
+    end
+
+    # Returns xpath for select decorated with chosen.jquery.js
+    # @param [String] id of the select
+    def select_xpath(id)
+      ".//div[@id='#{id}_chosen']/a"
+    end
+
+    def select_option_xpath(id, text)
+      ".//div[@id='#{id}_chosen']//li[text()='#{text}']"
+    end
+
+    # Returns xpath for the dropdown button that matches the text
+    # @param key [String] text of dropdown button
+    def dropdown_xpath(text)
+      ".//button[contains(.,'#{text}')]"
+    end
+
+    # Returns xpath for the select option that matches the text
+    # @param key [String] text of select option
+    def dropdown_menu_xpath(text)
+      ".//ul[@class='dropdown-menu']/li[contains(.,'#{text}')]/a"
+    end
+
+    def section_xpath(text)
+      ".//section//div[@class='panel-header']
+       /h3[@class='suspended area-name']/strong/a[contains(.,'#{text}')]"
+    end
+  end
+end

data/lib/selenium_record/translations.rb

@@ -0,0 +1,10 @@
+module SeleniumRecord
+  # Contains helper methods for translations
+  module Translations
+    # @param key [String] the key to be used to lookup text translations
+    # @return [String] the translation for the given key
+    def trans(key)
+      I18n.t(key)
+    end
+  end
+end

data/lib/selenium_record/version.rb

@@ -0,0 +1,3 @@
+module SeleniumRecord
+  VERSION = '0.0.1.beta1'
+end

data/lib/selenium_record/waits.rb

@@ -0,0 +1,106 @@
+#:nodoc:
+module SeleniumRecord
+  # Helpers to make easy waiting for something to happen
+  module Waits
+    DEFAULT_WAITING_TIME = 20
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Wait selenium execution until no ajax request is pending in the browser
+    # @param seconds [Integer] number of seconds to wait
+    def wait_js_inactive(seconds = DEFAULT_WAITING_TIME)
+      klass = self.class
+      yield if block_given?
+      klass.wait_for(seconds) do
+        browser.execute_script(klass.js_inactive_script) == 0
+      end
+    end
+
+    def wait_page_load
+      self.class.wait_for do
+        browser.execute_script('return document.readyState;') == 'complete'
+      end
+      load_dom
+    end
+
+    # Wait selenium execution until the element is displayed
+    # @param locator [Hash] contains unique {key: value} where the key is the
+    #   locator_type (:class, :class_name, :css, :id, :link_text, :link,
+    #   :partial_link_text, :name, :tag_name, :xpath)
+    def wait_displayed(locator, opts = {})
+      klass = self.class
+      klass.wait_for(klass.seconds_for(opts)) do
+        begin
+          evaluate_displayed(locator)
+        rescue Selenium::WebDriver::Error::StaleElementReferenceError
+          lookup unless parent_el
+          false
+        end
+      end
+    end
+
+    # Waits until the 'model_view' corresponding to the model is completely
+    # visible
+    # @param model[PORO] plain old ruby object with a related 'model_view'
+    def wait_fade_in(model)
+      web_el = view_for(model).root_el
+      self.class.wait_for { web_el.css_value('opacity').to_i == 1 }
+    end
+
+    # Waits until the 'model_view' corresponding to the model is completely
+    # hidden
+    # @param locator [Hash] contains unique {key: value} where the key is the
+    #   locator_type (:class, :class_name, :css, :id, :link_text, :link,
+    #   :partial_link_text, :name, :tag_name, :xpath)
+    def wait_hidden(locator)
+      self.class.wait_for do
+        begin
+          finder = root_el || browser
+          element = finder.find_element(locator)
+          !element.displayed?
+        rescue Selenium::WebDriver::Error::StaleElementReferenceError
+          true
+        end
+      end
+    end
+
+    private
+
+    # @return element [Selenium::WebDriver::Element] if the element is visible.
+    #   Otherwise returns nil.
+    def evaluate_displayed(locator)
+      finder = root_el || browser
+      element = finder.find_element(locator)
+      element if element.displayed?
+    end
+
+    # Utilities for waiting methods
+    module ClassMethods
+      # Wait selenium execution until a condition take place
+      # @raise [Selenium::WebDriver::Error::TimeOutError] if the precondition we
+      #   are waiting for doesn't take place after completing the wait period
+      # @param seconds [Integer] number of seconds to wait
+      # @yieldreturn [Boolean] marks whether the condition we are waiting for
+      #   passes
+      def wait_for(seconds = DEFAULT_WAITING_TIME)
+        Selenium::WebDriver::Wait.new(timeout: seconds).until { yield }
+      end
+
+      # @return [String] the string containing javascript code to be evaluated
+      #   to check if there are ajax calls pending
+      def js_inactive_script
+        {
+          jquery: 'return $.active'
+        }[Configuration.js_library]
+      end
+
+      def seconds_for(opts)
+        seconds = opts[:seconds]
+        return seconds if seconds
+        20
+      end
+    end
+  end
+end

data/selenium_record.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'selenium_record/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'seleniumrecord'
+  spec.version       = SeleniumRecord::VERSION
+  spec.authors       = ['David Saenz Tagarro']
+  spec.email         = ['david.saenz.tagarro@gmail.com']
+  spec.summary       = <<-summary
+Selenium Record is a DSL for easily writing acceptance tests.
+summary
+  spec.description   = <<-desc
+Selenium Record is a wrapper over Selenium ruby bindings to let you easily
+apply the well known page object pattern.
+desc
+  spec.homepage      = 'https://github.com/dsaenztagarro/selenium-record'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'codeclimate-test-reporter'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'coveralls'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'reek'
+  spec.add_development_dependency 'cane'
+end

metadata

@@ -0,0 +1,194 @@
+--- !ruby/object:Gem::Specification
+name: seleniumrecord
+version: !ruby/object:Gem::Version
+  version: 0.0.1.beta1
+platform: ruby
+authors:
+- David Saenz Tagarro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: reek
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cane
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  Selenium Record is a wrapper over Selenium ruby bindings to let you easily
+  apply the well known page object pattern.
+email:
+- david.saenz.tagarro@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/selenium_record.rb
+- lib/selenium_record/action_builder.rb
+- lib/selenium_record/actions.rb
+- lib/selenium_record/axis.rb
+- lib/selenium_record/base.rb
+- lib/selenium_record/configuration.rb
+- lib/selenium_record/core.rb
+- lib/selenium_record/html.rb
+- lib/selenium_record/lookup.rb
+- lib/selenium_record/navigation_item.rb
+- lib/selenium_record/preconditions.rb
+- lib/selenium_record/scopes.rb
+- lib/selenium_record/theme.rb
+- lib/selenium_record/translations.rb
+- lib/selenium_record/version.rb
+- lib/selenium_record/waits.rb
+- selenium_record.gemspec
+homepage: https://github.com/dsaenztagarro/selenium-record
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Selenium Record is a DSL for easily writing acceptance tests.
+test_files: []