page_magic 1.0.0.alpha10 → 1.0.0.alpha11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d169c7cf7a4d49cfe0424e561f0a52cc732ec56
-  data.tar.gz: c8c26faa46d799b27f985e88bbec7ae21839b227
+  metadata.gz: df390dca05439be5b971179c257c5b8d6e73ade2
+  data.tar.gz: 63e5f1d5579f2981e69ff1dbc8dc31d3505f2e9c
 SHA512:
-  metadata.gz: f9c32d2a85aad55ab12396ff2fad7da5b3e8bc319eef54ba34ec27182f24564853ed110b5b450ec8aea3bdeca2a70a2a992336a0e82186a5c9d32d66fa3e478c
-  data.tar.gz: 002e9bc54cc7e99e4c0d05996d1afeed3a68d141264d44bcef6e1ff47231f1083cc611bc0bb3a8445cbe30d96f37ee5d766a08c79e49df356156bd85bc57b7bf
+  metadata.gz: e635b5836e8a2376b28507c87240d09b870a2d6720aa3e94eac6fc5723e1269c85659a935f7dada8b1543afa48d47b0e8c0dcdf87f065c9937523aed73207b63
+  data.tar.gz: a710f169e452e3408652064347feedf1f81ddc2d4d9093fd948299f683f51f6fb1a71d00601e71ce7a6508761994206d885922010f257ff22886dd01cc4b1686

data/README.md

@@ -4,10 +4,10 @@ PageMagic is an API for testing web applications.
 It has a simple but powerful DSL which makes modelling and interacting with your pages easy.
 
 Wouldn't it be great if there was a framework that could:
-- Model your pages
-- Define custom wait activity that should occur before or after you interact with a page element at the point the element is defined
-- Map the paths to pages so that when you transition from one page to another, you don't have to do awkward things to work out which page object you need to use next?
-- Be really really dynamic so that you could do even more things at runtime?
+- [Model your pages](#modelling-pages)
+- [Fluently define interaction hooks / waiters on page elements](#interaction-hooks)
+- [Provide urls to pages to avoid awkward page object switching](#page-mapping)
+- [Be super dynamic](#dynamic-selectors)
 
 Well PageMagic might just be the answer!
 
@@ -58,35 +58,13 @@ Out of the box, PageMagic knows how to work with:
 - poltergeist
 - RackTest - Read more on testing rack compliant object's directly later on
 
-Under the hood, PageMagic is using [Capybara](https://github.com/jnicklas/capybara) so you can register any Capybara specific driver you want. See below for how to do this.
+Under the hood, PageMagic is using [Capybara](https://github.com/jnicklas/capybara) so you can register any Capybara specific driver you want. See [below](#registering-a-custom-driver) for how to do this.
 
 **Note:** We don't want to impose particular driver versions so PageMagic does not list any as dependencies. Therefore you will need add the requiste gem to your Gemfile.
 
-## Defining Pages
-To define something that PageMagic can work with, simply include PageMagic in to a class. Here are the classes we would need for the example above.
-```ruby
-class LoginPage
-  include PageMagic
-end
-
-class MailBox
-  include PageMagic
-end
-
-class MessageView
-  include PageMagic
-end
-```
+## Modeling pages
+To define something that PageMagic can work with, simply include PageMagic in to a class. Your you will also want to model the elements on your page so that you can interact with them. Here are we are modelling the login page we would need for the example above
 
-## Visiting a page
-To use a page ojbect you need to 'visit' it.
-```ruby
-session.visit(LoginPage, url: 'https://21st-century-mail.com')
-```
-**Note:** soon you won't even have to specify the page class :)
-
-##Defining elements
-Your pages are going to have elements on them that you will want to interact with. In the case of the Login page, it's easy to imagine that it will have text fields for a username and password and a button to login in with. 
 ```ruby
 class LoginPage
   include PageMagic
@@ -95,6 +73,8 @@ class LoginPage
   button(:login_button, text: 'login')
 end
 ```
+In the case of the Login page, it's easy to imagine that it will have text fields for a username and password and a button to login in with.
+
 ##Interacting with elements
 Elements are defined with a id which is the name of the method you will use to reference it. In the above example, the textfields and button were defined with the id's, `:username`, `:password`, and `:login_button`
 
@@ -104,7 +84,24 @@ session.username.set 'joe@blogs.com'
 session.password.set 'passw0rd'
 session.login_button.click
 ```
-##Defining helper methods
+
+## Defining Pages
+To define something that PageMagic can work with, simply include PageMagic in to a class. Here are the classes we would need for the example above.
+```ruby
+class LoginPage
+  include PageMagic
+end
+
+class MailBox
+  include PageMagic
+end
+
+class MessageView
+  include PageMagic
+end
+```
+
+## Helper methods
 Using elements that are defined on a page is great, but if you are enacting a procedure through interacting with a few of them then your code could end up with some pretty repetitive code. In this case you can define helper methods instead. 
 
 In the above [example](#an example) we used a helper called `login`.
@@ -183,6 +180,24 @@ browser.define_page_mappings %r{/messages/\d+} => MessagePage,
 ```
 You can use even use regular expressions to map multiple paths to the same page. In the above example we are mapping paths that that starts with '/messages/' and are followed by one ore more digits to the `MessagePage` class.
 
+## Registering a custom driver
+You can register any Capybara compliant driver as follows
+
+```ruby
+#1. Define driver, constructor to PageMagic::Driver takes a list of browser aliases.
+# Selenium Webdriver for example supports driving more than one.
+Webkit = PageMagic::Driver.new(:webkit) do |app, options, browser_alias_chosen|
+  # Write the code necessary to initialise the driver you have chosen
+  require 'capybara/webkit'
+  Capybara::Webkit::Driver.new(app, options)
+end
+
+#2. Register driver
+PageMagic.drivers.register Webkit
+
+#3. Use registered driver
+session = PageMagic.session(browser: webkit)
+```
 ##What else can you do with PageMagic?
 PageMagic has lots of other useful features. I'm writing up the documentation so check back here soon!
 

data/VERSION

@@ -1 +1 @@
-1.0.0.alpha10
+1.0.0.alpha11

data/lib/page_magic/element.rb

@@ -10,6 +10,7 @@ module PageMagic
   end
 
   class Element
+    EVENT_TYPES = [:set, :select, :select_option, :unselect_option, :click]
     attr_reader :type, :name, :selector, :browser_element
 
     include Elements
@@ -26,7 +27,7 @@ module PageMagic
     end
 
     def initialize(name, parent_page_element, options, &block)
-      options = { type: :element, selector: {}, browser_element: nil }.merge(options)
+      options = {type: :element, selector: {}, browser_element: nil}.merge(options)
       @browser_element = options[:browser_element]
       @selector = options[:selector]
 
@@ -67,13 +68,17 @@ module PageMagic
       @after_hook = block
     end
 
-    def method_missing(method, *args)
-      element_context(args).send(method, args.first)
-    rescue ElementMissingException
+    def method_missing method, *args, &block
       begin
-        @browser_element.send(method, *args)
-      rescue
-        super
+        ElementContext.new(self, browser_element, self, *args).send(method, args.first, &block)
+      rescue ElementMissingException
+        if browser_element.respond_to?(method)
+          browser_element.send(method, *args, &block)
+        elsif @parent_page_element.respond_to?(method)
+          @parent_page_element.send(method, *args, &block)
+        else
+          super
+        end
       end
     end
 
@@ -91,34 +96,63 @@ module PageMagic
         options = selector_copy
 
         finder_method, selector_type, selector_arg = case method
-                                                     when :id
-                                                       [:find, "##{selector}"]
-                                                     when :xpath
-                                                       [:find, :xpath, selector]
-                                                     when :name
-                                                       [:find, "*[name='#{selector}']"]
-                                                     when :css
-                                                       [:find, :css, selector]
-                                                     when :label
-                                                       [:find_field, selector]
-                                                     when :text
-                                                       if @type == :link
-                                                         [:find_link, selector]
-                                                       elsif @type == :button
-                                                         [:find_button, selector]
+                                                       when :id
+                                                         [:find, "##{selector}"]
+                                                       when :xpath
+                                                         [:find, :xpath, selector]
+                                                       when :name
+                                                         [:find, "*[name='#{selector}']"]
+                                                       when :css
+                                                         [:find, :css, selector]
+                                                       when :label
+                                                         [:find_field, selector]
+                                                       when :text
+                                                         if @type == :link
+                                                           [:find_link, selector]
+                                                         elsif @type == :button
+                                                           [:find_button, selector]
+                                                         else
+                                                           fail UnsupportedSelectorException
+                                                         end
+
                                                        else
                                                          fail UnsupportedSelectorException
-                                                       end
-
-                                                     else
-                                                       fail UnsupportedSelectorException
                                                      end
 
         finder_args = [selector_type, selector_arg].compact
         finder_args << options unless options.empty?
-        @browser_element = @parent_page_element.browser_element.send(finder_method, *finder_args)
+        @browser_element = @parent_page_element.browser_element.send(finder_method, *finder_args).tap do |browser_element|
+          EVENT_TYPES.each do |action_method|
+            apply_hooks(page_element: browser_element,
+                        capybara_method: action_method,
+                        before_hook: before,
+                        after_hook: after)
+          end
+        end
+
       end
-      @browser_element
+    end
+
+    def apply_hooks(options)
+      _self = self
+      page_element = options[:page_element]
+      capybara_method = options[:capybara_method]
+      if page_element.respond_to?(capybara_method)
+        original_method = page_element.method(capybara_method)
+
+        page_element.define_singleton_method capybara_method do |*arguments, &block|
+          _self.call_hook &options[:before_hook]
+          original_method.call *arguments, &block
+          _self.call_hook &options[:after_hook]
+        end
+      end
+    end
+
+    def call_hook(&block)
+      @executing_hooks = true
+      result = instance_exec @browser, &block
+      @executing_hooks = false
+      result
     end
 
     private

data/lib/page_magic/element_context.rb

@@ -3,6 +3,8 @@ module PageMagic
   end
 
   class ElementContext
+    EVENT_TYPES = [:set, :select, :select_option, :unselect_option, :click]
+
     attr_reader :caller, :page_element
 
     def initialize(page_element, browser, caller, *_args)
@@ -11,55 +13,24 @@ module PageMagic
       @caller = caller
     end
 
-    def method_missing(method, *args)
-      return @caller.send(method, *args) if @executing_hooks
-      return @page_element.send(method, *args) if @page_element.methods.include?(method)
+    def method_missing(method, *args, &block)
+      return page_element.send(method, *args, &block) if page_element.methods.include?(method)
 
-      element_locator_factory = @page_element.element_definitions[method]
+      element_locator_factory = page_element.element_definitions[method]
 
-      fail ElementMissingException, "Could not find: #{method}" unless element_locator_factory
+      raise ElementMissingException, "Could not find: #{method}" unless element_locator_factory
 
       if args.empty?
-        element_locator = element_locator_factory.call(@page_element, nil)
+        element_locator = element_locator_factory.call(page_element, nil)
       else
-        element_locator = element_locator_factory.call(@page_element, *args)
-      end
-
-      [:set, :select_option, :unselect_option, :click].each do |action_method|
-        apply_hooks(page_element: element_locator.browser_element,
-                    capybara_method: action_method,
-                    before_hook: element_locator.before,
-                    after_hook: element_locator.after
-                   )
+        element_locator = element_locator_factory.call(page_element, *args)
       end
 
       element_locator.section? ? element_locator : element_locator.browser_element
     end
 
     def respond_to?(*args)
-      @page_element.element_definitions.keys.include?(args.first)
-    end
-
-    def apply_hooks(options)
-      _self = self
-      page_element = options[:page_element]
-      capybara_method = options[:capybara_method]
-      if page_element.respond_to?(capybara_method)
-        original_method = page_element.method(capybara_method)
-
-        page_element.define_singleton_method capybara_method do |*arguments, &block|
-          _self.call_hook &options[:before_hook]
-          original_method.call *arguments, &block
-          _self.call_hook &options[:after_hook]
-        end
-      end
-    end
-
-    def call_hook(&block)
-      @executing_hooks = true
-      result = instance_exec @browser, &block
-      @executing_hooks = false
-      result
+      page_element.element_definitions.keys.include?(args.first)
     end
   end
 end

data/spec/element_spec.rb

@@ -1,218 +1,232 @@
-describe 'Page elements' do
-  before :each do
-    Capybara.app = Class.new(Sinatra::Base) do
-      get '/' do
-        <<-HTML
-          <label>enter text
-          <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
+module PageMagic
 
-    Capybara.current_session.visit('/')
-  end
+  describe Element do
 
-  describe 'inheriting' do
     include_context :webapp
 
-    it 'lets you create custom elements' do
-      custom_element = Class.new(PageMagic::Element) do
-        selector css: '.form'
-
-        link :form_link, id: 'form_link'
-        def self.name
-          'Form'
-        end
-      end
-
-      page = Class.new do
+    let(:page_class) do
+      Class.new do
         include PageMagic
         url '/elements'
-        section custom_element
       end
+    end
 
-      page = page.new
-      page.visit
-      page.form.form_link.visible?.should be_true
+    let(:page) do
+      page_class.new.tap do |page|
+        page.visit
+      end
     end
-  end
 
-  it 'should raise an error if a selector has not been specified' do
-    expect { PageMagic::Element.new(:name, Object.new, type: :element).browser_element }.to raise_error(PageMagic::UndefinedSelectorException)
-  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'
+
+          def self.name
+            'Form'
+          end
+        end
 
-  describe '#respond_to?' do
-    subject do
-      PageMagic::Element.new(:name, Object.new, type: :element, browser_element: double(element_method: '')) do
-        element :sub_element, css: '.sub-element'
+        page_class.class_eval do
+          section custom_element, css: '.form'
+        end
+
+        expect(page.form.form_field).to be_visible
       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)
+    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)
     end
 
-    it 'checks for the method of the browser_element' do
-      expect(subject.respond_to?(:element_method)).to eq(true)
-    end
-  end
+    describe '#respond_to?' do
+      subject do
+        described_class.new(:name, Object.new, type: :element, 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
 
-  describe '#browser_element' do
-    let!(:browser) { double('browser') }
-    let!(:page) do
-      page_class = Class.new do
-        include PageMagic
+      it 'checks against registered elements' do
+        expect(subject.respond_to?(:sub_element)).to eq(true)
       end
-      page_class.new
-    end
 
-    context 'options supplied to selector' do
-      it 'passes them on to the cappybara finder method' do
-        options = { key: :value }
-        xpath_selector = '//input'
-        expect(Capybara.current_session).to receive(:find).with(:xpath, xpath_selector, options)
-        PageMagic::Element.new(:my_input, page, type: :text_field, selector: { xpath: xpath_selector }.merge(options)).browser_element
+      it 'checks for the method of the browser_element' do
+        expect(subject.respond_to?(:element_method)).to eq(true)
       end
     end
 
-    it 'should find by xpath' do
-      element = PageMagic::Element.new(:my_input, page, type: :text_field, selector: { xpath: '//input' }).browser_element
-      element.value == 'filled in'
-    end
+    describe '#browser_element' do
+      let!(:browser) { double('browser') }
 
-    it 'should locate an element using its id' do
-      element = PageMagic::Element.new(:my_input, page, type: :text_field, selector: { id: 'field_id' }).browser_element
-      element.value.should == 'filled in'
-    end
+      context 'options supplied to selector' do
+        it 'passes them on to the cappybara finder method' do
+          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
+        end
+      end
 
-    it 'should locate an element using its name' do
-      element = PageMagic::Element.new(:my_input, page, type: :text_field, selector: { name: 'field_name' }).browser_element
-      element.value.should == 'filled in'
-    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 label' do
-      element = PageMagic::Element.new(:my_link, page, type: :link, selector: { label: 'enter text' }).browser_element
-      element[:id].should == 'field_id'
-    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 raise an exception when finding another element using its text' do
-      expect { PageMagic::Element.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 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 css' do
-      element = PageMagic::Element.new(:my_link, page, type: :link, selector: { css: "input[name='field_name']" }).browser_element
-      element[:id].should == 'field_id'
-    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
+        expect(element[:id]).to eq('field_id')
+      end
 
-    it 'should return a prefetched value' do
-      PageMagic::Element.new(:help, page, type: :link, browser_element: :prefetched_object).browser_element.should == :prefetched_object
-    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 raise errors for unsupported selectors' do
-      expect { PageMagic::Element.new(:my_link, page, type: :link, selector: { unsupported: '' }).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
+        expect(element[:id]).to eq('field_id')
+      end
 
-    context 'text selector' do
-      it 'should locate a link' do
-        element = PageMagic::Element.new(:my_link, page, type: :link, selector: { text: 'my link' }).browser_element
-        element[:id].should == 'my_link'
+      it 'should return a prefetched value' do
+        described_class.new(:help, page, type: :link, browser_element: :prefetched_object).browser_element.should == :prefetched_object
       end
 
-      it 'should locate a button' do
-        element = PageMagic::Element.new(:my_button, page, type: :button, selector: { text: 'my button' }).browser_element
-        element[:id].should == 'my_button'
+      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)
       end
-    end
-  end
 
-  describe '#section?' do
-    context 'element definitions exist' do
-      subject do
-        PageMagic::Element.new(:my_link, :page, type: :link, selector: { text: 'my link' }) do
-          element :thing, text: 'text'
+      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
+          element[:id].should == 'form_button'
         end
-      end
-      it 'returns true' do
-        expect(subject.section?).to eq(true)
       end
     end
 
-    context 'method defined' do
-      subject do
-        PageMagic::Element.new(:my_link, :page, type: :link, selector: { text: 'my link' }) do
-          def custom_method
+    describe '#section?' do
+      context 'element definitions exist' do
+        subject do
+          described_class.new(:my_link, :page, type: :link, selector: {text: 'my link'}) do
+            element :thing, text: 'text'
+          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
           end
         end
+
+        it 'returns true' do
+          expect(subject.section?).to eq(true)
+        end
       end
 
-      it 'returns true' do
-        expect(subject.section?).to eq(true)
+      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
 
-    context 'neither method or elements defined' do
+    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)
+      end
+    end
+
+    describe 'hooks' do
       subject do
-        PageMagic::Element.new(:my_link, :page, type: :link, selector: { text: 'my link' })
+        described_class.new(:my_button, page, type: :button, selector: {id: 'my_button'}) do
+          before do
+            call_in_before_hook
+          end
+        end
       end
-      it 'returns false' do
-        expect(subject.section?).to eq(false)
+      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
-    end
-  end
 
-  describe 'session' do
-    it 'should have a handle to the session' do
-      page_class = Class.new do
-        include PageMagic
+      context 'method called in before hook' do
+        subject do
+          described_class.new(:my_button, page, type: :button, selector: {id: 'my_button'}) do
+            after do
+              call_in_after_hook
+            end
+          end
+        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
       end
-      page = page_class.new
 
-      PageMagic::Element.new(:help, page, type: :link, selector: :selector).session.should == page.session
     end
-  end
 
-  context 'tests coppied in from section' do
-    include_context :webapp
-
-    before :each do
-      @elements_page = elements_page.new
-      @elements_page.visit
-    end
+    describe '#method_missing' do
 
-    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')
+      before do
+        page_class.class_eval do
+          section :form_by_css, css: '.form' do
+            link(:link_in_form, text: 'a in a form')
+          end
         end
+      end
 
-        section :form_by_id do
-          selector id: 'form'
-          link(:link_in_form, text: 'a in a form')
-        end
+      it 'can delegate to capybara' do
+        expect(page.form_by_css).to be_visible
       end
-    end
 
-    describe 'method_missing' do
-      it 'should delegate to capybara' do
-        @elements_page.form_by_css.visible?.should be(true)
+      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
 
-      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
+      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
 
-    it 'can have elements' do
-      @elements_page.form_by_css.link_in_form.visible?.should be_true
     end
+
   end
-end
+end

data/spec/page_magic/element_context_spec.rb

@@ -1,126 +1,72 @@
-describe PageMagic::ElementContext do
-  include_context :webapp
+module PageMagic
 
-  let!(:page1) do
-    Class.new do
-      include PageMagic
-      url '/page1'
-      link(:next, text: 'next page')
+  describe ElementContext do
+    include_context :webapp
+
+    let!(:elements_page) do
+      Class.new do
+        include PageMagic
+        url '/elements'
+        link(:a_link, text: 'a link')
+      end
     end
-  end
 
-  let!(:elements_page) do
-    Class.new do
-      include PageMagic
-      url '/elements'
-      link(:a_link, text: 'a link')
+    let!(:session) do
+      double('session', raw_session: double('browser'))
     end
-  end
 
-  let!(:session) do
-    double('session', raw_session: double('browser'))
-  end
+    describe '#method_missing' do
 
-  describe 'resolving field definitions' do
-    it 'should only evaluate the targeted field definition' do
-      page1.class_eval do
-        link(:link, :selector) do
-          fail('should not have been evaluated')
+      let(:page) do
+        elements_page.new.tap do |page|
+          page.visit
         end
       end
-      page = page1.new
-      page.visit
-
-      described_class.new(page, page.browser, self).next
-    end
-  end
-
-  it 'should raise an error if an element is not found' do
-    expect { described_class.new(page1.new(session), session, self).missing_thing }.to raise_error PageMagic::ElementMissingException
-  end
 
-  it 'should attempt to execute method on page object it is defined' do
-    page1.class_eval do
-      def page_method
-        :called
+      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
+        end
       end
-    end
-
-    described_class.new(page1.new(session), session, self).page_method.should == :called
-  end
 
-  describe 'retrieving elements' do
-    it 'should give the capybara object' do
-      page = elements_page.new
-      page.visit
+      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.
+          expect(element.text).to eq('a link')
+        end
 
-      element = described_class.new(page, page.browser, self).a_link
-      element.text.should == 'a link'
-    end
-  end
+        it 'does not evaluate any of the other definitions' do
+          elements_page.class_eval do
+            link(:another_link, :selector) do
+              fail('should not have been evaluated')
+            end
+          end
 
-  describe 'accessing page sections' do
-    it 'should go through page sections' do
-      elements_page.class_eval do
-        section :form do
-          selector css: '.form'
-          link :form_link, text: 'in a form'
+          described_class.new(page, page.browser, self).a_link
         end
       end
 
-      page = elements_page.new
-      page.visit
-
-      described_class.new(page, page.browser, self).form
-    end
-
-    it 'should delegate to page element if method not found' do
-      # TODO: call page method, look for subelement, delagate to capybara object
-    end
-  end
-
-  describe 'hooks' do
-    subject(:page) do
-      elements_page.new.tap(&:visit)
-    end
-
-    before do
-      browser = page.browser
-      browser.should_receive(:call_in_before_hook)
-      browser.should_receive(:call_in_after_before_hook)
-    end
-
-    context 'section' do
-      it 'applies the hooks' do
-        elements_page.section(:form, id: 'form') do
-          link :form_link, id: 'form_link'
+      context 'method found on page_element' do
+        it 'calls page_element method' do
+          elements_page.class_eval do
+            def page_method
+              :called
+            end
+          end
 
-          before(&:call_in_before_hook)
-
-          after(&:call_in_after_before_hook)
+          expect(described_class.new(page, :browser, self).page_method).to eq(:called)
         end
-
-        described_class.new(page, page.browser, self).form.click
       end
     end
 
-    it 'should execute a before and after action that gives access to the browser' do
-      elements_page.link(:create, text: 'a link') do
-        before(&:call_in_before_hook)
-
-        after(&:call_in_after_before_hook)
+    describe '#respond_to?' do
+      subject do
+        described_class.new(elements_page.new(session), session, self)
+      end
+      it 'checks against the names of the elements passed in' do
+        expect(subject.respond_to?(:a_link)).to eq(true)
       end
-
-      described_class.new(page, page.browser, self).create.click
-    end
-  end
-
-  describe '#respond_to?' do
-    subject do
-      described_class.new(page1.new(session), session, self)
-    end
-    it 'checks against the names of the elements passed in' do
-      expect(subject.respond_to?(:next)).to eq(true)
     end
   end
-end
+end

data/spec/page_magic/elements_spec.rb

@@ -118,7 +118,7 @@ describe PageMagic::Elements do
     describe 'location' do
       context 'a prefetched object' do
         it 'should add a section' do
-          expected_section = PageMagic::Element.new(:element, parent_page_element, type: :section, browser_element: :object)
+          expected_section = PageMagic::Element.new(:page_section, parent_page_element, type: :element, browser_element: :object)
           page_elements.element :page_section, :object
           expected_section.should == page_elements.elements(parent_page_element).first
         end

data/spec/spec_helper.rb

@@ -12,6 +12,7 @@ require 'helpers/capybara'
 
 shared_context :files do
   require 'tmpdir'
+
   def scratch_dir
     @dir ||= Dir.mktmpdir
   end
@@ -40,19 +41,20 @@ RSpec.configure do
         end
       end
       alias_method :initialize_backup, :initialize
+
       def initialize(*args, &block)
         initialize_backup *args, &block
-        @before_hook = self.class.default_before_hook
-        @after_hook = self.class.default_after_hook
+        # @before_hook = self.class.default_before_hook
+        # @after_hook = self.class.default_after_hook
       end
 
       def ==(page_element)
         page_element.is_a?(Element) &&
-          @type == page_element.type &&
-          @name == page_element.name &&
-          @selector == page_element.selector
-        @before_hook == page_element.before &&
-          @after_hook == page_element.after
+            @type == page_element.type &&
+            @name == page_element.name &&
+            @selector == page_element.selector
+        # @before_hook == page_element.before &&
+        #     @after_hook == page_element.after
       end
     end
   end
@@ -72,11 +74,16 @@ RSpec.configure do
       get '/elements' do
         <<-ELEMENTS
           <a href='#'>a link</a>
-          <input type='submit' value='a button'/>
+
 
           <div id='form' class="form">
-            <a id='form_link' href='/page2'>a in a form</a>
+            <a id='form_link' href='/page2'>link in a form</a>
+            <label>enter text
+              <input id='field_id' name='field_name' class='input_class' type='text' value='filled in'/>
+            </label>
+            <input id='form_button' type='submit' value='a button'/>
           </form>
+
         ELEMENTS
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: page_magic
 version: !ruby/object:Gem::Version
-  version: 1.0.0.alpha10
+  version: 1.0.0.alpha11
 platform: ruby
 authors:
 - Leon Davis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-29 00:00:00.000000000 Z
+date: 2015-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capybara