selenium_fury 1.0.0 → 1.0.1

data/lib/selenium_fury.rb

@@ -23,7 +23,6 @@ require "selenium-client"
 require 'nokogiri'
 
 require "selenium_fury/common/page_parser"
-require "selenium_fury/common/selenium_api_chooser"
 require "selenium_fury/selenium_web_driver/create_selenium_web_driver"
 require "selenium_fury/selenium_web_driver/element_finder"
 require "selenium_fury/selenium_web_driver/page_object_components"
@@ -36,5 +35,3 @@ require "selenium_fury/selenium_web_driver/generic_elements/generic_element"
 
 include SeleniumFury::SeleniumWebDriver::PageGenerator
 include SeleniumFury::SeleniumWebDriver::PageValidator
-
-include SeleniumFury::SeleniumApiChooser

data/lib/selenium_fury/selenium_web_driver/generic_elements/generic_element.rb

@@ -9,9 +9,16 @@ module SeleniumFury
         def initialize(locator, driver=nil, opt={})
           @location = locator
           @driver = driver
+          @tags = opt[:tags]
+          @validate = opt[:validate] != false  # true if nil
         end
 
-        attr_accessor :location, :driver
+        attr_accessor :location, :driver, :tags
+        attr_writer :validate
+
+        def validate?
+          @validate
+        end
       end
 
       class CheckboxElement < GenericElement

data/lib/selenium_fury/selenium_web_driver/generic_elements/generic_element_helpers.rb

@@ -31,6 +31,12 @@ module GenericElementHelpers
 end
 
 module ElementWaitHelpers
+  def web_driver_wait(opt=10, &condition)
+    options={}
+    opt.kind_of?(Integer) ? options[:timeout] = opt : options = opt
+    Selenium::WebDriver::Wait.new(options).until { condition.call }
+  end
+
   def wait_present(timeout)
     web_driver_wait(timeout) { present? }
   end

data/lib/selenium_fury/selenium_web_driver/page_generator.rb

@@ -28,7 +28,7 @@ module SeleniumFury
         end
         result += "\n\nend"
         $stdout.puts result
-        return result
+        result
       end
 
 # @param page_object_attributes [Hash]
@@ -41,8 +41,7 @@ module SeleniumFury
           end
         }
         print_selenium_web_driver_page_object page_object_attributes,class_name
-        return Object.const_set(class_name, klass).new(driver)
-
+        Object.const_set(class_name, klass).new(driver)
       end
 
 # @param driver [Selenium::WebDriver::Driver]
@@ -56,6 +55,12 @@ module SeleniumFury
         print_selenium_web_driver_page_object page_object_attributes
       end
 
+# @param driver [Selenium::WebDriver::Driver]
+# @return [String]
+      def generate(driver)
+        web_driver_generate(driver)
+      end
+
 # @param driver [Selenium::WebDriver::Driver]
 # @param class_name [string]
 # @return [PageObject]

data/lib/selenium_fury/selenium_web_driver/page_validator.rb

@@ -16,34 +16,54 @@
 module SeleniumFury
   module SeleniumWebDriver
     module PageValidator
-      def web_driver_validate(page_class)
+      def web_driver_validate(page_class, validate_tags={})
         raise("Cannot find driver") if driver.nil?
         missing_elements=[]
-        validated_elements=[]
+        skipped_elements=[]
         puts "class #{page_class}"
         page_object=page_class.new(driver)
         raise "Could not find web driver elements in #{page_class}" if page_class.elements.nil?
         page_class.elements.each do |web_driver_element_name|
           puts "\tValidating #{web_driver_element_name}"
           begin
-            if page_object.send(web_driver_element_name).is_a? Selenium::WebDriver::Element
-              page_object.method(web_driver_element_name).call
-            else
-              raise unless page_object.send(web_driver_element_name).present?
-            end
+            element_obj = page_object.send(web_driver_element_name)
           rescue
             puts "\t\t\tCould not find #{web_driver_element_name}"
             missing_elements.push(web_driver_element_name)
           end
+          next unless element_obj.respond_to? :validate?
+          validate_element = case
+                               when validate_tags[:validate_any] && validate_tags[:validate_all]
+                                 raise "Can't use both :validate_any and :validate_all tags"
+                               when !element_obj.validate?
+                                 false # Already set to skip
+                               when validate_tags[:validate_any] && element_obj.tags
+                                 element_obj.tags.any? { |tag| validate_tags[:validate_any].include? tag }
+                               when validate_tags[:validate_all] && element_obj.tags
+                                 element_obj.tags.all? { |tag| validate_tags[:validate_all].include? tag }
+                               else
+                                 true
+                             end
+          if validate_element && !element_obj.present?
+            puts "\t\t\tCould not find #{web_driver_element_name}"
+            missing_elements.push(web_driver_element_name)
+          end
+          skipped_elements.push(web_driver_element_name) unless validate_element
         end
         if missing_elements.length > 0
           puts "Missing Elements:"
-          missing_elements.each do |element|
-            puts element
-          end
+          missing_elements.each { |element| puts "\t#{element}" }
+        end
+        if skipped_elements.length > 0
+          puts "Skipped Elements:"
+          skipped_elements.each { |element| puts "\t#{element}" }
         end
         raise "Found Missing Elements: #{missing_elements.inspect}" if missing_elements.length > 0
       end
+
+      def validate(page_class, validate_tags={})
+        web_driver_validate(page_class, validate_tags)
+      end
     end
   end
 end

data/lib/selenium_fury/version.rb

@@ -1,3 +1,3 @@
 module SeleniumFury
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

data/spec/selenium_web_driver/page_validator_spec.rb

@@ -1,18 +1,66 @@
 require 'spec_helper'
 describe SeleniumFury::SeleniumWebDriver::PageValidator do
 
-  it "should have a missing element exception" do
+  before(:each) do
+    launch_web_driver TEST_PAGE_URL
+  end
+
+  context "with present elements" do
+
+    it "should not raise an error when validating" do
+      expect { validate(TestPage) }.to_not raise_error
+    end
+  end
+
+  context "with missing elements" do
     class MissingElement < PageObject
       element :not_a_element1, {:id => "not a element1"}
       element :not_a_element2, {:id => "not a element2"}
+      generic_element :not_a_element3, {:id => "not a element3"}
+      generic_element :not_a_element4, {:id => "not a element4"}
     end
-    launch_web_driver TEST_PAGE_URL
-    expect { validate(MissingElement) }.to raise_exception RuntimeError, "Found Missing Elements: [:not_a_element1, :not_a_element2]"
-  end
 
-  it "should validate elements" do
-    launch_web_driver TEST_PAGE_URL
-    validate(TestPage)
+    it "should find missing elements for both old and new element types" do
+      expect { validate(MissingElement) }.
+          to raise_exception(RuntimeError, "Found Missing Elements: [:not_a_element1, :not_a_element2, :not_a_element3, :not_a_element4]")
+    end
   end
 
-end
+  context "with skipped elements" do
+    class SkippedElement < PageObject
+      generic_element :skip_hard_coded_element, {id: 'not_here'}, {validate: false}
+      generic_element :foo_element, {css: 'missing_foo_element'}, {tags: [:foo]}
+      generic_element :bar_element, {css: 'missing_bar_element'}, {tags: [:bar]}
+      generic_element :multiple_tag, {css: 'missing_mult_tag_element'}, {tags: [:foo, :bar]}
+      generic_element :no_tag, {css: 'missing_no_tag_element'}
+    end
+
+    it "should validate everything not hard coded when no tags are passed" do
+      expect { validate(SkippedElement) }.
+        to raise_exception(RuntimeError, "Found Missing Elements: [:foo_element, :bar_element, :multiple_tag, :no_tag]")
+    end
+
+    it "should validate all elements where all tags defined in the Page Object are passed in with the test" do
+      expect { validate(SkippedElement, validate_all: [:foo]) }.
+          to raise_exception(RuntimeError, "Found Missing Elements: [:foo_element, :no_tag]")
+      expect { validate(SkippedElement, validate_all: [:bar]) }.
+          to raise_exception(RuntimeError, "Found Missing Elements: [:bar_element, :no_tag]")
+      expect { validate(SkippedElement, validate_all: [:foo, :bar]) }.
+          to raise_exception(RuntimeError, "Found Missing Elements: [:foo_element, :bar_element, :multiple_tag, :no_tag]")
+    end
+
+    it "should validate all elements where any tag defined in Page Object is passed in with the test" do
+      expect { validate(SkippedElement, validate_any: [:foo]) }.
+          to raise_exception(RuntimeError, "Found Missing Elements: [:foo_element, :multiple_tag, :no_tag]")
+      expect { validate(SkippedElement, validate_any: [:bar]) }.
+          to raise_exception(RuntimeError, "Found Missing Elements: [:bar_element, :multiple_tag, :no_tag]")
+      expect { validate(SkippedElement, validate_any: [:foo, :bar]) }.
+          to raise_exception(RuntimeError, "Found Missing Elements: [:foo_element, :bar_element, :multiple_tag, :no_tag]")
+    end
+
+    it "should not allow multiple types of tag logic" do
+      expect { validate(SkippedElement, {validate_any: [:foo], validate_all: [:bar]}) }.
+          to raise_exception(RuntimeError, "Can't use both :validate_any and :validate_all tags")
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: selenium_fury
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-17 00:00:00.000000000 Z
+date: 2013-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: selenium-webdriver
@@ -130,7 +130,6 @@ files:
 - features/validate_page_object.feature
 - lib/selenium_fury.rb
 - lib/selenium_fury/common/page_parser.rb
-- lib/selenium_fury/common/selenium_api_chooser.rb
 - lib/selenium_fury/selenium_web_driver/create_selenium_web_driver.rb
 - lib/selenium_fury/selenium_web_driver/element_finder.rb
 - lib/selenium_fury/selenium_web_driver/generic_elements/generic_element.rb
@@ -142,7 +141,6 @@ files:
 - lib/selenium_fury/version.rb
 - selenium_fury.gemspec
 - spec/common/page_parser_spec.rb
-- spec/common/selenium_api_chooser_spec.rb
 - spec/selenium_web_driver/element_finder_spec.rb
 - spec/selenium_web_driver/generic_elements_spec.rb
 - spec/selenium_web_driver/page_generator_spec.rb
@@ -167,7 +165,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4010786722862812326
+      hash: 417938360726335985
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -176,7 +174,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4010786722862812326
+      hash: 417938360726335985
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25
@@ -191,7 +189,6 @@ test_files:
 - features/support/hooks.rb
 - features/validate_page_object.feature
 - spec/common/page_parser_spec.rb
-- spec/common/selenium_api_chooser_spec.rb
 - spec/selenium_web_driver/element_finder_spec.rb
 - spec/selenium_web_driver/generic_elements_spec.rb
 - spec/selenium_web_driver/page_generator_spec.rb

data/lib/selenium_fury/common/selenium_api_chooser.rb

@@ -1,42 +0,0 @@
-#/* 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 SeleniumApiChooser
-    def generate(selenium_api_object)
-      if selenium_api_object.class == Selenium::Client::Driver
-        return get_source_and_print_elements(selenium_api_object)
-      end
-      if selenium_api_object.class == Selenium::WebDriver::Driver
-        return web_driver_generate(selenium_api_object)
-      end
-    end
-
-    # @return [Array] validated page elements
-    # @param [PageObject] page_object
-    # @param [string] live_url
-    def validate(page_object, live_url = nil)
-      if defined?(browser)
-        unless browser.nil?
-          return check_page_file_class(page_object, *live_url)
-        end
-      end
-      unless driver.nil?
-        return web_driver_validate(page_object)
-      end
-    end
-
-  end
-end

data/spec/common/selenium_api_chooser_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-describe SeleniumFury::SeleniumApiChooser do
-  context "Finding generate/validate methods" do
-    it "should find the generator for selenium web_driver tests" do
-      launch_web_driver TEST_PAGE_URL
-      should_receive(:web_driver_generate)
-      generate(driver)
-    end
-    it "should find the validator for selenium web driver tests" do
-      launch_web_driver TEST_PAGE_URL
-      should_receive(:web_driver_validate).with(NilClass)
-      validate(NilClass)
-    end
-  end
-end