fluent 0.1.0 → 0.2.0

data/spec/generators/cell_generators_spec.rb

@@ -0,0 +1,50 @@
+require_relative '../spec_helper'
+
+class CellGenerators
+  include Fluent
+
+  cell :total, id: 'total'
+end
+
+describe Fluent::Generators do
+  let(:watir_browser)    { mock_browser_for_watir }
+  let(:watir_definition) { CellGenerators.new(watir_browser) }
+
+  describe 'cell generators' do
+    context 'when declared on a page definition' do
+      it 'should generate methods for referencing the cell' do
+        watir_definition.should respond_to(:total_object)
+        watir_definition.should respond_to(:total_element)
+        watir_definition.should respond_to(:total_cell)
+        watir_definition.should respond_to(:total_td)
+      end
+
+      it 'should generate methods for interacting with the cell' do
+        watir_definition.should respond_to(:total)
+        watir_definition.should respond_to(:total_exists?)
+        watir_definition.should respond_to(:total_visible?)
+        watir_definition.should respond_to(:total?)
+        watir_definition.should respond_to(:total_?)
+        watir_definition.should respond_to(:total_td_exists?)
+        watir_definition.should respond_to(:total_td_visible?)
+        watir_definition.should respond_to(:total_td?)
+        watir_definition.should respond_to(:total_td_?)
+      end
+    end
+
+    context 'when used by the watir platform' do
+      it 'should locate the cell' do
+        watir_browser.should_receive(:td).and_return(watir_browser)
+        web_element = watir_definition.total_cell
+        web_element.should_not be_nil
+        web_element.should be_instance_of Fluent::WebElements::Cell
+      end
+
+      it 'should return the text of a table' do
+        watir_browser.should_receive(:td).and_return(watir_browser)
+        watir_browser.should_receive(:text).and_return('testing')
+        watir_definition.total.should == 'testing'
+      end
+    end
+  end
+end

data/spec/generators/div_generators_spec.rb

@@ -0,0 +1,49 @@
+require_relative '../spec_helper'
+
+class DivGenerators
+  include Fluent
+
+  div :section, id: 'section'
+end
+
+describe Fluent::Generators do
+  let(:watir_browser)    { mock_browser_for_watir }
+  let(:watir_definition) { DivGenerators.new(watir_browser) }
+
+  describe 'div generators' do
+    context 'when declared on a page definition' do
+      it 'should generate methods for referencing the div' do
+        watir_definition.should respond_to(:section_object)
+        watir_definition.should respond_to(:section_element)
+        watir_definition.should respond_to(:section_div)
+      end
+
+      it 'should generate methods for interacting with the div' do
+        watir_definition.should respond_to(:section)
+        watir_definition.should respond_to(:section_exists?)
+        watir_definition.should respond_to(:section_visible?)
+        watir_definition.should respond_to(:section?)
+        watir_definition.should respond_to(:section_?)
+        watir_definition.should respond_to(:section_div_exists?)
+        watir_definition.should respond_to(:section_div_visible?)
+        watir_definition.should respond_to(:section_div?)
+        watir_definition.should respond_to(:section_div_?)
+      end
+    end
+
+    context 'when used by the watir platform' do
+      it 'should locate the div' do
+        watir_browser.should_receive(:div).and_return(watir_browser)
+        web_element = watir_definition.section_div
+        web_element.should_not be_nil
+        web_element.should be_instance_of Fluent::WebElements::Div
+      end
+
+      it 'should return the text of a div' do
+        watir_browser.should_receive(:div).and_return(watir_browser)
+        watir_browser.should_receive(:text).and_return('testing')
+        watir_definition.section.should == 'testing'
+      end
+    end
+  end
+end

data/spec/generators/list_item_generators_spec.rb

@@ -0,0 +1,53 @@
+require_relative '../spec_helper'
+
+class ListItemGenerators
+  include Fluent
+
+  li :list_short, id: 'list1'
+  list_item :list, id: 'list2'
+end
+
+describe Fluent::Generators do
+  let(:watir_browser)    { mock_browser_for_watir }
+  let(:watir_definition) { ListItemGenerators.new(watir_browser) }
+
+  describe 'list item generators' do
+    context 'when declared on a page definition' do
+      it 'should generate methods for referencing the list item' do
+        watir_definition.should respond_to(:list_object)
+        watir_definition.should respond_to(:list_element)
+        watir_definition.should respond_to(:list_list_item)
+        watir_definition.should respond_to(:list_short_li)
+      end
+
+      it 'should generate methods for interacting with the list item' do
+        watir_definition.should respond_to(:list)
+        watir_definition.should respond_to(:list_exists?)
+        watir_definition.should respond_to(:list_visible?)
+        watir_definition.should respond_to(:list?)
+        watir_definition.should respond_to(:list_?)
+        watir_definition.should respond_to(:list_li_exists?)
+        watir_definition.should respond_to(:list_li_visible?)
+        watir_definition.should respond_to(:list_li?)
+        watir_definition.should respond_to(:list_li_?)
+      end
+    end
+
+    context 'when used by the watir platform' do
+      it 'should locate the list item' do
+        watir_browser.should_receive(:li).and_return(watir_browser)
+        web_element = watir_definition.list_list_item
+        web_element.should_not be_nil
+        web_element.should be_instance_of Fluent::WebElements::ListItem
+      end
+
+      it 'should return the text of a list item' do
+        watir_browser.should_receive(:li).twice.and_return(watir_browser)
+        watir_browser.should_receive(:text).twice.and_return('testing')
+        watir_definition.list.should == 'testing'
+        watir_definition.list_short.should == 'testing'
+      end
+    end
+  end
+
+end

data/spec/generators/ordered_list_generators_spec.rb

@@ -0,0 +1,53 @@
+require_relative '../spec_helper'
+
+class OrderedListGenerators
+  include Fluent
+  
+  ol :list_short, id: 'list1'
+  ordered_list :list, id: 'list2'
+end
+
+describe Fluent::Generators do
+  let(:watir_browser)    { mock_browser_for_watir }
+  let(:watir_definition) { OrderedListGenerators.new(watir_browser) }
+
+  describe 'ordered list generators' do
+    context 'when declared on a page definition' do
+      it 'should generate methods for referencing the ordered list' do
+        watir_definition.should respond_to(:list_object)
+        watir_definition.should respond_to(:list_element)
+        watir_definition.should respond_to(:list_ordered_list)
+        watir_definition.should respond_to(:list_short_ol)
+      end
+
+      it 'should generate methods for interacting with the ordered list' do
+        watir_definition.should respond_to(:list)
+        watir_definition.should respond_to(:list_exists?)
+        watir_definition.should respond_to(:list_visible?)
+        watir_definition.should respond_to(:list?)
+        watir_definition.should respond_to(:list_?)
+        watir_definition.should respond_to(:list_ol_exists?)
+        watir_definition.should respond_to(:list_ol_visible?)
+        watir_definition.should respond_to(:list_ol?)
+        watir_definition.should respond_to(:list_ol_?)
+      end
+    end
+
+    context 'when used by the watir platform' do
+      it 'should locate the ordered list' do
+        watir_browser.should_receive(:ol).and_return(watir_browser)
+        web_element = watir_definition.list_ordered_list
+        web_element.should_not be_nil
+        web_element.should be_instance_of Fluent::WebElements::OrderedList
+      end
+
+      it 'should return the text of a ordered list' do
+        watir_browser.should_receive(:ol).twice.and_return(watir_browser)
+        watir_browser.should_receive(:text).twice.and_return('testing')
+        watir_definition.list.should == 'testing'
+        watir_definition.list_short.should == 'testing'
+      end
+    end
+  end
+  
+end

data/spec/generators/span_generators_spec.rb

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

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

@@ -0,0 +1,55 @@
+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(:text_area).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(:text_area).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(:text_area).and_return(watir_browser)
+        watir_browser.should_receive(:set).with('testing')
+        watir_definition.summary = 'testing'
+      end
+    end
+  end
+end

data/spec/generators/unordered_list_generators_spec.rb

@@ -0,0 +1,53 @@
+require_relative '../spec_helper'
+
+class UnorderedListGenerators
+  include Fluent
+
+  ul :list_short, id: 'list1'
+  unordered_list :list, id: 'list2'
+end
+
+describe Fluent::Generators do
+  let(:watir_browser)    { mock_browser_for_watir }
+  let(:watir_definition) { UnorderedListGenerators.new(watir_browser) }
+
+  describe 'unordered list generators' do
+    context 'when declared on a page definition' do
+      it 'should generate methods for referencing the unordered list' do
+        watir_definition.should respond_to(:list_object)
+        watir_definition.should respond_to(:list_element)
+        watir_definition.should respond_to(:list_unordered_list)
+        watir_definition.should respond_to(:list_short_ul)
+      end
+
+      it 'should generate methods for interacting with the unordered list' do
+        watir_definition.should respond_to(:list)
+        watir_definition.should respond_to(:list_exists?)
+        watir_definition.should respond_to(:list_visible?)
+        watir_definition.should respond_to(:list?)
+        watir_definition.should respond_to(:list_?)
+        watir_definition.should respond_to(:list_ul_exists?)
+        watir_definition.should respond_to(:list_ul_visible?)
+        watir_definition.should respond_to(:list_ul?)
+        watir_definition.should respond_to(:list_ul_?)
+      end
+    end
+
+    context 'when used by the watir platform' do
+      it 'should locate the unordered list' do
+        watir_browser.should_receive(:ul).and_return(watir_browser)
+        web_element = watir_definition.list_unordered_list
+        web_element.should_not be_nil
+        web_element.should be_instance_of Fluent::WebElements::UnorderedList
+      end
+
+      it 'should return the text of a unordered list' do
+        watir_browser.should_receive(:ul).twice.and_return(watir_browser)
+        watir_browser.should_receive(:text).twice.and_return('testing')
+        watir_definition.list.should == 'testing'
+        watir_definition.list_short.should == 'testing'
+      end
+    end
+  end
+
+end

data/spec/generators_spec.rb

@@ -3,13 +3,19 @@ require 'mock_app'
 
 describe Fluent::Generators do
   let(:watir_browser)    { mock_browser_for_watir }
+  let(:selenium_browser) { mock_browser_for_selenium }
+  
   let(:watir_definition) { TestDefinition.new(watir_browser) }
+  let(:selenium_definition) { TestDefinition.new(selenium_browser) }
   
   context 'any page definition' do
     context 'providing a page title to be verified' do
       it 'should specify and verify the page title' do
         watir_browser.should_receive(:title).twice.and_return('Test App')
         watir_definition.check_title
+
+        selenium_browser.should_receive(:title).twice.and_return('Test App')
+        selenium_definition.check_title
       end
 
       it 'should raise an error if the page title is not verified' do
@@ -27,6 +33,30 @@ describe Fluent::Generators do
         watir_browser.should_receive(:title).twice.and_return('Symbiote')
         QuickDefinition.new(watir_browser).check_title
       end
+
+      it 'should allow frames to act as a context' do
+        watir_browser.should_receive(:frame).with(id: 'frame').and_return(watir_browser)
+        watir_browser.should_receive(:text_field).and_return(watir_browser)
+        web_element = watir_definition.framedName_text_field
+        web_element.should_not be_nil
+        web_element.should be_instance_of Fluent::WebElements::TextField
+      end
+
+      context 'automatically looking for an element' do
+        it 'should specify and verify an expected elements' do
+          watir_definition.should_receive(:name_object).and_return(watir_browser)
+          watir_browser.should_receive(:when_present).with(5).and_return(watir_browser)
+          watir_definition.check_objects
+        end
+
+        it 'should raise an error if an expected elements are not verified' do
+          class QuickDefinition
+            include Fluent
+            look_for :fakeLink
+          end
+          expect { QuickDefinition.new(watir_browser).check_objects }.to raise_error
+        end
+      end
     end
 
     context 'a definition using watir-webdriver' do
@@ -37,6 +67,16 @@ describe Fluent::Generators do
         end
       end
     end
+
+    context 'a definition using selenium-webdriver' do
+      context 'providing a url' do
+        it 'should navigate to the page when viewed' do
+          selenium_browser.should_receive(:navigate).and_return(selenium_browser)
+          selenium_browser.should_receive(:to)
+          selenium_definition.view
+        end
+      end
+    end
     
   end
 end