page_navigation 0.9 → 0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4ebc2cb244eb336736f35d2bebd8ffe53070dd32
-  data.tar.gz: f04fc258fdb71e36343d247700258ad9da77cb40
+  metadata.gz: 26e978842cccf0452d958bb6a2c7efd0fc095e57
+  data.tar.gz: 0c3c880153a5a05a23c8e6687d3942972c14b11d
 SHA512:
-  metadata.gz: f78f9d41851504fe576f033be34342b8d936449fd5a7460b064d353e22ecaedfbc3224391bf0c2e90928a73a1d98d72062413cd85fd66cef501a65cb4d48a124
-  data.tar.gz: d1d31040c6989a4d0a6029caa6f450a1a0363eed048984ae2c5a41c8b0d2685d639d71efd3d575476dcefcdefe3cc63c5a27cfc54bf7ba1f02b65623499927bf
+  metadata.gz: b20c38f047c3d17a3fd4175b0eb5b5a6effa3f2f9459f04a0c5bbe977b87ca348b613a285f4d3be0a44d30686ad40fec39a226b6ffbcf1d4401809c3648d2ec9
+  data.tar.gz: 968fdf507da0d612bb1d7ed1cd4a2359bc39b10d7dd75e0f9868abf2b89ebbec61ccd030f2b8068991c2aa03be0ca48dece92dfe22ff132f771d577b5c061942

data/.gitignore

@@ -3,6 +3,7 @@
 .bundle
 .config
 .yardoc
+.idea
 Gemfile.lock
 InstalledFiles
 _yardoc

data/ChangeLog

@@ -1,3 +1,7 @@
+=== Version 0.10 / 2016-10-18
+* Improved error message when navigation methods are undefined
+* Added optional 'visit' argument to navigate_to and navigate_all to visit first page (Thanks sciros)
+
 === Version 0.9 / 2013-05-03
 * Added :from entry to navigate_to method call
 

data/lib/page_navigation.rb

@@ -7,7 +7,7 @@ require 'data_magic'
 # that implement a PageObject like pattern.
 #
 # In order to use these two methods you must define routes.  A route
-# is cimply an array of Class/Method calls and can contain parameters
+# is simply an array of Class/Method calls and can contain parameters
 # that can be passed to the methods.  Here is an example:
 #
 # @example Example routes defined in env.rb
@@ -47,22 +47,24 @@ module PageNavigation
   #   page.navigate_to(PageThree)  # will use the default path
   #   page.navigate_to(PageThree, :using => :another_route)
   #
-  # @param [PageObject]  a class that implements the PageObject pattern.
-  # @param [Hash] a hash that contains an element with the key
+  # @param [PageObject] page_cls a class that implements the PageObject pattern.
+  # @param [Hash] how a hash that contains two elements. One with the key
   # :using.  This will be used to lookup the route.  It has a
-  # default value of :default.
-  # @param [block]  an optional block to be called
+  # default value of :default. The other is with the key :visit. This specifies
+  # whether to explicitly visit the first page. It has a default value of false.
+  # @param [block] block an optional block to be called
   # @return [PageObject] the page you are navigating to
   #
-  def navigate_to(page_cls, how = {:using => :default}, &block)
+  def navigate_to(page_cls, how = {:using => :default, :visit => false}, &block)
     how[:using] = :default unless how[:using]
+    how[:visit] = false unless how[:visit]
     path = path_for how
     to_index = find_index_for(path, page_cls)-1
     if to_index == -1
       return on(page_cls, &block)
     else
       start = how[:from] ? path.find_index { |entry| entry[0] == how[:from] } : 0
-      navigate_through_pages(path[start..to_index])
+      navigate_through_pages(path[start..to_index], how[:visit])
     end
     on(page_cls, &block)
   end
@@ -71,11 +73,11 @@ module PageNavigation
   # Same as navigate_to except it will start at the @current_page
   # instead the beginning of the path.
   #
-  # @param [PageObject]  a class that implements the PageObject pattern.
-  # @param [Hash] a hash that contains an element with the key
+  # @param [PageObject] page_cls a class that implements the PageObject pattern.
+  # @param [Hash] how a hash that contains an element with the key
   # :using.  This will be used to lookup the route.  It has a
   # default value of :default.
-  # @param [block]  an optional block to be called
+  # @param [block] block an optional block to be called
   # @return [PageObject] the page you are navigating to
   #
   def continue_navigation_to(page_cls, how = {:using => :default}, &block)
@@ -83,9 +85,9 @@ module PageNavigation
     from_index = find_index_for(path, @current_page.class)
     to_index = find_index_for(path, page_cls)-1
     if from_index == to_index
-      navigate_through_pages([path[from_index]]) 
+      navigate_through_pages([path[from_index]], false)
     else
-      navigate_through_pages(path[from_index..to_index]) 
+      navigate_through_pages(path[from_index..to_index], false)
     end
     on(page_cls, &block)
   end
@@ -101,13 +103,14 @@ module PageNavigation
   #   page.navigate_all  # will use the default path
   #   page.navigate_all(:using => :another_route)
   #
-  # @param [Hash] a hash that contains an element with the key
+  # @param [Hash] how a hash that contains two elements. One with the key
   # :using.  This will be used to lookup the route.  It has a
-  # default value of :default.
+  # default value of :default. The other is with the key :visit. This specifies
+  # whether to explicitly visit the first page. It has a default value of false.
   #
-  def navigate_all(how = {:using => :default})
+  def navigate_all(how = {:using => :default, :visit => false})
     path = path_for how
-    navigate_through_pages(path[0..-1])
+    navigate_through_pages(path[0..-1], how[:visit])
   end
   
   private
@@ -122,10 +125,11 @@ module PageNavigation
     path
   end
   
-  def navigate_through_pages(pages)
+  def navigate_through_pages(pages, visit)
     pages.each do |cls, method, *args|
-      page = on(cls)
-      fail("Navigation method not specified on #{cls}.") unless page.respond_to? method
+      page = visit ? visit(cls) : on(cls)
+      visit = false # visit once, for just the first page
+      fail("Navigation method '#{method}' not defined on #{cls}.") unless page.respond_to? method
       page.send method unless args
       page.send method, *args if args
     end

data/lib/page_navigation/routes.rb

@@ -6,7 +6,7 @@ module PageNavigation
     end
     
     def routes=(routes)
-      raise("You must provide a :default route") unless routes[:default]
+      raise('You must provide a :default route') unless routes[:default]
       @routes = routes
     end
 

data/lib/page_navigation/version.rb

@@ -1,3 +1,3 @@
 module PageNavigation
-  VERSION = "0.9"
+  VERSION = '0.10'
 end

data/page_navigation.gemspec

@@ -4,24 +4,23 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'page_navigation/version'
 
 Gem::Specification.new do |gem|
-  gem.name          = "page_navigation"
+  gem.name          = 'page_navigation'
   gem.version       = PageNavigation::VERSION
   gem.platform      = Gem::Platform::RUBY
-  gem.authors       = ["Jeffrey S. Morgan"]
-  gem.email         = ["jeff.morgan@leandog.com"]
-  gem.homepage      = "http://github.com/cheezy/page_navigation"
+  gem.authors       = ['Jeffrey S. Morgan','Dmitry Sharkov']
+  gem.email         = ['jeff.morgan@leandog.com']
+  gem.homepage      = 'http://github.com/cheezy/page_navigation'
   gem.description   = %q{Provides basic navigation through a collection of items that use the PageObject pattern.}
   gem.summary       = %q{Provides basic navigation through a collection of items that use the PageObject pattern.}
 
-  gem.rubyforge_project = "page_naigation"
+  gem.rubyforge_project = 'page_navigation'
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.require_paths = ["lib"]
+  gem.require_paths = ['lib']
 
-  gem.add_dependency 'data_magic', '>= 0.14'
+  gem.add_dependency 'data_magic', '>= 0.22'
   
-  gem.add_development_dependency 'rspec', '>= 2.12.0'
-
+  gem.add_development_dependency 'rspec', '>= 3.4.0'
 end

data/spec/lib/page_navigation_spec.rb

@@ -1,22 +1,28 @@
 require 'spec_helper'
 
-class FactoryTestPage
+class FirstPage
 end
 
-class AnotherPage
+class MiddlePage
 end
 
-class YetAnotherPage
+class LastPage
 end
 
 class TestNavigator
   include PageNavigation
   attr_accessor :current_page
 
-  def on(cls)
+  def on(cls) #placeholder for PageFactory's on_page (alias 'on')
     cls.new
   end
 
+  def visit(cls) #placeholder for PageFactory's visit_page (alias 'visit')
+    page_instance = cls.new
+    page_instance.visit
+    page_instance
+  end
+
   def class_from_string(str)
     str.split('::').inject(Object) do |mod, class_name|
       mod.const_get(class_name)
@@ -27,137 +33,178 @@ end
 describe PageNavigation do
   before(:each) do
     @navigator = TestNavigator.new
-    DataMagic.stub(:load)
+    allow(DataMagic).to receive(:load)
   end
 
-  it "should raise an error when you do not provide a default route" do
-    expect { TestNavigator.routes = {:another => []} }.to raise_error
+  it 'should raise an error when you do not provide a default route' do
+    expect { TestNavigator.routes = {:another => []} }.to raise_error 'You must provide a :default route'
   end
 
-  it "should store the routes" do
-    routes = ['a', 'b', 'c']
+  it 'should store the routes' do
+    routes = %w(a b c)
     TestNavigator.routes = {:default => routes}
-    TestNavigator.routes[:default].should == routes
+    expect(TestNavigator.routes[:default]).to be routes
   end
 
-  it "should store route data" do
+  it 'should store route data' do
     TestNavigator.route_data = {:default => :blah}
-    TestNavigator.route_data.should == {:default => :blah}
+    expect(TestNavigator.route_data).to eq ({:default => :blah})
   end
 
-  it "should navigate to a page calling the default methods" do
-    pages = [[FactoryTestPage, :a_method], [AnotherPage, :b_method]]
+  it 'should navigate to a page calling the default methods' do
+    pages = [[FirstPage, :a_method], [MiddlePage, :b_method]]
     TestNavigator.routes = {:default => pages}
-    fake_page = double('a_page')
-    FactoryTestPage.should_receive(:new).and_return(fake_page)
-    fake_page.should_receive(:a_method)
-    @navigator.navigate_to(AnotherPage).class.should == AnotherPage
+    fake_page = double('middle_page')
+    expect(FirstPage).to receive(:new).and_return(fake_page)
+    expect(fake_page).to receive(:a_method)
+    expect(@navigator.navigate_to(MiddlePage).class).to be MiddlePage
   end
 
-  it "should load the DataMagic file when specified" do
-    pages = [[FactoryTestPage, :a_method], [AnotherPage, :b_method]]
+  it 'should load the DataMagic file when specified' do
+    pages = [[FirstPage, :a_method], [MiddlePage, :b_method]]
     TestNavigator.routes = {:default => pages}
     TestNavigator.route_data = {:default => :dm_file}
-    fake_page = double('a_page')
-    FactoryTestPage.should_receive(:new).and_return(fake_page)
-    fake_page.should_receive(:a_method)
-    DataMagic.should_receive(:load).with('dm_file.yml')
-    @navigator.navigate_to(AnotherPage).class.should == AnotherPage
+    fake_page = double('middle_page')
+    expect(FirstPage).to receive(:new).and_return(fake_page)
+    expect(fake_page).to receive(:a_method)
+    expect(DataMagic).to receive(:load).with('dm_file.yml')
+    expect(@navigator.navigate_to(MiddlePage).class).to be MiddlePage
   end
 
-  it "should pass parameters to methods when navigating" do
-    pages = [[FactoryTestPage, :a_method, 'blah'], [AnotherPage, :b_method]]
+  it 'should pass parameters to methods when navigating' do
+    pages = [[FirstPage, :a_method, 'blah'], [MiddlePage, :b_method]]
     TestNavigator.routes = {:default => pages}
-    fake_page = double('a_page')
-    FactoryTestPage.should_receive(:new).and_return(fake_page)
-    fake_page.should_receive(:a_method).with('blah')
-    @navigator.navigate_to(AnotherPage).class.should == AnotherPage
+    fake_page = double('middle_page')
+    expect(FirstPage).to receive(:new).and_return(fake_page)
+    expect(fake_page).to receive(:a_method).with('blah')
+    expect(@navigator.navigate_to(MiddlePage).class).to be MiddlePage
   end
 
-  it "should fail when it does not find a proper route" do
+  it 'should fail when it does not find a proper route' do
     TestNavigator.routes = {:default => ['a'], :another => ['b']}
-    expect { @navigator.navigate_to(AnotherPage, :using => :no_route) }.to raise_error
+    expect { @navigator.navigate_to(MiddlePage, :using => :no_route) }.to raise_error
   end
 
-  it "should fail when no default method specified" do
+  it 'should fail when no default method specified' do
     TestNavigator.routes = {
-      :default => [[FactoryTestPage, :a_method], [AnotherPage, :b_method]]
+      :default => [[FirstPage, :a_method], [MiddlePage, :b_method]]
     }
-    fake_page = double('a_page')
-    FactoryTestPage.should_receive(:new).and_return(fake_page)
-    fake_page.should_receive(:respond_to?).with(:a_method).and_return(false)
-    expect { @navigator.navigate_to(AnotherPage) }.to raise_error
+    fake_page = double('middle_page')
+    expect(FirstPage).to receive(:new).and_return(fake_page)
+    expect(fake_page).to receive(:respond_to?).with(:a_method).and_return(false)
+    expect { @navigator.navigate_to(MiddlePage) }.to raise_error
   end
 
-  it "should know how to continue routng from a location" do
-    TestNavigator.routes = {
-      :default => [[FactoryTestPage, :a_method],
-                   [AnotherPage, :b_method],
-                   [YetAnotherPage, :c_method]]
-    }
-    @navigator.current_page = FactoryTestPage.new
-    f_page = FactoryTestPage.new
-    a_page = AnotherPage.new
-    FactoryTestPage.should_receive(:new).and_return(f_page)
-    f_page.should_receive(:respond_to?).with(:a_method).and_return(true)
-    f_page.should_receive(:a_method)
-    AnotherPage.should_receive(:new).and_return(a_page)
-    a_page.should_receive(:respond_to?).with(:b_method).and_return(true)
-    a_page.should_receive(:b_method)
-    @navigator.continue_navigation_to(YetAnotherPage).class.should == YetAnotherPage
-  end
-
-  it "should know how to continue routng from a location that is one page from the end" do
-    TestNavigator.routes = {
-      :default => [[FactoryTestPage, :a_method],
-                   [AnotherPage, :b_method],
-                   [YetAnotherPage, :c_method]]
-    }
-    @navigator.current_page = FactoryTestPage.new
-    f_page = FactoryTestPage.new
-    FactoryTestPage.should_receive(:new).and_return(f_page)
-    f_page.should_receive(:respond_to?).with(:a_method).and_return(true)
-    f_page.should_receive(:a_method)
-    a_page = AnotherPage.new
-    AnotherPage.should_receive(:new).and_return(a_page)
-    a_page.should_receive(:respond_to?).with(:b_method).and_return(true)
-    a_page.should_receive(:b_method)
-    @navigator.continue_navigation_to(YetAnotherPage).class.should == YetAnotherPage
-  end
-
-  it "should know how to navigate an entire route including the last page" do
-    TestNavigator.routes = {
-      :default => [[FactoryTestPage, :a_method],
-                   [AnotherPage, :b_method],
-                   [YetAnotherPage, :c_method]]
-    }
-    f_page = FactoryTestPage.new
-    a_page = AnotherPage.new
-    y_page = YetAnotherPage.new
-    FactoryTestPage.should_receive(:new).and_return(f_page)
-    f_page.should_receive(:respond_to?).with(:a_method).and_return(true)
-    f_page.should_receive(:a_method)
-    AnotherPage.should_receive(:new).and_return(a_page)
-    a_page.should_receive(:respond_to?).with(:b_method).and_return(true)
-    a_page.should_receive(:b_method)
-    YetAnotherPage.should_receive(:new).and_return(y_page)
-    y_page.should_receive(:respond_to?).with(:c_method).and_return(true)
-    y_page.should_receive(:c_method)
+  it 'should know how to continue routing from a location' do
+    first_page, middle_page, last_page = mock_common_method_calls
+
+    @navigator.current_page = FirstPage.new
+    
+    expect(first_page).to receive(:a_method)
+    expect(middle_page).to receive(:b_method)
+
+    expect(@navigator.continue_navigation_to(LastPage).class).to be LastPage
+  end
+
+  it 'should know how to continue routing from a location that is one page from the end' do
+    first_page, middle_page, last_page = mock_common_method_calls
+
+    @navigator.current_page = MiddlePage.new
+
+    expect(first_page).not_to receive(:a_method)
+    expect(middle_page).to receive(:b_method)
+
+    expect(@navigator.continue_navigation_to(LastPage).class).to be LastPage
+  end
+
+  it 'should know how to navigate an entire route including the last page' do
+    first_page, middle_page, last_page = mock_common_method_calls
+
+    expect(first_page).to receive(:a_method)
+    expect(middle_page).to receive(:b_method)
+    expect(last_page).to receive(:c_method)
+
     @navigator.navigate_all
   end
 
-  it "should be able to start in the middle of a route and proceed" do
-    TestNavigator.routes = {
-      :default => [[FactoryTestPage, :a_method],
-                   [AnotherPage, :b_method],
-                   [YetAnotherPage, :c_method]]
-    }
-    a_page = AnotherPage.new
-    y_page = YetAnotherPage.new
-    AnotherPage.should_receive(:new).and_return(a_page)
-    a_page.should_receive(:respond_to?).with(:b_method).and_return(true)
-    a_page.should_receive(:b_method)
-    YetAnotherPage.should_receive(:new).and_return(y_page)
-    @navigator.navigate_to(YetAnotherPage, :from => AnotherPage)
+  it 'should be able to start in the middle of a route and proceed' do
+    first_page, middle_page, last_page = mock_common_method_calls
+
+    expect(first_page).not_to receive(:a_method)
+    expect(middle_page).to receive(:b_method)
+
+    @navigator.navigate_to(LastPage, :from => MiddlePage)
+  end
+
+  it 'should visit page at start of route given visit param set to true' do
+    first_page, middle_page, last_page = mock_common_method_calls
+
+    expect(first_page).to receive(:visit)
+    expect(first_page).to receive(:a_method)
+    expect(middle_page).to receive(:b_method)
+    expect(middle_page).not_to receive(:visit)
+
+    @navigator.navigate_to(LastPage, visit: true)
+  end
+
+  it 'should not visit page at start of route given visit param set to false (explicit)' do
+    first_page, middle_page, last_page = mock_common_method_calls
+
+    expect(first_page).not_to receive(:visit)
+    expect(first_page).to receive(:a_method)
+    expect(middle_page).to receive(:b_method)
+
+    @navigator.navigate_to(LastPage, visit: false)
   end
+
+  it 'should not visit page at start of route given visit param set to false (default)' do
+    first_page, middle_page, last_page = mock_common_method_calls
+
+    expect(first_page).not_to receive(:visit)
+    expect(first_page).to receive(:a_method)
+    expect(middle_page).to receive(:b_method)
+
+    @navigator.navigate_to(LastPage)
+  end
+
+  it 'should handle specification of both using and visit params' do
+    first_page, middle_page, last_page = mock_common_method_calls
+
+    expect(first_page).to receive(:respond_to?).with(:x_method).at_least(:once).and_return(true)
+    expect(first_page).to receive(:visit)
+    expect(first_page).to receive(:x_method)
+    expect(middle_page).to receive(:respond_to?).with(:y_method).at_least(:once).and_return(true)
+    expect(middle_page).to receive(:y_method)
+    expect(middle_page).not_to receive(:visit)
+
+    @navigator.navigate_to(LastPage, visit: true, using: :alt)
+  end
+end
+
+def mock_common_method_calls
+  TestNavigator.routes = {
+      :default => [[FirstPage, :a_method],
+                   [MiddlePage, :b_method],
+                   [LastPage, :c_method]],
+      :alt => [[FirstPage, :x_method],
+               [MiddlePage, :y_method],
+               [LastPage, :z_method]]
+  }
+
+  first_page = FirstPage.new
+  allow(FirstPage).to receive(:new).and_return(first_page)
+  allow(first_page).to receive(:respond_to?).with(:visit).and_return(true)
+  allow(first_page).to receive(:respond_to?).with(:a_method).and_return(true)
+
+  middle_page = MiddlePage.new
+  allow(MiddlePage).to receive(:new).and_return(middle_page)
+  allow(middle_page).to receive(:respond_to?).with(:visit).and_return(true)
+  allow(middle_page).to receive(:respond_to?).with(:b_method).and_return(true)
+
+  last_page = LastPage.new
+  allow(LastPage).to receive(:new).and_return(last_page)
+  allow(last_page).to receive(:respond_to?).with(:visit).and_return(true)
+  allow(last_page).to receive(:respond_to?).with(:c_method).and_return(true)
+
+  return first_page, middle_page, last_page
 end

metadata

@@ -1,43 +1,44 @@
 --- !ruby/object:Gem::Specification
 name: page_navigation
 version: !ruby/object:Gem::Version
-  version: '0.9'
+  version: '0.10'
 platform: ruby
 authors:
 - Jeffrey S. Morgan
+- Dmitry Sharkov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-03 00:00:00.000000000 Z
+date: 2016-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: data_magic
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.14'
+        version: '0.22'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.14'
+        version: '0.22'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.12.0
+        version: 3.4.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.12.0
+        version: 3.4.0
 description: Provides basic navigation through a collection of items that use the
   PageObject pattern.
 email:
@@ -46,10 +47,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .ruby-gemset
-- .ruby-version
+- ".gitignore"
+- ".rspec"
+- ".ruby-gemset"
+- ".ruby-version"
 - ChangeLog
 - Gemfile
 - Guardfile
@@ -71,17 +72,17 @@ 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: '0'
 requirements: []
-rubyforge_project: page_naigation
-rubygems_version: 2.0.0
+rubyforge_project: page_navigation
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Provides basic navigation through a collection of items that use the PageObject