seleniumrecord 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5c45b76e17d2e8c4e62e0d8cb713020357031879
-  data.tar.gz: 5e8752075f3ab3ab1e82ef15a7603b8508c5f490
+  metadata.gz: c218633c4ac035844b5029134164f49fbbbffd09
+  data.tar.gz: d79b3c62f1b796e10a42d7306ce056a096a0ea5e
 SHA512:
-  metadata.gz: 9eba4632b6c62af6a81b7003a17f566a470b3dab8141fe49ce03503195e45a9fe7af072212e4e9c774bf12813156dfb8fc75256361be1007b8cc4f9c56f38af3
-  data.tar.gz: 9ca10dc331a610e02720c695d452dd5e11e5809ab7c74f6107ad200cce588f823c75d92846bef2699a52fd6cd9feaad34821a759f273c21ff9a28c3d654bec5d
+  metadata.gz: 3315d71b705d77a4a943aab0ab82733b1bb31db8e49f4dd7ac9c39557e9b63150c02c34bc5048a454d00e0f093d3b57a9132fe972cfd46ca413b447457687d46
+  data.tar.gz: 2eaeecf4f932bc1494bfb89e3e230a84de40a8d5cc2b15ce2b2848bb7fbc63f24178869b4fbd40b3d2caa8c9630c8617797c4f4dcd2292b5bc8bd02343fe4dd8

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 0.0.3
+
+* Fixed SeleniumRecord::Lookup::MatchingStrategy
+* Renamed Lookup strategies for cleaner code
+* Added Basic Documentation
+* Added method `focus` to `SeleniumRecord::Actions` module
+
+## 0.0.2.revision
+
+* Updated `activesupport` dependency gem version
+
 ## 0.0.2
 
 * Added rake task for scaffolding

data/README.md

@@ -32,6 +32,253 @@ Options:
 - 'navigation_components': [Array] The names of the navigation components 
   expected. Default: ['pages', 'tab']
 
+## Usage
+
+### Lookup strategy
+
+Everytime you create a Selenium object it is fired the lookup process. This mean
+that based on selected strategy is defined the value for `root_el` (an instance
+of `Selenium::WebDriver::Element`). What really matters about this is that all
+`find_element` or `find_elements` operations will be done always in the scope
+of the `root_el`.
+
+#### Hooks
+
+The lookup process defines two hooks:
+
+- before_load_dom: This hook allows you to do some actions before the lookup
+  process. For example, `SeleniumRecord::NavigationItem` takes this hook to
+  click on a menu page and start lookup only once the new page it is loaded.
+
+- after_load_dom: This hook allows you to do some actions after lookup process.
+  For example, `SeleniumRecord::Base` takes this hook to inject components
+  defined.
+
+```ruby
+# selenium_record/component_autoload.rb
+
+# Inject components after loading dom, providing reader methods for
+# accessing them
+# @param names [Array<Symbol>] component names. Valid formats Regex:
+# /(?<component_name>.*)_(?<component_type>view|tab|pill|modal|panel)$/
+def component_reader(*names)
+  names.each { |name| create_component_reader name }
+  define_method :after_load_dom do
+    load_components names
+  end
+end
+```
+
+**REMEMBER:** All selenium objects should define their lookup strategy through
+the class method `lookup_strategy`.
+
+#### Relative title
+
+In the next example it is search in first place element relative to element for
+locator returned by `title_locator` instance method. Once found this element 
+it is searched the `root_el` using a relative xpath.
+
+```ruby
+# spec/support/selenium_objects/panels/image_panel.rb
+module SeleniumObjects
+  module Panels
+    # Selenium Page Object to interact with areas sections for a page
+    class ImagePanel < Base::ApplicationView
+      lookup_strategy :relative_title, locator: { xpath: '../../..' }
+      
+      # ...
+```
+
+#### Matching element
+
+This strategy searchs exactly for the element which the locator passed as
+parameter.
+
+```ruby
+# spec/support/selenium_objects/panels/image_panel.rb
+module SeleniumObjects
+  module Panels
+    # Selenium Page Object to interact with areas sections for a page
+    class ImagePanel < Base::ApplicationView
+      lookup_strategy :matching, locator: { xpath: ".//div[@class='todo-list']" }
+      # ...
+```
+
+
+#### Root
+
+This strategy sets as `root_el` the element associated with html `body` tag
+
+```ruby
+module SeleniumRecord
+  # Base model to be extended by all Selenium page objects
+  class NavigationItem < Base
+    lookup_strategy :root
+    # ...
+```
+
+### Dependency injection
+
+When you call `component_reader` class method you pass a list of components that
+will be injected into the current component once it is instantiated. They will
+be available through the related accessor methods (Example: `filter_panel`).
+
+#### Components
+
+```ruby
+# spec/support/selenium_objects/panels/search/filter_panel
+module SeleniumObjects
+  module Panels
+    class FilterPanel < Base::ApplicationPanel
+      # ...
+      def search
+        # Do search stuff
+      end
+
+# spec/support/selenium_objects/views/search_view
+module SeleniumObjects
+  module Views
+    class SearchView < Base::ApplicationView
+      navigate_to :labels
+      component_reader :filter_panel, :results_panel
+# ...
+```
+
+In addition all method calls to instance methods of components will be proxied
+through the container component if this component doesn't define the proper
+method. In the previous example:
+
+```ruby
+search_view # => SearchView instance
+search_view.search  # => equal to search_view.filter_panel.search
+```
+
+#### Action components
+
+When you call `action_component_reader` class method you can pass a list of
+components that will perform an action once they are instantiated. Because of
+that, when you create an instance of `ConceptView` it will be generated only
+the accessors methods to create the related instance of `DetailsTab` (equal to
+other tabs).
+
+As `DetailsTab` is a component of `ConceptView`, the attribute `parent_el` of
+`DetailsTab` will match the `root_el` of `ConceptView`.
+
+```ruby
+# spec/support/selenium_objects/tabs/details_tab
+module SeleniumObjects
+  module Tabs
+    class DetailsTab < Base::ApplicationView
+      navigate_to :details
+
+# spec/support/selenium_objects/views/concept_view.rb
+module SeleniumObjects
+  module Views
+    class ConceptView < Base::ApplicationView
+      lookup_strategy :root
+      action_component_reader :main_tab, :details_tab, :audit_tab
+
+```
+
+If we focus on `DetailsTab`:
+
+```ruby
+    class DetailsTab < Base::ApplicationView
+      navigate_to :details
+```
+
+The method `navigate_to` will perform a click on link with localized string 
+"details".
+
+Of course you can customize to fit your needs this approach using a code like
+this one. In the next example we change from expected `trans key` to 
+`trans "txt.views.layouts.sections.#{key}"`
+
+```ruby
+# spec/support/selenium_objects/base/application_tab.rb
+module SeleniumObjects
+  module Base
+    # Base class for all selenium objects representing an application tab
+    class ApplicationTab < ::SeleniumRecord::NavigationItem
+
+      def self.navigate_to(key)
+        define_method :before_navigate do
+          @title = trans "txt.views.layouts.sections.#{key}"
+        end
+      end
+
+      # ...
+```
+
+### Scopes
+
+Scopes allow you to execute code inside a block in the scope of the 
+`Selenium::WebDriver::Element` associated to the scope definition. To define
+a scoped block you use the syntax: `scope :my_symbol { #stuff }`.
+The code will be executed in the context of the element with locator defined
+through method `my_symbol_locator`.
+
+#### Using locator symbol
+
+```ruby
+# spec/support/selenium_objects/views/concept_view.rb
+module SeleniumObjects
+  module Views
+    class ConceptView < Base::ApplicationView
+      lookup_strategy :root
+
+      def create_new_version
+        scope :fieldset_relations do
+          # Methods from Actions module are executed relative to the element
+          # specified by fieldset_relations_locator
+          # See `selenium_record/actions` for more details
+        end
+      end
+
+      def fieldset_relations_locator
+        { xpath: ".//div[@class='relations']"
+      end
+      
+      # ...
+```
+
+#### Extensions
+
+Everytime you call methods like `find` or `find_elements`, it will be returned
+the `Selenium::WebDriver::Element` instances with methods from modules:
+
+- `SeleniumRecord::Axiable`
+
+**WARNING**: Currently this behaviour it is only implemented for `find`
+
+#### Plugins
+
+As a good practice, all stuff related to a explicit javascript library should
+be package inside plugins folder. As an example:
+
+```
+# spec/support/selenium_objects/plugins/jquery_autocomplete.rb
+module SeleniumObjects
+  module Plugins
+    class JQueryAutocomplete < ::SeleniumRecord::Base
+      attr_accessor :input_el
+      # @param browser [Selenium::WebDriver::Driver]
+      # @param locator [Hash] The locator of the input text autocomplete element
+      def initialize(browser, locator)
+        @root_el = browser
+        @input_el = find(locator)
+      end
+
+      def perform(text)
+        @text = text
+        search_text
+        select_from_pulldown_menu
+        wait_for_tag_created
+      end
+
+      # ...
+```
+
 ## Install
 
 After running `rake selenium_record::install`, you should include a module in
@@ -59,11 +306,8 @@ should be completed for '1.0.0' version. Keep up to date!
 
 ## Roadmap
 
-- [ ] Full test coverage
-- [ ] Wiki and README Documentation
-- [X] Basic install generator
-- [X] ComponentAutoload integration in core (Currently present as a framework
-    extension)
+SeleniumRecord is on its way towards 1.0.0. Please refer to 
+[issues](https://github.com/dsaenztagarro/selenium-record/issues) for details.
 
 ## Installation
 

data/lib/selenium_record/actions.rb

@@ -35,6 +35,10 @@ module SeleniumRecord
       el.clear
     end
 
+    def click_on(locator)
+      find(locator).click
+    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)
@@ -54,6 +58,12 @@ module SeleniumRecord
       find(locator).send_keys(text || '')
     end
 
+    # @param locator [Hash|Selenium::WebDriver::Element]
+    def focus(locator)
+      element = (locator.is_a?(Hash) && find(locator)) || locator
+      browser.action.move_to(element).perform
+    end
+
     def submit
       click(xpath: ".//button[@type='submit']")
       wait_page_load

data/lib/selenium_record/axiable.rb

@@ -3,8 +3,12 @@ module SeleniumRecord
   module Axiable
     # @param element [Selenium::WebDriver::Element]
     # @return [Selenium::WebDriver::Element] The preceding-sibling axis element
-    def preceding_sibling(tag_name)
+    def preceding_sibling(tag_name = '*')
       find_element xpath: "./preceding-sibling::#{tag_name}"
     end
+
+    def parent(tag_name = '*')
+      find_element xpath: "./parent::#{tag_name}"
+    end
   end
 end

data/lib/selenium_record/component_autoload.rb

@@ -16,7 +16,7 @@ module SeleniumRecord
     # @return [Module] the module containing the classes for the marker type
     #   group
     def self.extract_namespace(*modules)
-      modules.compact.reduce(so_module) do |klass, sym|
+      modules.compact.reduce(Configuration.objects_module) do |klass, sym|
         klass.const_get(sym)
       end
     end

data/lib/selenium_record/core.rb

@@ -18,10 +18,6 @@ module SeleniumRecord
       false
     end
 
-    def click_on(locator)
-      find(locator).click
-    end
-
     # @param [Hash] opts the options to find element
     # @param opts [String] :global_scope Marks whether the global scope is used
     #   whenever a root element is not present

data/lib/selenium_record/lookup.rb

@@ -49,7 +49,7 @@ module SeleniumRecord
       # @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"
+        locator_klass = "#{strategy_sym.to_s.camelize}Strategy"
         Module.nesting.shift.const_get(locator_klass).new(self, opts).run
       end
 
@@ -82,7 +82,7 @@ module SeleniumRecord
       end
 
       # Defines a lookup sequence relative to the title xpath
-      class LookupRelativeTitleStrategy < LookupStrategy
+      class RelativeTitleStrategy < LookupStrategy
         def run
           lookup_sequence do
             [title_locator, lookup_attributes[:locator]]
@@ -92,7 +92,7 @@ module SeleniumRecord
 
       # Defines a lookup sequence relative to the xpath of an element present in
       # the selenium object
-      class LookupRelativePathStrategy < LookupStrategy
+      class RelativePathStrategy < LookupStrategy
         def run
           lookup_sequence do
             [send("#{lookup_attributes[:to]}_locator"),
@@ -102,14 +102,14 @@ module SeleniumRecord
       end
 
       # Defines a lookup sequence matching an element path
-      class LookupMatchingStrategy < LookupStrategy
+      class MatchingStrategy < LookupStrategy
         def run
-          lookup_sequence { [lookup_attrs[:locator]] }
+          lookup_sequence { [lookup_attributes[:locator]] }
         end
       end
 
       # Defines a lookup sequence matching the whole document body
-      class LookupRootStrategy < LookupStrategy
+      class RootStrategy < LookupStrategy
         def run
           lookup_sequence { [{ xpath: '//body' }] }
         end

data/lib/selenium_record/version.rb

@@ -1,3 +1,3 @@
 module SeleniumRecord
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/selenium_record.gemspec

@@ -23,7 +23,7 @@ desc
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_runtime_dependency 'activesupport', '~> 4.1.8'
+  spec.add_runtime_dependency 'activesupport', '~> 3.2.0'
 
   spec.add_development_dependency 'bundler', '~> 1.6'
   spec.add_development_dependency 'cane', '~> 2.6.2'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: seleniumrecord
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - David Saenz Tagarro
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-16 00:00:00.000000000 Z
+date: 2014-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.1.8
+        version: 3.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.1.8
+        version: 3.2.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement