druid-s 1.0.0

data/spec/druid/elements/table_cell_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::TableCell do
+  describe "interface" do
+    it "should register with tag_name :td" do
+      expect(Druid::Elements.element_class_for(:td)).to be Druid::Elements::TableCell
+    end
+
+    it "should register with tag_name :th" do
+      expect(Druid::Elements.element_class_for(:th)).to be Druid::Elements::TableCell
+    end
+  end
+end

data/spec/druid/elements/table_row_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::TableRow do
+  let(:table_cell) { double('table_cell') }
+  let(:element) { double 'element' }
+  let(:table_row) { Druid::Elements::TableRow.new(element) }
+
+  describe "interface" do
+
+    before(:each) do
+      allow(element).to receive(:find_elements).and_return(element)
+      allow(element).to receive(:cells).and_return(Array.new(2, Watir::TableCell))
+    end
+
+    it "should return a table cell when indexed" do
+      expect(table_row[1]).to be_instance_of Druid::Elements::TableCell
+    end
+
+    it "should return the number of columns" do
+      expect(table_row.columns).to eql 2
+    end
+
+    it "should iterate  over the table columns" do
+      count = 0
+      table_row.each{ count += 1}
+      expect(count).to eql 2
+    end
+
+    it "should register with tag_name :tr" do
+      expect(Druid::Elements.element_class_for(:tr)).to be Druid::Elements::TableRow
+    end
+  end
+end

data/spec/druid/elements/table_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::Table do
+  describe "interface" do
+    let(:element) { double('element')}
+
+    before(:each) do
+      allow(element).to receive(:rows).and_return(Array.new(2, Watir::TableRow))
+    end
+
+    it "should register with tag_name :table" do
+      expect(Druid::Elements.element_class_for(:table)).to eql Druid::Elements::Table
+    end
+
+    context "for sub methods" do
+
+      let(:table) { Druid::Elements::Table.new(element) }
+
+      it "should return a table row" do
+        expect(table[1]).to be_instance_of Druid::Elements::TableRow
+      end
+
+      it "should return the number of rows" do
+        expect(table.rows).to eql 2
+      end
+
+      it "should iterate over the table rows" do
+        count = 0
+        table.each do
+          count += 1
+        end
+        expect(count).to eql 2
+      end
+
+      it "should return the first row" do
+        expect(table.first_row).to be_instance_of Druid::Elements::TableRow
+      end
+
+      it "should return the last row" do
+        expect(table.last_row).to be_instance_of Druid::Elements::TableRow
+      end
+
+    end
+
+  end
+end

data/spec/druid/elements/text_area_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::TextArea do
+  describe "interface" do
+    let(:element) { double "element" }
+    let(:text_area) { Druid::Elements::TextArea.new(element) }
+
+    it "should register with tag_name :textarea" do
+      expect(Druid::Elements.element_class_for(:textarea)).to be Druid::Elements::TextArea
+    end
+  end
+end

data/spec/druid/elements/text_field_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::TextField do
+  describe "interface" do
+    let(:element) { double 'element' }
+    let(:text_field) { Druid::Elements::TextField.new(element) }
+
+    it "should register with type :text" do
+      expect(Druid::Elements.element_class_for(:input, :text)).to be Druid::Elements::TextField
+    end
+
+    it "should register with type :password" do
+      expect(Druid::Elements.element_class_for(:input, :password)).to be Druid::Elements::TextField
+    end
+
+    it "should append text" do
+      expect(element).to receive(:append).with('abc')
+      text_field.append('abc')
+    end
+  end
+end

data/spec/druid/elements/unordered_list_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::UnOrderedList do
+  let(:ul) { Druid::Elements::UnOrderedList.new(ul_element) }
+
+  describe "interface" do
+    let(:ul_element) { double('ul_element').as_null_object }
+    let(:li_element) { double('li_element').as_null_object }
+
+    it "should register with tag_name :ul" do
+      expect(Druid::Elements.element_class_for(:ul)).to be Druid::Elements::UnOrderedList
+    end
+
+    context "for sub method" do
+      before(:each) do
+        allow(ul_element).to receive(:children).and_return([li_element, li_element])
+        allow(li_element).to receive(:tag_name).and_return(:li)
+      end
+
+      it "should return a list item when indexed" do
+        expect(ul[1]).to be_instance_of Druid::Elements::ListItem
+      end
+
+      it "should know how many items it contains" do
+        expect(ul.items).to eql 2
+      end
+
+      it "should know how to iterate over the items" do
+        count = 0
+        ul.each { count += 1 }
+        expect(count).to eql 2
+      end
+    end
+
+
+
+  end
+end

data/spec/druid/javascript_framework_facade_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'druid/javascript/jquery'
+
+class TestClass
+  include Druid::JavascriptFrameworkFacade
+end
+
+describe Druid::JavascriptFrameworkFacade do
+  let(:facade) { Druid::JavascriptFrameworkFacade }
+
+  it "should allow the selection of a javascript framework" do
+    facade.framework = :jquery
+    expect(facade.framework).to eql :jquery
+  end
+
+  it "should register the jQuery script builder" do
+    facade.framework = :jquery
+    expect(facade.script_builder).to eql Druid::Javascript::JQuery
+  end
+
+  it "should return script for pending requests in jQuery" do
+    facade.framework = :jquery
+    expect(facade.pending_requests).to eql 'return jQuery.active'
+  end
+
+  it "should register the Prototype script builder" do
+    facade.framework = :prototype
+    expect(facade.script_builder).to eql Druid::Javascript::Prototype
+  end
+
+  it "should return script for pending requests in Prototype" do
+    facade.framework = :prototype
+    expect(facade.pending_requests).to eql "return Ajax.activeRequestCount"
+  end
+
+  it "should not allow you to set the framework to one it does not know about" do
+    expect{ facade.framework = :blah }.to raise_error "You specified the Javascript framework blah and it is unknown to the system"
+  end
+
+  it "should allow you to add a new javascript framework" do
+    module GoodFake
+      def self.pending_requests
+        "fake"
+      end
+    end
+
+    facade.add_framework(:blah, GoodFake)
+    facade.framework = :blah
+    expect(facade.pending_requests).to eql "fake"
+  end
+
+  it "should not allow you to add a new javascript framework that is invalid" do
+    module BadFake
+      def self.blah
+      end
+    end
+    expect{ facade.add_framework(:blah, BadFake) }.to raise_error "The Javascript framework you provided does not implement the necessary methods"
+  end
+end

data/spec/druid/nested_element_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe "Element with nested elements" do
+  let(:we) { double 'we'}
+  let(:element) { Druid::Elements::Element.new(we) }
+  let(:driver) { driver = element}
+
+  it "should find nested links" do
+    expect(we).to receive(:link).with(:id => 'blah').and_return(we)
+    element.link_element(:id => 'blah')
+  end
+
+  it "should find nested buttons" do
+    expect(we).to receive(:button).with(:id => 'blah').and_return(we)
+    element.button_element(:id => 'blah')
+  end
+
+  it "should find nested text fields" do
+    expect(we).to receive(:text_field).with(:id => 'blah').and_return(we)
+    element.text_field_element(:id => 'blah')
+  end
+
+  it "should find nested hidden fields" do
+    expect(we).to receive(:hidden).and_return(we)
+    element.hidden_field_element
+  end
+
+  it "should find nested text areas" do
+    expect(we).to receive(:textarea).and_return(we)
+    element.text_area_element
+  end
+
+  it "should find nested select list" do
+    expect(we).to receive(:select_list).and_return(we)
+    element.select_list_element
+  end
+
+  it "should find a nested checkbox" do
+    expect(we).to receive(:checkbox).and_return(we)
+    element.checkbox_element
+  end
+
+  it "should find a nested radio button" do
+    expect(we).to receive(:radio).and_return(we)
+    element.radio_button_element
+  end
+
+  it "should find a nested div" do
+    expect(we).to receive(:div).and_return(we)
+    element.div_element
+  end
+
+  it "should find a nested span" do
+    expect(we).to receive(:span).and_return(we)
+    element.span_element
+  end
+
+  it "should find a nested table" do
+    expect(we).to receive(:table).and_return(we)
+    element.table_element
+  end
+
+  it "should find a nested cell" do
+    expect(we).to receive(:td).and_return(we)
+    element.cell_element
+  end
+
+  it "should find a nested image" do
+    expect(we).to receive(:image).and_return(we)
+    element.image_element
+  end
+
+  it "should find a nested form" do
+    expect(we).to receive(:form).and_return(we)
+    element.form_element
+  end
+
+  it "should find a nested ordered list" do
+    expect(we).to receive(:ol).and_return(we)
+    element.ordered_list_element
+  end
+
+  it "should find a nested unordered list" do
+    expect(we).to receive(:ul).and_return(we)
+    element.unordered_list_element
+  end
+
+  it "should find a nested list item" do
+    expect(we).to receive(:li).and_return(we)
+    element.list_item_element
+  end
+
+  it "should find a nested h1" do
+    expect(we).to receive(:h1).and_return(we)
+    element.h1_element
+  end
+
+  it "should find a nested h2" do
+    expect(we).to receive(:h2).and_return(we)
+    element.h2_element
+  end
+
+  it "should find a nested h3" do
+    expect(we).to receive(:h3).and_return(we)
+    element.h3_element
+  end
+
+  it "should find a nested h4" do
+    expect(we).to receive(:h4).and_return(we)
+    element.h4_element
+  end
+
+  it "should find a nested h5" do
+    expect(we).to receive(:h5).and_return(we)
+    element.h5_element
+  end
+
+  it "should find a nested h6" do
+    expect(we).to receive(:h6).and_return(we)
+    element.h6_element
+  end
+
+  it "should find a nested paragraph" do
+    expect(we).to receive(:p).and_return(we)
+    element.paragraph_element
+  end
+end

data/spec/druid/page_factory_spec.rb

@@ -0,0 +1,235 @@
+require 'spec_helper'
+require 'druid/page_factory'
+
+class FactoryTestDruid
+  include Druid
+  page_url "http://google.com"
+end
+
+class TestPageWithDirectUrl
+  include Druid
+  direct_url "http://google.com"
+end
+
+class AnotherPage
+  include Druid
+end
+
+class YetAnotherPage
+  include Druid
+end
+
+module ContainingModule
+  class PageInsideModule
+    include Druid
+    page_url "http://google.co.uk"
+  end
+end
+
+class WorldSuper
+  attr_reader :super_called
+  def on_page(cls, params={}, visit=false, &block)
+    @super_called = true
+  end
+end
+
+class TestWorld < WorldSuper
+  include Druid::PageFactory
+  attr_accessor :driver
+  attr_accessor :current_page
+end
+
+describe Druid::PageFactory do
+
+  let(:world) { TestWorld.new }
+  let(:driver) do
+    world.driver = mock_driver
+    driver = world.driver
+  end
+
+  it "should call super when non druid class passed" do
+    class NoDruid
+    end
+    world.on(NoDruid)
+    expect(world.super_called).to be true
+  end
+
+  it "should create a new page object and execute a block" do
+    expect(driver).not_to receive(:goto)
+    world.on_page FactoryTestDruid do |page|
+      expect(page).to be_instance_of FactoryTestDruid
+    end
+    world.on_page "FactoryTestDruid" do |page|
+      expect(page).to be_instance_of FactoryTestDruid
+    end
+    world.on_page "ContainingModule::PageInsideModule" do |page|
+      expect(page).to be_instance_of ContainingModule::PageInsideModule
+    end
+  end
+
+  it "should create a new page object and execute a block using 'on'" do
+    expect(driver).not_to receive(:goto)
+    world.on FactoryTestDruid do |page|
+      expect(page).to be_instance_of FactoryTestDruid
+    end
+    world.on "FactoryTestDruid" do |page|
+      expect(page).to be_instance_of FactoryTestDruid
+    end
+    world.on "ContainingModule::PageInsideModule" do |page|
+      expect(page).to be_instance_of ContainingModule::PageInsideModule
+    end
+  end
+
+  it "should create and visit a new page" do
+    expect(driver).to receive(:goto).exactly(3).times
+    world.visit_page FactoryTestDruid do |page|
+      expect(page).to be_instance_of FactoryTestDruid
+    end
+    world.visit_page "FactoryTestDruid" do |page|
+      expect(page).to be_instance_of FactoryTestDruid
+    end
+    world.visit_page "ContainingModule::PageInsideModule" do |page|
+      expect(page).to be_instance_of ContainingModule::PageInsideModule
+    end
+  end
+
+  it "should merge params with the class level params if provided when visiting" do
+    expect(driver).to receive(:goto)
+    FactoryTestDruid.params = {:initial => :value}
+    world.visit_page(FactoryTestDruid, :using_params => {:new_value => :merged})
+    merged = FactoryTestDruid.instance_variable_get("@merged_params")
+    expect(merged[:initial]).to eql :value
+    expect(merged[:new_value]).to eql :merged
+  end
+
+  it "should use the params in the url when they are provided" do
+    class PageUsingParams
+      include Druid
+      page_url "http://google.com/<%=params[:value]%>"
+    end
+    expect(driver).to receive(:goto).with("http://google.com/Druid")
+    world.visit_page(PageUsingParams, :using_params => {:value => 'Druid'})
+  end
+
+  it "should use the params as well as interpolated values" do
+    class PageUsingParamsAndInterpolated
+      include Druid
+      page_url "http://google.com/#{1+2}/<%=params[:value]%>"
+    end
+    expect(driver).to receive(:goto).with("http://google.com/3/Druid")
+    world.visit_page(PageUsingParamsAndInterpolated, :using_params => {:value => 'Druid'})
+  end
+
+  it "should create and visit a new page using 'visit'" do
+    expect(driver).to receive(:goto).exactly(3).times
+    world.visit FactoryTestDruid do |page|
+      expect(page).to be_instance_of FactoryTestDruid
+    end
+    world.visit "FactoryTestDruid" do |page|
+      expect(page).to be_instance_of FactoryTestDruid
+    end
+    world.visit "ContainingModule::PageInsideModule" do |page|
+      expect(page).to be_instance_of ContainingModule::PageInsideModule
+    end
+  end
+
+  it "should create and visit a new page when url is defined as 'direct_url'" do
+    expect(driver).to receive(:goto)
+    world.visit TestPageWithDirectUrl do |page|
+      expect(page).to be_instance_of TestPageWithDirectUrl
+    end
+  end
+
+  it "should set an instance variable that can be used outside of the block" do
+    expect(driver).not_to receive(:goto)
+    page = world.on_page FactoryTestDruid
+    current_page = world.instance_variable_get "@current_page"
+    expect(current_page).to be page
+  end
+
+  it "should not execute block if page is not @current_page" do
+    world.instance_variable_set "@current_page", TestPageWithDirectUrl.new(driver)
+    world.if_page(FactoryTestDruid) do |page|
+      fail
+    end
+    world.if_page("FactoryTestDruid") do |page|
+      fail
+    end
+    world.if_page("ContainingModule::PageInsideModule") do |page|
+      fail
+    end
+  end
+
+  it "should return the @current_page if asking for another page" do
+    expected = TestPageWithDirectUrl.new(driver)
+    world.instance_variable_set "@current_page", expected
+    expect(world.if_page(FactoryTestDruid)).to be expected
+    expect(world.if_page("FactoryTestDruid")).to be expected
+    expect(world.if_page("ContainingModule::PageInsideModule")).to be expected
+  end
+
+  it "should execute the block when we ask if it is the correct page" do
+    world.instance_variable_set "@current_page", FactoryTestDruid.new(driver)
+    done = false
+    world.if_page(FactoryTestDruid) do |page|
+      expect(page).to be_instance_of FactoryTestDruid
+      done = true
+    end
+    expect(done).to be true
+    done = false
+    world.if_page("FactoryTestDruid") do |page|
+      expect(page).to be_instance_of FactoryTestDruid
+      done = true
+    end
+    expect(done).to be true
+    done = false
+    world.instance_variable_set "@current_page", ContainingModule::PageInsideModule.new(driver)
+    world.if_page("ContainingModule::PageInsideModule") do |page|
+      expect(page).to be_instance_of ContainingModule::PageInsideModule
+      done = true
+    end
+    expect(done).to be true
+  end
+
+  it "should raise an error when you do not provide a default route" do
+    expect { Druid::PageFactory.routes = {:another => []} }.to raise_error 'You must provide a :default route'
+  end
+
+  it "should store the routes" do
+    routes = ['a', 'b', 'c']
+    Druid::PageFactory.routes = {:default => routes}
+    expect(Druid::PageFactory.routes[:default]).to eql routes
+  end
+
+  it "should navigate to a page calling the default methods" do
+    pages = [[FactoryTestDruid, :a_method], [AnotherPage, :b_method]]
+    Druid::PageFactory.routes = {:default => pages}
+    fake_page = double('a_page')
+    expect(FactoryTestDruid).to receive(:new).with(driver,false).and_return(fake_page)
+    expect(fake_page).to receive(:a_method)
+    expect(world.navigate_to(AnotherPage).class).to eql AnotherPage
+  end
+
+  it "should pass parameters to methods when navigating" do
+    pages = [[FactoryTestDruid, :a_method, 'blah'], [AnotherPage, :b_method]]
+    Druid::PageFactory.routes = {:default => pages}
+    fake_page = double('a_page')
+    expect(FactoryTestDruid).to receive(:new).with(driver,false).and_return(fake_page)
+    expect(fake_page).to receive(:a_method).with('blah')
+    expect(world.navigate_to(AnotherPage).class).to eql AnotherPage
+  end
+
+  it "should fail when it does not find a proper route" do
+    Druid::PageFactory.routes = {:default => ['a'], :another => ['b']}
+    expect{world.navigate_to(AnotherPage, :using => :no_route)}.to raise_error 'PageFactory route :no_route not found'
+  end
+
+  it "should fail when no default method specified" do
+    Druid::PageFactory.routes = {:default => [[FactoryTestDruid, :a_method], [AnotherPage, :b_method]]}
+    fake_page = double('a_page')
+    expect(FactoryTestDruid).to receive(:new).and_return(fake_page)
+    expect(fake_page).to receive(:respond_to?).with(:a_method).and_return(false)
+    expect{world.navigate_to(AnotherPage)}.to raise_error "Navigation method 'a_method' not defined on FactoryTestDruid."
+  end
+
+end