symbiont 0.2.1 → 0.3.0

data/spec/symbiont/web_objects/table_spec.rb

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

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

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

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

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

data/specs/common/support/events.rb

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

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

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

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

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

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

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

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

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

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

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

data/specs/steps/select_list_steps.rb

@@ -1,94 +0,0 @@
-When(/^the physics expertise select list is searched for by "(.*?)"$/) do |identifier|
-  @find_by = identifier
-end
-
-When(/^the sith power select list is enabled$/) do
-  on(WebObjects).check_make_sith_active
-end
-
-When(/^the physics expertise topic "(.*?)" is selected$/) do |value|
-  on(WebObjects).physics_id = value
-end
-
-When(/^the physics expertise option "(.*?)" is selected$/) do |option|
-  on(WebObjects).physics_id_object.select_value(option)
-end
-
-When(/^the physics expertise values "(.*?)" and "(.*?)" are selected$/) do |value1, value2|
-  on(WebObjects).physics_id_object.select(value1)
-  on(WebObjects).physics_id_object.select(value2)
-end
-
-When(/^the physics expertise select list is cleared$/) do
-  on(WebObjects).physics_id_object.clear
-end
-
-Then(/^the physics expertise select list should exist$/) do
-  on(WebObjects).physics_id_exists?.should == true
-  on(WebObjects).physics_id?.should == true
-end
-
-Then(/^the physics expertise select list should be visible$/) do
-  on(WebObjects).physics_id_visible?.should == true
-  on(WebObjects).physics_id?.should == true
-end
-
-Then(/^the physics expertise select list should be enabled$/) do
-  on(WebObjects).physics_id_enabled?.should == true
-  on(WebObjects).physics_id!.should == true
-end
-
-Then(/^the physics expertise select list should be a select list object$/) do
-  element = on(WebObjects).physics_id_select_list
-  element.should be_instance_of Symbiont::WebObjects::SelectList
-end
-
-Then(/^the sith power select list should not be enabled$/) do
-  on(WebObjects).sith_power_enabled?.should == false
-end
-
-Then(/^it is possible to select a physics topic of "(.*?)"$/) do |value|
-  on(WebObjects).send "physics_#{@find_by}=".to_sym, value
-end
-
-Then(/^the value of the selected item for physics expertise should be "(.*?)"$/) do |value|
-  result = on(WebObjects).send "physics_#{@find_by}".to_sym
-  result.should == value
-end
-
-Then(/^the value of the selected option for physics expertise should be "(.*?)"$/) do |option|
-  element = on(WebObjects).send "physics_#{@find_by}_object".to_sym
-  element.value.should == option
-end
-
-Then(/^the physics expertise select list should include "(.*?)"$/) do |value|
-  on(WebObjects).physics_id_object.should include value
-  on(WebObjects).physics_id_object.include?(value)
-end
-
-Then(/^the selected physics expertise value is "(.*?)"$/) do |value|
-  on(WebObjects).select_list_object(id: 'physics').selected_options[0].should == value
-  on(WebObjects).physics_id_object.selected?(value).should be_true
-  on(WebObjects).physics_id_object.selected?(value)
-  on(WebObjects).physics_id.should == value
-end
-
-Then(/^the selected physics expertise option is "(.*?)"$/) do |value|
-  on(WebObjects).physics_id_option?.should == value
-  on(WebObjects).physics_id_object.selected_values[0].should == value
-end
-
-Then(/^the selected physics expertise values are "(.*?)" and "(.*?)"$/) do |value1, value2|
-  on(WebObjects).physics_id_object.selected_options.should == [value1, value2]
-end
-
-Then(/^the physics expertise select list should have no selected values$/) do
-  on(WebObjects).physics_id_object.selected_options.should be_empty
-end
-
-Then(/^the physics expertise select list contains the following$/) do |values|
-  list = on(WebObjects).physics_id_options?
-  values.raw.each do |item|
-    list.should include item[0]
-  end
-end

data/specs/steps/table_cell_steps.rb

@@ -1,31 +0,0 @@
-When(/^the founded table entry for DC is searched for by "(.*?)"$/) do |identifier|
-  @find_by = identifier
-end
-
-Then(/^the founded table entry for DC should exist$/) do
-  @active.dc_year_id_exists?.should == true
-  @active.dc_year_id?.should == true
-end
-
-Then(/^the founded table entry for DC should be visible$/) do
-  @active.dc_year_id_visible?.should == true
-  @active.dc_year_id_?.should == true
-end
-
-Then(/^the founded table entry for DC should be a table cell object$/) do
-  element = @active.dc_year_id_cell
-  element.should be_instance_of Symbiont::WebObjects::TableCell
-end
-
-Then(/^the founded table entry for DC should be "(.*?)"$/) do |value|
-  @active.dc_year_id.should == value
-end
-
-Then(/^the founded table entry for Marvel should be "(.*?)"$/) do |value|
-  @active.marvel_year_id.should == value
-end
-
-Then(/^it can be confirmed that the founded table entry for DC should be "(.*?)"$/) do |value|
-  result = @active.send "dc_year_#{@find_by}".to_sym
-  result.should == value
-end