symbiont 0.2.1 → 0.3.0

data/spec/symbiont/data_setter_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
-
-describe Symbiont::DataSetter do
-  let(:watir_browser)    { mock_browser_for_watir }
-  let(:watir_definition) { DefinitionTest.new(watir_browser) }
-
-  it "should set data in a text field" do
-    watir_definition.should_receive(:name=).with('jnyman')
-    watir_definition.should_receive(:object_enabled_for).and_return(true)
-    watir_definition.using('name' => 'jnyman')
-  end
-
-  it "should not set data in a non-existent text field" do
-    watir_browser.should_not_receive(:text_field)
-    watir_definition.using('fake_field' => 'fake data')
-  end
-
-  it "should not set data in a disabled text field" do
-    watir_definition.should_not_receive(:name=)
-    watir_definition.should_receive(:name_object).twice.and_return(watir_browser)
-    watir_browser.should_receive(:enabled?).and_return(false)
-    watir_browser.should_receive(:tag_name).with(no_args)
-    watir_definition.using('name' => 'test data')
-  end
-
-  it "should set data in a select list field" do
-    watir_definition.should_receive(:concepts=).with('physics')
-    watir_definition.should_receive(:object_enabled_for).and_return(true)
-    watir_definition.using('concepts' => 'physics')
-  end
-
-  it "should check a checkbox field" do
-    watir_definition.should_receive(:check_apply_tax)
-    watir_definition.should_receive(:object_enabled_for).and_return(true)
-    watir_definition.using('apply_tax' => true)
-  end
-
-  it "should uncheck a checkbox field" do
-    watir_definition.should_receive(:uncheck_apply_tax)
-    watir_definition.should_receive(:object_enabled_for).and_return(true)
-    watir_definition.using('apply_tax' => false)
-  end
-
-  it "should not check data in a disabled checkbox field" do
-    watir_definition.should_not_receive(:check_apply_tax)
-    watir_definition.should_receive(:apply_tax_object).twice.and_return(watir_browser)
-    watir_browser.should_receive(:enabled?).and_return(false)
-    watir_browser.should_receive(:tag_name).with(no_args)
-    watir_definition.using('apply_tax' => true)
-  end
-
-  it "should select a radio field" do
-    watir_definition.should_receive(:select_include_tax)
-    watir_definition.should_receive(:object_enabled_for).and_return(true)
-    watir_definition.using('include_tax' => true)
-  end
-
-  it "should not select data in a disable radio field" do
-    watir_definition.should_not_receive(:select_include_tax)
-    watir_definition.should_receive(:include_tax_object).twice.and_return(watir_browser)
-    watir_browser.should_receive(:enabled?).and_return(false)
-    watir_browser.should_receive(:tag_name).with(no_args)
-    watir_definition.using('include_tax' => true)
-  end
-end

data/spec/symbiont/enclosers_spec.rb

@@ -1,76 +0,0 @@
-require "spec_helper"
-
-describe Symbiont::Enclosers do
-  let(:watir_browser) { mock_browser_for_watir }
-  let(:watir_definition) { DefinitionTest.new(watir_browser) }
-
-  context "a definition using watir-webdriver" do
-    it "should wait for a condition to be true" do
-      watir_browser.should_receive(:wait_until).with(5, "some condition")
-      watir_definition.wait_for(5, "some condition")
-    end
-
-    it "should wait for a condition to be true with any page level timeout" do
-      Symbiont.page_level_wait = 30
-      watir_browser.should_receive(:wait_until).with(30, nil)
-      watir_definition.wait_for
-    end
-
-    it "should be able to attach to a window by using the title" do
-      watir_browser.should_receive(:window).with(:title => /Display\ Results/).and_return(watir_browser)
-      watir_browser.should_receive(:use)
-      watir_definition.within_window(title: "Display Results")
-    end
-
-    it "should be able to attach to a window by using the url" do
-      watir_browser.should_receive(:window).with(:url => /results\.html/).and_return(watir_browser)
-      watir_browser.should_receive(:use)
-      watir_definition.within_window(url: "results.html")
-    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)
-      watir_browser.should_receive(:wd).and_return(watir_browser)
-      watir_browser.should_receive(:switch_to).and_return(watir_browser)
-      watir_browser.should_receive(:default_content).and_return(watir_browser)
-      web_object = watir_definition.framedLoginName_text_field
-      web_object.should_not be_nil
-      web_object.should be_instance_of Symbiont::WebObjects::TextField
-    end
-
-    it "should be able to convert a modal popup to a window" do
-      watir_browser.should_receive(:execute_script)
-      watir_definition.within_modal {}
-    end
-
-    it "should handle alert message boxes" do
-      #watir_browser.should_receive(:wd).twice.and_return(watir_browser)
-      #watir_browser.should_receive(:execute_script).twice
-      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(:wd).twice.and_return(watir_browser)
-      #watir_browser.should_receive(:execute_script).twice
-      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("Question") do
-      end
-    end
-  end
-end

data/spec/symbiont/evaluators_spec.rb

@@ -1,95 +0,0 @@
-require "spec_helper"
-
-describe Symbiont::Evaluators do
-  let(:watir_browser)    { mock_browser_for_watir }
-  let(:watir_definition) { DefinitionTest.new(watir_browser) }
-
-  describe "browser-level actions" do
-    context "a definition using watir-webdriver" do
-      it "should visit a page" do
-        watir_browser.should_receive(:goto).twice.with("http://localhost:9292")
-        watir_definition.visit("http://localhost:9292")
-        watir_definition.navigate_to("http://localhost:9292")
-      end
-
-      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 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
-
-      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 be able to go back to a previous page" do
-        watir_browser.should_receive(:back)
-        watir_definition.back
-      end
-
-      it "should be able to go forward to an already visited page" do
-        watir_browser.should_receive(:forward)
-        watir_definition.forward
-      end
-
-      it "should be able to refresh the page contents" do
-        watir_browser.should_receive(:refresh)
-        watir_definition.refresh
-      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
-    end
-  end
-
-  describe "page-level actions" do
-    context "a definition using watir-webdriver" do
-      it "should return all the text on a page" do
-        watir_browser.should_receive(:text).and_return("page text")
-        watir_definition.text.should == "page text"
-      end
-
-      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).and_return("Page Title")
-        watir_definition.title.should == "Page Title"
-      end
-
-      it "should return the web object that has focus" do
-        watir_browser.should_receive(:execute_script).and_return(watir_browser)
-        watir_browser.should_receive(:tag_name).twice.and_return(:input)
-        watir_browser.should_receive(:type).and_return(:submit)
-        watir_definition.focus.class.should == Symbiont::WebObjects::Button
-      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).with('return jQuery.active')
-        watir_browser.should_receive(:execute_script).with('return jQuery.active').and_return(1)
-        expect { watir_definition.wait_for_pending_requests(1) }.to raise_error
-      end
-    end
-  end
-end

data/spec/symbiont/generators/button_generators_spec.rb

@@ -1,72 +0,0 @@
-require 'spec_helper'
-
-describe Symbiont::Generators do
-  let(:watir_browser)    { mock_browser_for_watir }
-  let(:watir_definition) { DefinitionTest.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(:login_object)
-        watir_definition.should respond_to(:login_button)
-      end
-
-      it "should generate methods for interacting with the button" do
-        watir_definition.should respond_to(:login)
-        watir_definition.should respond_to(:login_text)
-        watir_definition.should respond_to(:login_exists?)
-        watir_definition.should respond_to(:login_visible?)
-        watir_definition.should respond_to(:login_enabled?)
-        watir_definition.should respond_to(:login?)
-        watir_definition.should respond_to(:login_?)
-        watir_definition.should respond_to(:login!)
-      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_object = watir_definition.login_object
-        web_object.should_not be_nil
-        web_object.should be_instance_of Symbiont::WebObjects::Button
-      end
-
-      it "should return the text of the button" do
-        watir_browser.should_receive(:button).and_return(watir_browser)
-        watir_browser.should_receive(:text).and_return('Login')
-        watir_definition.login_text.should == "Login"
-      end
-
-      it "should click the button" do
-        watir_browser.should_receive(:button).and_return(watir_browser)
-        watir_browser.should_receive(:click)
-        watir_definition.login
-      end
-
-      it "should determine if a button exists" do
-        watir_browser.should_receive(:button).twice.and_return(watir_browser)
-        watir_browser.should_receive(:exists?).twice.and_return(watir_browser)
-        watir_definition.login?.should be_true
-        watir_definition.login_exists?.should be_true
-      end
-
-      it "should determine if a button is visible" do
-        watir_browser.should_receive(:button).twice.and_return(watir_browser)
-        watir_browser.should_receive(:present?).twice.and_return(watir_browser)
-        watir_definition.login_?.should be_true
-        watir_definition.login_visible?.should be_true
-      end
-
-      it "should determine if a button is enabled" do
-        watir_browser.should_receive(:button).twice.and_return(watir_browser)
-        watir_browser.should_receive(:enabled?).twice.and_return(watir_browser)
-        watir_definition.login_enabled?.should be_true
-        watir_definition.login!.should be_true
-      end
-
-      it "should call a block on the button if specified" do
-        watir_definition.logout_object.should == "logout"
-      end
-    end
-  end
-end

data/spec/symbiont/generators/checkbox_generators_spec.rb

@@ -1,79 +0,0 @@
-require 'spec_helper'
-
-describe Symbiont::Generators do
-  let(:watir_browser)    { mock_browser_for_watir }
-  let(:watir_definition) { DefinitionTest.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(:apply_tax_checkbox)
-        watir_definition.should respond_to(:apply_tax_object)
-      end
-
-      it "should generate methods for interacting with the checkbox" do
-        watir_definition.should respond_to(:apply_tax_exists?)
-        watir_definition.should respond_to(:apply_tax_visible?)
-        watir_definition.should respond_to(:apply_tax_enabled?)
-        watir_definition.should respond_to(:apply_tax?)
-        watir_definition.should respond_to(:apply_tax_?)
-        watir_definition.should respond_to(:apply_tax!)
-        watir_definition.should respond_to(:apply_tax_checked?)
-        watir_definition.should respond_to(:check_apply_tax)
-        watir_definition.should respond_to(:uncheck_apply_tax)
-      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_object = watir_definition.apply_tax_object
-        web_object.should_not be_nil
-        web_object.should be_instance_of Symbiont::WebObjects::CheckBox
-      end
-
-      it "should determine if a checkbox exists" do
-        watir_browser.should_receive(:checkbox).twice.and_return(watir_browser)
-        watir_browser.should_receive(:exists?).twice.and_return(watir_browser)
-        watir_definition.apply_tax_exists?.should be_true
-        watir_definition.apply_tax?.should be_true
-      end
-
-      it "should determine if a checkbox is visible" do
-        watir_browser.should_receive(:checkbox).twice.and_return(watir_browser)
-        watir_browser.should_receive(:present?).twice.and_return(watir_browser)
-        watir_definition.apply_tax_visible?.should be_true
-        watir_definition.apply_tax_?.should be_true
-      end
-
-      it "should determine if a checkbox is enabled" do
-        watir_browser.should_receive(:checkbox).twice.and_return(watir_browser)
-        watir_browser.should_receive(:enabled?).twice.and_return(watir_browser)
-        watir_definition.apply_tax_enabled?.should be_true
-        watir_definition.apply_tax!.should be_true
-      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.apply_tax_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_apply_tax
-      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_apply_tax
-      end
-
-      it "should call a block on the checkbox if specified" do
-        watir_definition.apply_fee_object.should == "apply_fee"
-      end
-    end
-  end
-end

data/spec/symbiont/generators/div_generators_spec.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-
-describe Symbiont::Generators do
-  let(:watir_browser)    { mock_browser_for_watir }
-  let(:watir_definition) { DefinitionTest.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_div)
-        watir_definition.should respond_to(:section_object)
-      end
-
-      it "should generate methods for interacting with the div" do
-        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)
-      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_object = watir_definition.section_div
-        web_object.should_not be_nil
-        web_object.should be_instance_of Symbiont::WebObjects::Div
-      end
-
-      it "should determine if a div exists" do
-        watir_browser.should_receive(:div).twice.and_return(watir_browser)
-        watir_browser.should_receive(:exists?).twice.and_return(watir_browser)
-        watir_definition.section_exists?.should be_true
-        watir_definition.section?.should be_true
-      end
-
-      it "should determine if a div is visible" do
-        watir_browser.should_receive(:div).twice.and_return(watir_browser)
-        watir_browser.should_receive(:present?).twice.and_return(watir_browser)
-        watir_definition.section_visible?.should be_true
-        watir_definition.section_?.should be_true
-      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
-
-      it "should call a block on the div if specified" do
-        watir_definition.aside_object.should == "aside"
-      end
-    end
-  end
-end

data/spec/symbiont/generators/hidden_field_generators_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
-
-describe Symbiont::Generators do
-  let(:watir_browser)    { mock_browser_for_watir }
-  let(:watir_definition) { DefinitionTest.new(watir_browser) }
-
-  describe "hidden field generators" do
-    context "when declared on a page definition" do
-      it "should generate methods for referencing the hidden field" do
-        watir_definition.should respond_to(:ssn_hidden_field)
-        watir_definition.should respond_to(:ssn_object)
-      end
-
-      it "should generate methods for interacting with the hidden field" 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_enabled?)
-        watir_definition.should respond_to(:ssn?)
-        watir_definition.should respond_to(:ssn_?)
-        watir_definition.should respond_to(:ssn!)
-      end
-    end
-
-    context "when used by the watir platform" do
-      it "should locate the hidden field" do
-        watir_browser.should_receive(:hidden).and_return(watir_browser)
-        web_object = watir_definition.ssn_object
-        web_object.should_not be_nil
-        web_object.should be_instance_of Symbiont::WebObjects::HiddenField
-      end
-
-      it "should retrieve text from the text field" do
-        watir_browser.should_receive(:hidden).and_return(watir_browser)
-        watir_browser.should_receive(:value).and_return("testing")
-        watir_definition.ssn.should == "testing"
-      end
-
-      it "should determine if a hidden field exists" do
-        watir_browser.should_receive(:hidden).twice.and_return(watir_browser)
-        watir_browser.should_receive(:exists?).twice.and_return(watir_browser)
-        watir_definition.ssn_exists?.should be_true
-        watir_definition.ssn?.should be_true
-      end
-
-      it "should determine if a hidden field is visible" do
-        watir_browser.should_receive(:hidden).twice.and_return(watir_browser)
-        watir_browser.should_receive(:present?).twice.and_return(watir_browser)
-        watir_definition.ssn_visible?.should be_true
-        watir_definition.ssn_?.should be_true
-      end
-
-      it "should determine if a hidden field is enabled" do
-        watir_browser.should_receive(:hidden).twice.and_return(watir_browser)
-        watir_browser.should_receive(:enabled?).twice.and_return(watir_browser)
-        watir_definition.ssn_enabled?.should be_true
-        watir_definition.ssn!.should be_true
-      end
-
-      it "should call a block on the hidden field if specified" do
-        watir_definition.visa_object.should == "visa"
-      end
-    end
-  end
-end

data/spec/symbiont/generators/link_generators_spec.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-
-describe Symbiont::Generators do
-  let(:watir_browser)    { mock_browser_for_watir }
-  let(:watir_definition) { DefinitionTest.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(:welcome_object)
-        watir_definition.should respond_to(:welcome_link)
-      end
-
-      it "should generate methods for interacting with the link" do
-        watir_definition.should respond_to(:welcome)
-        watir_definition.should respond_to(:welcome_text)
-        watir_definition.should respond_to(:welcome_exists?)
-        watir_definition.should respond_to(:welcome_visible?)
-        watir_definition.should respond_to(:welcome?)
-        watir_definition.should respond_to(:welcome_?)
-      end
-    end
-
-    context "when used by the watir platform" do
-      it "should click the link" do
-        watir_browser.stub_chain(:link, :click)
-        watir_definition.welcome
-      end
-
-      it "should locate the link" do
-        watir_browser.should_receive(:link).and_return(watir_browser)
-        web_object = watir_definition.welcome_object
-        web_object.should_not be_nil
-        web_object.should be_instance_of Symbiont::WebObjects::Link
-      end
-
-      it "should retrieve text from the link" do
-        watir_browser.should_receive(:link).and_return(watir_browser)
-        watir_browser.should_receive(:text).and_return('Welcome')
-        watir_definition.welcome_text.should == "Welcome"
-      end
-
-      it "should determine if a link exists" do
-        watir_browser.should_receive(:link).twice.and_return(watir_browser)
-        watir_browser.should_receive(:exists?).twice.and_return(watir_browser)
-        watir_definition.welcome_exists?.should be_true
-        watir_definition.welcome?.should be_true
-      end
-
-      it "should determine if a link is visible" do
-        watir_browser.should_receive(:link).twice.and_return(watir_browser)
-        watir_browser.should_receive(:present?).twice.and_return(watir_browser)
-        watir_definition.welcome_visible?.should be_true
-        watir_definition.welcome_?.should be_true
-      end
-
-      it "should call a block on the link if specified" do
-        watir_definition.greetings_object.should == "greetings"
-      end
-    end
-  end
-end

data/spec/symbiont/generators/paragraph_generators_spec.rb

@@ -1,57 +0,0 @@
-require 'spec_helper'
-
-describe Symbiont::Generators do
-  let(:watir_browser)    { mock_browser_for_watir }
-  let(:watir_definition) { DefinitionTest.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(:first_paragraph)
-        watir_definition.should respond_to(:first_object)
-        watir_definition.should respond_to(:last_paragraph)
-      end
-
-      it "should generate methods for interacting with the paragraph" do
-        watir_definition.should respond_to(:first_exists?)
-        watir_definition.should respond_to(:first_visible?)
-        watir_definition.should respond_to(:first?)
-        watir_definition.should respond_to(:first_?)
-        watir_definition.should respond_to(:first)
-      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_object = watir_definition.first_paragraph
-        web_object.should_not be_nil
-        web_object.should be_instance_of Symbiont::WebObjects::Paragraph
-      end
-
-      it "should determine if a paragraph exists" do
-        watir_browser.should_receive(:p).twice.and_return(watir_browser)
-        watir_browser.should_receive(:exists?).twice.and_return(watir_browser)
-        watir_definition.first_exists?.should be_true
-        watir_definition.first?.should be_true
-      end
-
-      it "should determine if a paragraph is visible" do
-        watir_browser.should_receive(:p).twice.and_return(watir_browser)
-        watir_browser.should_receive(:present?).twice.and_return(watir_browser)
-        watir_definition.first_visible?.should be_true
-        watir_definition.first_?.should be_true
-      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.first.should == "testing"
-      end
-
-      it "should call a block on the paragraph if specified" do
-        watir_definition.middle_object.should == "middle"
-      end
-    end
-  end
-end