fluent 0.4.0 → 0.5.0

data/spec/enclosers_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-class EnclosersTest
-  include Fluent
-  
-end
-
-describe Fluent::Enclosers do
-  let(:watir_browser) { mock_browser_for_watir }
-  let(:watir_definition) { EnclosersTest.new(watir_browser) }
-
-  context 'a definition using watir-webdriver' do
-    it 'should handle alert message boxes' do
-      watir_browser.should_receive(:alert).exactly(3).times.and_return(watir_browser)
-      watir_browser.should_receive(:exists?).and_return(true)
-      watir_browser.should_receive(:text)
-      watir_browser.should_receive(:ok)
-      watir_definition.will_alert do
-      end
-    end
-
-    it 'should handle confirmation message boxes' do
-      watir_browser.should_receive(:alert).exactly(3).times.and_return(watir_browser)
-      watir_browser.should_receive(:exists?).and_return(true)
-      watir_browser.should_receive(:text)
-      watir_browser.should_receive(:ok)
-      watir_definition.will_confirm(true) do
-      end
-    end
-
-    it 'should handle prompt message boxes' do
-      watir_browser.should_receive(:wd).twice.and_return(watir_browser)
-      watir_browser.should_receive(:execute_script).twice
-      watir_definition.will_prompt('Testing') do
-      end
-    end
-  end
-end

data/spec/evaluators_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-require 'mock_app'
-
-describe Fluent::Evaluators do
-  let(:watir_browser)    { mock_browser_for_watir }
-  let(:watir_definition) { TestDefinition.new(watir_browser) }
-  
-  describe 'browser-level actions' do
-    context 'a definition using watir-webdriver' do
-      it 'should get the active url' do
-        watir_browser.should_receive(:url).twice.and_return('http://localhost:9292')
-        watir_definition.url.should == 'http://localhost:9292'
-        watir_definition.current_url.should == 'http://localhost:9292'
-      end
-
-      it 'should be able to clear all of the cookies from the browser' do
-        watir_browser.should_receive(:cookies).twice.and_return(watir_browser)
-        watir_browser.should_receive(:clear).twice
-        watir_definition.remove_cookies
-        watir_definition.clear_cookies
-      end
-
-      it 'should be able to refresh the page contents' do
-        watir_browser.should_receive(:refresh).twice.and_return(watir_browser)
-        watir_definition.refresh_page
-        watir_definition.refresh
-      end
-
-      it 'should run a script against the browser' do
-        watir_browser.should_receive(:execute_script).twice.and_return('input')
-        watir_definition.run_script('return document.activeElement').should == 'input'
-        watir_definition.execute_script('return document.activeElement').should == 'input'
-      end
-
-      it 'should get a screenshot' do
-        watir_browser.should_receive(:wd).twice.and_return(watir_browser)
-        watir_browser.should_receive(:save_screenshot).twice
-        watir_definition.screenshot('testing.png')
-        watir_definition.save_screenshot('testing.png')
-      end
-    end
-  end
-
-  describe 'page-level actions' do
-    context 'a definition using watir-webdriver' do
-      it 'should return all the markup on a page' do
-        watir_browser.should_receive(:html).twice.and_return('<h1>Page Title</h1>')
-        watir_definition.markup.should == '<h1>Page Title</h1>'
-        watir_definition.html.should == '<h1>Page Title</h1>'
-      end
-
-      it 'should return the title of a page' do
-        watir_browser.should_receive(:title).twice.and_return('Page Title')
-        watir_definition.page_title.should == 'Page Title'
-        watir_definition.title.should == 'Page Title'
-      end
-
-      it 'should return all the text on a page' do
-        watir_browser.should_receive(:text).twice.and_return('page text')
-        watir_definition.page_text.should == 'page text'
-        watir_definition.text.should == 'page text'
-      end
-
-      it 'should wait for jquery pending requests to finish' do
-        watir_browser.should_receive(:execute_script).with('return jQuery.active').and_return(0)
-        watir_definition.wait_for_pending_requests
-      end
-
-      it 'should return an exception if pending requests did not finish' do
-        watir_browser.should_receive(:execute_script).at_least(1).times.with('return jQuery.active').and_return(1)
-        expect { watir_definition.wait_for_pending_requests(0.1) }.to raise_error
-      end
-
-      it 'should wait for a condition to be true' do
-        watir_browser.should_receive(:wait_until).with(5, 'some condition')
-        watir_definition.wait_until(5, 'some condition')
-      end
-
-      it 'should wait for a condition to be true with any page level timeout' do
-        Fluent.page_level_wait = 30
-        watir_browser.should_receive(:wait_until).with(30, nil)
-        watir_definition.wait_until
-      end
-      
-      
-    end
-  end
-end

data/spec/factory_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-require 'mock_app'
-
-class TestFactory
-  include Fluent::Factory
-
-  attr_accessor :driver
-end
-
-class DefinitionTest
-  include Fluent
-
-  url_is 'http://localhost:9292'
-end
-
-describe Fluent::Factory do
-  before(:each) do
-    @factory = TestFactory.new
-    @factory.driver = mock_browser_for_watir
-  end
-  
-  it 'should create a new definition object and view it, using on_view' do
-    @factory.driver.should_receive(:goto)
-    @factory.on_view DefinitionTest do |page|
-      page.should be_instance_of DefinitionTest
-    end
-  end
-
-  it 'should create a new definition object, using on' do
-    @factory.driver.should_not_receive(:goto)
-    @factory.on DefinitionTest do |page|
-      page.should be_instance_of DefinitionTest
-    end
-  end
-  
-  it 'should set a reference to be used outside the factory' do
-    active = @factory.on DefinitionTest
-    current = @factory.instance_variable_get '@active'
-    current.should === active
-  end
-  
-  it 'should create a new definition based on a string' do
-    @factory.driver.should_receive(:goto)
-    @factory.on_view "DefinitionTest" do |page|
-      page.should be_instance_of DefinitionTest
-    end
-  end
-  
-end

data/spec/fluent_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe Fluent do
-  
-  it 'should return version information' do
-    Fluent.version.should == "Fluent v#{Fluent::VERSION}"
-  end
-
-  it 'should set the element level wait default to 5' do
-    Fluent.instance_variable_set('@element_wait', nil)
-    Fluent.element_level_wait.should == 5
-  end
-
-  it 'should allow the element level wait to be set' do
-    Fluent.instance_variable_set('@element_wait', 10)
-    Fluent.element_level_wait.should == 10
-  end
-
-  it 'should be able to set an element level wait value' do
-    Fluent.element_level_wait = 10
-    value = Fluent.instance_variable_get('@element_wait')
-    value.should == 10
-  end
-
-  it 'should set the page level wait default to 15' do
-    Fluent.instance_variable_set('@page_wait', nil)
-    Fluent.page_level_wait.should == 15
-  end
-
-  it 'should allow the page level wait to be set' do
-    Fluent.instance_variable_set('@page_wait', 10)
-    Fluent.page_level_wait.should == 10
-  end
-
-  it 'should be able to set a page level wait value' do
-    Fluent.page_level_wait = 30
-    value = Fluent.instance_variable_get('@page_wait')
-    value.should == 30
-  end
-end

data/spec/generators/button_generators_spec.rb

@@ -1,77 +0,0 @@
-require_relative '../spec_helper'
-
-class ButtonGenerators
-  include Fluent
-
-  button :submit, id: 'submit'
-end
-
-describe Fluent::Generators do
-  let(:watir_browser)    { mock_browser_for_watir }
-  let(:watir_definition) { ButtonGenerators.new(watir_browser) }
-
-  describe 'button generators' do
-    context 'when declared on a page definition' do
-      it 'should generate methods for referencing the button' do
-        watir_definition.should respond_to(:submit_object)
-        watir_definition.should respond_to(:submit_element)
-        watir_definition.should respond_to(:submit_button)
-      end
-
-      it 'should generate methods for interacting with the button' do
-        watir_definition.should respond_to(:submit)
-        watir_definition.should respond_to(:submit_exists?)
-        watir_definition.should respond_to(:submit_visible?)
-        watir_definition.should respond_to(:submit_enabled?)
-        watir_definition.should respond_to(:submit?)
-        watir_definition.should respond_to(:submit_?)
-        watir_definition.should respond_to(:submit!)
-        watir_definition.should respond_to(:submit_button_exists?)
-        watir_definition.should respond_to(:submit_button_visible?)
-        watir_definition.should respond_to(:submit_button_enabled?)
-        watir_definition.should respond_to(:submit_button?)
-        watir_definition.should respond_to(:submit_button_?)
-        watir_definition.should respond_to(:submit_button!)
-      end
-    end
-
-    context 'when used by the watir platform' do
-      it 'should locate the button' do
-        watir_browser.should_receive(:button).and_return(watir_browser)
-        web_element = watir_definition.submit_object
-        web_element.should_not be_nil
-        web_element.should be_instance_of Fluent::WebElements::Button
-      end
-
-      it 'should click the button' do
-        watir_browser.should_receive(:button).and_return(watir_browser)
-        watir_browser.should_receive(:click)
-        watir_definition.submit
-      end
-
-      it 'should determine if a button exists' do
-        watir_browser.should_receive(:button).exactly(3).times.and_return(watir_browser)
-        watir_browser.should_receive(:exists?).exactly(3).times.and_return(watir_browser)
-        watir_definition.submit?.should be_true
-        watir_definition.submit_exists?.should be_true
-        watir_definition.submit_button_exists?.should be_true
-      end
-
-      it 'should determine if a button is visible' do
-        watir_browser.should_receive(:button).exactly(3).times.and_return(watir_browser)
-        watir_browser.should_receive(:present?).exactly(3).times.and_return(watir_browser)
-        watir_definition.submit_?.should be_true
-        watir_definition.submit_visible?.should be_true
-        watir_definition.submit_button_visible?.should be_true
-      end
-
-      it 'should determine if a button is enabled' do
-        watir_browser.should_receive(:button).exactly(3).times.and_return(watir_browser)
-        watir_browser.should_receive(:enabled?).exactly(3).times.and_return(watir_browser)
-        watir_definition.submit!.should be_true
-        watir_definition.submit_enabled?.should be_true
-        watir_definition.submit_button_enabled?.should be_true
-      end
-    end
-  end
-end

data/spec/generators/cell_generators_spec.rb

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

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

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