symbiont 0.0.4 → 0.1.0

data/lib/symbiont/web_objects/table_row.rb

@@ -0,0 +1,26 @@
+module Symbiont
+  module WebObjects
+    
+    class TableRow < WebObject
+      
+      # This method is used to return a TableCell object based on the index provided.
+      # @return [Symbiont::WebObjects::TableCell]
+      def [](index)
+        Object::Symbiont::WebObjects::TableCell.new(@web_object[index])
+      end
+      
+      # This method returns the number of columns in a table object.
+      def columns
+        @web_object.wd.find_elements(:xpath, cell_xpath).size
+      end
+      
+      protected
+      
+      def cell_xpath
+        ".//child::td|th"
+      end
+      
+    end # class: TableRow
+    
+  end # module: WebObjects
+end # module: Symbiont

data/spec/spec_helper.rb

@@ -23,6 +23,13 @@ class DefinitionTest
   link :reset_password, id: "resetPassword"
   button :submit, id: "btnSubmit"
   text_field :login_name, id: "loginName"
+  select_list :concepts, id: "concepts"
+  checkbox :apply_tax, id: "applyTax"
+  radio :include_tax, id: "includeTax"
+  table :accounts, id: "accounts"
+  cell :totalValue, id: "totalValue"
+  div :section, id: "section"
+  span :inline, id: "inline"
   
   within_frame(id: "frame") do |frame|
     text_field :framedLoginName, id: "framedLoginName", frame: frame

data/spec/symbiont/generators/cell_generators_spec.rb

@@ -0,0 +1,52 @@
+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(:visible?).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

data/spec/symbiont/generators/checkbox_generators_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Symbiont::Generators do
+  let(:watir_browser) { mock_browser_for_watir }
+  let(:watir_definition) { DefinitionTest.new(watir_browser) }
+  
+  describe "checkbox web objects" do
+    context "when declared in a 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(:visible?).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
+    end
+  end
+end

data/spec/symbiont/generators/div_generators_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Symbiont::Generators do
+  let(:watir_browser) { mock_browser_for_watir }
+  let(:watir_definition) { DefinitionTest.new(watir_browser) }
+  
+  describe "div web objects" do
+    context "when declared in a 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(:visible?).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 span" 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

data/spec/symbiont/generators/radio_generators_spec.rb

@@ -0,0 +1,78 @@
+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 in a 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_radio_button)
+        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(:visible?).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 clear a radio" do
+      #  watir_browser.should_receive(:radio).and_return(watir_browser)
+      #  watir_browser.should_receive(:clear).and_return(watir_browser)
+      #  watir_definition.clear_include_tax
+      #end
+    end
+  end
+end

data/spec/symbiont/generators/select_list_generators_spec.rb

@@ -0,0 +1,77 @@
+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(:visible?).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

data/spec/symbiont/generators/span_generators_spec.rb

@@ -0,0 +1,52 @@
+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(:visible?).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

data/spec/symbiont/generators/table_generators_spec.rb

@@ -0,0 +1,45 @@
+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_?)
+      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(:visible?).twice.and_return(watir_browser)
+        watir_definition.accounts_visible?.should be_true
+        watir_definition.accounts_?.should be_true
+      end
+    end
+  end
+end

data/spec/symbiont/web_object_spec.rb

@@ -4,6 +4,26 @@ describe "Web Objects" do
   let(:watir_browser) { mock_browser_for_watir }
   let(:watir_definition) { ::Symbiont::WebObjects::WebObject.new(watir_browser) }
   
+  it "should determine if a web object is enabled" do
+    watir_browser.should_receive(:enabled?).and_return(true)
+    watir_definition.enabled?.should == true
+  end
+  
+  it "should determine if a web object is disabled" do
+    watir_browser.should_receive(:enabled?).and_return(false)
+    watir_definition.disabled?.should == true
+  end
+  
+  it "should determine if a web object exists" do
+    watir_browser.should_receive(:exists?).and_return(true)
+    watir_definition.exists?.should == true
+  end
+  
+  it "should determine if a web object is visible" do
+    watir_browser.should_receive(:visible?).and_return(true)
+    watir_definition.visible?.should == true
+  end
+  
   it "should return the text contained by a web object" do
     watir_browser.should_receive(:text).and_return("testing")
     watir_definition.text.should == "testing"

data/spec/symbiont/web_objects/table_row_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Symbiont::WebObjects::TableRow do
+  describe "implementation" do
+    let(:table_cell) { double('table_cell') }
+    let(:table_row_object) { double('table_row_object') }
+    
+    context "on the watir platform" do
+      it "should return a table cell when indexed" do
+        table_row = Symbiont::WebObjects::TableRow.new(table_row_object)
+        table_row_object.should_receive(:[]).with(1).and_return(table_cell)
+        table_row[1].should be_instance_of Symbiont::WebObjects::TableCell
+      end
+      
+      it "should return the number of columns" do
+        table_row = Symbiont::WebObjects::TableRow.new(table_row_object)
+        table_row_object.stub(:wd).and_return(table_row_object)
+        table_row_object.should_receive(:find_elements).with(:xpath, ".//child::td|th").and_return(table_row_object)
+        table_row_object.should_receive(:size).and_return(3)
+        table_row.columns.should == 3
+      end
+    end
+  end
+end

data/spec/symbiont/web_objects/table_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Symbiont::WebObjects::Table do
+  describe "implementation" do
+    let(:table_object) { double('table_object') }
+    
+    context "on the watir platform" do
+      let(:watir_table) { Symbiont::WebObjects::Table.new(table_object) }
+      
+      it "should return a table row when indexed" do
+        table_object.stub(:[]).with(1).and_return(table_object)
+        watir_table[1].should be_instance_of Symbiont::WebObjects::TableRow
+      end
+      
+      it "should return the first row" do
+        table_object.stub(:[]).with(0).and_return(table_object)
+        watir_table.first_row.should be_instance_of Symbiont::WebObjects::TableRow
+      end
+      
+      it "should return the last row" do
+        table_object.stub(:[]).with(-1).and_return(table_object)
+        watir_table.last_row.should be_instance_of Symbiont::WebObjects::TableRow
+      end
+      
+      it "should return the number of rows" do
+        table_object.should_receive(:wd).and_return(table_object)
+        table_object.should_receive(:find_elements).with(:xpath, ".//child::tr").and_return(table_object)
+        table_object.should_receive(:size).and_return(2)
+        watir_table.rows.should == 2
+      end
+    end
+  end
+end

data/specs/button.feature

@@ -1,36 +1,36 @@
 Feature: Ability to Support Button Web Objects
-
+  
   Scenario: Reference a button
-    When on the test page
+    When on the object test page
     Then the click me button should exist
     And the click me button should be visible
     And the click me button should be enabled
-    And the click me button object should be usable
-
+    And the click me button should be a button object
+    
   Scenario: Get text from a button
-    When on the test page
+    When on the object test page
     Then the text of the click me button should be "Click Me"
-
+  
   Scenario: Click a button
-    When the click me button on the test page is clicked
-    Then the success page appears
-
-  Scenario: A non-existent button
-    When on the test page
+    When the click me button on the simple object test page is clicked
+    Then the first success page appears
+    
+  Scenario: Handling a non-existent button
+    When on the object test page
     Then the fake button should not exist
-    But the fake button object should be usable
-
-  Scenario: A disabled button
-    When on the test page
-    Then the disabled button should exist
-    And the disabled button should be visible
-    And the disabled button should not be enabled
-    And the text of the disabled button should be "Can't Click Me"
-    But the disabled button object should be usable
+    But the fake button should be a button object
+  
+  Scenario: Handling a disabled button
+    When on the object test page
+    Then the can't click me button should exist
+    And the can't click me button should be visible
+    And the text of the can't click me button should be "Can't Click Me"
+    And the can't click me button should be a button object
+    But the can't click me button should not be enabled
     
   Scenario Outline: Finding buttons with locators
-    When the click me button on the test page is clicked by "<locator>"
-    Then the success page appears
+    When the click me button on the object test page is clicked by "<locator>"
+    Then the first success page appears
     
     Scenarios:
       | locator |

data/specs/checkbox.feature

@@ -0,0 +1,40 @@
+Feature: Ability to Support Checkbox Web Objects
+
+  Scenario: Reference a button
+    When on the object test page
+    Then the organic circuitry checkbox should exist
+    And the organic circuitry checkbox should be visible
+    And the organic circuitry checkbox should be enabled
+    And the organic circuitry checkbox should be a checkbox object
+
+  Scenario: Modify checkbox and check state
+    When organic circuitry is not chosen as the futuristic technology
+    Then the organic circuitry checkbox should be unchecked
+    When organic circuitry is chosen as the futuristic technology
+    Then the organic circuitry checkbox should be checked
+    When organic circuitry is not chosen as the futuristic technology
+    Then the organic circuitry checkbox should be unchecked
+  
+  Scenario: Handling a non-existent checkbox
+    When on the object test page
+    Then the fake checkbox should not exist
+    But the fake checkbox should be a checkbox object
+
+  Scenario: Handling a disabled checkbox
+    When on the object test page
+    Then the preferential eigenstate selector checkbox should exist
+    And the preferential eigenstate selector checkbox should be visible
+    And the preferential eigenstate selector checkbox should be a checkbox object
+    But the preferential eigenstate selector checkbox should not be enabled
+
+  Scenario Outline: Finding buttons with locators
+    When the kinetic harpoon checkbox on the object test page is checked by "<locator>"
+    Then the kinetic harpoon checkbox should be checked
+    
+    Scenarios:
+      | locator |
+      | id      |
+      | name    |
+      | class   |
+      | xpath   |
+      | index   |