symbiont 0.1.9 → 0.2.0

data/spec/symbiont/web_objects/table_spec.rb

@@ -1,61 +1,61 @@
-require 'spec_helper'
-
-describe Symbiont::WebObjects::Table do
-  describe "implementation" do
-    let(:table_object) { double('table_object') }
-    let(:table_row_object) { double('table_row_object') }
-    let(:table) { Symbiont::WebObjects::Table }
-    
-    it "should reference standard usable selectors" do
-      [:class, :id, :name, :index, :xpath].each do |s|
-        locator = table.provide_locator_for s => 'value'
-        locator.keys.first.should == s
-      end
-    end
-    
-    it "should register with a table tag" do
-      ::Symbiont::WebObjects.get_class_for(:table).should == ::Symbiont::WebObjects::Table
-    end
-    
-    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 a row using text from the first column" do
-        table_object.stub(:[]).with("row_text").and_return(table_object)
-        table_object.should_receive(:rows).and_return(table_object)
-        table_object.should_receive(:find_index).and_return("row_text")
-        watir_table["row_text"].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
-      
-      it "should iterate over the table rows" do
-        watir_table.should_receive(:rows).and_return(2)
-        table_object.stub(:[]).and_return(table_object)
-        count = 0
-        watir_table.each { |e| count += 1 }
-        count.should == 2
-      end
-    end
-  end
-end
+require 'spec_helper'
+
+describe Symbiont::WebObjects::Table do
+  describe "implementation" do
+    let(:table_object) { double('table_object') }
+    let(:table_row_object) { double('table_row_object') }
+    let(:table) { Symbiont::WebObjects::Table }
+
+    it "should reference standard usable selectors" do
+      [:class, :id, :name, :index, :xpath].each do |s|
+        locator = table.provide_locator_for s => 'value'
+        locator.keys.first.should == s
+      end
+    end
+
+    it "should register with a table tag" do
+      ::Symbiont::WebObjects.get_class_for(:table).should == ::Symbiont::WebObjects::Table
+    end
+
+    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 a row using text from the first column" do
+        table_object.stub(:[]).with("row_text").and_return(table_object)
+        table_object.should_receive(:rows).and_return(table_object)
+        table_object.should_receive(:find_index).and_return("row_text")
+        watir_table["row_text"].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
+
+      it "should iterate over the table rows" do
+        watir_table.should_receive(:rows).and_return(2)
+        table_object.stub(:[]).and_return(table_object)
+        count = 0
+        watir_table.each { |e| count += 1 }
+        count.should == 2
+      end
+    end
+  end
+end

data/spec/symbiont/web_objects/text_area_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Symbiont::WebObjects::TextArea do
+  describe "implementation" do
+    let(:text_area_object) { Symbiont::WebObjects::TextArea }
+
+    it "should reference standard usable selectors" do
+      [:class, :id, :name, :index, :xpath, :title, :value, :text, :label].each do |s|
+        locator = text_area_object.provide_locator_for s => 'value'
+        locator.keys.first.should == s
+      end
+    end
+
+    it "should register with a text area tag" do
+      ::Symbiont::WebObjects.get_class_for(:textarea).should == ::Symbiont::WebObjects::TextArea
+    end
+  end
+end

data/spec/symbiont/web_objects/text_field_spec.rb

@@ -1,39 +1,39 @@
-require 'spec_helper'
-
-describe Symbiont::WebObjects::TextField do
-  describe "implementation" do
-    let(:text_field_object) { double('text_field_object') }
-    let(:text_field_definition) { ::Symbiont::WebObjects::TextField.new(text_field_object) }
-    let(:text_field) { Symbiont::WebObjects::TextField }
-    
-    it "should reference standard usable selectors" do
-      [:class, :id, :name, :index, :xpath].each do |s|
-        locator = text_field.provide_locator_for s => 'value'
-        locator.keys.first.should == s
-      end
-    end
-    
-    it "should get the value of a text field" do
-      text_field_object.should_receive(:value).and_return("testing")
-      text_field_definition.value.should == "testing"
-    end
-      
-    it "should set the value of a text field" do
-      text_field_object.should_receive(:set).with("testing")
-      text_field_definition.value = "testing"
-    end
-    
-    it "should append text to a text field" do
-      text_field_object.should_receive(:send_keys).with("testing")
-      text_field_definition.append "testing"
-    end
-    
-    it "should register with a text type" do
-      ::Symbiont::WebObjects.get_class_for(:input, :text).should == ::Symbiont::WebObjects::TextField
-    end
-    
-    it "should register with a password type" do
-      ::Symbiont::WebObjects.get_class_for(:input, :password).should == ::Symbiont::WebObjects::TextField
-    end
-  end
-end
+require 'spec_helper'
+
+describe Symbiont::WebObjects::TextField do
+  describe "implementation" do
+    let(:text_field_object) { double('text_field_object') }
+    let(:text_field_definition) { ::Symbiont::WebObjects::TextField.new(text_field_object) }
+    let(:text_field) { Symbiont::WebObjects::TextField }
+
+    it "should reference standard usable selectors" do
+      [:class, :id, :name, :index, :xpath].each do |s|
+        locator = text_field.provide_locator_for s => 'value'
+        locator.keys.first.should == s
+      end
+    end
+
+    it "should get the value of a text field" do
+      text_field_object.should_receive(:value).and_return("testing")
+      text_field_definition.value.should == "testing"
+    end
+
+    it "should set the value of a text field" do
+      text_field_object.should_receive(:set).with("testing")
+      text_field_definition.value = "testing"
+    end
+
+    it "should append text to a text field" do
+      text_field_object.should_receive(:send_keys).with("testing")
+      text_field_definition.append "testing"
+    end
+
+    it "should register with a text type" do
+      ::Symbiont::WebObjects.get_class_for(:input, :text).should == ::Symbiont::WebObjects::TextField
+    end
+
+    it "should register with a password type" do
+      ::Symbiont::WebObjects.get_class_for(:input, :password).should == ::Symbiont::WebObjects::TextField
+    end
+  end
+end

data/spec/symbiont/web_objects/unordered_list_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Symbiont::WebObjects::UnorderedList do
+  describe "implementation" do
+    let(:unordered_list_object) { Symbiont::WebObjects::UnorderedList }
+
+    it "should allow locators to be used" do
+      [:class, :id, :index, :xpath, :name].each do |t|
+        locator = unordered_list_object.provide_locator_for t => 'value'
+        locator.keys.first.should == t
+      end
+    end
+
+    it "should register with a unordered list (ul) tag" do
+      ::Symbiont::WebObjects.get_class_for(:ul).should == ::Symbiont::WebObjects::UnorderedList
+    end
+
+    context "on the watir platform" do
+      let(:ul_element) { double('ul_element') }
+      let(:watir_unordered_list) { Symbiont::WebObjects::UnorderedList.new(ul_element) }
+
+      it "should return a list item when indexed" do
+        ul_element.stub(:uls).and_return([ul_element])
+        ul_element.stub(:find_elements).and_return(ul_element)
+        ul_element.stub(:map).and_return([ul_element])
+        ul_element.stub(:parent).and_return(ul_element)
+        ul_element.stub(:element).and_return(ul_element)
+        ul_element.stub(:==).and_return(true)
+        watir_unordered_list[1]
+      end
+
+      it "should know how many list items it contains" do
+        ul_element.stub(:uls).and_return([ul_element])
+        ul_element.stub(:find_elements).and_return(ul_element)
+        ul_element.stub(:map).and_return([ul_element])
+        ul_element.stub(:parent).and_return(ul_element)
+        ul_element.stub(:element).and_return(ul_element)
+        ul_element.stub(:==).and_return(true)
+        watir_unordered_list.items.should == 1
+      end
+
+      it "should iterate over the list items" do
+        watir_unordered_list.should_receive(:items).and_return(5)
+        watir_unordered_list.stub(:[])
+        count = 0
+        watir_unordered_list.each { |item| count += 1 }
+        count.should == 5
+      end
+    end
+  end
+end

data/specs/common/support/browser.rb

@@ -0,0 +1,25 @@
+module Symbiont
+  module Browser
+
+    @@browser = false
+
+    def self.start
+      unless @@browser
+        target = ENV['BROWSER']
+        @@browser = watir_browser(target)
+      end
+      @@browser
+    end
+
+    def self.stop
+      @@browser.quit if @@browser
+      @@browser = false
+    end
+
+    private
+
+    def self.watir_browser(target)
+      Watir::Browser.new(target.to_sym)
+    end
+  end
+end

data/specs/common/support/env.rb

@@ -0,0 +1,6 @@
+require 'symbiont'
+require 'symbiont/factory'
+
+include RSpec::Matchers
+
+World(Symbiont::Factory)

data/specs/common/support/events.rb

@@ -0,0 +1,15 @@
+AfterConfiguration do |config|
+  puts("Tests are being executed from: #{config.feature_dirs}")
+end
+
+Before do
+  @browser = Symbiont::Browser.start
+end
+
+After do
+  #Symbiont::Browser.stop
+end
+
+at_exit do
+  Symbiont::Browser.stop
+end

data/specs/enclosers.feature

@@ -0,0 +1,9 @@
+Feature: Ability to handle enclosing elements.
+
+  Scenario: Handling javascript message boxes
+    * the alert message is "Alert Message Received"
+    * the confirm message is "Confirmation Message Received"
+    * the prompt message is "Favorite Sith Lord" and the default value is "Darth Bane"
+
+  Scenario: Handling framed elements
+    * the year for stardate "51887.2" is "2375"

data/specs/evaluators.feature

@@ -0,0 +1,26 @@
+Feature: Ability to handle browser and page actions.
+
+  Scenario: Getting web page text
+    * the text "Multiphasic Temporal Convergence" appears on the web objects page
+
+  Scenario: Getting web page markup
+    * the markup "<legend>Tell Us What You Read</legend>" appears in the web objects page
+
+  Scenario: Getting web page title
+    * the title "Web Objects | Symbiote" appears for the web objects page
+
+  Scenario: Getting the web page url
+    * the url "http://localhost:9292/webobject" matches the web objects page
+
+  Scenario: Getting the type of element with focus
+    * the "name" text field should have focus on initial loading of the web objects page
+
+  Scenario: Setting the focus to an element
+    When setting the focus on the chameleoflage armor field
+    Then the "cameleoflage armor" checkbox should have focus
+
+  Scenario: Back, forward, and refresh browser actions
+    * going back from the web objects to the home page
+    * going forward from the home page to the web objects page
+    * refreshing the web objects page
+

data/specs/pages/characters.rb

@@ -0,0 +1,22 @@
+class Characters
+  include Symbiont
+  include Symbiont::Factory
+
+  url_is "http://localhost:9292/comics"
+  title_is "Comic Heroes and Villains | Symbiote"
+
+  table  :characters_id,       id: "comic-grid"
+  table  :characters_name,     name: "comic-grid"
+  table  :characters_class,    class: "display"
+  table  :characters_xpath,    xpath: "//table"
+  table  :characters_index,    index: 0
+
+  table  :publishers,          id: "pub-grid"
+
+  cell   :dc_year_id,          id: "dc_founded"
+  cell   :dc_year_name,        name: "dc_founded"
+  cell   :dc_year_class,       class: "pub"
+  cell   :dc_year_xpath,       xpath: "//td[@id='dc_founded']"
+
+  cell   :marvel_year_id,      id: "marvel_founded"
+end

data/specs/pages/home.rb

@@ -0,0 +1,9 @@
+class Home
+  include Symbiont
+
+  url_is "http://localhost:9292"
+
+  def check_for_title(text)
+    self.title.should == text
+  end
+end

data/specs/pages/stardate.rb

@@ -0,0 +1,23 @@
+class Stardate
+  include Symbiont
+
+  url_is "http://localhost:9292/stardate"
+
+  link :calculator, href: "stardate_calc"
+
+  frame(id: "fancybox-frame") do |context|
+    text_field :tng_stardate, name: "stardateTNGValue", frame: context
+    text_field :tos_stardate, name: "stardateTOSValue", frame: context
+    text_field :tng_value,    name: "calendarTNGValue", frame: context
+    text_field :tos_value,    name: "calendarTOSValue", frame: context
+    button     :convert_tng,  id:   "convertTNG",       frame: context
+    button     :convert_tos,  id:   "convertTOS",       frame: context
+  end
+
+  def calculate_tng(value)
+    self.wait_for_app(2)
+    self.tng_stardate = value
+    self.convert_tng
+    self.tng_value
+  end
+end

data/specs/pages/web_objects.rb

@@ -0,0 +1,77 @@
+class WebObjects
+  include Symbiont
+  include Symbiont::Factory
+
+  url_is "http://localhost:9292/webobject"
+  title_is "Web Objects | Symbiote"
+
+  text_field  :name,                id: "name"
+  text_field  :email,               id: "email"
+
+  checkbox    :chameleoflage_armor, id: "camoArmor"
+  checkbox    :make_sith_active,    id: "toggleSith"
+
+  select_list :sith_power,          id: "sith"
+  select      :physics_id,          id: "physics"
+  select      :physics_name,        name: "physics"
+  select      :physics_xpath,       xpath: "//select[@id='physics']"
+  select      :physics_index,       index: 1
+
+  button      :alert,               id: "alertButton"
+  button      :confirm,             id: "confirmButton"
+  button      :prompt,              id: "promptButton"
+
+  def check_for_text(text)
+    self.text.include? text
+  end
+
+  def check_for_markup(text)
+    self.html.include? text
+  end
+
+  def check_for_title(text)
+    self.title.should == text
+  end
+
+  def check_for_url(text)
+    self.url.should == text
+  end
+
+  def check_for_focus(element)
+    case element
+      when "name"
+        self.focus.should be_an_instance_of Symbiont::WebObjects::TextField
+      when "cameleoflage armor"
+        self.focus.should be_an_instance_of Symbiont::WebObjects::CheckBox
+    end
+  end
+
+  def set_focus_for(locator)
+    self.checkbox_object(locator).focus
+  end
+
+  def generate_alert(text)
+    message = self.will_alert do
+      self.alert
+    end
+
+    message.should == text
+  end
+
+  def generate_confirm(text)
+    message = self.will_confirm(true) do
+      self.confirm
+    end
+
+    message.should == text
+  end
+
+  def generate_prompt(text, value)
+    message = self.will_prompt("Darth Invictus") do
+      self.prompt
+    end
+
+    message[:message].should == text
+    message[:default_value].should == value
+  end
+end

data/specs/select_list.feature

@@ -0,0 +1,53 @@
+Feature: Work with select list objects
+
+  Background:
+    Given the web objects page
+
+  Scenario: Checking the state of select lists
+    * the physics expertise select list should exist
+    * the physics expertise select list should be visible
+    * the physics expertise select list should be enabled
+    * the physics expertise select list should be a select list object
+    * the sith power select list should not be enabled
+
+  Scenario Outline: Finding a select list on the page
+    When the physics expertise select list is searched for by "<identifier>"
+    Then it is possible to select a physics topic of "Loop Quantum Gravity"
+    And  the value of the selected item for physics expertise should be "Loop Quantum Gravity"
+    And  the value of the selected option for physics expertise should be "lqg"
+
+    Scenarios:
+      | identifier |
+      | id         |
+      | name       |
+      | xpath      |
+      | index      |
+
+  Scenario: Finding if a select list contains a particular value
+    * the physics expertise select list should include "Alcubierre Warp Metrics"
+
+  Scenario: Getting the selected value and option
+    When the physics expertise topic "Loop Quantum Gravity" is selected
+    Then the selected physics expertise value is "Loop Quantum Gravity"
+    And  the selected physics expertise option is "lqg"
+
+  Scenario: Getting a value from the selected option
+    When the physics expertise option "lqg" is selected
+    Then the selected physics expertise option is "lqg"
+
+  Scenario: Selecting multiple values from a list
+    When the physics expertise values "Tachyonic Antitravel" and "Krasnikov Tubes" are selected
+    Then the selected physics expertise values are "Tachyonic Antitravel" and "Krasnikov Tubes"
+    When the physics expertise select list is cleared
+    Then the physics expertise select list should have no selected values
+
+  Scenario: Getting all values from a select list
+    * the physics expertise select list contains the following
+      | Quantum Entanglement            |
+      | Tachyonic Antitravel            |
+      | Bose-Einstein Condensates       |
+      | Alcubierre Warp Metrics         |
+      | Krasnikov Tubes                 |
+      | Supersymmetric Particle Theory  |
+      | Loop Quantum Gravity            |
+      | Noncommutative Geometric Spaces |

data/specs/steps/enclosers_steps.rb

@@ -0,0 +1,17 @@
+Given(/^the alert message is "(.*?)"$/) do |text|
+  on_view(WebObjects).generate_alert(text)
+end
+
+Given(/^the confirm message is "(.*?)"$/) do |text|
+  on_view(WebObjects).generate_confirm(text)
+end
+
+Given(/^the prompt message is "(.*?)" and the default value is "(.*?)"$/) do |text, value|
+  on_view(WebObjects).generate_prompt(text, value)
+end
+
+Given(/^the year for stardate "(.*?)" is "(.*?)"$/) do |value, year|
+  on_view(Stardate).calculator
+  result = on(Stardate).calculate_tng("51887.2")
+  result.include? year
+end

data/specs/steps/evaluators_steps.rb

@@ -0,0 +1,44 @@
+Given(/^the text "(.*?)" appears on the web objects page$/) do |text|
+  on_view(WebObjects).check_for_text(text)
+end
+
+Given(/^the markup "(.*?)" appears in the web objects page$/) do |text|
+  on_view(WebObjects).check_for_markup(text)
+end
+
+Given(/^the title "(.*?)" appears for the web objects page$/) do |text|
+  on_view(WebObjects).check_for_title(text)
+end
+
+Given(/^the url "(.*?)" matches the web objects page$/) do |text|
+  on_view(WebObjects).check_for_url(text)
+end
+
+Given(/^the "(.*?)" text field should have focus on initial loading of the web objects page$/) do |element|
+  on_view(WebObjects).check_for_focus(element)
+end
+
+When(/^setting the focus on the chameleoflage armor field$/) do
+  on_view(WebObjects).set_focus_for(:id => "camoArmor")
+end
+
+Then(/^the "(.*?)" checkbox should have focus$/) do |element|
+  on(WebObjects).check_for_focus(element)
+end
+
+Given(/^going back from the web objects to the home page$/) do
+  on_view(Home).check_for_title("Home | Symbiote")
+  on_view(WebObjects).check_for_title("Web Objects | Symbiote")
+  on(WebObjects).back
+  on(Home).check_for_title("Home | Symbiote")
+end
+
+Given(/^going forward from the home page to the web objects page$/) do
+  on(Home).forward
+  on(WebObjects).check_for_title("Web Objects | Symbiote")
+end
+
+Given(/^refreshing the web objects page$/) do
+  on(WebObjects).refresh
+  on(WebObjects).check_for_title("Web Objects | Symbiote")
+end

data/specs/steps/navigation_steps.rb

@@ -0,0 +1,14 @@
+#When(/^on the (.*) page$/) do |name|
+  #case name
+  #  when "web objects"
+  #    @page = WebObjects.new(@browser, true)
+  #end
+#end
+
+Given(/^the web objects page$/) do
+  on_view(WebObjects)
+end
+
+Given(/^the comic characters page$/) do
+  on_view(Characters)
+end