page_magic 2.0.0 → 2.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92b6df866c2bbcae9351e24417bf141c50101f96b74ce6a1225318998c30da9b
-  data.tar.gz: 2a605e1c74eda006717474066d6824806a20f35ca05ddeef75d684951ebea257
+  metadata.gz: 7cd51a69161a6e25593df1ee746057e38a23dbd5debcc5d22ea66cd0376df4c5
+  data.tar.gz: aea97edeac9689e324e7077fcd208091b5704bd2efb2cc6d62b9980d2f9f15cd
 SHA512:
-  metadata.gz: 773b643dcf348bd77718e53e924754dd47d23e2edc1bbc1c904a82d332a66b00f9d7285c409a91be37d7ecca27cdbb11f62d6b938ea47e7a9396a2dd97a724d3
-  data.tar.gz: 7864c97e2e3b196809835ad8a9d4ede8fd44a7ad84276a3bd06d72fb706b2400437ded32301f5e5bb299d13cbfbe2314d606c57fc1de809dfa396e3d8070de85
+  metadata.gz: 47914506ca6a1eaa24bacb0c83a0a8ff750bdf2a7a11bc5d3822218f75e9da0bca9a949b263d6beead2c549c740392ea431ff53bc1cc14cbae1b84b1426f8fea
+  data.tar.gz: 2a4c5ae39523e8835321d53ab463ca9d20fe9fe3ec0ddf0b30fb22fbf11d201f2be0e7642c337c4d4f4e9fd19a7cedc64a89d45bbee363296a05b9ead5e0bb51

data/Gemfile

@@ -8,9 +8,9 @@ gem 'capybara', '>=3.0'
 group :test do
   gem 'poltergeist'
   gem 'rspec', require: 'rspec/core/rake_task'
+  gem 'selenium-webdriver'
   gem 'simplecov', require: false
   gem 'sinatra'
-  gem 'watir'
 end
 
 group :development do

data/Gemfile.lock

@@ -144,9 +144,6 @@ GEM
     tzinfo (2.0.4)
       concurrent-ruby (~> 1.0)
     unicode-display_width (2.0.0)
-    watir (6.19.1)
-      regexp_parser (>= 1.2, < 3)
-      selenium-webdriver (>= 3.142.7)
     websocket-driver (0.7.3)
       websocket-extensions (>= 0.1.0)
     websocket-extensions (0.1.5)
@@ -169,9 +166,9 @@ DEPENDENCIES
   rubocop
   rubocop-rspec
   ruby-debug-ide
+  selenium-webdriver
   simplecov
   sinatra
-  watir
   yard (~> 0.8)
 
 BUNDLED WITH

data/README.md

@@ -56,6 +56,8 @@ Check it out :)
   - [Helper Methods](#helper-methods)
   - [Dynamic Selectors](#dynamic-selectors)
 - [Starting a session](#starting-a-session)
+  - [Using an existing session](#using-an-existing-session)
+  - [Rack applications and Rack::Test](#rack-applications-and-racktest)
 - [Page mapping](#page-mapping)
   - [Mapping against query string parameters](#mapping-against-query-string-parameters)
   - [Mapping against fragment identifiers](#mapping-against-fragment-identifiers)
@@ -325,9 +327,16 @@ session = PageMagic.session(browser: :chrome, url: 'https://www.github.com')
 ```
 
 Your session won't do much besides navigating to the given url until you have [mapped pages](#page-mapping) to it, so 
-take a look at this next! 
+take a look at this next!
 
 **Note** PageMagic supports having multiple sessions using different browsers at the same time :)
+
+## Using an existing session
+If you are introducing PageMagic in to a test suite that already makes use of Capybara, PageMagic can be configured to 
+make use of the session that is already configure like this:
+```ruby
+session = PageMagic.session(session: Capybara.current_session)
+```
  
 ## Rack applications and Rack::Test
 To run a session against a rack application instead of a live site, simply supply the rack application when creating 

data/VERSION

@@ -1 +1 @@
-2.0.0
+2.0.5

data/lib/page_magic.rb

@@ -50,16 +50,21 @@ module PageMagic
     # @param [Symbol] browser name of browser
     # @param [String] url url to start the session on
     # @param [Hash] options browser driver specific options
+    # @param [Capybara::Session] session - use you own already configure capybara session e.g. Capybara.current_session
     # @return [Session] configured session
-    def session(url: nil, application: nil, browser: :rack_test, options: {})
-      driver = drivers.find(browser)
-      raise UnsupportedBrowserException unless driver
+    def session(session: nil, url: nil, application: nil, browser: :rack_test, options: {})
+      session ||= begin
+        driver = drivers.find(browser)
+        raise UnsupportedBrowserException unless driver
 
-      Capybara.register_driver browser do |app|
-        driver.build(app, browser: browser, options: options)
+        Capybara.register_driver browser do |app|
+          driver.build(app, browser: browser, options: options)
+        end
+
+        Capybara::Session.new(browser, application)
       end
 
-      Session.new(Capybara::Session.new(browser, application), url)
+      Session.new(session, url)
     end
   end
 end

data/lib/page_magic/drivers/selenium.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 PageMagic::Drivers::Selenium = PageMagic::Driver.new(:chrome, :firefox) do |app, options, browser|
-  require 'watir'
+  require 'capybara/selenium/driver'
   Capybara::Selenium::Driver.new(app, **options.dup.merge(browser: browser))
 end

data/lib/page_magic/elements/config.rb

@@ -73,7 +73,9 @@ module PageMagic
       # Selector built using supplied configuration
       # @return [PageMagic::Element::Selector::Model]
       def selector
-        selector = self[:selector]
+        selector = self[:selector] || definition_class.selector
+        raise PageMagic::InvalidConfigurationException, INVALID_SELECTOR_MSG unless validate_selector?(selector)
+
         Element::Selector.find(selector.keys.first).build(type, selector.values.first, options: options)
       end
 
@@ -81,7 +83,6 @@ module PageMagic
       # @raise [PageMagic::InvalidConfigurationException]
       # @return [PageMagic::Elements::Config]
       def validate!
-        raise PageMagic::InvalidConfigurationException, INVALID_SELECTOR_MSG unless element || valid_selector?
         raise PageMagic::InvalidConfigurationException, 'element type required' unless type
         raise PageMagic::InvalidConfigurationException, INVALID_ELEMENT_CLASS_MSG unless valid_element_class?
 
@@ -90,8 +91,7 @@ module PageMagic
 
       private
 
-      def valid_selector?
-        selector = self[:selector]
+      def validate_selector?(selector)
         selector.is_a?(Hash) && !selector.empty?
       end
 

data/lib/page_magic/mapping.rb

@@ -3,7 +3,6 @@
 require_relative '../active_support/core_ext/object/to_query'
 require_relative 'comparator'
 
-
 module PageMagic
   # models mapping used to relate pages to uris
   class Mapping

data/lib/page_magic/session.rb

@@ -18,6 +18,8 @@ module PageMagic
     # Create a new session instance
     # @param [Object] capybara_session an instance of a capybara session
     # @param [String] base_url url to start the session at.
+    #
+
     def initialize(capybara_session, base_url = nil)
       @raw_session = capybara_session
       @base_url = base_url
@@ -32,16 +34,6 @@ module PageMagic
       @current_page
     end
 
-    # @return [String] path in the browser
-    def current_path
-      raw_session.current_path
-    end
-
-    # @return [String] full url in the browser
-    def current_url
-      raw_session.current_url
-    end
-
     # Map paths to Page classes. The session will auto load page objects from these mapping when
     # the {Session#current_path}
     # is matched.
@@ -54,26 +46,28 @@ module PageMagic
       @transitions = Transitions.new(transitions)
     end
 
-    #  execute javascript on the browser
-    #  @param [String] script the script to be executed
-    #  @return [Object] object returned by the capybara execute_script method
-    # @raise [NotSupportedException] if the capybara driver in use does not support execute script
-    def execute_script(script)
-      raw_session.execute_script(script)
-    rescue Capybara::NotSupportedByDriverError
-      raise NotSupportedException, UNSUPPORTED_OPERATION_MSG
+    def is_a?(klass)
+      return true if klass == Capybara::Session
+
+      super
     end
 
     # proxies unknown method calls to the currently loaded page object
     # @return [Object] returned object from the page object method call
     def method_missing(name, *args, &block)
+      return raw_session.send(name, *args, &block) if raw_session.respond_to?(name)
+
       current_page.send(name, *args, &block)
     end
 
+    def on?(page_class)
+      current_page.is_a?(page_class)
+    end
+
     # @param args see {::Object#respond_to?}
     # @return [Boolean] true if self or the current page object responds to the give method name
     def respond_to_missing?(*args)
-      super || current_page.respond_to?(*args)
+      super || current_page.respond_to?(*args) || raw_session.respond_to?(*args)
     end
 
     # Direct the browser to the given page or url. {Session#current_page} will be set be an instance of the given/mapped
@@ -89,13 +83,14 @@ module PageMagic
     # @raise [InvalidURLException] if a page is supplied and there isn't a mapped path for it
     # @raise [InvalidURLException] if neither a page or url are supplied
     # @raise [InvalidURLException] if the mapped path for a page is a Regexp
-    def visit(page = nil, url: nil)
-      url ||= transitions.url_for(page, base_url: base_url)
+    # @return [PageMagic::Session] - returns self
+    def visit(page_or_url = nil, url: nil)
+      url ||= page_or_url.is_a?(String) ? page_or_url : transitions.url_for(page_or_url, base_url: base_url)
 
       raise InvalidURLException, URL_MISSING_MSG unless url
 
       raw_session.visit(url)
-      @current_page = initialize_page(page) if page
+      @current_page = initialize_page(page_or_url) unless page_or_url.is_a?(String)
       self
     end
 

data/spec/page_magic/elements/config_spec.rb

@@ -59,6 +59,24 @@ RSpec.describe PageMagic::Elements::Config do
           expect(options.selector).to eq(PageMagic::Element::Selector.find(:id).build(:field, 'child'))
         end
 
+        context 'when is empty hash' do
+          it 'raises an error' do
+            options = described_class.build([{}], :field)
+            expect { options.selector }.to raise_exception(PageMagic::InvalidConfigurationException,
+                                                           described_class::INVALID_SELECTOR_MSG)
+          end
+        end
+
+        context 'when defined on both class and as parameter' do
+          it 'uses the supplied selector' do
+            options = described_class.build([{ css: 'supplied_selector' }], :field)
+            options.definition_class = Class.new(PageMagic::Element) do
+              selector css: 'class_selector'
+            end
+            expect(options.selector).to eq(PageMagic::Element::Selector.find(:css).build(:field, 'supplied_selector'))
+          end
+        end
+
         context 'when page_element class supplied' do
           it 'uses the selector on the class' do
             expected_selector = { css: 'class' }
@@ -91,6 +109,29 @@ RSpec.describe PageMagic::Elements::Config do
           end
         end
       end
+
+      context 'when no selector on class or page_element' do
+        context 'when dynamically assigned element definition block' do
+          it 'uses it' do
+            options = described_class.build([], :field)
+
+            options.definition_class = Class.new(PageMagic::Element) do
+              selector({ css: 'class' })
+            end
+
+            expect(options.selector).to eq(PageMagic::Element::Selector.find(:css).build(:field, 'class'))
+          end
+        end
+
+        context 'when not dynamically assigned' do
+          it 'raises and exception' do
+            options = described_class.build([], :field)
+            options.definition_class = Class.new(PageMagic::Element)
+            expect { options.selector }.to raise_exception(PageMagic::InvalidConfigurationException,
+                                                           described_class::INVALID_SELECTOR_MSG)
+          end
+        end
+      end
     end
 
     it 'sets prefetched options' do
@@ -119,44 +160,6 @@ RSpec.describe PageMagic::Elements::Config do
       }
     end
 
-    describe 'selector' do
-      context 'when nil' do
-        context 'and prefetched `element` is nil' do
-          it 'raise an error' do
-            subject = described_class.new(options.except(:selector, :element))
-            expect { subject.validate! }.to raise_exception(PageMagic::InvalidConfigurationException,
-                                                            described_class::INVALID_SELECTOR_MSG)
-          end
-        end
-
-        context 'when `element` is not nil' do
-          it 'does not raise an error' do
-            subject = described_class.new(options.except(:selector))
-            expect { subject.validate! }.not_to raise_exception
-          end
-        end
-      end
-
-      context 'when is empty hash' do
-        it 'raises an error' do
-          subject = described_class.new(options.update(selector: {}).except(:element))
-          expect { subject.validate! }.to raise_exception(PageMagic::InvalidConfigurationException,
-                                                          described_class::INVALID_SELECTOR_MSG)
-        end
-      end
-
-      context 'when defined on both class and as parameter' do
-        it 'uses the supplied selector' do
-          element_class = Class.new(PageMagic::Element) do
-            selector css: 'selector'
-          end
-
-          subject = described_class.new(options.update(element_class: element_class))
-          expect { subject.validate! }.not_to raise_exception
-        end
-      end
-    end
-
     context 'when type nil' do
       it 'raise an error' do
         subject = described_class.new(options.except(:type))

data/spec/page_magic/session_spec.rb

@@ -40,20 +40,6 @@ RSpec.describe PageMagic::Session do
     end
   end
 
-  describe '#current_path' do
-    it "returns the browser's current path" do
-      browser.visit('/url')
-      expect(session.current_path).to eq(browser.current_path)
-    end
-  end
-
-  describe '#current_url' do
-    it "returns the browser's current url" do
-      browser.visit('/url')
-      expect(session.current_url).to eq(session.current_url)
-    end
-  end
-
   describe '#define_page_mappings' do
     context 'when the mapping includes a literal' do
       it 'creates a matcher to contain the specification' do
@@ -71,22 +57,6 @@ RSpec.describe PageMagic::Session do
     end
   end
 
-  describe '#execute_script' do
-    it 'calls the execute script method on the capybara session' do
-      allow(browser).to receive(:execute_script).with(:script).and_return(:result)
-      expect(session.execute_script(:script)).to be(:result)
-    end
-
-    context 'when the Capybara session does not support #execute_script' do
-      let(:browser) { Capybara::Driver::Base.new }
-
-      it 'raises an error' do
-        expected_message = described_class::UNSUPPORTED_OPERATION_MSG
-        expect { session.execute_script(:script) }.to raise_error(PageMagic::NotSupportedException, expected_message)
-      end
-    end
-  end
-
   describe '#method_missing' do
     before do
       page.class_eval do
@@ -100,6 +70,21 @@ RSpec.describe PageMagic::Session do
       session = described_class.new(browser).visit(page, url: 'http://base.url')
       expect(session.my_method).to be(:called)
     end
+
+    context 'when method not on current page' do
+      it 'delegates to the capybara session' do
+        session = described_class.new(browser).visit(page, url: 'http://base.url')
+        expect(session).to have_text('ok')
+      end
+    end
+  end
+
+  describe '#is_a?' do
+    context 'when other is a `Capybara::Session`' do
+      it 'returns true' do
+        expect(described_class.new(browser).is_a?(Capybara::Session)).to eq(true)
+      end
+    end
   end
 
   describe '#respond_to?' do
@@ -123,6 +108,13 @@ RSpec.describe PageMagic::Session do
         expect(session.respond_to?(:my_method)).to eq(true)
       end
     end
+
+    context 'when method not on self or the current page' do
+      it 'checks the capybara session' do
+        session = described_class.new(browser)
+        expect(session).to respond_to(:has_text?)
+      end
+    end
   end
 
   describe '#visit' do
@@ -154,10 +146,17 @@ RSpec.describe PageMagic::Session do
       end
     end
 
+    context 'when a page and `:url` supplied' do
+      it 'uses the url' do
+        session.visit(page, url: 'http://other.url/')
+        expect(session.current_url).to eq('http://other.url/')
+      end
+    end
+
     context 'when `url` is supplied' do
       it 'visits that url' do
         expected_url = 'http://base.url/page'
-        session.visit(url: expected_url)
+        session.visit(expected_url)
         expect(browser.current_url).to eq(expected_url)
       end
     end

data/spec/page_magic_spec.rb

@@ -89,6 +89,13 @@ RSpec.describe PageMagic do
       end
     end
 
+    context 'when `session` is specified' do
+      it 'uses it' do
+        session = described_class.session(session: :custom_session)
+        expect(session.raw_session).to be(:custom_session)
+      end
+    end
+
     context 'when `:options` is specified' do
       it 'passes the options to the browser driver' do
         options = { option: :config }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: page_magic
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.5
 platform: ruby
 authors:
 - Leon Davis
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-07-01 00:00:00.000000000 Z
+date: 2021-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport