druid-ts 0.0.1 → 1.1.0

data/spec/druid/elements/file_field_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::FileField do
+  describe "when mapping how to find an element" do
+    it "should map watir types to same" do
+      [:class, :id, :index, :name, :xpath, :title].each do |t|
+        identifier = Druid::Elements::FileField.identifier_for t => 'value'
+        expect(identifier.keys.first).to eql t
+      end
+    end
+  end
+
+  describe "interface" do
+    let(:element) { double 'element' }
+    let(:file_field) { Druid::Elements::FileField.new(element) }
+
+    it "should set its' value" do
+      expect(element).to receive(:set).with('a file')
+      file_field.value = 'a file'
+    end
+
+    it "should register as type :file" do
+      expect(Druid::Elements.element_class_for(:input, :file)).to be Druid::Elements::FileField
+    end
+  end
+end

data/spec/druid/elements/form_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::Form do
+  describe "when mapping how to find an element" do
+    it "should map watir types to same" do
+      [:class, :id, :index, :name, :xpath, :action].each do |t|
+        identifier = Druid::Elements::Form.identifier_for t => 'value'
+        expect(identifier.keys.first).to eql t
+      end
+    end
+  end
+
+  describe "interface" do
+    let(:element) { double 'element' }
+    let(:form) { Druid::Elements::Form.new(element) }
+
+    it "should submit a form" do
+      expect(element).to receive(:submit)
+      form.submit
+    end
+
+    it "should register with tag_name :form" do
+       expect(Druid::Elements.element_class_for(:form)).to be Druid::Elements::Form
+    end
+  end
+end

data/spec/druid/elements/heading_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::Heading do
+  describe "When mapping how to find an element" do
+    it "should map watir types to same" do
+      [:class, :id, :index, :name, :xpath].each do |t|
+        identifier = Druid::Elements::Heading.identifier_for t => 'value'
+        expect(identifier.keys.first).to eql t
+      end
+    end
+  end
+
+  describe "interface" do
+    it "should register with tag :h1" do
+      expect(Druid::Elements.element_class_for(:h1)).to be Druid::Elements::Heading
+    end
+
+    it "should register with tag :h2" do
+      expect(Druid::Elements.element_class_for(:h2)).to be Druid::Elements::Heading
+    end
+
+    it "should register with tag :h3" do
+      expect(Druid::Elements.element_class_for(:h3)).to be Druid::Elements::Heading
+    end
+
+    it "should register with tag :h4" do
+      expect(Druid::Elements.element_class_for(:h4)).to be Druid::Elements::Heading
+    end
+
+    it "should register with tag :h5" do
+      expect(Druid::Elements.element_class_for(:h5)).to be Druid::Elements::Heading
+    end
+
+    it "should register with tag :h6" do
+      expect(Druid::Elements.element_class_for(:h6)).to be Druid::Elements::Heading
+    end
+  end
+end

data/spec/druid/elements/hidden_field_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::HiddenField do
+  describe "when mapping how to find an element" do
+    it "should map watir types to same" do
+      [:class, :id, :index, :name, :xpath, :value].each do |t|
+        identifier = Druid::Elements::HiddenField.identifier_for t => 'value'
+        expect(identifier.keys.first).to eql t
+      end
+    end
+
+    it "should map selenium types to watir" do
+      identifier = Druid::Elements::HiddenField.identifier_for :css => 'value'
+      expect(identifier.keys.first).to eql :tag_name
+    end
+  end
+
+  describe "interface" do
+    it "should register with type :hidden" do
+      expect(Druid::Elements.element_class_for(:input, :hidden)).to be Druid::Elements::HiddenField
+    end
+  end
+end

data/spec/druid/elements/image_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::Image do
+  describe "when mapping how to find an element" do
+    it "should map watir types to same" do
+      [:class, :id, :index, :name, :xpath, :alt].each do |t|
+        identifier = Druid::Elements::Image.identifier_for t => 'value'
+        expect(identifier.keys.first).to eql t
+      end
+    end
+  end
+
+  describe "interface" do
+    let(:element) { 'element' }
+    let(:image) { Druid::Elements::Image.new(element) }
+
+    it "should know the image width" do
+      expect(element).to receive(:width).and_return(100)
+      expect(image.width).to eql 100
+    end
+
+    it "should know the image height" do
+      expect(element).to receive(:height).and_return(120)
+      expect(image.height).to eql 120
+    end
+
+    it "should register with tag_name :img" do
+      expect(Druid::Elements.element_class_for(:img)).to be Druid::Elements::Image
+    end
+  end
+end

data/spec/druid/elements/link_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::Link do
+  describe "when mapping how to find an element" do
+    it "should map watir types to same" do
+      [:class, :href, :id, :name, :text, :xpath].each do |t|
+        identifier = Druid::Elements::Link.identifier_for t => 'value'
+        expect(identifier.keys.first).to eql t
+      end
+    end
+
+    it "should map selenium types to watir" do
+      [:link, :link_text].each do |t|
+        identifier = Druid::Elements::Link.identifier_for t => 'value'
+        expect(identifier.keys.first).to eql :text
+      end
+    end
+  end
+
+  describe "interface" do
+    it "should register with tag :a" do
+      expect(Druid::Elements.element_class_for(:a)).to be Druid::Elements::Link
+    end
+  end
+end

data/spec/druid/elements/list_item_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::ListItem do
+  describe "when mapping how to find an element" do
+    it "should map watir types to same" do
+      [:class, :id, :index, :name, :xpath].each do |t|
+        identifier = Druid::Elements::ListItem.identifier_for t => 'value'
+        expect(identifier.keys.first).to eql t
+      end
+    end
+  end
+
+  describe "interface" do
+    it "should register as tag_name :li" do
+      expect(Druid::Elements.element_class_for(:li)).to be Druid::Elements::ListItem
+    end
+  end
+end

data/spec/druid/elements/option_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::Option do
+  describe "interface" do
+    it "should register as tag_name :option" do
+      expect(Druid::Elements.element_class_for(:option)).to be Druid::Elements::Option
+    end
+  end
+end

data/spec/druid/elements/ordered_list_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::OrderedList do
+  describe "when mapping how to find an element" do
+    it "should map watir types to same" do
+      [:class, :id, :index, :xpath].each do |t|
+        identifier = Druid::Elements::OrderedList.identifier_for t => 'value'
+        expect(identifier.keys.first).to eql t
+      end
+    end
+  end
+
+  describe "interface" do
+    let(:element) { double 'element' }
+    let(:ol) { Druid::Elements::OrderedList.new(element) }
+
+    it "should return a list item when indexed" do
+      expect(element).to receive(:li)
+      expect(ol[1]).to be_instance_of Druid::Elements::ListItem
+    end
+
+    it "should know how many list items it contains" do
+      expect(element).to receive_message_chain(:lis, :size).and_return(2)
+      expect(ol.items).to eql 2
+    end
+
+    it "should iterate over the list items" do
+      expect(ol).to receive(:items).and_return(2)
+      allow(ol).to receive(:[])
+      count = 0
+      ol.each do
+        count += 1
+      end
+      expect(count).to eql 2
+    end
+
+    it "should register as tag_name :ol" do
+      expect(Druid::Elements.element_class_for(:ol)).to be Druid::Elements::OrderedList
+    end
+  end
+end

data/spec/druid/elements/page_factory_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'druid/page_factory'
+
+class FactoryTestDruid
+  include Druid
+  page_url "http://www.baidu.com"
+end
+
+class TestWorld
+  include Druid::PageFactory
+
+  attr_accessor :driver
+end
+
+describe Druid::PageFactory do
+  before(:each) do
+    @world = TestWorld.new
+    @world.driver = mock_driver
+  end
+
+  it "should create and visit a new page" do
+    expect(@world.driver).to receive(:goto)
+    @world.visit_page FactoryTestDruid do |page|
+      expect(page).to be_instance_of FactoryTestDruid
+    end
+  end
+
+  it "should create a new page object and execute a block" do
+    expect(@world.driver).not_to receive(:goto)
+    @world.on_page FactoryTestDruid do |page|
+      expect(page).to be_instance_of FactoryTestDruid
+    end
+  end
+
+  it "should set an instance variable that can be used outside of the block" do
+    page = @world.on_page FactoryTestDruid
+    current_page = @world.instance_variable_get "@current_page"
+    expect(current_page).to eq page
+  end
+end

data/spec/druid/elements/paragraph_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::Paragraph do
+  let(:paragraph) { Druid::Elements::Paragraph }
+
+  describe "when mapping how to find an element" do
+    it "should map watir types to same" do
+      [:class, :id, :index, :name, :xpath].each do |t|
+        identifier = paragraph.identifier_for t => 'value'
+        expect(identifier.keys.first).to eql t
+      end
+    end
+  end
+
+  describe "interface" do
+    it "should register with type :checkbox" do
+      expect(Druid::Elements.element_class_for(:p)).to be Druid::Elements::Paragraph
+    end
+  end
+end

data/spec/druid/elements/radio_button_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::RadioButton do
+  describe "when mapping how to find an element" do
+    it "should map watir types to same" do
+      [:class, :id, :index, :name, :xpath, :value].each do |t|
+        identifier = Druid::Elements::RadioButton.identifier_for t => 'value'
+        expect(identifier.keys.first).to eql t
+      end
+    end
+  end
+
+  describe "interface" do
+    let(:element) { double("element") }
+    let(:driver) { double("driver") }
+    let(:radio) { Druid::Elements::RadioButton.new(element)}
+
+    it "should select" do
+      expect(element).to receive(:set)
+      radio.select
+    end
+
+    it "should clear" do
+      expect(element).to receive(:clear)
+      radio.clear
+    end
+
+    it "should know if it is selected" do
+      expect(element).to receive(:set?)
+      radio.selected?
+    end
+
+    it "should register as type :radio" do
+      expect(Druid::Elements.element_class_for(:input, :radio)).to be Druid::Elements::RadioButton
+    end
+  end
+end

data/spec/druid/elements/select_list_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::SelectList do
+  describe "when mapping how to find an element" do
+    it "should map watir types to same" do
+      [:class, :id, :index, :name, :xpath, :text, :value].each do |t|
+        identifier = Druid::Elements::SelectList.identifier_for t => 'value'
+        expect(identifier.keys.first).to eql t
+      end
+    end
+  end
+
+  describe "interface" do
+    let(:element) { double 'element' }
+    let(:select_list) { Druid::Elements::SelectList.new(element) }
+
+    it "should return an option when indexed" do
+      expect(element).to receive_message_chain(:options, :[]).with(1)
+      expect(select_list[1]).to be_instance_of Druid::Elements::Option
+    end
+
+    it "should retrieve all values of select_list" do
+      expect(element).to receive(:options).and_return(['val1','val2'])
+      expect(select_list.options).to eql ['val1','val2']
+    end
+
+    it "should select an element" do
+      expect(element).to receive(:select).with('test')
+      select_list.select('test')
+    end
+
+    it "should register with tag_name :select" do
+      expect(Druid::Elements.element_class_for(:select)).to be Druid::Elements::SelectList
+    end
+  end
+end

data/spec/druid/elements/span_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::Span do
+  describe "when mapping how to find an element" do
+    it "should map watir types to same"  do
+      [:class, :id, :index, :xpath, :text].each do |t|
+        identifier = Druid::Elements::Span.identifier_for t => 'value'
+        expect(identifier.keys.first).to eql t
+      end
+    end
+  end
+
+  describe "interface" do
+    it "should register with tag_name :span" do
+      expect(Druid::Elements.element_class_for(:span)).to be Druid::Elements::Span
+    end
+  end
+end

data/spec/druid/elements/table_cell_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'druid/elements'
+
+describe Druid::Elements::TableCell do
+  describe "when mapping how to find an element" do
+    it "should map watir types to same"  do
+      [:class, :id, :index, :xpath, :name, :text].each do |t|
+        identifier = Druid::Elements::TableCell.identifier_for t => 'value'
+        expect(identifier.keys.first).to eql t
+      end
+    end
+  end
+
+  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