symbiont 0.1.9 → 0.2.0

data/spec/symbiont/generators/select_list_generators_spec.rb

@@ -1,77 +1,93 @@
-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 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
-    end
-  end
-end
+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,52 +1,56 @@
-require 'spec_helper'
-
-describe Symbiont::Generators do
-  let(:watir_browser) { mock_browser_for_watir }
-  let(:watir_definition) { DefinitionTest.new(watir_browser) }
-  
-  describe "span web objects" 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
-    end
-  end
-end
+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/{cell_generators_spec.rb → table_cell_generators_spec.rb}

@@ -1,52 +1,56 @@
-require 'spec_helper'
-
-describe Symbiont::Generators do
-  let(:watir_browser) { mock_browser_for_watir }
-  let(:watir_definition) { DefinitionTest.new(watir_browser) }
-  
-  describe "cell web objects" do
-    context "when declared in a definition" do
-      it "should generate methods for referencing the cell" do
-        watir_definition.should respond_to(:totalValue_cell)
-        watir_definition.should respond_to(:totalValue_object)
-      end
-      
-      it "should generate methods for interacting with the cell" do
-        watir_definition.should respond_to(:totalValue_exists?)
-        watir_definition.should respond_to(:totalValue_visible?)
-        watir_definition.should respond_to(:totalValue?)
-        watir_definition.should respond_to(:totalValue_?)
-        watir_definition.should respond_to(:totalValue)
-      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.totalValue_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.totalValue_exists?.should be_true
-        watir_definition.totalValue?.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.totalValue_visible?.should be_true
-        watir_definition.totalValue_?.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.totalValue.should == "testing"
-      end
-    end
-  end
-end
+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,52 +1,56 @@
-require 'spec_helper'
-
-describe Symbiont::Generators do
-  let(:watir_browser) { mock_browser_for_watir }
-  let(:watir_definition) { DefinitionTest.new(watir_browser) }
-  
-  describe "table web objects" do
-    context "when declared in a 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
-    end
-  end
-end
+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

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