druid-s 1.0.0

data/features/step_definations/section_steps.rb

@@ -0,0 +1,271 @@
+class Container
+  include Druid
+
+  link(:section_link)
+  button(:section_button)
+  text_field(:section_text_field)
+  hidden_field(:section_hidden_field)
+  text_area(:section_text_area)
+  select_list(:section_select_list)
+  file_field(:section_file_field)
+  checkbox(:section_checkbox)
+  radio_button(:section_radio_button)
+  div(:section_div)
+  span(:section_span)
+  table(:section_table)
+  cell(:section_cell) { |page| page.section_table_element.cell_element(:index => 1) }
+  image(:section_image)
+  form(:section_form)
+  ordered_list(:section_ordered_list)
+  unordered_list(:section_unordered_list)
+  list_item(:section_list_item) { |page| page.section_ordered_list_element.list_item_element }
+  h1(:section_h1)
+  h2(:section_h2)
+  h3(:section_h3)
+  h4(:section_h4)
+  h5(:section_h5)
+  h6(:section_h6)
+  paragraph(:section_paragraph)
+
+  unordered_list(:outside_section, :id => 'outer')
+end
+
+class InputSection
+  include Druid
+
+  def value
+    root.value
+  end
+end
+
+class SectionElementsPage
+  include Druid
+
+  page_section(:container, Container, :id => 'div_id')
+  page_sections(:page_inputs, InputSection, :tag_name => 'input')
+
+end
+Given(/^I am on the section elements page$/) do
+  @page = SectionElementsPage.new(@driver)
+  @page.navigate_to(UrlHelper.nested_elements)
+end
+
+When(/^I get the text from the section$/) do
+  @text = @page.container.text
+end
+
+Then(/^the text should include "([^"]*)"$/) do |expected_text|
+  expect(@text).to include expected_text
+end
+
+When(/^I access an element that is outside of the section$/) do
+  @element = @page.container.outside_section_element
+end
+
+Then(/^I should see that is doesn't exist in the section$/) do
+  expect(@element.exist?).to be false
+end
+
+When(/^I search for a link located in a section$/) do
+  @link = @page.container.section_link_element
+end
+
+Then(/^I should be able to click the section link$/) do
+  @link.click
+end
+
+When(/^I search for a button located in a section$/) do
+  @button = @page.container.section_button_element
+end
+
+Then(/^I should be able to click the section button$/) do
+  @button.click
+end
+
+When(/^I search for a text field located in a section$/) do
+  @text_field = @page.container.section_text_field_element
+end
+
+Then(/^I should be able to type "([^"]*)" in the section text field$/) do |value|
+  @text_field.value = value
+end
+
+When(/^I search for a hidden field located in a section$/) do
+  @hidden_field = @page.container.section_hidden_field_element
+end
+
+Then(/^I should be able to see that the section hidden field contains "([^"]*)"$/) do |value|
+  expect(@hidden_field.value).to eql value
+end
+
+When(/^I search for a text area located in a section$/) do
+  @text_area = @page.container.section_text_area_element
+end
+
+Then(/^I should be able to type "([^"]*)" in the section text area$/) do |value|
+  @text_area.value = value
+end
+
+When(/^I search for a select list located in a section$/) do
+  @select_list = @page.container.section_select_list_element
+end
+
+Then(/^I should be able to select "([^"]*)" in the section select list$/) do |value|
+  @select_list.select value
+end
+
+When(/^I search for a file field located in a section$/) do
+  @ff = @page.container.section_file_field_element
+end
+
+Then(/^I should be able to set the section file field$/) do
+  @ff.value = __FILE__
+end
+
+When(/^I search for a checkbox located in a section$/) do
+  @checkbox = @page.container.section_checkbox_element
+end
+
+Then(/^I should be able to check the section checkbox$/) do
+  @checkbox.check
+end
+
+When(/^I search for a radio button located in a section$/) do
+  @radio = @page.container.section_radio_button_element
+end
+
+Then(/^I should be able to select the section radio button$/) do
+  @radio.select
+end
+
+When(/^I search for a div located in a section$/) do
+  @div = @page.container.section_div_element
+end
+
+Then(/^I should see the text "([^"]*)" in the section div$/) do |value|
+  expect(@div.text).to eql value
+end
+
+When(/^I search for a span located in a section$/) do
+  @span = @page.container.section_span_element
+end
+
+Then(/^I should see the text "([^"]*)" in the section span$/) do |value|
+  expect(@span.text).to eql value
+end
+
+When(/^I search for a table located in a section$/) do
+  @table = @page.container.section_table_element
+end
+
+Then(/^the data for row "([^"]*)" of the section table should be "([^"]*)" and "([^"]*)"$/) do |row, col1, col2|
+  table_row = @table[row.to_i - 1]
+  expect(table_row[0].text).to eql col1
+  expect(table_row[1].text).to eql col2
+end
+
+When(/^I search the second table cell located in a table in a section$/) do
+  @cell = @page.container.section_cell_element
+end
+
+Then(/^the section table cell should contain "([^"]*)"$/) do |value|
+  expect(@cell.text).to eql value
+end
+
+When(/^I search for an image located in a section$/) do
+  @image = @page.container.section_image_element
+end
+
+Then(/^the section image should be "([^"]*)" pixels wide$/) do |width|
+  expect(@image.width).to eql width.to_i
+end
+
+Then(/^the section image should be "([^"]*)" pixels tall$/) do |height|
+  expect(@image.height).to eql height.to_i
+end
+
+When(/^I search for a form located in a section$/) do
+  @form = @page.container.section_form_element
+end
+
+Then(/^I should be able to submit the section form$/) do
+  @form.submit
+end
+
+When(/^I search for an ordered list located in a section$/) do
+  @list = @page.container.section_ordered_list_element
+end
+
+Then(/^the first section list items text should be "([^"]*)"$/) do |value|
+  expect(@list[0].text).to eql value
+end
+
+When(/^I search for an unordered list located in a section$/) do
+  @list = @page.container.section_unordered_list_element
+end
+
+When(/^I search for a list item section in an ordered list in a section$/) do
+  @li = @page.container.section_list_item_element
+end
+
+Then(/^I should see the section list items text should be "([^"]*)"$/) do |value|
+  expect(@li.text).to eql value
+end
+
+When(/^I search for a h(\d+) located in a section$/) do |num|
+  @header = @page.container.send "section_h#{num}_element"
+end
+
+Then(/^I should see the section h(\d+)s text should be "([^"]*)"$/) do |num, value|
+  expect(@header.text).to eql value
+end
+
+When(/^I search for a paragraph located in a section$/) do
+  @paragraph = @page.container.section_paragraph_element
+end
+
+Then(/^I should see the section paragraphs text should be "([^"]*)"$/) do |value|
+  expect(@paragraph.text).to eql value
+end
+
+When(/^I select multiple sections$/) do
+  @sections = @page.page_inputs
+end
+
+Then(/^I should have a section collection containing the sections$/) do
+  expect(@sections).to be_instance_of Druid::SectionCollection
+end
+
+Then(/^I can access any index of that collection of sections$/) do
+  expect(@sections[0]).to be_a(Druid)
+  expect(@sections[-1]).to be_a(Druid)
+end
+
+When(/^I search by a specific value of the section$/) do
+  @element = @sections.find_by(:value => 'LeanDog')
+end
+
+Then(/^I will find the first section with that value$/) do
+  expect(@element).to be_a(Druid)
+  expect(@element.value). to eq 'LeanDog'
+end
+
+When(/^I filter by a specific value of the sections$/) do
+  @elements = @sections.select_by(:value => /\w+/)
+end
+
+Then(/^I will find all sections with that value$/) do
+  expect(@elements).to be_a Druid::SectionCollection
+  @elements.map(&:value).each do |element|
+    expect(element).to match(/\w+/)
+  end
+end
+
+When(/^I have a page section$/) do
+  @section = @page.container
+end
+
+Then(/^methods called on the section are passed to the root if missing$/) do
+  expect { @section.present? }.not_to raise_error
+  expect(@section.present?).to be true
+end

data/features/step_definations/select_list_steps.rb

@@ -0,0 +1,91 @@
+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_element
+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}_element".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
+
+When(/^I find a select list while the script is executing$/) do
+  @select_list = @page.select_list_element(:id => "sel_list_id")
+end
+
+Then(/^I should be able to select "(.*?)" from the list$/) do |value|
+  @select_list.select value
+end
+
+Then(/^I should see that the select list exists$/) do
+  expect(@page.select_list_id?).to be true
+end
+
+Then(/^the selected option should be "(.*)"$/) do |text|
+  expect(@page.select_list_element(:id => 'sel_list_id').selected_options[0]).to eql text
+end
+
+Then(/^the select list should include "([^"]*)"$/) do |text|
+  expect(@page.select_list_id_element).to include text
+end
+
+Then(/^the select list should know that "([^"]*)" is selected$/) do |text|
+  expect(@page.select_list_id_element.selected?(text)).to be true
+end
+
+Then(/^the value for the option should be "([^"]*)"$/) do |value|
+  @element = @page.send "select_list_#{@how}_element".to_sym
+  expect(@element.value).to eql value
+end
+
+When(/^I clear multiple select list$/) do
+  @page.select_list_multiple_element.clear
+end
+
+Then(/^multiple select list should have no selected options$/) do
+  expect(@page.select_list_multiple_element.selected_options).to be_empty
+end
+
+When(/^I select an option using the value "([^"]*)"$/) do |value|
+  @page.select_list_id_element.select_value(value)
+end
+
+Then(/^the selected option should have a value of "([^"]*)"$/) do |value|
+  expect(@page.select_list_id_element.selected_values[0]).to eql value
+end
+
+Then(/^cleared multiple select list should return nil for value$/) do
+  expect(@page.select_list_multiple).to be nil
+end

data/features/step_definations/span_steps.rb

@@ -0,0 +1,23 @@
+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_element
+end
+
+When(/^I search for the span by "(.*?)" and "(.*?)"$/) do |param1, param2|
+  @text = @page.send "span_#{param1}_#{param2}".to_sym
+end
+
+When(/^I get the text from a span while the script is executing$/) do
+  @text = @page.span_element(:id => 'span_id').text
+end
+
+Then(/^I should see that the span exists$/) do
+  expect(@page.span_id?).to be true
+end

data/features/step_definations/table_cell_steps.rb

@@ -0,0 +1,27 @@
+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_element
+end
+
+When(/^I retrieve a table cell element by "(.*?)" and "(.*?)"$/) do |param1, param2|
+  @cell_text = @page.send "cell_#{param1}_#{param2}".to_sym
+end
+
+When(/^I retrieve a table cell element while the script is executing$/) do
+  @cell_text = @page.cell_element(:id => 'cell_id').text
+end
+
+Then(/^I should see that the cell exists$/) do
+  expect(@page.cell_id?).to be true
+end

data/features/step_definations/table_row_steps.rb

@@ -0,0 +1,23 @@
+When(/^I retrieve the data from the table row$/) do
+  @row_data = @page.tr_id
+end
+
+Then(/^the row data should be "([^"]*)"$/) do |expected|
+  expect(@row_data).to eql expected
+end
+
+When(/^I search for the table row by "([^"]*)"$/) do |how|
+  @row_data = @page.send "tr_#{how}"
+end
+
+When(/^I retrieve a table row element by "([^"]*)" and "([^"]*)"$/) do |param1, param2|
+  @row_data = @page.send "tr_#{param1}_#{param2}"
+end
+
+When(/^I retrieve a table row element while the script is executing$/) do
+  @row_data = @page.row_element(:id => 'tr_id').text
+end
+
+Then(/^I should see that the row exists$/) do
+  expect(@page.tr_id?).to be true
+end

data/features/step_definations/table_steps.rb

@@ -0,0 +1,109 @@
+When(/^I retrieve a table element$/) do
+  @element = @page.table_id_element
+end
+
+When(/^I retrieve a table element by "(.*?)"$/) do |how|
+  @element = @page.send "table_#{how}_element".to_sym
+end
+
+Then(/^the data for row "(.*?)" should be "(.*?)" and "(.*?)"$/) do |row, col1, col2|
+   row = (row.to_i - 1) if row.to_i > 0
+   table_row = @element[row]
+   expect(table_row[0].text).to eql col1
+   expect(table_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}_element".to_sym
+end
+
+When(/^I retrieve a table element while the script is executing$/) do
+  @element = @page.table_element(:id => 'table_id')
+end
+
+Then(/^the data for the first row should be "([^"]*)" and "([^"]*)"$/) do |col1, col2|
+  expect(@element.first_row[0].text).to eql col1
+  expect(@element.first_row[1].text).to eql col2
+end
+
+Then(/^the data for the last row should be "([^"]*)" and "([^"]*)"$/) do |col1, col2|
+  expect(@element.last_row[0].text).to eql col1
+  expect(@element.last_row[1].text).to eql col2
+end
+
+Then(/^I should see that the table exists$/) do
+  expect(@page.table_id?).to be true
+end
+
+Then(/^the data for column "([^"]*)" and row "([^"]*)" should be "([^"]*)"$/) do |column, row, value|
+  expect(@element[row.to_i - 1][column].text).to eql value
+end
+
+Then(/^the data for row "([^"]*)" and column "([^"]*)" should be "([^"]*)"$/) do |row, column, value|
+  expect(@element[row][column].text).to eql value
+end
+
+Then(/^the data for row "([^"]*)" should be nil$/) do |row|
+  expect(@element[row]).to be_nil
+end
+
+Then(/^the data for row "([^"]*)" and column "([^"]*)" should be nil$/) do |row, column|
+  expect(@element[row][column]).to be_nil
+end
+
+When(/^I retrieve a table with thead element$/) do
+  @element = @page.table_with_thead_id_element
+end
+
+Then(/^I should see the text includes "([^"]*)" when I retrieve it by "([^"]*)"$/) do |text, how|
+  expect(@page.send("table_#{how}")).to include text
+end
+
+Then(/^the data for the second row should be "([^"]*)" and "([^"]*)"$/) do |col1, col2|
+  expect(@element[1][0].text).to eql col1
+  expect(@element[1][1].text).to eql col2
+end
+
+Then(/^the table should be like the expected one$/) do |expected_table|
+  expect(expected_table.diff!@element.hashes).to be_nil
+end
+
+When(/^I retrieve a table element with regex characters$/) do
+  @element = @page.table_with_regex_element
+end
+
+When(/^I ask for the column values for "([^"]*)"$/) do |header|
+  @values = @page.table_id_element.column_values(header)
+end
+
+Then(/^I should receive:$/) do |table|
+  expect(@values.size).to eql 2
+  table.hashes.each do |hsh|
+    expect(@values).to include hsh['values']
+  end
+end
+
+When(/^I ask for the column values for column (\d+)$/) do |index|
+  @values = @page.table_id_element.column_values(index.to_i)
+end

data/features/step_definations/text_area_steps.rb

@@ -0,0 +1,39 @@
+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}_element".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}_element".to_sym
+end
+
+When(/^I retrieve the text area$/) do
+  @element = @page.text_area_id_element
+end
+
+When(/^I find a text area while the script is executing$/) do
+  @text_area = @page.text_area_element(:id => "text_area_id")
+end
+
+Then(/^I should be able to type "(.*?)" into the area element$/) do |value|
+  @text_area.value = value
+end
+
+When(/^I clear the text area$/) do
+  @page.text_area_id_element.clear
+end
+
+Then(/^I should see that the text area exists$/) do
+  expect(@page.text_area_id?).to be true
+end

data/features/step_definations/text_field_steps.rb

@@ -0,0 +1,39 @@
+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_element
+end
+
+When(/^I search for the text field by "(.*?)" and "(.*?)"$/) do |param1, param2|
+  @how = "#{param1}_#{param2}"
+end
+
+When(/^I find a text field while the script is executing$/) do
+  @text_field = @page.text_field_element(:id => 'text_field_id')
+end
+
+Then(/^I should be able to type "(.*?)" into the field element$/) do |value|
+  @text_field.value = value
+end
+
+Then(/^I should see that the text field exists$/) do
+  expect(@page.text_field_id?).to be true
+end
+
+When(/^I append "([^"]*)" to the text field$/) do |text|
+  @page.text_field_id_element.append text
+end

data/features/step_definations/unordered_list_steps.rb

@@ -0,0 +1,27 @@
+When(/^I get the first item from the unordered list$/) do
+  @element = @page.ul_id_element[0]
+end
+
+When(/^I locate the unordered list by "(.*?)"$/) do |how|
+  @list = @page.send "ul_#{how}_element".to_sym
+end
+
+When(/^I search for the unordered list by "(.*?)" and "(.*?)"$/) do |param1, param2|
+  @list = @page.send "ul_#{param1}_#{param2}_element".to_sym
+end
+
+When(/^I retrieve a unordered list element$/) do
+  @element = @page.ul_id_element
+end
+
+When(/^I search for the unordered list while the script is executing$/) do
+  @list = @page.unordered_list_element(:id => 'ul_id')
+end
+
+Then(/^I should see that the unordered list exists$/) do
+  expect(@page.ul_id?).to be true
+end
+
+Then(/^the text for the unordered list should contain "([^"]*)"$/) do |text|
+  expect(@page.send("ul_id")).to include text
+end

data/features/step_definations/video_steps.rb

@@ -0,0 +1,27 @@
+When(/^I retrieve the video element$/) do
+  @element = @avpage.video_id_element
+end
+
+When(/^I search for the video element by "([^"]*)"$/) do |how|
+  @element = @avpage.send "video_#{how}_element"
+end
+
+When(/^I search for the video element by "([^"]*)" and "([^"]*)"$/) do |param1, param2|
+  @element = @avpage.send "video_#{param1}_#{param2}_element"
+end
+
+Then(/^I should know the video is not autoplay$/) do
+  expect(@element).not_to be_autoplay
+end
+
+Then(/^I should know that the video is paused$/) do
+  expect(@element).to be_paused
+end
+
+Then(/^I should know that its height is (\d+) pixels$/) do |height|
+  @element.height.should == height.to_i
+end
+
+Then(/^I should knot what its width is (\d+) pixels$/) do |width|
+  @element.width.should == width.to_i
+end