fluent 0.2.0 → 0.3.0

data/spec/generators/form_generators_spec.rb

@@ -0,0 +1,42 @@
+require_relative '../spec_helper'
+
+class FormGenerators
+  include Fluent
+
+  form :group, id: 'group'
+end
+
+describe Fluent::Generators do
+  let(:watir_browser)    { mock_browser_for_watir }
+  let(:watir_definition) { FormGenerators.new(watir_browser) }
+
+  describe 'form generators' do
+    context 'when declared on a page definition' do
+      it 'should generate methods for referencing the form' do
+        watir_definition.should respond_to(:group_object)
+        watir_definition.should respond_to(:group_element)
+        watir_definition.should respond_to(:group_form)
+      end
+
+      it 'should generate methods for interacting with the form' do
+        watir_definition.should respond_to(:group_exists?)
+        watir_definition.should respond_to(:group_visible?)
+        watir_definition.should respond_to(:group?)
+        watir_definition.should respond_to(:group_?)
+        watir_definition.should respond_to(:group_form_exists?)
+        watir_definition.should respond_to(:group_form_visible?)
+        watir_definition.should respond_to(:group_form?)
+        watir_definition.should respond_to(:group_form_?)
+      end
+    end
+
+    context 'when used by the watir platform' do
+      it 'should locate the form' do
+        watir_browser.should_receive(:form).and_return(watir_browser)
+        web_element = watir_definition.group_object
+        web_element.should_not be_nil
+        web_element.should be_instance_of Fluent::WebElements::Form
+      end
+    end
+  end
+end

data/spec/generators/heading_generators_spec.rb

@@ -0,0 +1,87 @@
+require_relative '../spec_helper'
+
+class HeadingGenerators
+  include Fluent
+
+  h1 :headingOne, id: 'headingOne'
+  h2 :headingTwo, id: 'headingTwo'
+  h3 :headingThree, id: 'headingThree'
+  h4 :headingFour, id: 'headingFour'
+  h5 :headingFive, id: 'headingFive'
+  h6 :headingSix, id: 'headingSix'
+end
+
+describe Fluent::Generators do
+  let(:watir_browser)    { mock_browser_for_watir }
+  let(:watir_definition) { HeadingGenerators.new(watir_browser) }
+
+  describe 'heading generators' do
+    context 'when declared on a page definition' do
+      it 'should generate methods for referencing the heading' do
+        watir_definition.should respond_to(:headingOne_object)
+        watir_definition.should respond_to(:headingTwo_object)
+      end
+      
+      it 'should generate methods for interacting with the heading' do
+        watir_definition.should respond_to(:headingOne)
+        watir_definition.should respond_to(:headingTwo)
+      end
+    end
+
+    context 'when used by the watir platform' do
+      it 'should locate the heading' do
+        watir_browser.should_receive(:h1).and_return(watir_browser)
+        web_element = watir_definition.headingOne_h1
+        web_element.should_not be_nil
+        web_element.should be_instance_of Fluent::WebElements::Heading
+
+        watir_browser.should_receive(:h2).and_return(watir_browser)
+        web_element = watir_definition.headingTwo_h2
+        web_element.should be_instance_of Fluent::WebElements::Heading
+
+        watir_browser.should_receive(:h3).and_return(watir_browser)
+        web_element = watir_definition.headingThree_h3
+        web_element.should be_instance_of Fluent::WebElements::Heading
+
+        watir_browser.should_receive(:h4).and_return(watir_browser)
+        web_element = watir_definition.headingFour_h4
+        web_element.should be_instance_of Fluent::WebElements::Heading
+
+        watir_browser.should_receive(:h5).and_return(watir_browser)
+        web_element = watir_definition.headingFive_h5
+        web_element.should be_instance_of Fluent::WebElements::Heading
+
+        watir_browser.should_receive(:h6).and_return(watir_browser)
+        web_element = watir_definition.headingSix_h6
+        web_element.should be_instance_of Fluent::WebElements::Heading
+      end
+
+      it 'should return the text of a heading' do
+        watir_browser.should_receive(:h1).and_return(watir_browser)
+        watir_browser.should_receive(:text).and_return('testing')
+        watir_definition.headingOne.should == 'testing'
+
+        watir_browser.should_receive(:h2).and_return(watir_browser)
+        watir_browser.should_receive(:text).and_return('testing')
+        watir_definition.headingTwo.should == 'testing'
+
+        watir_browser.should_receive(:h3).and_return(watir_browser)
+        watir_browser.should_receive(:text).and_return('testing')
+        watir_definition.headingThree.should == 'testing'
+
+        watir_browser.should_receive(:h4).and_return(watir_browser)
+        watir_browser.should_receive(:text).and_return('testing')
+        watir_definition.headingFour.should == 'testing'
+
+        watir_browser.should_receive(:h5).and_return(watir_browser)
+        watir_browser.should_receive(:text).and_return('testing')
+        watir_definition.headingFive.should == 'testing'
+
+        watir_browser.should_receive(:h6).and_return(watir_browser)
+        watir_browser.should_receive(:text).and_return('testing')
+        watir_definition.headingSix.should == 'testing'
+      end
+    end
+  end
+  
+end

data/spec/generators/hidden_generators_spec.rb

@@ -0,0 +1,49 @@
+require_relative '../spec_helper'
+
+class HiddenGenerators
+  include Fluent
+
+  hidden :ssn, id: 'ssn'
+end
+
+describe Fluent::Generators do
+  let(:watir_browser)    { mock_browser_for_watir }
+  let(:watir_definition) { HiddenGenerators.new(watir_browser) }
+
+  describe 'hidden generators' do
+    context 'when declared on a page definition' do
+      it 'should generate methods for referencing the hidden' do
+        watir_definition.should respond_to(:ssn_object)
+        watir_definition.should respond_to(:ssn_element)
+        watir_definition.should respond_to(:ssn_hidden)
+      end
+
+      it 'should generate methods for interacting with the text area' do
+        watir_definition.should respond_to(:ssn)
+        watir_definition.should respond_to(:ssn_exists?)
+        watir_definition.should respond_to(:ssn_visible?)
+        watir_definition.should respond_to(:ssn?)
+        watir_definition.should respond_to(:ssn_?)
+        watir_definition.should respond_to(:ssn_hidden_exists?)
+        watir_definition.should respond_to(:ssn_hidden_visible?)
+        watir_definition.should respond_to(:ssn_hidden?)
+        watir_definition.should respond_to(:ssn_hidden_?)
+      end
+    end
+
+    context 'when used by the watir platform' do
+      it 'should locate the hidden' do
+        watir_browser.should_receive(:hidden).and_return(watir_browser)
+        web_element = watir_definition.ssn_object
+        web_element.should_not be_nil
+        web_element.should be_instance_of Fluent::WebElements::Hidden
+      end
+
+      it 'should retrieve text from the hidden' do
+        watir_browser.should_receive(:hidden).and_return(watir_browser)
+        watir_browser.should_receive(:value).and_return('testing')
+        watir_definition.ssn.should == 'testing'
+      end
+    end
+  end
+end

data/spec/generators/image_generators_spec.rb

@@ -0,0 +1,42 @@
+require_relative '../spec_helper'
+
+class ImageGenerators
+  include Fluent
+
+  image :logo, id: 'logo'
+end
+
+describe Fluent::Generators do
+  let(:watir_browser)    { mock_browser_for_watir }
+  let(:watir_definition) { ImageGenerators.new(watir_browser) }
+
+  describe 'image generators' do
+    context 'when declared on a page definition' do
+      it 'should generate methods for referencing the image' do
+        watir_definition.should respond_to(:logo_object)
+        watir_definition.should respond_to(:logo_element)
+        watir_definition.should respond_to(:logo_image)
+      end
+
+      it 'should generate methods for interacting with the image' do
+        watir_definition.should respond_to(:logo_exists?)
+        watir_definition.should respond_to(:logo_visible?)
+        watir_definition.should respond_to(:logo?)
+        watir_definition.should respond_to(:logo_?)
+        watir_definition.should respond_to(:logo_image_exists?)
+        watir_definition.should respond_to(:logo_image_visible?)
+        watir_definition.should respond_to(:logo_image?)
+        watir_definition.should respond_to(:logo_image_?)
+      end
+    end
+
+    context 'when used by the watir platform' do
+      it 'should locate the image' do
+        watir_browser.should_receive(:image).and_return(watir_browser)
+        web_element = watir_definition.logo_object
+        web_element.should_not be_nil
+        web_element.should be_instance_of Fluent::WebElements::Image
+      end
+    end
+  end
+end

data/spec/generators/label_generators_spec.rb

@@ -0,0 +1,49 @@
+require_relative '../spec_helper'
+
+class LabelGenerators
+  include Fluent
+
+  label :topic, id: 'topic'
+end
+
+describe Fluent::Generators do
+  let(:watir_browser)    { mock_browser_for_watir }
+  let(:watir_definition) { LabelGenerators.new(watir_browser) }
+
+  describe 'label generators' do
+    context 'when declared on a page definition' do
+      it 'should generate methods for referencing the label' do
+        watir_definition.should respond_to(:topic_object)
+        watir_definition.should respond_to(:topic_element)
+        watir_definition.should respond_to(:topic_label)
+      end
+
+      it 'should generate methods for interacting with the label' do
+        watir_definition.should respond_to(:topic)
+        watir_definition.should respond_to(:topic_exists?)
+        watir_definition.should respond_to(:topic_visible?)
+        watir_definition.should respond_to(:topic?)
+        watir_definition.should respond_to(:topic_?)
+        watir_definition.should respond_to(:topic_label_exists?)
+        watir_definition.should respond_to(:topic_label_visible?)
+        watir_definition.should respond_to(:topic_label?)
+        watir_definition.should respond_to(:topic_label_?)
+      end
+    end
+
+    context 'when used by the watir platform' do
+      it 'should locate the label' do
+        watir_browser.should_receive(:label).and_return(watir_browser)
+        web_element = watir_definition.topic_object
+        web_element.should_not be_nil
+        web_element.should be_instance_of Fluent::WebElements::Label
+      end
+
+      it 'should retrieve text from the label' do
+        watir_browser.should_receive(:label).and_return(watir_browser)
+        watir_browser.should_receive(:text).and_return('testing')
+        watir_definition.topic.should == 'testing'
+      end
+    end
+  end
+end

data/spec/generators/text_area_generators_spec.rb

@@ -33,20 +33,20 @@ describe Fluent::Generators do
 
     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)
+        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(:text_area).and_return(watir_browser)
+        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(:text_area).and_return(watir_browser)
+        watir_browser.should_receive(:textarea).and_return(watir_browser)
         watir_browser.should_receive(:set).with('testing')
         watir_definition.summary = 'testing'
       end

data/spec/generators_spec.rb

@@ -18,6 +18,11 @@ describe Fluent::Generators do
         selenium_definition.check_title
       end
 
+      it 'should specify and verify the page url' do
+        watir_browser.should_receive(:url).twice.and_return('http://localhost:4567')
+        watir_definition.check_url
+      end
+      
       it 'should raise an error if the page title is not verified' do
         msg = "Expected title: 'Test App'; Actual title: 'Testing'"
         watir_browser.should_receive(:title).twice.and_return('Testing')

data/spec/spec_helper.rb

@@ -3,6 +3,8 @@ require 'coveralls'
 
 Coveralls.wear!
 
+SimpleCov.add_filter '/spec'
+
 SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
   SimpleCov::Formatter::HTMLFormatter,
   Coveralls::SimpleCov::Formatter

data/spec/web_element_watir_spec.rb

@@ -147,4 +147,10 @@ describe 'Web Elements for Watir' do
     Object::Watir::Wait.stub(:until).with(5, 'Condition occurred.')
     watir_definition.wait_until(5, 'Condition occurred.') { true }
   end
+
+  it 'should find the parent for a web element' do
+    watir_browser.should_receive(:tag_name).twice.and_return(:p)
+    watir_browser.should_receive(:parent).and_return(watir_definition)
+    watir_definition.parent
+  end
 end

data/spec/web_elements/button_spec.rb

@@ -0,0 +1,21 @@
+require_relative '../spec_helper'
+
+describe 'Fluent::WebElements::Button' do
+
+  it 'should register with a submit tag' do
+    ::Fluent::WebElements.get_class_for(:input, :submit).should == ::Fluent::WebElements::Button
+  end
+
+  it 'should register with a button tag' do
+    ::Fluent::WebElements.get_class_for(:input, :button).should == ::Fluent::WebElements::Button
+  end
+
+  it 'should register with a image tag' do
+    ::Fluent::WebElements.get_class_for(:input, :image).should == ::Fluent::WebElements::Button
+  end
+
+  it 'should register with a reset tag' do
+    ::Fluent::WebElements.get_class_for(:input, :reset).should == ::Fluent::WebElements::Button
+  end
+  
+end

data/spec/web_elements/cell_spec.rb

@@ -0,0 +1,13 @@
+require_relative '../spec_helper'
+
+describe 'Fluent::WebElements::Cell' do
+
+  it 'should register with a table definition tag' do
+    ::Fluent::WebElements.get_class_for(:td).should == ::Fluent::WebElements::Cell
+  end
+
+  it 'should register with a table header tag' do
+    ::Fluent::WebElements.get_class_for(:th).should == ::Fluent::WebElements::Cell
+  end
+
+end

data/spec/web_elements/checkbox_spec.rb

@@ -18,4 +18,8 @@ describe 'WebElements::CheckBox' do
     checkbox_object.should_receive(:clear)
     checkbox_definition.uncheck
   end
+
+  it 'should register with a checkbox tag' do
+    ::Fluent::WebElements.get_class_for(:input, :checkbox).should == ::Fluent::WebElements::CheckBox
+  end
 end

data/spec/web_elements/div_spec.rb

@@ -0,0 +1,9 @@
+require_relative '../spec_helper'
+
+describe 'Fluent::WebElements::Div' do
+
+  it 'should register with a div tag' do
+    ::Fluent::WebElements.get_class_for(:div).should == ::Fluent::WebElements::Div
+  end
+  
+end

data/spec/web_elements/form_spec.rb

@@ -0,0 +1,9 @@
+require_relative '../spec_helper'
+
+describe 'Fluent::WebElements::Form' do
+
+  it 'should register with a form tag' do
+    ::Fluent::WebElements.get_class_for(:form).should == ::Fluent::WebElements::Form
+  end
+
+end

data/spec/web_elements/heading_spec.rb

@@ -0,0 +1,28 @@
+require_relative '../spec_helper'
+
+describe 'Fluent::WebElements::Heading' do
+
+  it 'should register with a h1 tag' do
+    ::Fluent::WebElements.get_class_for(:h1).should == ::Fluent::WebElements::Heading
+  end
+
+  it 'should register with a h2 tag' do
+    ::Fluent::WebElements.get_class_for(:h2).should == ::Fluent::WebElements::Heading
+  end
+
+  it 'should register with a h3 tag' do
+    ::Fluent::WebElements.get_class_for(:h3).should == ::Fluent::WebElements::Heading
+  end
+
+  it 'should register with a h4 tag' do
+    ::Fluent::WebElements.get_class_for(:h4).should == ::Fluent::WebElements::Heading
+  end
+
+  it 'should register with a h5 tag' do
+    ::Fluent::WebElements.get_class_for(:h5).should == ::Fluent::WebElements::Heading
+  end
+
+  it 'should register with a h6 tag' do
+    ::Fluent::WebElements.get_class_for(:h6).should == ::Fluent::WebElements::Heading
+  end
+end

data/spec/web_elements/hidden_spec.rb

@@ -0,0 +1,9 @@
+require_relative '../spec_helper'
+
+describe 'Fluent::WebElements::Div' do
+
+  it 'should register with a hidden tag' do
+    ::Fluent::WebElements.get_class_for(:hidden).should == ::Fluent::WebElements::Hidden
+  end
+
+end

data/spec/web_elements/image_spec.rb

@@ -0,0 +1,9 @@
+require_relative '../spec_helper'
+
+describe 'Fluent::WebElements::Image' do
+
+  it 'should register with a image tag' do
+    ::Fluent::WebElements.get_class_for(:img).should == ::Fluent::WebElements::Image
+  end
+
+end