selenium_fury 0.5.12 → 0.6.0

data/lib/selenium_fury/selenium_client/page_validator.rb

@@ -20,7 +20,7 @@ module SeleniumFury
       attr_accessor :found_missing_locators
       # @param page_file_class [Class] The page object class you want to test
       # @param live_url [String] the url of the page your testing
-      def check_page_file_class(page_file_class, *live_url)
+      def check_page_file_class(page_file_class, live_url = nil)
         raise "cannot access the selenium client driver" if browser.nil?
         missing_locators={}
         puts "Validating the #{page_file_class} class"
@@ -28,16 +28,14 @@ module SeleniumFury
         test_page = page_file_class.new(browser)
         raise "The test class is nil" if test_page.nil?
         #skip the open if we don't need to open the url again
-        unless live_url.empty?
+        if live_url
           puts "Opening  #{browser.browser_url}/#{live_url}" #if $DEBUG
           browser.open live_url
         end
 
-        #check for class methods and execute.
-        verify_class_variables(test_page, missing_locators) if test_page.public_methods(all=false).length > 0
-
         #check for instance methods and execute.
         verify_instance_variables(test_page, missing_locators) if test_page.instance_variables.length > 0
+
         @found_missing_locators=missing_locators
         return print_missing_locators(missing_locators)
       end
@@ -66,48 +64,25 @@ module SeleniumFury
       def verify_instance_variables(test_page, missing_locators)
         #test_page.print_properties browser
         test_page.instance_variables.each do |locator_name|
+          locator_name_string = locator_name.to_s
           #prepare the locator values
-          locator_name.slice!(0)
-          if attribute_name_filter(locator_name)
-            puts "Skipping validation for #{locator_name}"
-            next
-          end
-          next if (test_page.method(locator_name).call.class.to_s != "String")
-          puts "     Validating the #{locator_name} page element locator" #chomp the @ sign off of the method name.
-          locator_value = test_page.method(locator_name) # Create the reference to the get method of the instance variable
-          begin
-            browser.wait_for_element(locator_value.call, {:timeout_in_seconds => "5"})
-          rescue
-            puts "    -----------------------------------    Could not find '#{locator_name}'"
-          end
-          missing_locators[locator_name]= locator_value.call if !browser.element?(locator_value.call) # Use the value of the instance variable
-        end
-      end
-
-      # @param test_page [Object] an instantiated page object
-      # @param missing_locators [Hash]
-      def verify_class_variables(test_page, missing_locators)
-        test_page.public_methods(all=false).each do |locator_name|
-          #Only operate with the set methods not the get methods
-          next if (!locator_name.include?("="))
-
-          locator_name.slice!(locator_name.length-1)
+          locator_name_string.slice!(0)
 
-          if attribute_name_filter(locator_name)
+          if attribute_name_filter(locator_name_string)
             puts "Skipping validation for #{locator_name}"
             next
           end
-          next if (test_page.method(locator_name).call.class.to_s != "String")
+
+          # I don't understand where this would ever be true, but I'll leave it I guess?
+          # next if (test_page.method(locator_name_string.to_sym).class.to_s != "String")
           puts "     Validating the #{locator_name} page element locator" #chomp the @ sign off of the method name.
-          locator_value = test_page.method(locator_name) # Create the reference to the get method of the instance variable
-                                                                          #Now validate the page
+          locator_value = test_page.method(locator_name_string.to_sym) # Create the reference to the get method of the instance variable
           begin
             browser.wait_for_element(locator_value.call, {:timeout_in_seconds => "5"})
           rescue
-            puts "    -----------------------------------          Could not find #{locator_name}"
+            puts "    -----------------------------------    Could not find '#{locator_name}'"
+            missing_locators[locator_name_string]= locator_value.call
           end
-          missing_locators[locator_name]= locator_value.call if !browser.element?(locator_value.call) # Use the value of the instance variable
-
         end
       end
 

data/lib/selenium_fury/selenium_web_driver/element_finder.rb

@@ -1,3 +1,18 @@
+#/* Copyright (c) 2010 HomeAway, Inc.
+# * All rights reserved.  http://www.homeaway.com
+# *
+# * Licensed under the Apache License, Version 2.0 (the "License");
+# * you may not use this file except in compliance with the License.
+# * You may obtain a copy of the License at
+# *
+# *      http://www.apache.org/licenses/LICENSE-2.0
+# *
+# * Unless required by applicable law or agreed to in writing, software
+# * distributed under the License is distributed on an "AS IS" BASIS,
+# * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# * See the License for the specific language governing permissions and
+# * limitations under the License.
+# */
 module SeleniumFury
   module SeleniumWebDriver
     class ElementFinder
@@ -13,7 +28,7 @@ module SeleniumFury
         nokogiri_elements.each do |nokogiri_element|
           valid_locators.each do |valid_locator|
             if nokogiri_element.get_attribute(valid_locator) != nil
-              locators.push({valid_locator.to_sym, nokogiri_element.get_attribute(valid_locator)})
+              locators.push({valid_locator.to_sym => nokogiri_element.get_attribute(valid_locator)})
               break
             end
           end

data/lib/selenium_fury/selenium_web_driver/page_object.rb

@@ -18,8 +18,8 @@ class PageObject
   include SeleniumFury::SeleniumWebDriver::PageObjectComponents
   include SeleniumFury::SeleniumWebDriver::CreateSeleniumWebDriver
 
-  def initialize *driver
-    @driver = *driver
+  def initialize driver = nil
+    @driver = driver
   end
 
 end

data/lib/selenium_fury/selenium_web_driver/page_object_components.rb

@@ -57,7 +57,7 @@ module SeleniumFury
 # @return [PageObject]
         def page(page_sym, page_class)
           send :define_method, page_sym do
-            raise "#{page_class} does not inherit from PageObject" unless page_class.superclass == PageObject
+            raise "#{page_class.to_s} does not inherit from PageObject" unless page_class.superclass == PageObject
             page_class.new(driver)
           end
         end

data/spec/common/selenium_api_chooser_spec.rb

@@ -2,38 +2,38 @@ require 'spec_helper'
 describe SeleniumFury::SeleniumApiChooser do
   context "Finding generate/validate methods" do
     it "should find the generator for selenium client tests" do
-      create_selenium_client_driver "http://www.scottcsims.com"
+      create_selenium_client_driver TEST_PAGE_URL
       should_receive(:get_source_and_print_elements)
       generate(browser)
     end
     it "should find the generator for selenium web_driver tests" do
-      launch_web_driver "http://www.scottcsims.com"
+      launch_web_driver TEST_PAGE_URL
       should_receive(:web_driver_generate)
       generate(driver)
     end
     it "should find the validator for selenium client tests" do
-      create_selenium_client_driver "http://www.scottcsims.com"
-      should_receive(:check_page_file_class).with(NilClass)
-      validate(NilClass)
+      create_selenium_client_driver TEST_PAGE_URL
+      should_receive(:check_page_file_class).with(NilClass, nil)
+      validate(NilClass, nil)
     end
     it "should find the validator for selenium web driver tests" do
-      launch_web_driver "http://www.scottcsims.com"
+      launch_web_driver TEST_PAGE_URL
       should_receive(:web_driver_validate).with(NilClass)
       validate(NilClass)
     end
   end
   context "Integrating with generator/validator methods" do
     it "should find generate method for selenium client tests" do
-      create_selenium_driver "http://www.scottcsims.com"
+      create_selenium_driver TEST_PAGE_URL
       browser.start_new_browser_session
-      browser.open "/"
-      generate(browser).should include("found (9 elements)")
+      browser.open TEST_PAGE_URL
+      generate(browser).should include("found (15 elements)")
     end
     it "should find validate method for selenium client tests" do
-      create_selenium_driver("http://www.homeaway.com")
+      create_selenium_driver TEST_PAGE_URL
       browser.start_new_browser_session
       puts "Testing #{browser.browser_url} on #{browser.browser_string} "
-      validate(AdvancedSearch, "/searchForm")
+      validate(TestPageRc, TEST_PAGE_URL)
     end
     it "should have found missing locators in module", SeleniumFury::SeleniumApiChooser do
       SeleniumFury::SeleniumClient::PageValidator.respond_to?(:found_missing_locators).should be_true

data/spec/selenium_client/custom_generators_spec.rb

@@ -1,13 +1,29 @@
 require "spec_helper"
-describe AdvancedSearchCustomGeneratorConfiguration do
-  it "should generate the advanced search locators" do
-    create_selenium_driver("http://www.homeaway.com")
+describe TestPageCustomGeneratorConfiguration do
+
+  it "should generate the test page link locators" do
+    create_selenium_driver TEST_PAGE_URL
     browser.start_new_browser_session
     puts "Testing #{browser.browser_url} on #{browser.browser_string} "
-    browser.open "/searchForm"
-    advanced_search_custom_generator_configuration = AdvancedSearchCustomGeneratorConfiguration.new
+    browser.open TEST_PAGE_URL
+    test_page_custom_generator_configuration = TestPageCustomGeneratorConfiguration.new
     result = custom_generator(:browser => browser,
-                     :custom_configuration => advanced_search_custom_generator_configuration)
-    result.should include("found (30 elements)")
+                     :custom_configuration => test_page_custom_generator_configuration)
+    result.should == custom_generator_result
   end
+  let(:custom_generator_result){
+<<EOF
+found (3 elements)
+class YourPageFile
+	def initialize *browser
+		@browser = *browser
+		@link_1 = "link111111"
+		@link_2 = "link222222"
+		@link_3 = "link333333"
+	end
+	attr_accessor :browser, :link_1, :link_2, :link_3
+
+end
+EOF
+}
 end

data/spec/selenium_client/page_generator_spec.rb

@@ -1,11 +1,11 @@
 require "spec_helper"
 describe SeleniumFury::SeleniumClient::PageGenerator do
   it "should find elements on the HomeAway advanced search page" do
-    create_selenium_driver("http://www.homeaway.com")
+    create_selenium_driver TEST_PAGE_URL
     browser.start_new_browser_session
     puts "Testing #{browser.browser_url} on #{browser.browser_string} "
-    browser.open "/searchForm"
+    browser.open TEST_PAGE_URL
     result = generate(browser)
-    result.should include("found (43 elements)")
+    result.should include("found (15 elements)")
   end
 end

data/spec/selenium_client/page_validator_spec.rb

@@ -1,14 +1,14 @@
 require "spec_helper"
 describe SeleniumFury::SeleniumClient::PageValidator do
-  it "should validate the elements contained on the AdvancedSearch page object" do
-    create_selenium_driver("http://www.homeaway.com")
+  it "should validate the elements contained on the TestPage page object" do
+    create_selenium_driver TEST_PAGE_URL
     browser.start_new_browser_session
-    validate(AdvancedSearch, "/searchForm")
+    validate(TestPageRc, TEST_PAGE_URL)
     @found_missing_locators.should_not be_nil
     @found_missing_locators.should have(0).missing_locators
   end
   it "should fail if there are missing locators" do
-    create_selenium_driver("http://www.homeaway.com")
+    create_selenium_driver TEST_PAGE_URL
     class MissingLocators
       def initialize *browser
         @browser=browser
@@ -19,7 +19,7 @@ describe SeleniumFury::SeleniumClient::PageValidator do
     end
     browser.start_new_browser_session
     begin
-      validate(MissingLocators, browser, "/searchForm")
+      validate(MissingLocators, TEST_PAGE_URL)
     rescue Exception => e
       puts e.message.should include("found missing locators")
       @found_missing_locators["missing"].should =="missing_id"

data/spec/selenium_client/test_page_rc_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+describe TestPageRc do
+  it "should use elements on the TestPageRc" do
+    create_selenium_driver TEST_PAGE_URL
+    browser.start_new_browser_session
+    puts "Testing #{browser.browser_url} on #{browser.browser_string} "
+    browser.open  TEST_PAGE_URL
+    test_page = TestPageRc.new(browser)
+    browser.click test_page.input_message
+    browser.type test_page.input_message, "this is awesome"
+    browser.click test_page.input_msg_button
+    browser.text("message").should == "this is awesome"
+  end
+end

data/spec/selenium_web_driver/element_finder_spec.rb

@@ -1,4 +1,4 @@
-require "spec_helper"
+require 'spec_helper'
 describe SeleniumFury::SeleniumWebDriver::ElementFinder do
   it "should find elements" do
     html="<input id='myTestId1'><input name='myTestId2'>"

data/spec/selenium_web_driver/page_generator_spec.rb

@@ -1,15 +1,15 @@
-require "spec_helper"
+require 'spec_helper'
 describe SeleniumFury::SeleniumWebDriver::PageGenerator do
-  it "should find elements on the HomeAway advanced search page" do
-    launch_web_driver("http://www.homeaway.com/searchForm")
+  it "should find elements on the Test page" do
+    launch_web_driver TEST_PAGE_URL
     result = generate(driver)
-    result.should include("found (43 elements)")
-    result.should include("element :adv_search_form, {:id => \"adv-search-form\"}")
+    result.should include 'found (15 elements)'
+    result.should include 'element :form, {:id => "form"}'
   end
-  it "should return a page object" do
-    launch_web_driver("http://www.homeaway.com/searchForm")
-    search_form = get_page_object(driver,"SearchForm")
-    search_form.should be_instance_of SearchForm
-    search_form.special_offers.should be_instance_of Selenium::WebDriver::Element
+  it "should return a TestPage page object" do
+    launch_web_driver TEST_PAGE_URL
+    test_page = get_page_object driver, "TestPage"
+    test_page.should be_instance_of TestPage
+    test_page.input_button.should be_instance_of Selenium::WebDriver::Element
   end
 end

data/spec/selenium_web_driver/page_object_spec.rb

@@ -1,55 +1,84 @@
 require 'spec_helper'
-describe PageObject do
+describe SeleniumFury::SeleniumWebDriver::CreateSeleniumWebDriver do
+  it "should go to page using launch_web_driver" do
+    launch_web_driver TEST_PAGE_URL
+    driver.current_url.should include "/spec/test_page/test_page.html"
+    driver.title.should == "SeleniumFury Test Page"
+  end
+end
 
-  it "should go to the home page using launch site" do
-    launch_web_driver "http://www.scottcsims.com"
-    driver.current_url.should == "http://scottcsims.com/wordpress/"
-    driver.navigate.to "http://www.scottcsims"
-    driver.title.should == "Scott Sims"
+describe PageObject do
+  it "should have a text area method on the test page" do
+    launch_web_driver TEST_PAGE_URL
+    test_page = TestPage.new(driver)
+    test_page.should_not be_nil
+    test_page.textarea.should be_a(Selenium::WebDriver::Element)
   end
-  it "should have elements" do
-    launch_web_driver "http://www.homeaway.com"
-    search=get_page_object(driver, 'Search')
-    search.class.elements.should_not be_nil
-    search.class.elements.should have(8).elements
-    search.method(search.class.elements[0]).call.class.should == Selenium::WebDriver::Element
+  it "should have a test page" do
+    class ComponentPage < PageObject
+
+    end
+    TestPage.page(:component_page, ComponentPage)
+    TestPage.new().component_page.should be_a(ComponentPage)
   end
-  it 'should return a web_driver element when an attribute is accessed' do
-    launch_web_driver "http://www.homeaway.com"
-    search=get_page_object(driver, 'Search')
-    search.start_date_input.class.should == Selenium::WebDriver::Element
-    search.search_keywords Faker::Lorem.words
+
+  it "should have an error if a non page object class is passed to page method" do
+    TestPage.page(:not_a_page, String)
+    expect { TestPage.new().not_a_page }.to(raise_exception(RuntimeError, "String does not inherit from PageObject"))
   end
 
-  it "should raise an exception when the element can't be found'" do
-    launch_web_driver "http://www.homeaway.com"
-    search=get_page_object(driver, 'Search')
-    Search.element(:not_a_element, {:id =>"not a element"})
-    lambda{search.not_a_element}.should(raise_exception(RuntimeError,"Could not find element not_a_element"))
+  it "should use elements on the TestPage" do
+    launch_web_driver TEST_PAGE_URL
+    test_page = TestPage.new(driver)
+    test_page.input_message.send_keys "this is awesome"
+    test_page.input_msg_button.click
+    driver.find_element(:id => "message").text.should == "this is awesome"
   end
 
-  it "should have a property page that contains a inquiry sidebar" do
-    launch_web_driver "http://www.homeaway.com/vacation-rental/p254680"
-    property_page = PropertyPage.new(driver)
-    property_page.should_not be_nil
-    property_page.inquiry_side_bar.should_not be_nil
+  it "should use some methods man" do
+    launch_web_driver TEST_PAGE_URL
+    test_page = TestPage.new(driver)
+    test_page.click_check_box
+    driver.find_element(:id => "input_checkbox").selected?.should be_true
   end
 
-  it "should have an error if a non page object class is passed to page method" do
-    property_page = PropertyPage.new()
-    PropertyPage.page(:not_a_page, String)
-    lambda{property_page.not_a_page}.should raise_exception(RuntimeError,"String does not inherit from PageObject")
+  # OK, so here's some great info about the "magic" behind ruby.
+  # When ruby spins up, an Object class is created, and everything runs "inside" it
+  # When you do code like this: TestPage.new() an instance of TestPage is added as a constant
+  # to the instance of this "global" Object class
+  # Therefore, since rspec is running "inside" this Object Class, an instance of TestPage is
+  # instantiated and shared from test to test, BUT when you do get_page_object, an instance
+  # of the page object must be created and added as a constant, but if it already exists,
+  # you're gonna have bad time. Therefore, for testing sake, we must check for this,
+  # and handle it appropriately.
+  #
+  # It should also be noted that get_page_object only adds page elements to the class
+  # and currently doesn't look for a pre-defined page object in the project
+
+  it "should have elements" do
+    Object.instance_eval { remove_const :TestPage } if Object.const_defined? :TestPage
+    launch_web_driver TEST_PAGE_URL
+    test_page = get_page_object(driver, 'TestPage')
+    test_page.class.elements.should_not be_nil
+    test_page.class.elements.should have(15).elements
+    test_page.method(test_page.class.elements[0]).call.class.should == Selenium::WebDriver::Element
+    Object.instance_eval { remove_const :TestPage }
   end
-  it "should use elements on the HomeAway advanced search page" do
-    launch_web_driver("http://www.homeaway.com/searchForm")
-    advanced_search = AdvancedSearchWebDriver.new(driver)
-    advanced_search.amenity0_0.click
-    advanced_search.adv_search_form.submit
+  it "should return a web_driver element when an attribute is accessed" do
+    Object.instance_eval { remove_const :TestPage } if Object.const_defined? :TestPage
+    launch_web_driver TEST_PAGE_URL
+    test_page = get_page_object(driver, 'TestPage')
+    test_page.textarea.class.should == Selenium::WebDriver::Element
+    Object.instance_eval { remove_const :TestPage }
   end
 
-  it "should use methods on the HomeAway advanced search page" do
-    launch_web_driver("http://www.homeaway.com/searchForm")
-    advanced_search = AdvancedSearchWebDriver.new(driver)
-    advanced_search.click_one_item
+  it "should raise an exception when the element can't be found'" do
+    Object.instance_eval { remove_const :TestPage } if Object.const_defined? :TestPage
+    launch_web_driver TEST_PAGE_URL
+    test_page = get_page_object(driver, 'TestPage')
+    TestPage.element :not_a_element, {:id => "not a element"}
+    expect { test_page.not_a_element }.to raise_exception RuntimeError, "Could not find element not_a_element"
+    Object.instance_eval { remove_const :TestPage }
   end
+
 end

data/spec/selenium_web_driver/page_validator_spec.rb

@@ -1,4 +1,4 @@
-require "spec_helper"
+require 'spec_helper'
 describe SeleniumFury::SeleniumWebDriver::PageValidator do
 
   it "should have a missing element exception" do
@@ -6,13 +6,13 @@ describe SeleniumFury::SeleniumWebDriver::PageValidator do
       element :not_a_element1, {:id=>"not a element1"}
       element :not_a_element2, {:id=>"not a element2"}
     end
-    launch_web_driver("http://www.homeaway.com/searchForm")
-    lambda{web_driver_validate(MissingElement)}.should raise_exception(RuntimeError,"Found Missing Elements: [:not_a_element1, :not_a_element2]")
+    launch_web_driver TEST_PAGE_URL
+    expect{web_driver_validate(MissingElement)}.to raise_exception RuntimeError,"Found Missing Elements: [:not_a_element1, :not_a_element2]"
   end
 
   it "should validate elements" do
-    launch_web_driver("http://www.homeaway.com/searchForm")
-    validate(AdvancedSearchWebDriver)
+    launch_web_driver TEST_PAGE_URL
+    validate TestPage
   end
 
 end