page_magic 1.0.0.alpha13 → 1.0.0.alpha17

data/lib/page_magic/session.rb

@@ -1,15 +1,17 @@
 require 'wait'
 module PageMagic
-  class InvalidURLException < Exception;end
+  class InvalidURLException < Exception
+  end
 
   class Session
-    URL_MISSING_MSG = 'a url must be specified as either a parameter or on the page class'
+    URL_MISSING_MSG = 'a path must be mapped or a url supplied'
     REGEXP_MAPPING_MSG = 'URL could not be derived because mapping is a Regexp'
 
-    attr_accessor :current_page, :raw_session, :transitions
+    attr_reader :raw_session, :transitions
 
-    def initialize(browser)
+    def initialize(browser, url = nil)
       @raw_session = browser
+      raw_session.visit(url) if url
       @transitions = {}
     end
 
@@ -17,44 +19,30 @@ module PageMagic
       @transitions = transitions
     end
 
-
     def current_page
-      if transitions
-        mapping = find_mapped_page(current_path)
-        @current_page = mapping.new(self) if mapping
-      end
+      mapping = find_mapped_page(current_path)
+      @current_page = mapping.new(self) if mapping
       @current_page
     end
 
-    def find_mapped_page(path)
-      mapping = transitions.keys.find do |key|
-        string_matches?(path, key)
-      end
-      transitions[mapping]
-    end
-
-
-
-    def visit(page_or_url, url:nil)
-      if page_or_url.is_a?(String)
-        raw_session.visit page_or_url
-      elsif page_or_url.ancestors.include?(PageMagic)
-        page = page_or_url
-        if url
-          raw_session.visit(url)
-        elsif page.url
-          raw_session.visit(page.url)
-        elsif path = transitions.key(page)
-          raise InvalidURLException, REGEXP_MAPPING_MSG if path.is_a?(Regexp)
-          raw_session.visit("#{current_url}#{path}")
-        else
-          raise InvalidURLException, URL_MISSING_MSG
-        end
-        @current_page = page.new self
+    def visit(page = nil, url: nil)
+      if url
+        raw_session.visit(url)
+      elsif (path = transitions.key(page))
+        fail InvalidURLException, REGEXP_MAPPING_MSG if path.is_a?(Regexp)
+        raw_session.visit(url(current_url, path))
+      else
+        fail InvalidURLException, URL_MISSING_MSG
       end
+      @current_page = page.new(self) if page
       self
     end
 
+    def url(base_url, path)
+      path = path.sub(%r{^/}, '')
+      base_url = base_url.sub(%r{/$}, '')
+      "#{base_url}/#{path}"
+    end
 
     def current_path
       raw_session.current_path
@@ -66,7 +54,7 @@ module PageMagic
 
     def wait_until(&block)
       @wait ||= Wait.new
-      @wait.until &block
+      @wait.until(&block)
     end
 
     def method_missing(name, *args, &block)
@@ -77,6 +65,13 @@ module PageMagic
       super || current_page.respond_to?(*args)
     end
 
+    def find_mapped_page(path)
+      mapping = transitions.keys.find do |key|
+        string_matches?(path, key)
+      end
+      transitions[mapping]
+    end
+
     private
 
     def string_matches?(string, matcher)

data/lib/page_magic.rb

@@ -11,12 +11,23 @@ require 'page_magic/drivers'
 module PageMagic
   class UnspportedBrowserException < Exception; end
 
+  module ClassMethods
+    def url(url = nil)
+      @url = url if url
+      @url
+    end
+
+    def inherited(clazz)
+      clazz.element_definitions.merge!(element_definitions)
+    end
+  end
+
   class << self
     def drivers
       @drivers ||= Drivers.new.tap(&:load)
     end
 
-    def session(application: nil, browser: :rack_test, options: {})
+    def session(application: nil, browser: :rack_test, url:, options: {})
       driver = drivers.find(browser)
       fail UnspportedBrowserException unless driver
 
@@ -24,28 +35,11 @@ module PageMagic
         driver.build(app, browser: browser, options: options)
       end
 
-      Session.new(Capybara::Session.new(browser, application))
+      Session.new(Capybara::Session.new(browser, application), url)
     end
 
     def included(clazz)
-      clazz.extend Elements
-      pages << clazz if clazz.is_a? Class
-
-      class << clazz
-        def url(url = nil)
-          @url = url if url
-          @url
-        end
-
-        def inherited(clazz)
-          clazz.element_definitions.merge!(element_definitions)
-          PageMagic.pages << clazz
-        end
-      end
-    end
-
-    def pages
-      @pages ||= []
+      clazz.extend(Elements, ClassMethods)
     end
   end
 end

data/spec/element_spec.rb

@@ -1,8 +1,7 @@
+# rubocop:disable Metrics/ModuleLength
 module PageMagic
-
   describe Element do
-
-    include_context :webapp
+    include_context :webapp_fixture
 
     let(:page_class) do
       Class.new do
@@ -12,13 +11,10 @@ module PageMagic
     end
 
     let(:page) do
-      page_class.new.tap do |page|
-        page.visit
-      end
+      page_class.new.tap(&:visit)
     end
 
     describe 'inheriting' do
-
       it 'lets you create custom elements' do
         custom_element = Class.new(described_class) do
           text_field :form_field, id: 'field_id'
@@ -29,7 +25,7 @@ module PageMagic
         end
 
         page_class.class_eval do
-          section custom_element, css: '.form'
+          element custom_element, css: '.form'
         end
 
         expect(page.form.form_field).to be_visible
@@ -37,7 +33,8 @@ module PageMagic
     end
 
     it 'should raise an error if a selector has not been specified' do
-      expect { described_class.new(:name, Object.new, type: :element).browser_element }.to raise_error(PageMagic::UndefinedSelectorException)
+      page_element = described_class.new(:name, Object.new, type: :element)
+      expect { page_element.browser_element }.to raise_error(PageMagic::UndefinedSelectorException)
     end
 
     describe '#respond_to?' do
@@ -64,59 +61,82 @@ module PageMagic
 
       context 'options supplied to selector' do
         it 'passes them on to the cappybara finder method' do
-          options = {count: 1}
+          options = { count: 1 }
           xpath_selector = '//div/input'
           expect(Capybara.current_session).to receive(:find).with(:xpath, xpath_selector, options)
-          described_class.new(:my_input, page, type: :text_field, selector: {xpath: xpath_selector}.merge(options)).browser_element
+          described_class.new(:my_input,
+                              page,
+                              type: :text_field,
+                              selector: { xpath: xpath_selector }.merge(options)).browser_element
         end
       end
 
       it 'should find by xpath' do
-        element = described_class.new(:my_input, page, type: :text_field, selector: {xpath: '//div/label/input'}).browser_element
+        element = described_class.new(:my_input,
+                                      page,
+                                      type: :text_field,
+                                      selector: { xpath: '//div/label/input' }).browser_element
         expect(element.value).to eq('filled in')
       end
 
       it 'should locate an element using its id' do
-        element = described_class.new(:my_input, page, type: :text_field, selector: {id: 'field_id'}).browser_element
+        element = described_class.new(:my_input,
+                                      page,
+                                      type: :text_field,
+                                      selector: { id: 'field_id' }).browser_element
         expect(element.value).to eq('filled in')
       end
 
       it 'should locate an element using its name' do
-        element = described_class.new(:my_input, page, type: :text_field, selector: {name: 'field_name'}).browser_element
+        element = described_class.new(:my_input,
+                                      page,
+                                      type: :text_field,
+                                      selector: { name: 'field_name' }).browser_element
         expect(element.value).to eq('filled in')
       end
 
       it 'should locate an element using its label' do
-        element = described_class.new(:my_link, page, type: :link, selector: {label: 'enter text'}).browser_element
+        element = described_class.new(:my_input,
+                                      page,
+                                      type: :text_field,
+                                      selector: { label: 'enter text' }).browser_element
         expect(element[:id]).to eq('field_id')
       end
 
-      it 'should raise an exception when finding another element using its text' do
-        expect { described_class.new(:my_link, page, type: :text_field, selector: {text: 'my link'}).browser_element }.to raise_error(PageMagic::UnsupportedSelectorException)
-      end
-
       it 'should locate an element using css' do
-        element = described_class.new(:my_link, page, type: :link, selector: {css: "input[name='field_name']"}).browser_element
+        element = described_class.new(:my_input,
+                                      page,
+                                      type: :text_field,
+                                      selector: { css: "input[name='field_name']" }).browser_element
         expect(element[:id]).to eq('field_id')
       end
 
       it 'should return a prefetched value' do
-        described_class.new(:help, page, type: :link, browser_element: :prefetched_object).browser_element.should == :prefetched_object
+        element = described_class.new(:help, page, type: :link, browser_element: :prefetched_object)
+        expect(element.browser_element).to eq(:prefetched_object)
       end
 
-      it 'should raise errors for unsupported selectors' do
-        expect { described_class.new(:my_link, page, type: :link, selector: {unsupported: ''}).browser_element }.to raise_error(PageMagic::UnsupportedSelectorException)
+      it 'should raise errors for unsupported criteria' do
+        element = described_class.new(:my_link,
+                                      page,
+                                      type: :link,
+                                      selector: { unsupported: '' })
+
+        expect { element.browser_element }.to raise_error(PageMagic::UnsupportedCriteriaException)
       end
 
       context 'text selector' do
         it 'should locate a link' do
-          element = described_class.new(:my_link, page, type: :link, selector: {text: 'link in a form'}).browser_element
+          element = described_class.new(:my_link,
+                                        page,
+                                        type: :link,
+                                        selector: { text: 'link in a form' }).browser_element
           expect(element[:id]).to eq('form_link')
         end
 
         it 'should locate a button' do
-          element = described_class.new(:my_button, page, type: :button, selector: {text: 'a button'}).browser_element
-          element[:id].should == 'form_button'
+          element = described_class.new(:my_button, page, type: :button, selector: { text: 'a button' }).browser_element
+          expect(element[:id]).to eq('form_button')
         end
       end
     end
@@ -124,7 +144,7 @@ module PageMagic
     describe '#section?' do
       context 'element definitions exist' do
         subject do
-          described_class.new(:my_link, page, type: :button, selector: {text: 'a button'}) do
+          described_class.new(:my_link, page, type: :button, selector: { text: 'a button' }) do
             element :thing, text: 'text'
           end
         end
@@ -135,7 +155,7 @@ module PageMagic
 
       context 'method defined' do
         subject do
-          described_class.new(:my_link, :page, type: :link, selector: {text: 'my link'}) do
+          described_class.new(:my_link, :page, type: :link, selector: { text: 'my link' }) do
             def custom_method
             end
           end
@@ -148,7 +168,7 @@ module PageMagic
 
       context 'neither method or elements defined' do
         subject do
-          described_class.new(:my_link, :page, type: :link, selector: {text: 'my link'})
+          described_class.new(:my_link, :page, type: :link, selector: { text: 'my link' })
         end
         it 'returns false' do
           expect(subject.section?).to eq(false)
@@ -164,7 +184,7 @@ module PageMagic
 
     describe 'hooks' do
       subject do
-        described_class.new(:my_button, page, type: :button, selector: {id: 'my_button'}) do
+        described_class.new(:my_button, page, type: :button, selector: { id: 'my_button' }) do
           before do
             call_in_before_hook
           end
@@ -180,7 +200,7 @@ module PageMagic
 
       context 'method called in before hook' do
         subject do
-          described_class.new(:my_button, page, type: :button, selector: {id: 'my_button'}) do
+          described_class.new(:my_button, page, type: :button, selector: { id: 'my_button' }) do
             after do
               call_in_after_hook
             end
@@ -192,14 +212,12 @@ module PageMagic
           subject.click
         end
       end
-
     end
 
     describe '#method_missing' do
-
       before do
         page_class.class_eval do
-          section :form_by_css, css: '.form' do
+          element :form_by_css, css: '.form' do
             link(:link_in_form, text: 'a in a form')
           end
         end
@@ -225,8 +243,6 @@ module PageMagic
           expect { page.form_by_css.bobbins }.to raise_exception NoMethodError
         end
       end
-
     end
-
   end
-end
+end

data/spec/page_magic/driver_spec.rb

@@ -20,7 +20,6 @@ module PageMagic
       end
     end
     describe '#build' do
-
       it 'returns the result of the block passed to the driver class constructor' do
         subject = described_class.new(:custom_browser)do
           :driver
@@ -30,9 +29,9 @@ module PageMagic
 
       it 'passes rack app to the handler' do
         subject = described_class.new(:custom_browser) do |app, options, browser|
-            expect(app).to eq(:rack_app)
-            expect(options).to eq(:options)
-            expect(browser).to eq(:browser)
+          expect(app).to eq(:rack_app)
+          expect(options).to eq(:options)
+          expect(browser).to eq(:browser)
         end
 
         subject.build(:rack_app, options: :options, browser: :browser)

data/spec/page_magic/element/query_spec.rb

@@ -0,0 +1,76 @@
+module PageMagic
+  class Element
+    describe Query do
+      describe '.find' do
+        it 'finds the constant with the given name' do
+          expect(Query.find(:button)).to be(described_class::BUTTON)
+        end
+
+        context 'constant not found' do
+          it 'returns a default' do
+            expect(Query.find(:billy)).to be(described_class::ELEMENT)
+          end
+        end
+      end
+
+      describe '#build' do
+        let(:selector) { Selector.new }
+        before do
+          expect(Selector).to receive(:find).with(:css).and_return(selector)
+        end
+        let(:locator) { { css: '.css' } }
+
+        it 'uses the locator to find the correct selector builder' do
+          expect(subject.build(locator)).to eq(locator.values)
+        end
+
+        it 'adds options to the result' do
+          expect(subject.build(locator, :options)).to eq(locator.values.concat([:options]))
+        end
+
+        context 'selector support element type' do
+          subject do
+            described_class.new(:field)
+          end
+
+          it 'passes element type through to the selector' do
+            expect(selector).to receive(:build).with(:field, '.css').and_call_original
+            subject.build(locator)
+          end
+        end
+      end
+    end
+
+    class Query
+      describe 'predefined queries' do
+        it 'has a predefined query for each element type' do
+          missing = PageMagic::Elements::TYPES.find_all do |type|
+            !Query.constants.include?(type.upcase.to_sym)
+          end
+          expect(missing).to be_empty
+        end
+
+        describe 'queries for form fields' do
+          it 'uses field as the element type' do
+            expect(TEXT_FIELD.type).to eq(:field)
+          end
+          it 'uses the same query for all form field types' do
+            expect(TEXT_FIELD).to eq(CHECKBOX).and eq(SELECT_LIST).and eq(RADIOS).and eq(TEXTAREA)
+          end
+        end
+
+        it 'uses link as the element type for link' do
+          expect(LINK.type).to eq(:link)
+        end
+
+        it 'uses the button element type for button' do
+          expect(BUTTON.type).to eq(:button)
+        end
+
+        it 'does not use an element type for generic elements' do
+          expect(ELEMENT.type).to eq(nil)
+        end
+      end
+    end
+  end
+end

data/spec/page_magic/element/selector_spec.rb

@@ -0,0 +1,109 @@
+module PageMagic
+  class Element
+    describe Selector do
+      describe '.find' do
+        it 'returns the constant with the given name' do
+          expect(Selector.find(:css)).to be(described_class::CSS)
+        end
+
+        context 'selector not found' do
+          it 'raises an exception' do
+            expect { Selector.find(:invalid) }.to raise_exception(UnsupportedCriteriaException)
+          end
+        end
+      end
+
+      describe '#build' do
+        it 'puts the locator and element type in to the result' do
+          expect(subject.build(:field, :locator)).to eq([:locator])
+        end
+
+        context 'supports_type flag set to true in constructor' do
+          subject do
+            described_class.new(supports_type: true)
+          end
+          it 'includes the element type in the result' do
+            expect(subject.build(:field, :locator)).to eq([:field, :locator])
+          end
+        end
+
+        context 'formatter supplied to constructor' do
+          subject do
+            described_class.new do |param|
+              "formatted_#{param}".to_sym
+            end
+          end
+          it 'uses the formatter' do
+            expect(subject.build(:field, :locator)).to eq([:formatted_locator])
+          end
+        end
+
+        context 'name supplied to constructor' do
+          subject do
+            described_class.new(:css)
+          end
+
+          it 'is added to the result' do
+            expect(subject.build(:field, :locator)).to eq([:css, :locator])
+          end
+        end
+      end
+    end
+
+    class Selector
+      shared_examples 'named selector' do
+        it 'adds name to the result' do
+          expect(described_class.build(:element_type, :locator)).to eq([described_class.name, :locator])
+        end
+      end
+
+      shared_examples 'anonymous selector' do
+        it 'does not have a name' do
+          expect(described_class.name).to eq(nil)
+        end
+      end
+
+      shared_examples 'element type selector' do
+        it 'adds the element type to the result' do
+          expect(described_class.supports_type).to eq(true)
+        end
+      end
+
+      shared_examples 'non element type selector' do
+        it 'adds the element type to the result' do
+          expect(described_class.supports_type).to eq(false)
+        end
+      end
+
+      describe NAME do
+        it_behaves_like 'anonymous selector'
+        it_behaves_like 'non element type selector'
+
+        it 'formats locators' do
+          button_name = 'my_button'
+          expect(described_class.build(:button, button_name)).to eq(["*[name='#{button_name}']"])
+        end
+      end
+
+      describe XPATH do
+        it_behaves_like 'named selector'
+        it_behaves_like 'non element type selector'
+      end
+
+      describe ID do
+        it_behaves_like 'named selector'
+        it_behaves_like 'non element type selector'
+      end
+
+      describe LABEL do
+        it_behaves_like 'named selector', :field
+        it_behaves_like 'non element type selector'
+      end
+
+      describe TEXT do
+        it_behaves_like 'anonymous selector'
+        it_behaves_like 'element type selector'
+      end
+    end
+  end
+end

data/spec/page_magic/element_context_spec.rb

@@ -1,7 +1,6 @@
 module PageMagic
-
   describe ElementContext do
-    include_context :webapp
+    include_context :webapp_fixture
 
     let!(:elements_page) do
       Class.new do
@@ -16,23 +15,20 @@ module PageMagic
     end
 
     describe '#method_missing' do
-
       let(:page) do
-        elements_page.new.tap do |page|
-          page.visit
-        end
+        elements_page.new.tap(&:visit)
       end
 
       context 'neither a method or page element are defined' do
         it 'raises an error' do
-          expect { described_class.new(page, page.browser, self).missing_thing }.to raise_error PageMagic::ElementMissingException
+          expect { described_class.new(page, page.browser, self).missing_thing }.to raise_error ElementMissingException
         end
       end
 
       context 'method is a element defintion' do
         it 'returns the sub page element' do
           element = described_class.new(page, page.browser, self).a_link
-          #TODO - returns the capybara object. maybe we should think about wrapping this.
+          # TODO: - returns the capybara object. maybe we should think about wrapping this.
           expect(element.text).to eq('a link')
         end
 
@@ -69,4 +65,4 @@ module PageMagic
       end
     end
   end
-end
+end