page_magic 1.0.0.alpha21 → 1.0.0

data/lib/page_magic/watchers.rb

@@ -0,0 +1,43 @@
+require 'page_magic/watcher'
+
+module PageMagic
+  # module Watchers - contains methods for adding watchers and checking them
+  module Watchers
+    ELEMENT_MISSING_MSG = 'Unable to defined watcher: Element or method with the name %s can not be found'
+
+    # @param [Symbol] name - the name of the watcher
+    # @return [Boolean] true if a change is detected
+    def changed?(name)
+      watched_element = watcher(name)
+      watched_element.last != watched_element.check(self).last
+    end
+
+    # register a new watcher
+    # @param [Object] name of the watcher/element
+    # @param [Symbol] method - the method on the watched element to check
+    # @yieldreturn [Object] the value that should be checked
+    # @example
+    #  watch(:price, :text)
+    # @example
+    #  watch(:something) do
+    #   # more complicated code to get value
+    # end
+    def watch(name, method = nil, &block)
+      fail ElementMissingException, (ELEMENT_MISSING_MSG % name) unless block || respond_to?(name)
+      watched_element = block ? Watcher.new(name, &block) : Watcher.new(name, method)
+      watchers << watched_element.check(self)
+    end
+
+    # retrieve a watcher given its name
+    # @param [Symbol] name the name of the watcher
+    # @return [Watcher] watcher with the given name
+    def watcher(name)
+      watchers.find { |watcher| watcher.name == name }
+    end
+
+    # @return [Array] registered watchers
+    def watchers
+      @watchers ||= []
+    end
+  end
+end

data/lib/page_magic.rb

@@ -1,21 +1,32 @@
 $LOAD_PATH.unshift("#{File.dirname(__FILE__)}")
 require 'capybara'
 require 'page_magic/exceptions'
+require 'page_magic/wait_methods'
+require 'page_magic/watchers'
 require 'page_magic/session'
-require 'page_magic/instance_methods'
+require 'page_magic/session_methods'
 require 'page_magic/elements'
-require 'page_magic/class_methods'
 require 'page_magic/element_context'
 require 'page_magic/element'
+require 'page_magic/class_methods'
+require 'page_magic/instance_methods'
 require 'page_magic/drivers'
 
 # module PageMagic - PageMagic is an api for modelling pages in a website.
 module PageMagic
   class << self
+    # @return [Drivers] registered drivers
     def drivers
       @drivers ||= Drivers.new.tap(&:load)
     end
 
+    def included(clazz)
+      clazz.class_eval do
+        include(InstanceMethods)
+        extend(Elements, ClassMethods)
+      end
+    end
+
     # Visit this page based on the class level registered url
     # @param [Object] application rack application (optional)
     # @param [Symbol] browser name of browser
@@ -32,12 +43,5 @@ module PageMagic
 
       Session.new(Capybara::Session.new(browser, application), url)
     end
-
-    def included(clazz)
-      clazz.class_eval do
-        include(InstanceMethods)
-        extend(Elements, ClassMethods)
-      end
-    end
   end
 end

data/spec/element_spec.rb

@@ -14,6 +14,17 @@ module PageMagic
 
     let(:page) { session.current_page }
 
+    # let!(:browser) { double('browser') }
+
+    subject do
+      described_class.new(:page_element, page)
+    end
+
+    it_behaves_like 'session accessor'
+    it_behaves_like 'element watcher'
+    it_behaves_like 'waiter'
+    it_behaves_like 'element locator'
+
     describe 'inheriting' do
       it 'lets you create custom elements' do
         custom_element = Class.new(described_class) do
@@ -32,185 +43,58 @@ module PageMagic
       end
     end
 
-    it 'should raise an error if a selector has not been specified' do
-      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
-      subject do
-        described_class.new(:name,
-                            Object.new,
-                            type: :element,
-                            prefetched_browser_element: double(element_method: '')) do
-          element :sub_element, css: '.sub-element'
-        end
-      end
-      it 'checks for methods on self' do
-        expect(subject.respond_to?(:session)).to eq(true)
-      end
-
-      it 'checks against registered elements' do
-        expect(subject.respond_to?(:sub_element)).to eq(true)
-      end
-
-      it 'checks for the method of the browser_element' do
-        expect(subject.respond_to?(:element_method)).to eq(true)
-      end
-    end
-
-    describe '#browser_element' do
-      let!(:browser) { double('browser') }
-
-      context 'options supplied to selector' do
-        it 'passes them on to the cappybara finder method' do
-          options = { count: 1 }
-          xpath_selector = '//div/input'
-          expect(page.session.raw_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
+    describe 'EVENT_TYPES' do
+      context 'methods created' do
+        it 'creates methods for each of the event types' do
+          missing = described_class::EVENT_TYPES.find_all { |event| !subject.respond_to?(event) }
+          expect(missing).to be_empty
         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
-        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
-        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
-        expect(element.value).to eq('filled in')
-      end
-
-      it 'should locate an element using its label' do
-        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 locate an element using css' do
-        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
-        element = described_class.new(:help, page, type: :link, prefetched_browser_element: :prefetched_object)
-        expect(element.browser_element).to eq(:prefetched_object)
-      end
-
-      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
-          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
-          expect(element[:id]).to eq('form_button')
-        end
-      end
-    end
 
-    describe '#section?' do
-      context 'element definitions exist' do
-        subject do
-          described_class.new(:my_link, page, type: :button, selector: { text: 'a button' }) do
-            element :thing, text: 'text'
+        context 'method called' do
+          let(:browser_element) { instance_double(Capybara::Node::Element) }
+          subject do
+            described_class.new(browser_element, page)
           end
-        end
-        it 'returns true' do
-          expect(subject.section?).to eq(true)
-        end
-      end
-
-      context 'method defined' do
-        subject do
-          described_class.new(:my_link, :page, type: :link, selector: { text: 'my link' }) do
-            def custom_method
-            end
+          it 'calls the browser_element passing on all args' do
+            expect(browser_element).to receive(:select).with(:args)
+            subject.select :args
           end
         end
-
-        it 'returns true' do
-          expect(subject.section?).to eq(true)
-        end
-      end
-
-      context 'neither method or elements defined' do
-        subject do
-          described_class.new(:my_link, :page, type: :link, selector: { text: 'my link' })
-        end
-        it 'returns false' do
-          expect(subject.section?).to eq(false)
-        end
       end
     end
 
-    describe 'session' do
-      it 'should have a handle to the session' do
-        expect(described_class.new(:help, page, type: :link, selector: :selector).session).to eq(page.session)
+    describe '#initialize' do
+      it 'sets the parent element' do
+        instance = described_class.new(page, :parent_page_element)
+        expect(instance.parent_page_element).to eq(:parent_page_element)
       end
     end
 
     describe 'hooks' do
       subject do
-        described_class.new(:my_button, page, type: :button, selector: { id: 'my_button' }) do
+        Class.new(described_class) do
           before_events do
             call_in_before_hook
           end
-        end
+        end.new(double('button', click: true), page)
       end
       context 'method called in before hook' do
         it 'calls methods on the page element' do
-          expect(page.browser).to receive(:find).and_return(double('button', click: true))
           expect(subject).to receive(:call_in_before_hook)
           subject.click
         end
       end
 
-      context 'method called in before hook' do
+      context 'method called in after hook' do
         subject do
-          described_class.new(:my_button, page, type: :button, selector: { id: 'my_button' }) do
+          Class.new(described_class) do
             after_events do
               call_in_after_hook
             end
-          end
+          end.new(double('button', click: true), page)
         end
+
         it 'calls methods on the page element' do
-          expect(page.browser).to receive(:find).and_return(double('button', click: true))
           expect(subject).to receive(:call_in_after_hook)
           subject.click
         end
@@ -230,22 +114,36 @@ module PageMagic
         expect(page.form_by_css).to be_visible
       end
 
-      context 'method not on capybara browser element' do
-        it 'uses the parent page element' do
-          page_class.class_eval do
-            def parent_method
-              :called
-            end
-          end
-          expect(page.form_by_css.parent_method).to eq(:called)
-        end
-      end
-
       context 'no element definition and not a capybara method' do
         it 'throws and exception' do
           expect { page.form_by_css.bobbins }.to raise_exception NoMethodError
         end
       end
     end
+
+    describe '#respond_to?' do
+      subject do
+        Class.new(described_class) do
+          element :sub_element, css: '.sub-element'
+        end.new(double(element_method: ''), :parent_page_element)
+      end
+      it 'checks for methods on self' do
+        expect(subject.respond_to?(:session)).to eq(true)
+      end
+
+      it 'checks against registered elements' do
+        expect(subject.respond_to?(:sub_element)).to eq(true)
+      end
+
+      it 'checks for the method of the browser_element' do
+        expect(subject.respond_to?(:element_method)).to eq(true)
+      end
+    end
+
+    describe '#session' do
+      it 'should have a handle to the session' do
+        expect(subject.session).to eq(page.session)
+      end
+    end
   end
 end

data/spec/page_magic/class_methods_spec.rb

@@ -6,12 +6,6 @@ module PageMagic
         clazz.include(InstanceMethods)
       end
     end
-    describe '#url' do
-      it 'get/sets a value' do
-        subject.url(:url)
-        expect(subject.url).to eq(:url)
-      end
-    end
 
     describe 'on_load' do
       context 'block not set' do
@@ -29,6 +23,13 @@ module PageMagic
       end
     end
 
+    describe '#url' do
+      it 'get/sets a value' do
+        subject.url(:url)
+        expect(subject.url).to eq(:url)
+      end
+    end
+
     describe '#visit' do
       include_context :webapp_fixture
       it 'passes all options to create an active session on the registered url' do

data/spec/page_magic/driver_spec.rb

@@ -6,19 +6,6 @@ module PageMagic
       described_class.new :custom_browser
     end
 
-    describe '#supports?' do
-      context 'browser is in supported browsers' do
-        it 'returns true' do
-          expect(subject.support?(:custom_browser)).to eq(true)
-        end
-      end
-
-      context 'browser is not in supported browsers' do
-        it 'returns false' do
-          expect(subject.support?(:unsupported_browser)).to eq(false)
-        end
-      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
@@ -37,5 +24,19 @@ module PageMagic
         subject.build(:rack_app, options: :options, browser: :browser)
       end
     end
+
+    describe '#supports?' do
+      context 'browser is in supported browsers' do
+        it 'returns true' do
+          expect(subject.support?(:custom_browser)).to eq(true)
+        end
+      end
+
+      context 'browser is not in supported browsers' do
+        it 'returns false' do
+          expect(subject.support?(:unsupported_browser)).to eq(false)
+        end
+      end
+    end
   end
 end

data/spec/page_magic/drivers_spec.rb

@@ -3,12 +3,6 @@ module PageMagic
   describe Drivers do
     subject { described_class.new }
     let(:expected_driver) { Driver.new(:browser_driver) }
-    describe '#register' do
-      it 'stores the driver' do
-        subject.register expected_driver
-        expect(subject.all).to eq([expected_driver])
-      end
-    end
 
     describe '#find' do
       it 'returns the registered driver' do
@@ -34,5 +28,12 @@ module PageMagic
         expect(subject.find(:custom_browser)).to be(::CustomDriver)
       end
     end
+
+    describe '#register' do
+      it 'stores the driver' do
+        subject.register expected_driver
+        expect(subject.all).to eq([expected_driver])
+      end
+    end
   end
 end

data/spec/page_magic/element/locators_spec.rb

@@ -0,0 +1,33 @@
+module PageMagic
+  class Element
+    describe Locators do
+      subject(:element_clazz) do
+        Class.new do
+          extend(Elements)
+          include(Locators)
+        end
+      end
+      subject { element_clazz.new }
+
+      describe '#element_by_name' do
+        it 'returns the required element' do
+          selector = { id: 'child' }
+          element_clazz.element :child1, selector
+          element_clazz.element :child2, id: 'child 2'
+
+          expected_builder = ElementDefinitionBuilder.new(definition_class: Element, type: :element, selector: selector)
+
+          expect(subject.element_by_name(:child1)).to eq(expected_builder)
+        end
+
+        context 'element not found' do
+          it 'raises an error' do
+            expected_message = (described_class::ELEMENT_NOT_DEFINED_MSG % :child)
+            command = proc { subject.element_by_name(:child) }
+            expect(&command).to raise_exception ElementMissingException, expected_message
+          end
+        end
+      end
+    end
+  end
+end

data/spec/page_magic/element/query_spec.rb

@@ -1,6 +1,13 @@
 module PageMagic
   class Element
     describe Query do
+      it 'has a predefined query for each element type' do
+        missing = PageMagic::Elements::TYPES.find_all do |type|
+          !described_class.constants.include?(type.upcase.to_sym)
+        end
+        expect(missing).to be_empty
+      end
+
       describe '.find' do
         it 'finds the constant with the given name' do
           expect(Query.find(:button)).to be(described_class::BUTTON)
@@ -42,35 +49,53 @@ module PageMagic
     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
+      describe BUTTON do
+        it 'has an element type' do
+          expect(described_class.type).to eq(:button)
         end
+      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
+      describe ELEMENT do
+        it ' does not has an element type' do
+          expect(described_class.type).to be_nil
         end
+      end
 
-        it 'uses link as the element type for link' do
-          expect(LINK.type).to eq(:link)
+      describe LINK do
+        it 'has an element type' do
+          expect(described_class.type).to eq(:link)
         end
+      end
 
-        it 'uses the button element type for button' do
-          expect(BUTTON.type).to eq(:button)
+      describe TEXT_FIELD do
+        it 'has an element type' do
+          expect(described_class.type).to eq(:field)
         end
 
-        it 'does not use an element type for generic elements' do
-          expect(ELEMENT.type).to eq(nil)
+        it 'the same as all form field types' do
+          expect(described_class).to eq(CHECKBOX).and eq(SELECT_LIST).and eq(RADIOS).and eq(TEXTAREA)
         end
       end
     end
+
+    context 'integration' do
+      include_context :webapp_fixture
+      let(:capybara_session) { Capybara::Session.new(:rack_test, rack_app).tap { |s| s.visit('/elements') } }
+      it 'finds fields' do
+        expect(capybara_session.all(*Query.find(:text_field).build(name: 'field_name')).size).to eq(1)
+      end
+
+      it 'finds buttons' do
+        expect(capybara_session.all(*Query.find(:button).build(text: 'a button')).size).to eq(1)
+      end
+
+      it 'finds links' do
+        expect(capybara_session.all(*Query.find(:link).build(text: 'a link')).size).to eq(1)
+      end
+
+      it 'finds elements' do
+        expect(capybara_session.all(*Query.find(:element).build(name: 'field_name')).size).to eq(1)
+      end
+    end
   end
 end

data/spec/page_magic/element/selector_spec.rb

@@ -18,6 +18,16 @@ module PageMagic
           expect(subject.build(:field, :locator)).to eq([:locator])
         end
 
+        context 'exact is set to true' do
+          subject do
+            described_class.new(exact: true)
+          end
+
+          it 'includes the requirement for the match to be exact' do
+            expect(subject.build(:field, :locator)).to include(exact: true)
+          end
+        end
+
         context 'supports_type flag set to true in constructor' do
           subject do
             described_class.new(supports_type: true)
@@ -48,12 +58,19 @@ module PageMagic
           end
         end
       end
+
+      describe '#initialize' do
+        it 'sets exact to false by default' do
+          expect(subject.exact).to eq(false)
+        end
+      end
     end
 
     class Selector
-      shared_examples 'named selector' do
+      shared_examples 'named selector' do |options|
         it 'adds name to the result' do
-          expect(described_class.build(:element_type, :locator)).to eq([described_class.name, :locator])
+          expected = [described_class.name, :locator, options].compact
+          expect(described_class.build(:element_type, :locator)).to eq(expected)
         end
       end
 
@@ -96,7 +113,7 @@ module PageMagic
       end
 
       describe LABEL do
-        it_behaves_like 'named selector', :field
+        it_behaves_like 'named selector', exact: true
         it_behaves_like 'non element type selector'
       end
 
@@ -105,5 +122,30 @@ module PageMagic
         it_behaves_like 'element type selector'
       end
     end
+
+    context 'integration' do
+      include_context :webapp_fixture
+      let(:capybara_session) { Capybara::Session.new(:rack_test, rack_app).tap { |s| s.visit('/elements') } }
+
+      it 'finds elements by name' do
+        expect(capybara_session.all(*Query.find(:text_field).build(name: 'field_name')).size).to eq(1)
+      end
+
+      it 'finds elements by xpath' do
+        expect(capybara_session.all(*Query.find(:element).build(xpath: '//div/input')).size).to eq(1)
+      end
+
+      it 'finds elements by id' do
+        expect(capybara_session.all(*Query.find(:text_field).build(id: 'field_id')).size).to eq(1)
+      end
+
+      it 'finds elements by label' do
+        expect(capybara_session.all(*Query.find(:text_field).build(label: 'enter text')).size).to eq(1)
+      end
+
+      it 'finds elements by text' do
+        expect(capybara_session.all(*Query.find(:link).build(text: 'a link')).size).to eq(1)
+      end
+    end
   end
 end