symbiont 0.2.1 → 0.3.0

data/spec/symbiont/generators/radio_generators_spec.rb

@@ -1,76 +0,0 @@
-require 'spec_helper'
-
-describe Symbiont::Generators do
-  let(:watir_browser)    { mock_browser_for_watir }
-  let(:watir_definition) { DefinitionTest.new(watir_browser) }
-
-  describe "radio web objects" do
-    context "when declared on a page definition" do
-      it "should generate methods for referencing the radio" do
-        watir_definition.should respond_to(:include_tax_radio)
-        watir_definition.should respond_to(:include_tax_object)
-      end
-
-      it "should generate methods for interacting with the radio" do
-        watir_definition.should respond_to(:include_tax_exists?)
-        watir_definition.should respond_to(:include_tax_visible?)
-        watir_definition.should respond_to(:include_tax_enabled?)
-        watir_definition.should respond_to(:include_tax?)
-        watir_definition.should respond_to(:include_tax_?)
-        watir_definition.should respond_to(:include_tax!)
-        watir_definition.should respond_to(:include_tax_selected?)
-        watir_definition.should respond_to(:include_tax_set?)
-        watir_definition.should respond_to(:set_include_tax)
-      end
-    end
-
-    context "when used by the watir platform" do
-      it "should locate the radio" do
-        watir_browser.should_receive(:radio).and_return(watir_browser)
-        web_object = watir_definition.include_tax_radio
-        web_object.should_not be_nil
-        web_object.should be_instance_of Symbiont::WebObjects::Radio
-      end
-
-      it "should determine if a radio exists" do
-        watir_browser.should_receive(:radio).twice.and_return(watir_browser)
-        watir_browser.should_receive(:exists?).twice.and_return(watir_browser)
-        watir_definition.include_tax_exists?.should be_true
-        watir_definition.include_tax?.should be_true
-      end
-
-      it "should determine if a radio is visible" do
-        watir_browser.should_receive(:radio).twice.and_return(watir_browser)
-        watir_browser.should_receive(:present?).twice.and_return(watir_browser)
-        watir_definition.include_tax_visible?.should be_true
-        watir_definition.include_tax_?.should be_true
-      end
-
-      it "should determine if a radio is enabled" do
-        watir_browser.should_receive(:radio).twice.and_return(watir_browser)
-        watir_browser.should_receive(:enabled?).twice.and_return(watir_browser)
-        watir_definition.include_tax_enabled?.should be_true
-        watir_definition.include_tax!.should be_true
-      end
-
-      it "should determine if a radio is set" do
-        watir_browser.should_receive(:radio).twice.and_return(watir_browser)
-        watir_browser.should_receive(:set?).twice.and_return(watir_browser)
-        watir_definition.include_tax_selected?.should be_true
-        watir_definition.include_tax_set?.should be_true
-      end
-
-      it "should set a radio" do
-        watir_browser.should_receive(:radio).twice.and_return(watir_browser)
-        watir_browser.should_receive(:set).twice.and_return(watir_browser)
-        watir_definition.select_include_tax
-        watir_definition.set_include_tax
-      end
-
-      it "should call a block on the radio if specified" do
-        watir_definition.include_fee_object.should == "include_fee"
-      end
-    end
-
-  end
-end

data/spec/symbiont/generators/select_list_generators_spec.rb

@@ -1,93 +0,0 @@
-require 'spec_helper'
-
-describe Symbiont::Generators do
-  let(:watir_browser)    { mock_browser_for_watir }
-  let(:watir_definition) { DefinitionTest.new(watir_browser) }
-
-  describe "select list web objects" do
-    context "when declared in a definition" do
-      it "should generate methods for referencing the select list" do
-        watir_definition.should respond_to(:concepts_select_list)
-        watir_definition.should respond_to(:concepts_object)
-      end
-
-      it "should generate methods for interacting with the select list" do
-        watir_definition.should respond_to(:concepts)
-        watir_definition.should respond_to(:concepts_option?)
-        watir_definition.should respond_to(:concepts_exists?)
-        watir_definition.should respond_to(:concepts_visible?)
-        watir_definition.should respond_to(:concepts_enabled?)
-        watir_definition.should respond_to(:concepts?)
-        watir_definition.should respond_to(:concepts_?)
-        watir_definition.should respond_to(:concepts!)
-        watir_definition.should respond_to(:concepts=)
-      end
-    end
-
-    context "when used by the watir platform" do
-      it "should locate the select list" do
-        watir_browser.should_receive(:select_list).and_return(watir_browser)
-        web_object = watir_definition.concepts_object
-        web_object.should_not be_nil
-        web_object.should be_instance_of Symbiont::WebObjects::SelectList
-      end
-
-      it "should retrieve the current value of a selected option" do
-        watir_browser.should_receive(:select_list).and_return(watir_browser)
-        watir_browser.should_receive(:value).and_return("testing")
-        watir_definition.concepts_option?.should == "testing"
-      end
-
-      it "should retrieve the current selection from the select list" do
-        selected = "testing"
-        selected.should_receive(:text).and_return("testing")
-        watir_browser.should_receive(:select_list).and_return(watir_browser)
-        watir_browser.should_receive(:selected_options).and_return([selected])
-        watir_definition.concepts.should == "testing"
-      end
-
-      it "should select an item from the select list" do
-        watir_browser.should_receive(:select_list).and_return watir_browser
-        watir_browser.should_receive(:select).with("testing")
-        watir_definition.concepts = "testing"
-      end
-
-      it "should retrieve a list of selection options" do
-        option1 = double('option')
-        option2 = double('option')
-        option1.should_receive(:text).and_return("concept1")
-        option2.should_receive(:text).and_return("concept2")
-
-        select_element = double("select")
-        select_element.should_receive(:options).twice.and_return([option1, option2])
-        watir_definition.should_receive(:concepts_object).and_return(select_element)
-        watir_definition.concepts_options?.should == ["concept1","concept2"]
-      end
-
-      it "should determine if a select list exists" do
-        watir_browser.should_receive(:select_list).twice.and_return(watir_browser)
-        watir_browser.should_receive(:exists?).twice.and_return(watir_browser)
-        watir_definition.concepts_exists?.should be_true
-        watir_definition.concepts?.should be_true
-      end
-
-      it "should determine if a select list is visible" do
-        watir_browser.should_receive(:select_list).twice.and_return(watir_browser)
-        watir_browser.should_receive(:present?).twice.and_return(watir_browser)
-        watir_definition.concepts_visible?.should be_true
-        watir_definition.concepts_?.should be_true
-      end
-
-      it "should determine if a select list is enabled" do
-        watir_browser.should_receive(:select_list).twice.and_return(watir_browser)
-        watir_browser.should_receive(:enabled?).twice.and_return(watir_browser)
-        watir_definition.concepts_enabled?.should be_true
-        watir_definition.concepts!.should be_true
-      end
-
-      it "should call a block on the select list if specified" do
-        watir_definition.topics_object.should == "topics"
-      end
-    end
-  end
-end

data/spec/symbiont/generators/span_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 "span generators" do
-    context "when declared in a definition" do
-      it "should generate methods for referencing the span" do
-        watir_definition.should respond_to(:inline_span)
-        watir_definition.should respond_to(:inline_object)
-      end
-
-      it "should generate methods for interacting with the span" do
-        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)
-      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_object = watir_definition.inline_span
-        web_object.should_not be_nil
-        web_object.should be_instance_of Symbiont::WebObjects::Span
-      end
-
-      it "should determine if a span exists" do
-        watir_browser.should_receive(:span).twice.and_return(watir_browser)
-        watir_browser.should_receive(:exists?).twice.and_return(watir_browser)
-        watir_definition.inline_exists?.should be_true
-        watir_definition.inline?.should be_true
-      end
-
-      it "should determine if a span is visible" do
-        watir_browser.should_receive(:span).twice.and_return(watir_browser)
-        watir_browser.should_receive(:present?).twice.and_return(watir_browser)
-        watir_definition.inline_visible?.should be_true
-        watir_definition.inline_?.should be_true
-      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
-
-      it "should call a block on the span if specified" do
-        watir_definition.part_object.should == "part"
-      end
-    end
-  end
-end

data/spec/symbiont/generators/table_cell_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 "table 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_cell)
-        watir_definition.should respond_to(:total_object)
-      end
-
-      it "should generate methods for interacting with the cell" do
-        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)
-      end
-    end
-
-    context "when used by the watir platform" do
-      it "should locate the table cell" do
-        watir_browser.should_receive(:td).and_return(watir_browser)
-        web_object = watir_definition.total_cell
-        web_object.should_not be_nil
-        web_object.should be_instance_of Symbiont::WebObjects::TableCell
-      end
-
-      it "should determine if a table cell exists" do
-        watir_browser.should_receive(:td).twice.and_return(watir_browser)
-        watir_browser.should_receive(:exists?).twice.and_return(watir_browser)
-        watir_definition.total_exists?.should be_true
-        watir_definition.total?.should be_true
-      end
-
-      it "should determine if a table cell is visible" do
-        watir_browser.should_receive(:td).twice.and_return(watir_browser)
-        watir_browser.should_receive(:present?).twice.and_return(watir_browser)
-        watir_definition.total_visible?.should be_true
-        watir_definition.total_?.should be_true
-      end
-
-      it "should return the text of a table cell" do
-        watir_browser.should_receive(:td).and_return(watir_browser)
-        watir_browser.should_receive(:text).and_return("testing")
-        watir_definition.total.should == "testing"
-      end
-
-      it "should call a block on the table cell if specified" do
-        watir_definition.sum_object.should == "sum"
-      end
-    end
-  end
-end

data/spec/symbiont/generators/table_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 "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_table)
-        watir_definition.should respond_to(:accounts_object)
-      end
-
-      it "should generate methods for interacting with the table" do
-        watir_definition.should respond_to(:accounts_exists?)
-        watir_definition.should respond_to(:accounts?)
-        watir_definition.should respond_to(:accounts_visible?)
-        watir_definition.should respond_to(:accounts_?)
-        watir_definition.should respond_to(:accounts)
-      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_object = watir_definition.accounts_table
-        web_object.should_not be_nil
-        web_object.should be_instance_of Symbiont::WebObjects::Table
-      end
-
-      it "should determine if a table exists" do
-        watir_browser.should_receive(:table).twice.and_return(watir_browser)
-        watir_browser.should_receive(:exists?).twice.and_return(watir_browser)
-        watir_definition.accounts_exists?.should be_true
-        watir_definition.accounts?.should be_true
-      end
-
-      it "should determine if a table is visible" do
-        watir_browser.should_receive(:table).twice.and_return(watir_browser)
-        watir_browser.should_receive(:present?).twice.and_return(watir_browser)
-        watir_definition.accounts_visible?.should be_true
-        watir_definition.accounts_?.should be_true
-      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
-
-      it "should call a block on the table if specified" do
-        watir_definition.invoices_object.should == "invoices"
-      end
-    end
-  end
-end

data/spec/symbiont/generators/text_area_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 "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_text_area)
-        watir_definition.should respond_to(:summary_object)
-      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_enabled?)
-        watir_definition.should respond_to(:summary?)
-        watir_definition.should respond_to(:summary_?)
-        watir_definition.should respond_to(:summary!)
-        watir_definition.should respond_to(:summary=)
-      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_object = watir_definition.summary_object
-        web_object.should_not be_nil
-        web_object.should be_instance_of Symbiont::WebObjects::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
-
-      it "should determine if a text area exists" do
-        watir_browser.should_receive(:text_area).twice.and_return(watir_browser)
-        watir_browser.should_receive(:exists?).twice.and_return(watir_browser)
-        watir_definition.summary_exists?.should be_true
-        watir_definition.summary?.should be_true
-      end
-
-      it "should determine if a text area is visible" do
-        watir_browser.should_receive(:text_area).twice.and_return(watir_browser)
-        watir_browser.should_receive(:present?).twice.and_return(watir_browser)
-        watir_definition.summary_visible?.should be_true
-        watir_definition.summary_?.should be_true
-      end
-
-      it "should determine if a text area is enabled" do
-        watir_browser.should_receive(:text_area).twice.and_return(watir_browser)
-        watir_browser.should_receive(:enabled?).twice.and_return(watir_browser)
-        watir_definition.summary_enabled?.should be_true
-        watir_definition.summary!.should be_true
-      end
-
-      it "should call a block on the text area if specified" do
-        watir_definition.description_object.should == "description"
-      end
-    end
-  end
-end

data/spec/symbiont/generators/text_field_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 "text field generators" do
-    context "when declared on a page definition" do
-      it "should generate methods for referencing the text field" do
-        watir_definition.should respond_to(:name_text_field)
-        watir_definition.should respond_to(:name_object)
-      end
-
-      it "should generate methods for interacting with the text field" do
-        watir_definition.should respond_to(:name)
-        watir_definition.should respond_to(:name_exists?)
-        watir_definition.should respond_to(:name_visible?)
-        watir_definition.should respond_to(:name_enabled?)
-        watir_definition.should respond_to(:name?)
-        watir_definition.should respond_to(:name_?)
-        watir_definition.should respond_to(:name!)
-        watir_definition.should respond_to(:name=)
-      end
-    end
-
-    context "when used by the watir platform" do
-      it "should locate the text field" do
-        watir_browser.should_receive(:text_field).and_return(watir_browser)
-        web_object = watir_definition.name_object
-        web_object.should_not be_nil
-        web_object.should be_instance_of Symbiont::WebObjects::TextField
-      end
-
-      it "should retrieve text from the text field" do
-        watir_browser.should_receive(:text_field).and_return(watir_browser)
-        watir_browser.should_receive(:value).and_return("testing")
-        watir_definition.name.should == "testing"
-      end
-
-      it "should enter text into a text field" do
-        watir_browser.should_receive(:text_field).and_return(watir_browser)
-        watir_browser.should_receive(:set).with("testing")
-        watir_definition.name = "testing"
-      end
-
-      it "should determine if a text field exists" do
-        watir_browser.should_receive(:text_field).twice.and_return(watir_browser)
-        watir_browser.should_receive(:exists?).twice.and_return(watir_browser)
-        watir_definition.name_exists?.should be_true
-        watir_definition.name?.should be_true
-      end
-
-      it "should determine if a text field is visible" do
-        watir_browser.should_receive(:text_field).twice.and_return(watir_browser)
-        watir_browser.should_receive(:present?).twice.and_return(watir_browser)
-        watir_definition.name_visible?.should be_true
-        watir_definition.name_?.should be_true
-      end
-
-      it "should determine if a text field is enabled" do
-        watir_browser.should_receive(:text_field).twice.and_return(watir_browser)
-        watir_browser.should_receive(:enabled?).twice.and_return(watir_browser)
-        watir_definition.name_enabled?.should be_true
-        watir_definition.name!.should be_true
-      end
-
-      it "should call a block on the element method if specified" do
-        watir_definition.email_object.should == "email"
-      end
-    end
-  end
-end

data/spec/symbiont/generators_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-describe Symbiont::Generators do
-  let(:watir_browser)    { mock_browser_for_watir }
-  let(:watir_definition) { DefinitionTest.new(watir_browser) }
-
-  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
-
-      it "should navigate to the page when started" do
-        watir_browser.should_receive(:goto)
-        watir_definition.start
-      end
-    end
-  end
-
-  context "automatically looking for an object" do
-    it "should specify and verify an expected object" do
-      watir_definition.should_receive(:name_object).and_return(watir_browser)
-      watir_browser.should_receive(:when_actionable).with(5).and_return(watir_browser)
-      watir_definition.has_object?
-    end
-
-    it "should raise an error if an expected object is not verified" do
-      class QuickDefinition
-        include Symbiont
-        look_for :fakeLink
-      end
-      expect { QuickDefinition.new(watir_browser).has_object? }.to raise_error
-      expect { QuickDefinition.new(watir_browser).should_not have_object }.to raise_error
-    end
-  end
-
-  context "providing a page title to be verified" do
-    it "should specify and verify the page title" do
-      watir_browser.should_receive(:title).and_return("Symbiote")
-      watir_definition.should have_title
-    end
-
-    it "should raise an error if the page title is not verified" do
-      watir_browser.should_receive(:title).twice.and_return("Incorrect Title")
-      expect { watir_definition.has_title? }.to raise_error
-    end
-
-    it "should validate the title if provided a regular expression" do
-      class QuickDefinition
-        include Symbiont
-        title_is (/\w+/)
-      end
-      watir_browser.should_receive(:title).and_return("Symbiote")
-      QuickDefinition.new(watir_browser).should have_title
-    end
-  end
-
-end

data/spec/symbiont/locators_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-
-describe Symbiont::Locators do
-  let(:watir_browser)    { mock_browser_for_watir }
-  let(:watir_definition) { DefinitionTest.new(watir_browser) }
-
-  context "a definition using watir-webdriver" do
-    it "should locate a link web object" do
-      watir_browser.should_receive(:link).with(text: 'test').and_return(watir_browser)
-      web_object = watir_definition.link_object(text: 'test')
-      web_object.should be_instance_of Symbiont::WebObjects::Link
-    end
-
-    it "should locate a button web object" do
-      watir_browser.should_receive(:button).with(value: 'test').and_return(watir_browser)
-      web_object = watir_definition.button_object(value: 'test')
-      web_object.should be_instance_of Symbiont::WebObjects::Button
-    end
-
-    it "should locate a text field web object" do
-      watir_browser.should_receive(:text_field).with(id: 'test').and_return(watir_browser)
-      web_object = watir_definition.text_field_object(id: 'test')
-      web_object.should be_instance_of Symbiont::WebObjects::TextField
-    end
-
-    it "should locate a select list web object" do
-      watir_browser.should_receive(:select_list).with(class: 'test').and_return(watir_browser)
-      web_object = watir_definition.select_list_object(class: 'test')
-      web_object.should be_instance_of Symbiont::WebObjects::SelectList
-    end
-
-    it "should locate a checkbox web object" do
-      watir_browser.should_receive(:checkbox).with(id: 'test').and_return(watir_browser)
-      web_object = watir_definition.checkbox_object(id: 'test')
-      web_object.should be_instance_of Symbiont::WebObjects::CheckBox
-    end
-
-    it "should locate a radio web object" do
-      watir_browser.should_receive(:radio).with(id: 'test').and_return(watir_browser)
-      web_object = watir_definition.radio_object(id: 'test')
-      web_object.should be_instance_of Symbiont::WebObjects::Radio
-    end
-
-    it "should locate a div web object" do
-      watir_browser.should_receive(:div).with(id: 'test').and_return(watir_browser)
-      web_object = watir_definition.div_object(id: 'test')
-      web_object.should be_instance_of Symbiont::WebObjects::Div
-    end
-
-    it "should locate a span object" do
-      watir_browser.should_receive(:span).with(id: 'test').and_return(watir_browser)
-      web_object = watir_definition.span_object(id: 'test')
-      web_object.should be_instance_of Symbiont::WebObjects::Span
-    end
-
-    it "should locate a table web object" do
-      watir_browser.should_receive(:table).with(id: 'test').and_return(watir_browser)
-      web_object = watir_definition.table_object(id: 'test')
-      web_object.should be_instance_of Symbiont::WebObjects::Table
-    end
-
-    it "should locate a table cell web object" do
-      watir_browser.should_receive(:td).with(id: 'test').and_return(watir_browser)
-      web_object = watir_definition.cell_object(id: 'test')
-      web_object.should be_instance_of Symbiont::WebObjects::TableCell
-    end
-  end
-end

data/spec/symbiont/platform_object_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-describe Symbiont do
-  let(:watir_browser)    { mock_browser_for_watir }
-  let(:watir_definition) { DefinitionTest.new(watir_browser) }
-
-  context "a definition using watir-webdriver" do
-    it "should return a watir platform object" do
-      watir_definition.platform.should be_kind_of Symbiont::Platforms::WatirWebDriver::PlatformObject
-    end
-  end
-
-  context "an unrecognized browser" do
-    it "should raise an exception" do
-      expect { DefinitionTest.new(:unknown_browser) }.to raise_error
-    end
-  end
-end

data/spec/symbiont/symbiont_spec.rb

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