fluent 0.4.0 → 0.5.0

data/spec/generators/paragraph_generators_spec.rb

@@ -1,65 +0,0 @@
-require_relative '../spec_helper'
-
-class ParagraphGenerators
-  include Fluent
-
-  paragraph :purpose, id: 'purpose'
-end
-
-describe Fluent::Generators do
-  let(:watir_browser)    { mock_browser_for_watir }
-  let(:watir_definition) { ParagraphGenerators.new(watir_browser) }
-
-  describe 'paragraph generators' do
-    context 'when declared on a page definition' do
-      it 'should generate methods for referencing the paragraph' do
-        watir_definition.should respond_to(:purpose_object)
-        watir_definition.should respond_to(:purpose_element)
-        watir_definition.should respond_to(:purpose_paragraph)
-      end
-
-      it 'should generate methods for interacting with the paragraph' do
-        watir_definition.should respond_to(:purpose)
-        watir_definition.should respond_to(:purpose_exists?)
-        watir_definition.should respond_to(:purpose_visible?)
-        watir_definition.should respond_to(:purpose?)
-        watir_definition.should respond_to(:purpose_?)
-        watir_definition.should respond_to(:purpose_paragraph_exists?)
-        watir_definition.should respond_to(:purpose_paragraph_visible?)
-        watir_definition.should respond_to(:purpose_paragraph?)
-        watir_definition.should respond_to(:purpose_paragraph_?)
-      end
-    end
-
-    context 'when used by the watir platform' do
-      it 'should locate the paragraph' do
-        watir_browser.should_receive(:p).and_return(watir_browser)
-        web_element = watir_definition.purpose_object
-        web_element.should_not be_nil
-        web_element.should be_instance_of Fluent::WebElements::Paragraph
-      end
-
-      it 'should return the text of a paragraph' do
-        watir_browser.should_receive(:p).and_return(watir_browser)
-        watir_browser.should_receive(:text).and_return('testing')
-        watir_definition.purpose.should == 'testing'
-      end
-
-      it 'should determine if a paragraph exists' do
-        watir_browser.should_receive(:p).exactly(3).times.and_return(watir_browser)
-        watir_browser.should_receive(:exists?).exactly(3).times.and_return(watir_browser)
-        watir_definition.purpose_paragraph_exists?.should be_true
-        watir_definition.purpose_exists?.should be_true
-        watir_definition.purpose?.should be_true
-      end
-
-      it 'should determine if a paragraph is visible' do
-        watir_browser.should_receive(:p).exactly(3).times.and_return(watir_browser)
-        watir_browser.should_receive(:present?).exactly(3).times.and_return(watir_browser)
-        watir_definition.purpose_paragraph_visible?.should be_true
-        watir_definition.purpose_visible?.should be_true
-        watir_definition.purpose_?.should be_true
-      end
-    end
-  end
-end

data/spec/generators/radio_generators_spec.rb

@@ -1,85 +0,0 @@
-require_relative '../spec_helper'
-
-class RadioGenerators
-  include Fluent
-
-  radio :female, name: 'gender'
-end
-
-describe Fluent::Generators do
-  let(:watir_browser)    { mock_browser_for_watir }
-  let(:watir_definition) { RadioGenerators.new(watir_browser) }
-
-  describe 'radio generators' do
-    context 'when declared on a page definition' do
-      it 'should generate methods for referencing the radio' do
-        watir_definition.should respond_to(:female_object)
-        watir_definition.should respond_to(:female_element)
-        watir_definition.should respond_to(:female_radio)
-      end
-
-      it 'should generate methods for interacting with the radio' do
-        watir_definition.should respond_to(:select_female)
-        watir_definition.should respond_to(:set_female)
-        watir_definition.should respond_to(:female_set?)
-        watir_definition.should respond_to(:female_selected?)
-        watir_definition.should respond_to(:female_exists?)
-        watir_definition.should respond_to(:female_visible?)
-        watir_definition.should respond_to(:female_enabled?)
-        watir_definition.should respond_to(:female?)
-        watir_definition.should respond_to(:female_?)
-        watir_definition.should respond_to(:female!)
-        watir_definition.should respond_to(:female_radio?)
-        watir_definition.should respond_to(:female_radio_?)
-        watir_definition.should respond_to(:female_radio!)
-      end
-    end
-
-    context 'when used by the watir platform' do
-      it 'should locate the radio' do
-        watir_browser.should_receive(:radio).and_return(watir_browser)
-        web_element = watir_definition.female_radio
-        web_element.should_not be_nil
-        web_element.should be_instance_of Fluent::WebElements::Radio
-      end
-
-      it 'should determine if a radio is set' do
-        watir_browser.should_receive(:radio).twice.and_return(watir_browser)
-        watir_browser.should_receive(:set?).twice.and_return(watir_browser)
-        watir_definition.female_selected?.should be_true
-        watir_definition.female_set?.should be_true
-      end
-
-      it 'should set a radio' do
-        watir_browser.should_receive(:radio).twice.and_return(watir_browser)
-        watir_browser.should_receive(:set).twice.and_return(watir_browser)
-        watir_definition.select_female
-        watir_definition.set_female
-      end
-      
-      it 'should determine if a radio exists' do
-        watir_browser.should_receive(:radio).exactly(3).times.and_return(watir_browser)
-        watir_browser.should_receive(:exists?).exactly(3).times.and_return(watir_browser)
-        watir_definition.female_radio_exists?.should be_true
-        watir_definition.female_exists?.should be_true
-        watir_definition.female?.should be_true
-      end
-
-      it 'should determine if a radio is visible' do
-        watir_browser.should_receive(:radio).exactly(3).times.and_return(watir_browser)
-        watir_browser.should_receive(:present?).exactly(3).times.and_return(watir_browser)
-        watir_definition.female_radio_visible?.should be_true
-        watir_definition.female_visible?.should be_true
-        watir_definition.female_?.should be_true
-      end
-
-      it 'should determine if a radio is enabled' do
-        watir_browser.should_receive(:radio).exactly(3).times.and_return(watir_browser)
-        watir_browser.should_receive(:enabled?).exactly(3).times.and_return(watir_browser)
-        watir_definition.female_radio_enabled?.should be_true
-        watir_definition.female_enabled?.should be_true
-        watir_definition.female!.should be_true
-      end
-    end
-  end
-end

data/spec/generators/select_list_generators_spec.rb

@@ -1,120 +0,0 @@
-require_relative '../spec_helper'
-
-class SelectListGenerators
-  include Fluent
-
-  select_list :list, id: 'list'
-end
-
-describe Fluent::Generators do
-  let(:watir_browser)    { mock_browser_for_watir }
-  let(:watir_definition) { SelectListGenerators.new(watir_browser) }
-
-  describe 'select list generators' do
-    context 'when declared on a page definition' do
-      it 'should generate methods for referencing the select list' do
-        watir_definition.should respond_to(:list_object)
-        watir_definition.should respond_to(:list_element)
-        watir_definition.should respond_to(:list_select_list)
-      end
-
-      it 'should generate methods for interacting with the select list' do
-        watir_definition.should respond_to(:list)
-        watir_definition.should respond_to(:list=)
-        watir_definition.should respond_to(:list_value?)
-        watir_definition.should respond_to(:list_options?)
-        watir_definition.should respond_to(:list_exists?)
-        watir_definition.should respond_to(:list_visible?)
-        watir_definition.should respond_to(:list_enabled?)
-        watir_definition.should respond_to(:list?)
-        watir_definition.should respond_to(:list_?)
-        watir_definition.should respond_to(:list!)
-        watir_definition.should respond_to(:list_select_list?)
-        watir_definition.should respond_to(:list_select_list_?)
-        watir_definition.should respond_to(:list_select_list!)
-      end
-    end
-
-    context 'when used by the watir platform' do
-      it 'should locate the select list' do
-        watir_browser.should_receive(:select_list).and_return(watir_browser)
-        web_element = watir_definition.list_object
-        web_element.should_not be_nil
-        web_element.should be_instance_of Fluent::WebElements::SelectList
-      end
-
-      it 'should select an option from the select list' do
-        watir_browser.should_receive(:select_list).and_return watir_browser
-        watir_browser.should_receive(:select).with('testing')
-        watir_definition.list = 'testing'
-      end
-
-      it 'should retrieve the current selected option from the select list' do
-        selected = 'testing'
-        selected.should_receive(:text).and_return('testing')
-        watir_browser.should_receive(:select_list).and_return(watir_browser)
-        watir_browser.should_receive(:selected_options).and_return([selected])
-        watir_definition.list.should == 'testing'
-      end
-      
-      it 'should retrieve the current value of a selected option' do
-        watir_browser.should_receive(:select_list).and_return(watir_browser)
-        watir_browser.should_receive(:value).and_return('testing')
-        watir_definition.list_value?.should == 'testing'
-      end
-
-      it 'should retrieve a list of of selection options' do
-        option1 = double('option')
-        option2 = double('option')
-        option1.should_receive(:text).and_return('list_item_1')
-        option2.should_receive(:text).and_return('list_item_2')
-        select_element = double('select')
-        select_element.should_receive(:options).twice.and_return([option1, option2])
-        watir_definition.should_receive(:list_object).and_return(select_element)
-        watir_definition.list_options?.should == ['list_item_1','list_item_2']
-      end
-      
-      it 'should return an option when indexed' do
-        list_element = double('select_list')
-        options = [list_element, list_element]
-        web_element = Fluent::WebElements::SelectList.new(list_element, :platform => :watir_webdriver)
-        list_element.should_receive(:wd).and_return(list_element)
-        list_element.should_receive(:find_elements).with(:xpath, './/child::option').and_return(options)
-        web_element[0].should be_instance_of Fluent::WebElements::Option
-      end
-      
-      it 'should return an array of options when indexed' do
-        list_element = double('select_list')
-        options = [list_element, list_element]
-        web_element = Fluent::WebElements::SelectList.new(list_element, :platform => :watir_webdriver)
-        list_element.should_receive(:wd).and_return(list_element)
-        list_element.should_receive(:find_elements).with(:xpath, './/child::option').and_return(options)
-        web_element.options.size.should == 2
-      end
-      
-      it 'should determine if a select list exists' do
-        watir_browser.should_receive(:select_list).exactly(3).times.and_return(watir_browser)
-        watir_browser.should_receive(:exists?).exactly(3).times.and_return(watir_browser)
-        watir_definition.list_select_list_exists?.should be_true
-        watir_definition.list_exists?.should be_true
-        watir_definition.list?.should be_true
-      end
-
-      it 'should determine if a select list is visible' do
-        watir_browser.should_receive(:select_list).exactly(3).times.and_return(watir_browser)
-        watir_browser.should_receive(:present?).exactly(3).times.and_return(watir_browser)
-        watir_definition.list_select_list_visible?.should be_true
-        watir_definition.list_visible?.should be_true
-        watir_definition.list_?.should be_true
-      end
-
-      it 'should determine if a select list is enabled' do
-        watir_browser.should_receive(:select_list).exactly(3).times.and_return(watir_browser)
-        watir_browser.should_receive(:enabled?).exactly(3).times.and_return(watir_browser)
-        watir_definition.list_select_list_enabled?.should be_true
-        watir_definition.list_enabled?.should be_true
-        watir_definition.list!.should be_true
-      end
-    end
-  end
-end

data/spec/generators/span_generators_spec.rb

@@ -1,49 +0,0 @@
-require_relative '../spec_helper'
-
-class SpanGenerators
-  include Fluent
-
-  span :inline, id: 'inline'
-end
-
-describe Fluent::Generators do
-  let(:watir_browser)    { mock_browser_for_watir }
-  let(:watir_definition) { SpanGenerators.new(watir_browser) }
-
-  describe 'span generators' do
-    context 'when declared on a page definition' do
-      it 'should generate methods for referencing the span' do
-        watir_definition.should respond_to(:inline_object)
-        watir_definition.should respond_to(:inline_element)
-        watir_definition.should respond_to(:inline_span)
-      end
-
-      it 'should generate methods for interacting with the span' do
-        watir_definition.should respond_to(:inline)
-        watir_definition.should respond_to(:inline_exists?)
-        watir_definition.should respond_to(:inline_visible?)
-        watir_definition.should respond_to(:inline?)
-        watir_definition.should respond_to(:inline_?)
-        watir_definition.should respond_to(:inline_span_exists?)
-        watir_definition.should respond_to(:inline_span_visible?)
-        watir_definition.should respond_to(:inline_span?)
-        watir_definition.should respond_to(:inline_span_?)
-      end
-    end
-
-    context 'when used by the watir platform' do
-      it 'should locate the span' do
-        watir_browser.should_receive(:span).and_return(watir_browser)
-        web_element = watir_definition.inline_span
-        web_element.should_not be_nil
-        web_element.should be_instance_of Fluent::WebElements::Span
-      end
-
-      it 'should return the text of a span' do
-        watir_browser.should_receive(:span).and_return(watir_browser)
-        watir_browser.should_receive(:text).and_return('testing')
-        watir_definition.inline.should == 'testing'
-      end
-    end
-  end
-end

data/spec/generators/table_generators_spec.rb

@@ -1,49 +0,0 @@
-require_relative '../spec_helper'
-
-class TableGenerators
-  include Fluent
-
-  table :accounts, id: 'accounts'
-end
-
-describe Fluent::Generators do
-  let(:watir_browser)    { mock_browser_for_watir }
-  let(:watir_definition) { TableGenerators.new(watir_browser) }
-
-  describe 'table generators' do
-    context 'when declared on a page definition' do
-      it 'should generate methods for referencing the table' do
-        watir_definition.should respond_to(:accounts_object)
-        watir_definition.should respond_to(:accounts_element)
-        watir_definition.should respond_to(:accounts_table)
-      end
-
-      it 'should generate methods for interacting with the table' do
-        watir_definition.should respond_to(:accounts)
-        watir_definition.should respond_to(:accounts_exists?)
-        watir_definition.should respond_to(:accounts_visible?)
-        watir_definition.should respond_to(:accounts?)
-        watir_definition.should respond_to(:accounts_?)
-        watir_definition.should respond_to(:accounts_table_exists?)
-        watir_definition.should respond_to(:accounts_table_visible?)
-        watir_definition.should respond_to(:accounts_table?)
-        watir_definition.should respond_to(:accounts_table_?)
-      end
-    end
-
-    context 'when used by the watir platform' do
-      it 'should locate the table' do
-        watir_browser.should_receive(:table).and_return(watir_browser)
-        web_element = watir_definition.accounts_table
-        web_element.should_not be_nil
-        web_element.should be_instance_of Fluent::WebElements::Table
-      end
-
-      it 'should return the text of a table' do
-        watir_browser.should_receive(:table).and_return(watir_browser)
-        watir_browser.should_receive(:text).and_return('testing')
-        watir_definition.accounts.should == 'testing'
-      end
-    end
-  end
-end

data/spec/generators/text_area_generators_spec.rb

@@ -1,55 +0,0 @@
-require_relative '../spec_helper'
-
-class TextAreaGenerators
-  include Fluent
-
-  text_area :summary, id: 'summary'
-end
-
-describe Fluent::Generators do
-  let(:watir_browser)    { mock_browser_for_watir }
-  let(:watir_definition) { TextAreaGenerators.new(watir_browser) }
-
-  describe 'text area generators' do
-    context 'when declared on a page definition' do
-      it 'should generate methods for referencing the text area' do
-        watir_definition.should respond_to(:summary_object)
-        watir_definition.should respond_to(:summary_element)
-        watir_definition.should respond_to(:summary_text_area)
-      end
-
-      it 'should generate methods for interacting with the text area' do
-        watir_definition.should respond_to(:summary)
-        watir_definition.should respond_to(:summary_exists?)
-        watir_definition.should respond_to(:summary_visible?)
-        watir_definition.should respond_to(:summary?)
-        watir_definition.should respond_to(:summary_?)
-        watir_definition.should respond_to(:summary_text_area_exists?)
-        watir_definition.should respond_to(:summary_text_area_visible?)
-        watir_definition.should respond_to(:summary_text_area?)
-        watir_definition.should respond_to(:summary_text_area_?)
-      end
-    end
-
-    context 'when used by the watir platform' do
-      it 'should locate the text area' do
-        watir_browser.should_receive(:textarea).and_return(watir_browser)
-        web_element = watir_definition.summary_object
-        web_element.should_not be_nil
-        web_element.should be_instance_of Fluent::WebElements::TextArea
-      end
-
-      it 'should retrieve text from the text area' do
-        watir_browser.should_receive(:textarea).and_return(watir_browser)
-        watir_browser.should_receive(:value).and_return('testing')
-        watir_definition.summary.should == 'testing'
-      end
-
-      it 'should enter text into a text area' do
-        watir_browser.should_receive(:textarea).and_return(watir_browser)
-        watir_browser.should_receive(:set).with('testing')
-        watir_definition.summary = 'testing'
-      end
-    end
-  end
-end

data/spec/generators/text_field_generators_spec.rb

@@ -1,81 +0,0 @@
-require_relative '../spec_helper'
-
-class TextFieldGenerators
-  include Fluent
-
-  text_field :name, id: 'name'
-end
-
-describe Fluent::Generators do
-  let(:watir_browser)    { mock_browser_for_watir }
-  let(:watir_definition) { TextFieldGenerators.new(watir_browser) }
-
-  describe 'text field generators' do
-    context 'when declared on a page definition' do
-      it 'should generate methods for referencing the text field' do
-        watir_definition.should respond_to(:name_object)
-        watir_definition.should respond_to(:name_element)
-        watir_definition.should respond_to(:name_text_field)
-      end
-
-      it 'should generate methods for interacting with the text field' do
-        watir_definition.should respond_to(:name)
-        watir_definition.should respond_to(:name=)
-        watir_definition.should respond_to(:name_exists?)
-        watir_definition.should respond_to(:name_visible?)
-        watir_definition.should respond_to(:name_enabled?)
-        watir_definition.should respond_to(:name?)
-        watir_definition.should respond_to(:name_?)
-        watir_definition.should respond_to(:name!)
-        watir_definition.should respond_to(:name_text_field?)
-        watir_definition.should respond_to(:name_text_field_?)
-        watir_definition.should respond_to(:name_text_field!)
-      end
-    end
-
-    context 'when used by the watir platform' do
-      it 'should locate the text field' do
-        watir_browser.should_receive(:text_field).and_return(watir_browser)
-        web_element = watir_definition.name_object
-        web_element.should_not be_nil
-        web_element.should be_instance_of Fluent::WebElements::TextField
-      end
-
-      it 'should enter text into a text field' do
-        watir_browser.should_receive(:text_field).and_return(watir_browser)
-        watir_browser.should_receive(:set).with('testing')
-        watir_definition.name = 'testing'
-      end
-
-      it 'should retrieve text from the text field' do
-        watir_browser.should_receive(:text_field).and_return(watir_browser)
-        watir_browser.should_receive(:value).and_return('testing')
-        watir_definition.name.should == 'testing'
-      end
-
-      it 'should determine if a text field exists' do
-        watir_browser.should_receive(:text_field).exactly(3).times.and_return(watir_browser)
-        watir_browser.should_receive(:exists?).exactly(3).times.and_return(watir_browser)
-        watir_definition.name_text_field_exists?.should be_true
-        watir_definition.name_exists?.should be_true
-        watir_definition.name?.should be_true
-      end
-
-      it 'should determine if a text field is visible' do
-        watir_browser.should_receive(:text_field).exactly(3).times.and_return(watir_browser)
-        watir_browser.should_receive(:present?).exactly(3).times.and_return(watir_browser)
-        watir_definition.name_text_field_visible?.should be_true
-        watir_definition.name_visible?.should be_true
-        watir_definition.name_?.should be_true
-      end
-
-      it 'should determine if a text field is enabled' do
-        watir_browser.should_receive(:text_field).exactly(3).times.and_return(watir_browser)
-        watir_browser.should_receive(:enabled?).exactly(3).times.and_return(watir_browser)
-        watir_definition.name_text_field_enabled?.should be_true
-        watir_definition.name_enabled?.should be_true
-        watir_definition.name!.should be_true
-      end
-    end
-  end
-end