page_magic 0.10.0 → 0.11.0.alpha

data/spec/element_spec.rb

@@ -1,9 +1,8 @@
-require 'spec_helper'
 require 'sinatra'
 
-
 describe 'Page elements' do
 
+
   before :each do
     Capybara.app = Class.new(Sinatra::Base) do
       get '/' do
@@ -12,6 +11,7 @@ describe 'Page elements' do
           <input id='field_id' name='field_name' class='input_class' type='text' value='filled in'/>
           </label>
           <a id=my_link href='#'>my link</a>
+          <button id=my_button href='#'>my button</button>
         HTML
       end
     end
@@ -19,6 +19,25 @@ describe 'Page elements' do
     Capybara.current_session.visit('/')
   end
 
+  describe 'construction' do
+
+    let(:page_section_class) do
+      Class.new(PageMagic::Element)
+    end
+
+    let(:selector) { {css: '.class_name'} }
+
+    let!(:browser) { double('browser', find: :browser_element) }
+    let!(:parent_page_element) { double('parent_page_element', browser_element: browser) }
+
+  end
+
+  describe 'browser_element' do
+    it 'should raise an error if a selector has not been specified' do
+      expect { PageMagic::Element.new(:name, Object.new, :type).browser_element }.to raise_error(PageMagic::UndefinedSelectorException)
+    end
+  end
+
   describe 'location' do
     let!(:browser) { double('browser') }
     let!(:page) do
@@ -28,53 +47,109 @@ describe 'Page elements' do
       page_class.new
     end
 
-    it 'should locate an element using its id' do
-      element = PageMagic::Element.new(:my_input,page, :text_field, id:'field_id').locate
+    it 'should find by xpath' do
+      element = PageMagic::Element.new(:my_input, page, :text_field, xpath: '//input').browser_element
       element.value == 'filled in'
     end
 
-    it 'should locate an element using its name' do
-      element = PageMagic::Element.new(:my_input,page, :text_field, name:'field_name').locate
-      element.value == 'filled in'
+    it 'should locate an element using its id' do
+      element = PageMagic::Element.new(:my_input, page, :text_field, id: 'field_id').browser_element
+      element.value.should == 'filled in'
     end
 
-    it 'should locate a link using its text' do
-      element = PageMagic::Element.new(:my_link,page, :link, text: 'my link').locate
-      element[:id].should == 'my_link'
+    it 'should locate an element using its name' do
+      element = PageMagic::Element.new(:my_input, page, :text_field, name: 'field_name').browser_element
+      element.value.should == 'filled in'
     end
 
+
     it 'should locate an element using its label' do
-      element = PageMagic::Element.new(:my_link,page, :link, label: 'enter text').locate
+      element = PageMagic::Element.new(:my_link, page, :link, label: 'enter text').browser_element
       element[:id].should == 'field_id'
     end
 
     it 'should raise an exception when finding another element using its text' do
-      expect{PageMagic::Element.new(:my_link,page, :text_field, text: 'my link').locate}.to raise_error(PageMagic::UnsupportedSelectorException)
+      expect { PageMagic::Element.new(:my_link, page, :text_field, text: 'my link').browser_element }.to raise_error(PageMagic::UnsupportedSelectorException)
     end
 
     it 'should locate an element using css' do
-      element = PageMagic::Element.new(:my_link,page, :link, css: "input[name='field_name']").locate
+      element = PageMagic::Element.new(:my_link, page, :link, css: "input[name='field_name']").browser_element
       element[:id].should == 'field_id'
     end
 
+
+    it 'should return a prefetched value' do
+      PageMagic::Element.new(:help, page, :link, :prefetched_object).browser_element.should == :prefetched_object
+    end
+
     it 'should raise errors for unsupported selectors' do
-      expect{PageMagic::Element.new(:my_link,page, :link, unsupported:"").locate}.to raise_error(PageMagic::UnsupportedSelectorException)
+      expect { PageMagic::Element.new(:my_link, page, :link, unsupported: "").browser_element }.to raise_error(PageMagic::UnsupportedSelectorException)
     end
 
+    context 'text selector' do
+      it 'should locate a link' do
+        element = PageMagic::Element.new(:my_link, page, :link, text: 'my link').browser_element
+        element[:id].should == 'my_link'
+      end
 
+      it 'should locate a button' do
+        element = PageMagic::Element.new(:my_button, page, :button, text: 'my button').browser_element
+        element[:id].should == 'my_button'
+      end
+    end
+  end
+
+  describe 'session' do
+    it 'should have a handle to the session' do
+      page_class = Class.new do
+        include PageMagic
+      end
+      page = page_class.new
 
-    it 'should return the browser element if a selector was not specified' do
-      PageMagic::Element.new(:help, browser, :link, nil).locate.should == browser
+      PageMagic::Element.new(:help, page, :link, :selector).session.should == page.session
     end
+  end
 
-    #TODO - Bug here, parent element reference is not available
-    it 'should return a prefetched value' do
-      PageMagic::Element.new(:help, "prefetched text", :link ).locate.should == "prefetched text"
+
+  context 'tests coppied in from section' do
+    include_context :webapp
+
+    before :each do
+      @elements_page = elements_page.new
+      @elements_page.visit
     end
 
-    it 'should have a handle to the session' do
-      PageMagic::Element.new(:help, page, :link, :selector ).session.should == page.session
+    let!(:elements_page) do
+
+      Class.new do
+        include PageMagic
+        url '/elements'
+        section :form_by_css do
+          selector css: '.form'
+          link(:link_in_form, text: 'a in a form')
+        end
+
+        section :form_by_id do
+          selector id: 'form'
+          link(:link_in_form, text: 'a in a form')
+        end
+      end
+    end
+
+    describe 'method_missing' do
+      it 'should delegate to capybara' do
+        @elements_page.form_by_css.visible?.should be(true)
+      end
+
+      it 'should throw default exception if the method does not exist on the capybara object' do
+        expect { @elements_page.form_by_css.bobbins }.to raise_exception NoMethodError
+      end
+    end
+
+    it 'can have elements' do
+      @elements_page.form_by_css.link_in_form.visible?.should be_true
     end
   end
 
+
 end

data/spec/member_methods_spec.rb

@@ -3,34 +3,12 @@ require 'page_magic'
 
 describe 'member methods' do
   
-  let(:page_object_class) do
-    Class.new do
-      extend PageMagic::Elements
-    end
-  end
 
-  it 'should say you have fields when you do' do
-    page_object_class.elements?.should == false
-    page_object_class.link(:link, :text => "text")
-    page_object_class.elements?.should == true
-  end
 
 
-  describe 'the element types that you can define' do
-    PageMagic::Elements::TYPES.each do |element_type|
 
-      it "can have a #{element_type}" do
-        parent_page_element = double('parent_page_object', browser_element: double('browser_element'))
-        friendly_name = "#{element_type}_name".to_sym
 
-        page_object_class.send(element_type, friendly_name,{})
 
 
-        expected_element = PageMagic::Element.new(friendly_name,parent_page_element, element_type, {})
-        page_object_class.element_definitions[friendly_name].call(parent_page_element) == expected_element
-      end
-    end
-  end
-
 
 end

data/spec/{elements_spec.rb → page_magic/elements/elements_spec.rb}

@@ -16,101 +16,55 @@ describe PageMagic::Elements do
     double('parent_page_element', browser_element: browser_element)
   end
 
-
   describe 'adding elements' do
 
     context 'using a selector' do
       it 'should add an element' do
+        expected_element = PageMagic::Element.new(:name, parent_page_element, :text_field, selector)
         page_elements.text_field :name, selector
-        page_elements.element_definitions[:name].call(parent_page_element).should == PageMagic::Element.new(:name, parent_page_element, :text_field, selector)
-      end
-
-      it 'should return your a copy of the core definition' do
-        page_elements.text_field :name, selector
-        first = page_elements.element_definitions[:name].call(parent_page_element)
-        second = page_elements.element_definitions[:name].call(parent_page_element)
-        first.should_not equal(second)
-      end
-    end
-
-    context 'passing in a prefetched watir object' do
-      it 'should create a page element with the prefetched watir object as the core browser object' do
-        watir_element = double('watir_element')
-        page_elements.text_field :name, watir_element
-        page_elements.elements(browser_element).first.locate.should == watir_element
-      end
-    end
-
-  end
-
-  context 'section' do
-
-    let!(:section_class) do
-      Class.new do
-        extend PageMagic::Section
-
-        def == object
-          object.class.is_a?(PageMagic::Section) &&
-              object.name == self.name &&
-              object.browser_element == self.browser_element
-        end
+        page_elements.element_definitions[:name].call(parent_page_element).should == expected_element
       end
     end
 
-    context 'session handle' do
-      it 'should be on instances created from a class' do
+    context 'complex elements' do
 
-        browser_element = double(:browser_element, find: :browser_element)
-        parent = double('parent', session: :current_session, browser_element: browser_element)
-        page_elements.section section_class, :page_section, selector
 
-        section = page_elements.element_definitions[:page_section].call(parent)
+      let!(:section_class) do
+        Class.new(PageMagic::Element) do
 
-        section.session.should == :current_session
+          def == other
 
-      end
-
-      it 'should be on instances created dynamically using the section method' do
-
-        browser_element = double('browser_element')
-        browser_element.stub(:find)
-        parent = double('parent', session: :current_session, browser_element: browser_element)
-
-        page_elements.section :page_section, css: :selector do
+            other.name == self.name &&
+                other.browser_element == self.browser_element
+          end
 
         end
-
-        section = page_elements.element_definitions[:page_section].call(parent)
-        section.session.should == :current_session
       end
-    end
-
-    describe 'definition' do
 
-
-      context 'using a class as a definition' do
+      context 'using a predefined class' do
         it 'should add a section' do
+          expected_section = section_class.new(:page_section, parent_page_element, :section, selector)
+
           page_elements.section section_class, :page_section, selector
-          page_elements.elements(parent_page_element).first.should == section_class.new(parent_page_element, :page_section, selector)
+          page_elements.elements(parent_page_element).first.should == expected_section
         end
-      end
 
-      it 'should not require a block' do
-        expect { page_elements.section :page_section, :object }.not_to raise_exception
-      end
+        context 'name' do
+          it 'should default to the name of the class if one is not supplied' do
+            section_class.stub(:name).and_return('PageSection')
+            page_elements.section section_class, selector
+            page_elements.elements(parent_page_element).first.name.should == :page_section
 
-      context 'an object that has already been found' do
-        it 'should add a section' do
-          page_elements.section :page_section, :object
+          end
+        end
 
-          section_class.browser_element = :object
-          expected_section = section_class.new(parent_page_element, :page_section, nil)
-          expected_section.should == page_elements.elements(parent_page_element).first
+        it 'does not require a block' do
+          expect { page_elements.section :page_section, :object }.not_to raise_exception
         end
       end
 
 
-      context 'using a block to define a section inline' do
+      context 'using a block' do
 
         context 'browser_element' do
           before :each do
@@ -134,7 +88,6 @@ describe PageMagic::Elements do
             element = @element
 
             page_elements.section :page_section do
-              browser_element.should == nil
               selector css: :selector
               browser_element.should == element
             end
@@ -143,16 +96,6 @@ describe PageMagic::Elements do
           end
         end
 
-        it 'should raise an exception if the selector is not passed' do
-
-          arg, browser, element = {}, double('browser'), double('element')
-          parent_page_element = double('parent_browser_element', browser_element: browser)
-
-          page_elements.section :page_section, nil
-
-          expect { page_elements.elements(parent_page_element, arg) }.to raise_error(PageMagic::Section::UndefinedSelectorException)
-        end
-
 
         it 'should pass args through to the block' do
           page_elements.section :page_section, css: '.blah' do |arg|
@@ -165,17 +108,65 @@ describe PageMagic::Elements do
           arg[:passed_through].should be_true
         end
 
+
+        it 'should return your a copy of the core definition' do
+          page_elements.section section_class, :page_section, selector
+          first = page_elements.element_definitions[:page_section].call(parent_page_element)
+          second = page_elements.element_definitions[:page_section].call(parent_page_element)
+          first.should_not equal(second)
+        end
+
       end
 
-      it 'should return your a copy of the core definition' do
-        page_elements.section section_class, :page_section, selector
-        first = page_elements.element_definitions[:page_section].call(parent_page_element)
-        second = page_elements.element_definitions[:page_section].call(parent_page_element)
-        first.should_not equal(second)
+      describe 'location' do
+        context 'a prefetched object' do
+          it 'should add a section' do
+            expected_section = section_class.new(:page_section, parent_page_element, :section, :object)
+            page_elements.section :page_section, :object
+            expected_section.should == page_elements.elements(parent_page_element).first
+          end
+        end
+      end
+
+      describe 'session handle' do
+        it 'should be on instances created from a class' do
+          browser_element = double(:browser_element, find: :browser_element)
+          parent = double('parent', session: :current_session, browser_element: browser_element)
+          page_elements.section section_class, :page_section, selector
+
+          section = page_elements.element_definitions[:page_section].call(parent)
+
+          section.session.should == :current_session
+
+        end
+
+        it 'should be on instances created dynamically using the section method' do
+
+          browser_element = double('browser_element')
+          browser_element.stub(:find)
+          parent = double('parent', session: :current_session, browser_element: browser_element)
+
+          page_elements.section :page_section, css: :selector do
+
+          end
+
+          section = page_elements.element_definitions[:page_section].call(parent)
+          section.session.should == :current_session
+        end
       end
     end
   end
 
+  describe 'retrieving element definitions' do
+    it 'should return your a copy of the core definition' do
+      page_elements.text_field :name, selector
+      first = page_elements.element_definitions[:name].call(parent_page_element)
+      second = page_elements.element_definitions[:name].call(parent_page_element)
+      first.should_not equal(second)
+    end
+  end
+
+
 
   describe 'restrictions' do
     it 'should not allow method names that match element names' do

data/spec/page_magic/usage/defining_page_elements_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+describe 'The Elements of a Page' do
+  include Capybara::DSL
+
+  describe 'a Page Class' do
+
+  end
+end

data/spec/page_magic/usage/defining_pages_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+require 'sinatra/base'
+
+describe 'The Elements of a Page' do
+
+  describe 'instances' do
+
+    include_context :webapp
+
+    let(:my_page_class) do
+      Class.new do
+        include PageMagic
+        url '/page1'
+        link(:next, :text => "next page")
+      end
+    end
+
+    let(:another_page_class) do
+      Class.new do
+        include PageMagic
+        url '/another_page1'
+      end
+    end
+
+    before :each do
+      @page = my_page_class.new
+    end
+
+
+    describe 'browser integration' do
+      it "should use capybara's default session if a one is not supplied" do
+        Capybara.default_driver = :rack_test
+        my_page_class.new.browser.mode.should == :rack_test
+      end
+    end
+
+
+    it 'should copy fields on to element' do
+      new_page = my_page_class.new
+      @page.element_definitions[:next].call(@page).should_not equal(new_page.element_definitions[:next].call(new_page))
+    end
+
+    it 'gives access to the page text' do
+      @page.visit.text.should == 'next page'
+    end
+
+    it 'should access a field' do
+      @page.visit
+      @page.click_next
+      @page.text.should == 'page 2 content'
+    end
+
+    it 'are registered at class level' do
+      PageMagic.instance_variable_set(:@pages, nil)
+
+      page = Class.new { include PageMagic }
+      PageMagic.pages.should == [page]
+    end
+  end
+
+  describe 'inheritance' do
+    let(:parent_page) do
+      Class.new do
+        include PageMagic
+        link(:next, :text => "next page")
+      end
+    end
+
+    let(:child_page) do
+      Class.new(parent_page)
+    end
+
+    context 'children' do
+      it 'should inherit elements defined on the parent class' do
+        child_page.element_definitions.should include(:next)
+      end
+
+      it 'are added to PageMagic.pages list' do
+        PageMagic.pages.should include(child_page)
+      end
+
+      it 'should pass on element definitions to their children' do
+        grand_child_class = Class.new(child_page)
+        grand_child_class.element_definitions.should include(:next)
+      end
+    end
+  end
+end

data/spec/page_magic/usage/include_page_magic_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe 'including PageMagic' do
+  include Capybara::DSL
+
+  context 'lets you define pages' do
+    let :page_class do
+      Class.new{include PageMagic}
+    end
+
+    it 'gives a method for defining the url' do
+      page_class.url :url
+      page_class.url.should == :url
+    end
+
+    it 'lets you define elements' do
+      page_class.is_a?(PageMagic::Elements).should be_true
+    end
+  end
+end

data/spec/page_magic/usage/interacting_with_pages_spec.rb

@@ -0,0 +1,56 @@
+describe 'interacting with pages' do
+  include_context :webapp
+
+  let :page do
+    Class.new do
+      include PageMagic
+      link(:next_page, text: 'next page')
+      url '/page1'
+    end.new
+  end
+
+  before(:each) { page.visit }
+
+  describe 'visit' do
+    it 'goes to the class define url' do
+      page.visit
+      page.session.current_path.should == '/page1'
+    end
+  end
+
+  describe 'session' do
+    it 'gives access to the page magic object wrapping the user session' do
+      page.session.raw_session.should == Capybara.current_session
+    end
+  end
+
+  describe 'text_on_page?' do
+    it 'returns true if the text is present' do
+      page.text_on_page?('next page').should be_true
+    end
+
+    it 'returns false if the text is not present' do
+      page.text_on_page?('not on page').should be_false
+    end
+  end
+
+  describe 'title' do
+    it 'returns the title' do
+      page.title.should == 'page1'
+    end
+  end
+
+  describe 'text' do
+    it 'returns the text on the page' do
+      page.text.should == 'next page'
+    end
+  end
+
+  describe 'method_missing' do
+    it 'gives access to the elements defined on your page classes' do
+      page.next_page.tag_name.should == 'a'
+    end
+  end
+
+end
+

data/spec/page_magic/usage/starting_a_session_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+describe 'PageMagic.session' do
+  let(:app_class) do
+    Class.new do
+      def call env
+        [200, {}, ["hello world!!"]]
+      end
+    end
+  end
+
+  def registered_driver browser
+    Capybara.drivers[browser].call(nil)
+  end
+
+  context 'using a symbol as a parameter' do
+    it 'sets up a session using the specified browser' do
+      Capybara::Session.should_receive(:new).with(:chrome, nil).and_return(:chrome_session)
+
+      session = PageMagic.session(:chrome)
+
+      registered_driver(:chrome).should == Capybara::Selenium::Driver.new(nil, browser: :chrome)
+
+      session.raw_session.should == :chrome_session
+    end
+
+    context 'browsers' do
+      it 'supports poltergeist' do
+        session = PageMagic.session(:poltergeist, application: app_class.new)
+        session.raw_session.driver.is_a?(Capybara::Poltergeist::Driver).should be_true
+      end
+
+      it 'supports selenium' do
+        session = PageMagic.session(:firefox, application: app_class.new)
+        session.raw_session.driver.is_a?(Capybara::Selenium::Driver).should be_true
+      end
+    end
+  end
+
+  context 'defaulting the browser used from PageMagic sessions' do
+    it "uses what ever Capybara's default_driver is set to" do
+      Capybara.default_driver = :rack_test
+      session = PageMagic.session
+      session.raw_session.mode.should == :rack_test
+    end
+  end
+
+  context 'testing against rack applications' do
+
+    it 'requires the app to be supplied' do
+      session = PageMagic.session(application: app_class.new)
+      session.raw_session.visit('/')
+      session.raw_session.text.should == 'hello world!!'
+    end
+
+    it 'can run against an rack application using a particular browser' do
+      session = PageMagic.session(:rack_test, application: app_class.new)
+      session.raw_session.mode.should == :rack_test
+      session.raw_session.visit('/')
+      session.raw_session.text.should == 'hello world!!'
+    end
+  end
+
+end