page_magic 0.8.8

data/lib/page_magic.rb

@@ -0,0 +1,55 @@
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}")
+require 'capybara'
+require 'wait'
+require 'page_magic/wait'
+require 'page_magic/browser'
+require 'page_magic/session'
+require 'page_magic/ajax_support'
+require 'page_magic/page_elements'
+require 'page_magic/element_context'
+require 'page_magic/page_element'
+require 'page_magic/page_magic'
+require 'page_magic/page_section'
+
+module PageMagic
+  class << self
+    def session browser=nil, options = {}
+      if browser
+        Capybara.register_driver browser do |app|
+          options[:browser] = browser
+          Capybara::Selenium::Driver.new(app, options)
+        end
+        Session.new(Capybara::Session.new(browser, nil))
+      else
+        Capybara.reset!
+        Session.new(Capybara.current_session)
+      end
+    end
+
+    def included clazz
+      clazz.extend ClassMethods, PageElements
+      pages << clazz if clazz.is_a? Class
+
+      def clazz.url url=nil
+        @url = url if url
+        @url
+      end
+    end
+
+    def pages
+      @pages||=[]
+    end
+  end
+
+  module ClassMethods
+    def included clazz
+      clazz.instance_eval { include PageMagic }
+      clazz.element_definitions.merge!(element_definitions)
+    end
+
+    def method_missing method_name, *args
+      raise "You can only instantiate child pages" if method_name == :new
+      super
+    end
+  end
+end

data/page_magic.gemspec

@@ -0,0 +1,80 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "page_magic"
+  s.version = "0.8.8"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Leon Davis"]
+  s.date = "2013-11-10"
+  s.description = "Framework for modeling and interacting with webpages which wraps capybara"
+  s.email = "info@lad-tech.com"
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    ".ruby-gemset",
+    ".ruby-version",
+    ".travis.yml",
+    "Gemfile",
+    "Gemfile.lock",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "lib/page_magic.rb",
+    "lib/page_magic/ajax_support.rb",
+    "lib/page_magic/browser.rb",
+    "lib/page_magic/element_context.rb",
+    "lib/page_magic/page_element.rb",
+    "lib/page_magic/page_elements.rb",
+    "lib/page_magic/page_magic.rb",
+    "lib/page_magic/page_section.rb",
+    "lib/page_magic/session.rb",
+    "lib/page_magic/wait.rb",
+    "page_magic.gemspec",
+    "spec/browser_spec.rb",
+    "spec/element_context_spec.rb",
+    "spec/helpers.rb",
+    "spec/helpers/capybara.rb",
+    "spec/member_methods_spec.rb",
+    "spec/page_element_spec.rb",
+    "spec/page_elements_spec.rb",
+    "spec/page_magic_spec.rb",
+    "spec/page_section_spec.rb",
+    "spec/session_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = "https://github.com/ladtech/page_magic"
+  s.licenses = ["ruby"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.25"
+  s.summary = "Framework for modeling and interacting with webpages"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<watir-webdriver>, [">= 0"])
+      s.add_runtime_dependency(%q<capybara>, [">= 0"])
+      s.add_runtime_dependency(%q<wait>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.4"])
+      s.add_runtime_dependency(%q<watir-webdriver>, [">= 0"])
+    else
+      s.add_dependency(%q<watir-webdriver>, [">= 0"])
+      s.add_dependency(%q<capybara>, [">= 0"])
+      s.add_dependency(%q<wait>, [">= 0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
+      s.add_dependency(%q<watir-webdriver>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<watir-webdriver>, [">= 0"])
+    s.add_dependency(%q<capybara>, [">= 0"])
+    s.add_dependency(%q<wait>, [">= 0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
+    s.add_dependency(%q<watir-webdriver>, [">= 0"])
+  end
+end
+

data/spec/browser_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe PageMagic::Browser do
+  let(:app) { Object.new }
+
+  before do
+    PageMagic::Browser.session = nil
+    app.extend PageMagic::Browser
+  end
+
+  describe 'page' do
+    it 'should return the existing session' do
+      session = double(:session)
+      PageMagic::Browser.session = session
+
+      app.browser.should == session
+    end
+
+    it 'should create a session if not already set' do
+      new_session = double(:new_session)
+
+      PageMagic.should_receive(:session).with(:chrome).and_return new_session
+      app.browser.should == new_session
+    end
+
+    it 'should use custom browser' do
+      PageMagic::Browser.use :firefox
+
+      PageMagic.should_receive(:session).with(:firefox)
+      app.browser
+    end
+  end
+end

data/spec/element_context_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+require 'page_magic'
+
+describe 'Element Context' do
+
+  include_context :webapp
+
+  let!(:page1) do
+    Class.new do
+      include PageMagic
+      url '/page1'
+      link(:next, :text => "next page")
+    end
+  end
+
+  let!(:elements_page) do
+    Class.new do
+      include PageMagic
+      url '/elements'
+      link(:a_link, :text => "a link")
+    end
+  end
+
+  let!(:session) do
+    double('session', browser: double('browser'))
+  end
+
+  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")
+        end
+      end
+      page = page1.new
+      page.visit
+
+      PageMagic::ElementContext.new(page, page.browser, self).next
+    end
+  end
+
+  it 'should raise an error if an element is not found' do
+    expect { PageMagic::ElementContext.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
+      end
+    end
+
+    PageMagic::ElementContext.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
+
+      element = PageMagic::ElementContext.new(page, page.browser, self).a_link
+      element.text.should == 'a link'
+    end
+  end
+
+  describe 'actions' do
+    it 'should click the element' do
+      page = page1.new
+      page.visit
+
+      PageMagic::ElementContext.new(page, page.browser, self).click_next
+      page.current_path.should == '/page2'
+      page.text.should == 'page 2 content'
+    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'
+        end
+      end
+
+      page = elements_page.new
+      page.visit
+
+      PageMagic::ElementContext.new(page, page.browser, self).form('a', 'b')
+    end
+  end
+
+  describe 'hooks' do
+
+    it 'should execute a before and after action that gives access to the browser' do
+
+      page = elements_page.new
+      page.visit
+
+      selector = {text: 'a link'}
+      browser = page.browser
+      browser.should_receive(:call_in_before_hook)
+      browser.should_receive(:call_in_after_before_hook)
+
+
+      elements_page.link(:create, selector) do
+        before do |page_browser|
+          page_browser.call_in_before_hook
+        end
+
+        after do |page_browser|
+          page_browser.call_in_after_before_hook
+        end
+      end
+
+      PageMagic::ElementContext.new(page, page.browser, self).create.click
+    end
+
+  end
+
+end

data/spec/helpers/capybara.rb

@@ -0,0 +1,10 @@
+module Capybara
+  module Selenium
+    class Driver
+      def == driver
+        driver.respond_to?(:options) && self.options == driver.options &&
+            driver.respond_to?(:app) && self.app == driver.app
+      end
+    end
+  end
+end

data/spec/helpers.rb

@@ -0,0 +1 @@
+require 'helpers/capybara'

data/spec/member_methods_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'page_magic'
+
+describe 'member methods' do
+  
+  let(:page_object_class) do
+    Class.new do
+      extend PageMagic::PageElements
+    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::PageElements::ELEMENT_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::PageElement.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/page_element_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+require 'sinatra'
+
+
+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>
+        HTML
+      end
+    end
+
+    Capybara.current_session.visit('/')
+  end
+
+  describe 'location' do
+    let!(:browser) { double('browser') }
+    let!(:page) do
+      page_class = Class.new do
+        include PageMagic
+      end
+      page_class.new
+    end
+
+    it 'should locate an element using its id' do
+      element = PageMagic::PageElement.new(:my_input,page, :text_field, id:'field_id').locate
+      element.value == 'filled in'
+    end
+
+    it 'should locate an element using its name' do
+      element = PageMagic::PageElement.new(:my_input,page, :text_field, name:'field_name').locate
+      element.value == 'filled in'
+    end
+
+    it 'should locate a link using its text' do
+      element = PageMagic::PageElement.new(:my_link,page, :link, text: 'my link').locate
+      element[:id].should == 'my_link'
+    end
+
+    it 'should locate an element using its label' do
+      element = PageMagic::PageElement.new(:my_link,page, :link, label: 'enter text').locate
+      element[:id].should == 'field_id'
+    end
+
+    it 'should raise an exception when finding another element using its text' do
+      expect{PageMagic::PageElement.new(:my_link,page, :text_field, text: 'my link').locate}.to raise_error(PageMagic::UnsupportedSelectorException)
+    end
+
+    it 'should locate an element using css' do
+      element = PageMagic::PageElement.new(:my_link,page, :link, css: "input[name='field_name']").locate
+      element[:id].should == 'field_id'
+    end
+
+    it 'should raise errors for unsupported selectors' do
+      expect{PageMagic::PageElement.new(:my_link,page, :link, unsupported:"").locate}.to raise_error(PageMagic::UnsupportedSelectorException)
+    end
+
+
+
+    it 'should return the browser element if a selector was not specified' do
+      PageMagic::PageElement.new(:help, browser, :link, nil).locate.should == browser
+    end
+
+    #TODO - Bug here, parent element reference is not available
+    it 'should return a prefetched value' do
+      PageMagic::PageElement.new(:help, "prefetched text", :link ).locate.should == "prefetched text"
+    end
+
+    it 'should have a handle to the session' do
+      PageMagic::PageElement.new(:help, page, :link, :selector ).session.should == page.session
+    end
+  end
+
+end

data/spec/page_elements_spec.rb

@@ -0,0 +1,202 @@
+require 'spec_helper'
+require 'page_magic'
+
+describe PageMagic::PageElements do
+
+
+  let(:page_elements) do
+    page_element = Class.new do
+      extend(PageMagic::PageElements)
+    end
+  end
+
+  let(:selector) { {id: 'id'} }
+  let(:browser_element) { double('browser_element', find: :browser_element) }
+  let(:parent_page_element) 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
+        page_elements.text_field :name, selector
+        page_elements.element_definitions[:name].call(parent_page_element).should == PageMagic::PageElement.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::PageSection
+
+        def == object
+          object.class.is_a?(PageMagic::PageSection) &&
+              object.name == self.name
+        end
+      end
+    end
+
+    context '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
+
+    context 'using a class as a definition' do
+      it 'should add a section' do
+        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)
+      end
+    end
+
+    context 'using a block to define a section inline' do
+
+      context 'browser_element' do
+        before :each do
+
+          @browser, @element, @parent_page_element = double('browser'), double('element'), double('parent_page_element')
+          @parent_page_element.stub(:browser_element).and_return(@browser)
+          @browser.should_receive(:find).with(:css, :selector).twice.and_return(@element)
+        end
+
+        it 'should be assigned when selector is passed to section method' do
+          element = @element
+
+          page_elements.section :page_section, css: :selector do
+            browser_element.should == element
+          end
+
+          page_elements.element_definitions[:page_section].call(@parent_page_element)
+        end
+
+        it 'should be assigned when selector is defined in the block passed to the section method' do
+          element = @element
+
+          page_elements.section :page_section do
+            browser_element.should == nil
+            selector css: :selector
+            browser_element.should == element
+          end
+
+          page_elements.elements(@parent_page_element, nil)
+        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 do
+        end
+
+        expect { page_elements.elements(parent_page_element, arg) }.to raise_error(PageMagic::PageSection::UndefinedSelectorException)
+      end
+
+
+
+      it 'should pass args through to the block' do
+        page_elements.section :page_section, css: '.blah' do |arg|
+          arg[:passed_through] = true
+        end
+
+        arg, browser = {}, double('browser', find: :browser_element)
+        parent_page_element = double('parent_browser_element', browser_element: browser)
+        page_elements.elements(parent_page_element, arg)
+        arg[:passed_through].should be_true
+      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)
+    end
+  end
+
+  describe 'restrictions' do
+    it 'should not allow method names that match element names' do
+      expect do
+        page_elements.class_eval do
+          link(:hello, text: 'world')
+
+          def hello;
+          end
+        end
+      end.to raise_error(PageMagic::PageElements::InvalidMethodNameException)
+    end
+
+    it 'should not allow element names that match method names' do
+      expect do
+        page_elements.class_eval do
+          def hello;
+          end
+
+          link(:hello, text: 'world')
+        end
+      end.to raise_error(PageMagic::PageElements::InvalidElementNameException)
+    end
+
+    it 'should not allow duplicate element names' do
+      expect do
+        page_elements.class_eval do
+          link(:hello, text: 'world')
+          link(:hello, text: 'world')
+        end
+      end.to raise_error(PageMagic::PageElements::InvalidElementNameException)
+    end
+
+    it 'should not evaluate the elements when applying naming checks' do
+      page_elements.class_eval do
+        link(:link1, :selector) do
+          fail("should not have been evaluated")
+        end
+        link(:link2, :selector)
+      end
+    end
+  end
+end