fluent 0.4.0 → 0.5.0

data/spec/generators/unordered_list_generators_spec.rb

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

@@ -1,87 +0,0 @@
-require 'spec_helper'
-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
-        msg = "Expected title: 'Test App'; Actual title: 'Testing'"
-        watir_browser.should_receive(:title).twice.and_return('Testing')
-        expect { watir_definition.check_title }.to raise_error(Fluent::Errors::TitleNotMatched, msg)
-      end
-
-      it 'should validate the title if provided a regular expression' do
-        class QuickDefinition
-          include Fluent
-          title_is (/\w+/)
-        end
-
-        watir_browser.should_receive(:title).twice.and_return('Symbiote')
-        QuickDefinition.new(watir_browser).check_title
-      end
-    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 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
-
-    context 'a definition using watir-webdriver' do
-      context 'providing a url' do
-        it 'should navigate to the page when viewed' do
-          watir_browser.should_receive(:goto)
-          watir_definition.view
-        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

data/spec/mock_app.rb

@@ -1,31 +0,0 @@
-require 'watir-webdriver'
-require 'selenium-webdriver'
-
-def mock_browser_for_watir
-  watir_browser = double('watir')
-  watir_browser.stub(:is_a?).with(Watir::Browser).and_return(true)
-  watir_browser.stub(:is_a?).with(Selenium::WebDriver::Driver).and_return(false)
-  watir_browser
-end
-
-def mock_browser_for_selenium
-  selenium_browser = double('selenium')
-  selenium_browser.stub(:is_a?).with(Watir::Browser).and_return(false)
-  selenium_browser.stub(:is_a?).with(Selenium::WebDriver::Driver).and_return(true)
-  selenium_browser
-end
-
-class TestDefinition
-  include Fluent
-
-  url_is 'http://localhost:4567'
-  title_is 'Test App'
-  
-  look_for :name
-  
-  text_field :name, id: 'name'
-  
-  within_frame(id: 'frame') do |frame|
-    text_field :framedName, id: 'framedName', frame: frame
-  end
-end

data/spec/platform_object_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-class PageDefinition
-  include Fluent
-end
-
-describe Fluent do
-  let(:watir_browser)    { mock_browser_for_watir }
-  let(:selenium_browser) { mock_browser_for_selenium }
-  
-  let(:watir_definition) { PageDefinition.new(watir_browser) }
-  let(:selenium_definition) { PageDefinition.new(selenium_browser) }
-
-  context 'a definition using watir-webdriver' do
-    it 'should return a watir platform object' do
-      watir_definition.platform.should be_kind_of Fluent::Platforms::WatirWebDriver::PlatformObject
-    end
-  end
-
-  context 'a definition using selenium-webdriver' do
-    it 'should return a selenium platform object' do
-      selenium_definition.platform.should be_kind_of Fluent::Platforms::SeleniumWebDriver::PlatformObject
-    end
-  end
-  
-  context 'a definition using an unrecognized driver' do
-    it 'should raise an exception' do
-      msg = 'Unable to create a platform object for unknown_browser.'
-      expect { PageDefinition.new(:unknown_browser) }.to raise_error(Fluent::Errors::UnableToCreatePlatform, msg)
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,19 +0,0 @@
-require 'simplecov'
-require 'coveralls'
-
-Coveralls.wear!
-
-SimpleCov.add_filter '/spec'
-
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-  SimpleCov::Formatter::HTMLFormatter,
-  Coveralls::SimpleCov::Formatter
-]
-
-SimpleCov.at_exit do
-  SimpleCov.result.format!
-  SimpleCov.minimum_coverage 90
-  SimpleCov.maximum_coverage_drop 5
-end
-
-require 'fluent'

data/spec/web_element_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-describe 'Web Elements' do
-  let(:watir_browser)    { mock_browser_for_watir }
-  let(:watir_definition) { ::Fluent::WebElements::WebElement.new(watir_browser, :platform => :watir_webdriver) }
-
-  it 'should return the text contained by a web element' do
-    watir_browser.should_receive(:text).and_return('testing')
-    watir_definition.text.should == 'testing'
-  end
-  
-  it 'should perform a click event on a web element' do
-    watir_browser.should_receive(:click)
-    watir_definition.click
-  end
-
-  it 'should determine if a web element is enabled' do
-    watir_browser.should_receive(:enabled?).twice.and_return(true)
-    watir_definition.enabled?.should == true
-    watir_definition.should be_enabled
-  end
-
-  it 'should determine if a web element is disabled' do
-    watir_browser.should_receive(:enabled?).twice.and_return(false)
-    watir_definition.disabled?.should == true
-    watir_definition.should be_disabled
-  end
-
-  it 'should retrieve the style of a web element' do
-    watir_browser.should_receive(:style).with('display').and_return('none')
-    watir_definition.style('display').should == 'none'
-  end
-
-  it 'should retrieve the class name of a web element' do
-    watir_browser.should_receive(:attribute_value).and_return('class')
-    watir_definition.class_name
-  end
-end

data/spec/web_element_watir_spec.rb

@@ -1,156 +0,0 @@
-require 'spec_helper'
-
-describe 'Web Elements for Watir' do
-  let(:watir_browser)    { mock_browser_for_watir }
-  let(:watir_definition) { ::Fluent::WebElements::WebElement.new(watir_browser, :platform => :watir_webdriver) }
-
-  it 'should determine if a web element exists' do
-    watir_browser.should_receive(:exists?).and_return(true)
-    watir_definition.exists?.should == true
-  end
-
-  it 'should determine if a web element does not exist' do
-    watir_browser.should_receive(:exists?).and_return(false)
-    watir_definition.exists?.should == false
-  end
-
-  it 'should determine if a web element is visible' do
-    watir_browser.should_receive(:present?).twice.and_return(true)
-    watir_definition.visible?.should == true
-    watir_definition.should be_visible
-  end
-
-  it 'should determine if a web element is not visible' do
-    watir_browser.should_receive(:present?).and_return(false)
-    watir_definition.visible?.should == false
-  end
-
-  it 'should simulate a double-click event on a web element' do
-    watir_browser.should_receive(:double_click)
-    watir_definition.double_click
-  end
-
-  it 'should allow a clear event on a web element' do
-    watir_browser.should_receive(:clear)
-    watir_definition.clear
-  end
-  
-  it 'should be able to flash a web element' do
-    watir_browser.should_receive(:flash).exactly(5).times.and_return(watir_definition)
-    watir_browser.should_receive(:exists?).and_return(watir_definition)
-    watir_definition.flash.should be_instance_of Fluent::WebElements::WebElement
-  end
-
-  it 'should be able to flash a web element a specified number of times' do
-    watir_browser.should_receive(:flash).exactly(1).times.and_return(watir_definition)
-    watir_browser.should_receive(:exists?).and_return(watir_definition)
-    watir_definition.flash(1).should be_instance_of Fluent::WebElements::WebElement
-  end
-
-  it 'should retrieve the tag of a web element' do
-    watir_browser.should_receive(:tag_name).and_return('div')
-    watir_definition.tag_name.should == 'div'
-  end
-
-  it 'should retrieve the html of a web element' do
-    watir_browser.should_receive(:html).and_return('<p>Testing</p>')
-    watir_definition.html.should == '<p>Testing</p>'
-  end
-  
-  it 'should retrieve the value of an attribute' do
-    watir_browser.should_receive(:attribute_value).and_return(true)
-    watir_definition.attribute('readonly').should be_true
-  end
-
-  it 'should be able to fire an event on a web element' do
-    watir_browser.should_receive(:fire_event).and_return('onclick')
-    watir_definition.fire_event('onclick')
-  end
-
-  it 'should retrieve the value of a web element' do
-    watir_browser.should_receive(:value).and_return("value")
-    watir_definition.value.should == 'value'
-  end
-
-  it 'should retrieve the id of a web element' do
-    watir_browser.should_receive(:id).and_return('id')
-    watir_definition.id.should == 'id'
-  end
-
-  it 'should send key presses to a web element' do
-    watir_browser.should_receive(:send_keys).with([:control, 'a'])
-    watir_definition.send_keys([:control, 'a'])
-  end
-
-  it 'should scroll elements into view' do
-    watir_browser.should_receive(:wd).and_return(watir_browser)
-    watir_browser.should_receive(:location_once_scrolled_into_view)
-    watir_definition.scroll_into_view
-  end
-
-  it 'should be able to focus on a web element' do
-    watir_browser.should_receive(:focus).and_return(watir_definition)
-    watir_definition.focus
-  end
-
-  it 'should be able to hover over a web element' do
-    watir_browser.should_receive(:hover).and_return(watir_definition)
-    watir_definition.hover
-  end
-
-  it 'should wait for a web element to be present' do
-    watir_browser.should_receive(:wait_until_present).twice.with(5)
-    watir_definition.when_actionable(5)
-    watir_definition.when_present(5)
-  end
-
-  it 'should use the provided element wait time for presence checks' do
-    Fluent.element_level_wait = 30
-    watir_browser.should_receive(:wait_until_present).with(30)
-    watir_definition.when_present
-  end
-
-  it 'should reference a web element when it is present' do
-    watir_browser.should_receive(:wait_until_present).with(5)
-    web_element = watir_definition.when_actionable(5)
-    web_element.should === watir_definition
-  end
-
-  it 'should wait for a web element to become non-present' do
-    watir_browser.should_receive(:wait_while_present).and_return(false)
-    watir_definition.when_not_present(5)
-  end
-
-  it 'should wait for a web element to become visible' do
-    watir_browser.should_receive(:present?).and_return(true)
-    watir_definition.when_visible(5)
-  end
-
-  it 'should reference a web element when it is visible' do
-    watir_browser.should_receive(:present?).and_return(true)
-    web_element = watir_definition.when_visible(5)
-    web_element.should === watir_definition
-  end
-
-  it 'should wait for a web element to become invisible' do
-    watir_browser.should_receive(:present?).and_return(false)
-    watir_definition.when_not_visible(5)
-  end
-
-  it 'should reference a web element when it is not visible' do
-    watir_browser.stub(:present?).and_return(false)
-    web_element = watir_definition.when_not_visible(5)
-    web_element.should === watir_definition
-  end
-
-  it 'should wait until a specific condition occurs' 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

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