druid-ts 0.0.1

data/features/step_definations/image_steps.rb

@@ -0,0 +1,19 @@
+When(/^I get the image element$/) do
+  @element = @page.image_id_image
+end
+
+Then(/^the image should be "(.*?)" pixels wide$/) do |width|
+  expect(@element.width.to_s).to eql width
+end
+
+Then(/^the image should be "(.*?)" pixels tall$/) do |height|
+  expect(@element.height.to_s).to eql height
+end
+
+When(/^I get the image element by "(.*?)"$/) do |how|
+  @element = @page.send "image_#{how}_image".to_sym
+end
+
+When /^I get the image element bys "([^"]*)" and "([^"]*)"$/ do |param1, param2|
+  @element = @page.send "image_#{param1}_#{param2}_image"
+end

data/features/step_definations/link_steps.rb

@@ -0,0 +1,29 @@
+When(/^I select the link labeled "(.*?)"$/) do |text|
+  @page.google_search_id_link
+  @page.google_search_id
+end
+
+When(/^I locate the link by "(.*?)"$/) do |how|
+  @how = how
+end
+
+Then(/^I should be able to select the link$/) do
+  @page.send "google_search_#{@how}_link".to_sym
+  @page.send "google_search_#{@how}".to_sym
+end
+
+When(/^I retrieve a link element$/) do
+  @element = @page.google_search_id_link
+end
+
+Then(/^I should know it exists$/) do
+  expect(@element.exist?).to be true
+end
+
+Then(/^I should know it is visible$/) do
+  expect(@element.visible?).to be true
+end
+
+When(/^I select a link labeled "(.*?)" and index "(.*?)"$/) do |label, index|
+  @page.send "#{label.downcase}#{index}".to_sym
+end

data/features/step_definations/list_item_steps.rb

@@ -0,0 +1,12 @@
+When(/^I get the text from the list item$/) do
+  @text = @page.li_id
+end
+
+When(/^I locate the list item by "(.*?)"$/) do |how|
+  @element = @page.send "li_#{how}_list_item".to_sym
+  @text = @element.text
+end
+
+When(/^I search for the list item by "(.*?)" and "(.*?)"$/) do |param1, param2|
+  @text = @page.send "li_#{param1}_#{param2}"
+end

data/features/step_definations/ordered_list_steps.rb

@@ -0,0 +1,33 @@
+When(/^I get the first item from the ordered list$/) do
+  @element = @page.ol_id_ordered_list[0]
+end
+
+Then(/^the list item's text should be "(.*?)"$/) do |text|
+  expect(@element.text).to eql text
+end
+
+When(/^I locate the ordered list by "(.*?)"$/) do |how|
+  @list = @page.send "ol_#{how}_ordered_list"
+end
+
+When(/^I get the first item from the list$/) do
+  @element = @list[0]
+end
+
+Then(/^the list should contain (\d+) items$/) do |items|
+  expect(@list.items).to eql items.to_i
+end
+
+Then(/^each item should contain "(.*?)"$/) do |text|
+  @list.each do |item|
+    expect(item.text).to include text
+  end
+end
+
+When(/^I search for the ordered list by "(.*?)" and "(.*?)"$/) do |param1, param2|
+  @list = @page.send "ol_#{param1}_#{param2}_ordered_list"
+end
+
+Then(/^the list items text should be "(.*?)"$/) do |expected_text|
+  expect(@element.text).to eql expected_text
+end

data/features/step_definations/page_level_actions_steps.rb

@@ -0,0 +1,48 @@
+Then(/^the page should contain the text "(.*?)"$/) do |text|
+  expect(@page.text).to include text
+end
+
+Then(/^the page should contain the html "(.*?)"$/) do |html|
+  expect(@page.html).to include html
+end
+
+Then(/^the page should have the title "(.*?)"$/) do |title|
+  expect(@page.title).to include title
+end
+
+Then(/^I am able to go to baidu\.com$/) do
+  @page.goto
+end
+
+Given(/^I can goto baidu\.com by default$/) do
+  @page = Page.new(@driver)
+  @page.goto
+end
+
+Given(/^I can goto baidu\.com using visit_page without block$/) do
+  visit_page(Page)
+  # @page = visit_page Page
+end
+
+Then(/^the page should have the title "(.*?)" using on_page without block$/) do |text|
+  expect(on_page(Page).title).to include text
+  # expect(on_page(@page).title).to include text
+end
+
+Given(/^I can goto baidu\.com using visit_page with block$/) do
+  visit_page(Page) do |page|
+    expect(page.title).to include "百度"
+  end
+  # @page = visit_page Page do |page|
+  #   expect(page.title).to include "百度"
+  # end
+end
+
+Then(/^the page should have the title "(.*?)" using on_page with block$/) do |text|
+  on_page(Page) do |page|
+    expect(page.title).to include text
+  end
+  # on_page(@page) do |page|
+  #   expect(page.title).to include text
+  # end
+end

data/features/step_definations/page_traversal_steps.rb

@@ -0,0 +1,4 @@
+Given /^I am on the static elements page$/ do
+  @page = Page.new(@driver)
+  @page.navigate_to(UrlHelper.static_elements)
+end

data/features/step_definations/radio_button_steps.rb

@@ -0,0 +1,23 @@
+When(/^I select the "(.*?)" radio button$/) do |name|
+  @page.send "select_#{name.downcase}_id".to_sym
+end
+
+Then(/^the "(.*?)" radio button should be selected$/) do |name|
+  expect(@page.send "#{name.downcase}_id_selected?".to_sym).to be true
+end
+
+When(/^I locate the radio button by "(.*?)"$/) do |how|
+  @how = how
+end
+
+When(/^I select the radio button$/) do
+  @page.send "select_milk_#{@how}".to_sym
+end
+
+When(/^I retrieve a radio button$/) do
+  @element = @page.milk_id_radio_button
+end
+
+When(/^I search for the radio button by "(.*?)" and "(.*?)"$/) do |param1, param2|
+  @how = "#{param1}_#{param2}"
+end

data/features/step_definations/select_list_steps.rb

@@ -0,0 +1,42 @@
+When(/^I select "(.*?)" from the select list$/) do |item|
+  @page.select_list_id = item
+end
+
+Then(/^the current item should be "(.*?)"$/) do |expected_item|
+  expect(@page.select_list_id).to eql expected_item
+end
+
+When(/^I locate the select list by "(.*?)"$/) do |how|
+  @how = how
+end
+
+Then(/^I should be able to select "(.*?)"$/) do |item|
+  @page.send "select_list_#{@how}=".to_sym, item
+end
+
+Then(/^the value for the selected item should be "(.*?)"$/) do |expected_item|
+  expect(@page.send "select_list_#{@how}".to_sym).to eql expected_item
+end
+
+When(/^I retrieve a select list$/) do
+  @element = @page.select_list_id_select_list
+end
+
+When(/^I search for the select list by "(.*?)"$/) do |how|
+  @how = how
+end
+
+Then(/^option "(.*?)" should contain "(.*?)"$/) do |opt_num, text|
+  @element = @page.send "select_list_#{@how}_select_list".to_sym
+  expect(@element[opt_num.to_i - 1].text).to eql text
+end
+
+Then(/^each option should contain "(.*?)"$/) do |text|
+  @element.options.each do |option|
+    expect(option.text).to include text
+  end
+end
+
+When(/^I search for the select list bys "(.*?)" and "(.*?)"$/) do |param1, param2|
+  @how = "#{param1}_#{param2}"
+end

data/features/step_definations/span_steps.rb

@@ -0,0 +1,15 @@
+When(/^I get the text from the span$/) do
+  @text = @page.span_id
+end
+
+When(/^I locate the span by "(.*?)"$/) do |how|
+  @text = @page.send "span_#{how}".to_sym
+end
+
+When(/^I retrieve a span element$/) do
+  @element = @page.span_id_span
+end
+
+When(/^I search for the span by "(.*?)" and "(.*?)"$/) do |param1, param2|
+  @text = @page.send "span_#{param1}_#{param2}".to_sym
+end

data/features/step_definations/table_cell_steps.rb

@@ -0,0 +1,19 @@
+When(/^I retrieve the data from the table cell$/) do
+  @cell_text = @page.cell_id
+end
+
+Then(/^the cell data should be '(.*?)'$/) do |expected_text|
+  expect(@cell_text).to eql expected_text
+end
+
+When(/^I locate the table cell by "(.*?)"$/) do |how|
+  @cell_text = @page.send "cell_#{how}".to_sym
+end
+
+When(/^I retrieve table cell$/) do
+  @element = @page.cell_id_cell
+end
+
+When(/^I retrieve a table cell element by "(.*?)" and "(.*?)"$/) do |param1, param2|
+  @cell_text = @page.send "cell_#{param1}_#{param2}".to_sym
+end

data/features/step_definations/table_steps.rb

@@ -0,0 +1,38 @@
+When(/^I retrieve a table element$/) do
+  @element = @page.table_id_table
+end
+
+When(/^I retrieve a table element by "(.*?)"$/) do |how|
+  @element = @page.send "table_#{how}_table".to_sym
+end
+
+Then(/^the data for row "(.*?)" should be "(.*?)" and "(.*?)"$/) do |row, col1, col2|
+   row = @element[row.to_i - 1]
+   expect(row[0].text).to eql col1
+   expect(row[1].text).to eql col2
+end
+
+Then(/^the table should have "(.*?)" rows$/) do |number|
+  expect(@element.rows).to eql number.to_i
+end
+
+Then(/^each row should contain "(.*?)"$/) do |text|
+  @element.each do |row|
+    expect(row.text).to include text
+  end
+end
+
+Then(/^row "(.*?)" should have "(.*?)" columns$/) do |row, cols|
+  expect(@element[row.to_i - 1].columns).to eql cols.to_i
+end
+
+Then(/^each column should contain "(.*?)"$/) do |text|
+  row = @element[0]
+  row.each do |column|
+    expect(column.text).to include text
+  end
+end
+
+When(/^I retrieve a table element bys "(.*?)" and "(.*?)"$/) do |param1, param2|
+  @element = @page.send "table_#{param1}_#{param2}_table".to_sym
+end

data/features/step_definations/text_area_steps.rb

@@ -0,0 +1,19 @@
+When(/^I type "(.*?)" into the text area$/) do |text|
+  @page.text_area_id = text
+end
+
+Then(/^the text area should contain "(.*?)"$/) do |text|
+  expect(@page.text_area_id).to eql text
+end
+
+When(/^I locate the text area by "(.*?)"$/) do |how|
+  @element = @page.send "text_area_#{how}_text_area".to_sym
+end
+
+Then(/^I should be able to type "(.*?)" into the area$/) do |text|
+  @element.send_keys text
+end
+
+When(/^I search for the text area by "(.*?)" and "(.*?)"$/) do |param1, param2|
+  @element = @page.send "text_area_#{param1}_#{param2}_text_area".to_sym
+end

data/features/step_definations/text_field_steps.rb

@@ -0,0 +1,23 @@
+When(/^I type "(.*?)" into the text field$/) do |text|
+  @page.text_field_id = text
+end
+
+Then(/^the text field should contain "(.*?)"$/) do |expected_text|
+  expect(@page.text_field_id).to include expected_text
+end
+
+When(/^I locate the text field by "(.*?)"$/) do |how|
+  @how = how
+end
+
+Then(/^I should be able to type "(.*?)" into the field$/) do |value|
+  @page.send "text_field_#{@how}=".to_sym, value
+end
+
+When(/^I retrieve a text field$/) do
+  @element = @page.text_field_id_text_field
+end
+
+When(/^I search for the text field by "(.*?)" and "(.*?)"$/) do |param1, param2|
+  @how = "#{param1}_#{param2}"
+end

data/features/step_definations/unordered_list_steps.rb

@@ -0,0 +1,11 @@
+When(/^I get the first item from the unordered list$/) do
+  @element = @page.ul_id_unordered_list[0]
+end
+
+When(/^I locate the unordered list by "(.*?)"$/) do |how|
+  @list = @page.send "ul_#{how}_unordered_list".to_sym
+end
+
+When(/^I search for the unordered list by "(.*?)" and "(.*?)"$/) do |param1, param2|
+  @list = @page.send "ul_#{param1}_#{param2}_unordered_list".to_sym
+end

data/features/support/env.rb

@@ -0,0 +1,17 @@
+require 'simplecov'
+SimpleCov.start if ENV["COVERAGE"]
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '../../', 'lib'))
+
+require 'watir-webdriver'
+require 'druid'
+
+World(Druid::PageFactory)
+
+Before do
+  @driver = Watir::Browser.new :firefox if ENV['DRIVER'] == 'WATIR'
+end
+
+After do |s|
+  @driver.close
+end

data/features/support/page.rb

@@ -0,0 +1,163 @@
+class Page
+  include Druid
+  page_url("http://www.baidu.com")
+
+  link(:google_search_id, :id => "link_id")
+  link(:google_search_name, :name => "link_name")
+  link(:google_search_class, :class => "link_class")
+  link(:google_search_xpath, :xpath => "//a[text()='Google Search']")
+  link(:google_search_href, :href => "success.html")
+  link(:google_search_text, :text => "Google Search")
+  link(:google_search_index, :index => 0)
+  link(:google_search_link, :link => "Google Search")
+  link(:google_search_link_text, :link_text => "Google Search")
+  link(:hello0, {:text => "Hello", :index => 0})
+  link(:hello1, {:text => "Hello", :index => 1})
+  link(:hello2, {:text => "Hello", :index => 2})
+
+  text_field(:text_field_id, :id => "text_field_id")
+  text_field(:text_field_class, :class => "text_field_class")
+  text_field(:text_field_name, :name => "text_field_name")
+  text_field(:text_field_xpath, :xpath => "//input[@type='text']")
+  text_field(:text_field_css, :css => "input[type='text']")
+  text_field(:text_field_tag_name, :tag_name => "input[type='text']")
+  text_field(:text_field_index, :index => 0)
+  text_field(:text_field_text, :text => "")
+  text_field(:text_field_value, :value => "")
+  text_field(:text_field_class_index, :class => "text_field_class", :index => 0)
+  text_field(:text_field_name_index, :name => "text_field_name", :index => 0)
+
+  checkbox(:cb_id, :id => "cb_id")
+  checkbox(:cb_name, :name => 'cb_name')
+  checkbox(:cb_class, :class => 'cb_class')
+  checkbox(:cb_index, :index => 0)
+  checkbox(:cb_xpath, :xpath => "//input[@type='checkbox']")
+  checkbox(:cb_class_index, :class => "cb_class", :index => 0)
+  checkbox(:cb_name_index, :name => "cb_name", :index => 0)
+
+  select_list(:select_list_id, :id => "sel_list_id")
+  select_list(:select_list_class, :class => "sel_list_class")
+  select_list(:select_list_index, :index => 0)
+  select_list(:select_list_name, :name => "sel_list_name")
+  select_list(:select_list_xpath, :xpath => "//select")
+  select_list(:select_list_text, :text => "Test 1")
+  select_list(:select_list_value, :value => "option1")
+  select_list(:select_list_class_index, :class => "sel_list_class", :index => 0)
+  select_list(:select_list_name_index, :name => "sel_list_name", :index => 0)
+
+  radio_button(:milk_id, :id => 'milk_id')
+  radio_button(:butter_id, :id => 'butter_id')
+  radio_button(:milk_name, :name => 'milk_name')
+  radio_button(:milk_class, :class => 'milk_class')
+  radio_button(:milk_index, :index => 0)
+  radio_button(:milk_xpath, :xpath => "//input[@type='radio']")
+  radio_button(:milk_class_index, :class => "milk_class", :index => 0)
+  radio_button(:milk_name_index, :name => "milk_name", :index => 0)
+
+  button(:button_id, :id => 'button_id')
+  button(:button_name, :name => 'button_name')
+  button(:button_class, :class => 'button_class')
+  button(:button_index, :index => 0)
+  button(:button_xpath, :xpath=> "//input[@type='submit']")
+  button(:button_text, :text => 'Click Me')
+  button(:button_class_index, :class => "button_class", :index => 0)
+  button(:button_name_index, :name => "button_name", :index => 0)
+
+  div(:div_id, :id => "div_id")
+  div(:div_name, :name => "div_name")
+  div(:div_class, :class => 'div_class')
+  div(:div_index, :index => 0)
+  div(:div_xpath, :xpath => '//div')
+  div(:div_class_index, :class => "div_class", :index => 0)
+  div(:div_name_index, :name => "div_name", :index => 0)
+
+  table(:table_id, :id => "table_id")
+  table(:table_class, :class => 'table_class')
+  table(:table_index, :index => 0)
+  table(:table_xpath, :xpath => '//table')
+  table(:table_name, :name => 'table_name')
+  table(:table_class_index, :class => "table_class", :index => 0)
+  table(:table_name_index, :name => "table_name", :index => 0)
+
+  cell(:cell_id, :id => 'cell_id')
+  cell(:cell_class, :class => 'cell_class')
+  cell(:cell_index, :index => 3)
+  cell(:cell_xpath, :xpath => '//table//tr[2]//td[2]')
+  cell(:cell_name, :name => 'cell_name')
+  cell(:cell_class_index, :class => "cell_class", :index => 0)
+  cell(:cell_name_index, :name => "cell_name", :index => 0)
+
+  span(:span_id, :id => "span_id")
+  span(:span_class, :class => 'span_class')
+  span(:span_index, :index => 0)
+  span(:span_xpath, :xpath => '//span')
+  span(:span_name, :name => 'span_name')
+  span(:span_class_index, :class => "span_class", :index => 0)
+  span(:span_name_index, :name => "span_name", :index => 0)
+
+  image(:image_id, :id => "image_id")
+  image(:image_name, :name => 'image_name')
+  image(:image_class, :class => 'image_class')
+  image(:image_index, :index => 0)
+  image(:image_xpath, :xpath => '//img')
+  image(:image_class_index, :class => "image_class", :index => 0)
+  image(:image_name_index, :name => "image_name", :index => 0)
+
+  form(:form_id, :id => 'form_id')
+  form(:form_name, :id => 'form_name')
+  form(:form_class, :class => 'form_class')
+  form(:form_index, :index => 0)
+  form(:form_xpath, :xpath => '//form')
+  form(:form_class_index, :class => "form_class", :index => 0)
+  form(:form_name_index, :name => "form_name", :index => 0)
+
+  hidden_field(:hidden_field_id, :id => "hidden_field_id")
+  hidden_field(:hidden_field_class, :class => "hidden_field_class")
+  hidden_field(:hidden_field_name, :name => "hidden_field_name")
+  hidden_field(:hidden_field_xpath, :xpath => "//input[@type='hidden']")
+  hidden_field(:hidden_field_css, :css => "input[type='hidden']")
+  hidden_field(:hidden_field_tag_name, :tag_name => "input[type='hidden']")
+  hidden_field(:hidden_field_index, :index => 0)
+  hidden_field(:hidden_field_text, :text => "")
+  hidden_field(:hidden_field_value, :value => "")
+  hidden_field(:hidden_field_class_index, :class => "hidden_field_class", :index => 0)
+  hidden_field(:hidden_field_name_index, :name => "hidden_field_name", :index => 0)
+
+  list_item(:li_id, :id => 'li_id')
+  list_item(:li_class, :class => 'li_class')
+  list_item(:li_name, :name => 'li_name')
+  list_item(:li_index, :index => 0)
+  list_item(:li_xpath, :xpath => '//li[1]')
+  list_item(:li_class_index, :class => "li_class", :index => 0)
+  list_item(:li_name_index, :name => "li_name", :index => 0)
+
+  ordered_list(:ol_id, :id => 'ol_id')
+  ordered_list(:ol_class, :class => 'ol_class')
+  ordered_list(:ol_index, :index => 0)
+  ordered_list(:ol_xpath, :xpath => '//ol')
+  ordered_list(:ol_name, :name => 'ol_name')
+  ordered_list(:ol_class_index, :class => "ol_class", :index => 0)
+  ordered_list(:ol_name_index, :name => "ol_name", :index => 0)
+
+  text_area(:text_area_id, :id => "text_area_id")
+  text_area(:text_area_class, :class => "text_area_class")
+  text_area(:text_area_name, :name => "text_area_name")
+  text_area(:text_area_xpath, :xpath => "//textarea")
+  text_area(:text_area_css, :css => "textarea")
+  text_area(:text_area_tag_name, :tag_name => "textarea")
+  text_area(:text_area_index, :index => 0)
+  text_area(:text_area_text, :text => "")
+  text_area(:text_area_value, :value => "")
+  text_area(:text_area_class_index, :class => "text_area_class", :index => 0)
+  text_area(:text_area_name_index, :name => "text_area_name", :index => 0)
+
+  unordered_list(:ul_id, :id => 'ul_id')
+  unordered_list(:ul_class, :class => 'ul_class')
+  unordered_list(:ul_index, :index => 0)
+  unordered_list(:ul_xpath, :xpath => '//ul')
+  unordered_list(:ul_name, :name => 'ul_name')
+  unordered_list(:ul_class_index, :class => "ul_class", :index => 0)
+  unordered_list(:ul_name_index, :name => "ul_name", :index => 0)
+  unordered_list(:ul_class_name, :class => "ul_class", :name => "ul_name")
+
+end