fluent 0.1.0

data/spec/generators/checkbox_generators_spec.rb

@@ -0,0 +1,88 @@
+require_relative '../spec_helper'
+
+class CheckboxGenerators
+  include Fluent
+
+  checkbox :toggle, id: 'toggle'
+end
+
+describe Fluent::Generators do
+  let(:watir_browser)    { mock_browser_for_watir }
+  let(:watir_definition) { CheckboxGenerators.new(watir_browser) }
+
+  describe 'checkbox generators' do
+    context 'when declared on a page definition' do
+      it 'should generate methods for referencing the checkbox' do
+        watir_definition.should respond_to(:toggle_object)
+        watir_definition.should respond_to(:toggle_element)
+        watir_definition.should respond_to(:toggle_checkbox)
+      end
+
+      it 'should generate methods for interacting with the text checkbox' do
+        watir_definition.should respond_to(:toggle_checked?)
+        watir_definition.should respond_to(:check_toggle)
+        watir_definition.should respond_to(:uncheck_toggle)
+        watir_definition.should respond_to(:toggle_exists?)
+        watir_definition.should respond_to(:toggle_visible?)
+        watir_definition.should respond_to(:toggle_enabled?)
+        watir_definition.should respond_to(:toggle?)
+        watir_definition.should respond_to(:toggle_?)
+        watir_definition.should respond_to(:toggle!)
+        watir_definition.should respond_to(:toggle_checkbox?)
+        watir_definition.should respond_to(:toggle_checkbox_?)
+        watir_definition.should respond_to(:toggle_checkbox!)
+      end
+    end
+
+    context 'when used by the watir platform' do
+      it 'should locate the checkbox' do
+        watir_browser.should_receive(:checkbox).and_return(watir_browser)
+        web_element = watir_definition.toggle_object
+        web_element.should_not be_nil
+        web_element.should be_instance_of Fluent::WebElements::CheckBox
+      end
+
+      it 'should determine if a checkbox is checked' do
+        watir_browser.should_receive(:checkbox).and_return(watir_browser)
+        watir_browser.should_receive(:set?).and_return(true)
+        watir_definition.toggle_checked?.should be_true
+      end
+
+      it 'should be able to check a checkbox' do
+        watir_browser.should_receive(:checkbox).and_return(watir_browser)
+        watir_browser.should_receive(:set)
+        watir_definition.check_toggle
+      end
+
+      it 'should be able to uncheck a checkbox' do
+        watir_browser.should_receive(:checkbox).and_return(watir_browser)
+        watir_browser.should_receive(:clear)
+        watir_definition.uncheck_toggle
+      end
+
+      it 'should determine if a checkbox exists' do
+        watir_browser.should_receive(:checkbox).exactly(3).times.and_return(watir_browser)
+        watir_browser.should_receive(:exists?).exactly(3).times.and_return(watir_browser)
+        watir_definition.toggle_checkbox_exists?.should be_true
+        watir_definition.toggle_exists?.should be_true
+        watir_definition.toggle?.should be_true
+      end
+
+      it 'should determine if a checkbox is visible' do
+        watir_browser.should_receive(:checkbox).exactly(3).times.and_return(watir_browser)
+        watir_browser.should_receive(:present?).exactly(3).times.and_return(watir_browser)
+        watir_definition.toggle_checkbox_visible?.should be_true
+        watir_definition.toggle_visible?.should be_true
+        watir_definition.toggle_?.should be_true
+      end
+
+      it 'should determine if a checkbox is enabled' do
+        watir_browser.should_receive(:checkbox).exactly(3).times.and_return(watir_browser)
+        watir_browser.should_receive(:enabled?).exactly(3).times.and_return(watir_browser)
+        watir_definition.toggle_checkbox_enabled?.should be_true
+        watir_definition.toggle_enabled?.should be_true
+        watir_definition.toggle!.should be_true
+      end
+    end
+  end
+end

data/spec/generators/link_generators_spec.rb

@@ -0,0 +1,64 @@
+require_relative '../spec_helper'
+
+class LinkGenerators
+  include Fluent
+  
+  link :contact, id: 'contact'
+end
+
+describe Fluent::Generators do
+  let(:watir_browser)    { mock_browser_for_watir }
+  let(:watir_definition) { LinkGenerators.new(watir_browser) }
+
+  describe 'link generators' do
+    context 'when declared on a page definition' do
+      it 'should generate methods for referencing the link' do
+        watir_definition.should respond_to(:contact_object)
+        watir_definition.should respond_to(:contact_element)
+        watir_definition.should respond_to(:contact_link)
+      end
+
+      it 'should generate methods for interacting with the link' do
+        watir_definition.should respond_to(:contact)
+        watir_definition.should respond_to(:contact_exists?)
+        watir_definition.should respond_to(:contact_visible?)
+        watir_definition.should respond_to(:contact?)
+        watir_definition.should respond_to(:contact_?)
+        watir_definition.should respond_to(:contact_link_exists?)
+        watir_definition.should respond_to(:contact_link_visible?)
+        watir_definition.should respond_to(:contact_link?)
+        watir_definition.should respond_to(:contact_link_?)
+      end
+    end
+
+    context 'when used by the watir platform' do
+      it 'should locate the link' do
+        watir_browser.should_receive(:link).and_return(watir_browser)
+        web_element = watir_definition.contact_object
+        web_element.should_not be_nil
+        web_element.should be_instance_of Fluent::WebElements::Link
+      end
+
+      it 'should click the link' do
+        watir_browser.stub_chain(:link, :click)
+        watir_definition.contact
+      end
+
+      it 'should determine if a link exists' do
+        watir_browser.should_receive(:link).exactly(3).times.and_return(watir_browser)
+        watir_browser.should_receive(:exists?).exactly(3).times.and_return(watir_browser)
+        watir_definition.contact_link_exists?.should be_true
+        watir_definition.contact_exists?.should be_true
+        watir_definition.contact?.should be_true
+      end
+
+      it 'should determine if a link is visible' do
+        watir_browser.should_receive(:link).exactly(3).times.and_return(watir_browser)
+        watir_browser.should_receive(:present?).exactly(3).times.and_return(watir_browser)
+        watir_definition.contact_link_visible?.should be_true
+        watir_definition.contact_visible?.should be_true
+        watir_definition.contact_?.should be_true
+      end
+    end
+  end
+end

data/spec/generators/paragraph_generators_spec.rb

@@ -0,0 +1,65 @@
+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

@@ -0,0 +1,85 @@
+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

@@ -0,0 +1,120 @@
+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/text_field_generators_spec.rb

@@ -0,0 +1,81 @@
+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