browserstack-webdriver 0.0.1

data/spec/integration/selenium/webdriver/mouse_spec.rb

@@ -0,0 +1,57 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+module Selenium
+  module WebDriver
+    describe Mouse do
+
+      not_compliant_on :browser => [:android, :iphone, :safari] do
+        it "clicks an element" do
+          driver.navigate.to url_for("formPage.html")
+          driver.mouse.click driver.find_element(:id, "imageButton")
+        end
+
+        it "can drag and drop" do
+          driver.navigate.to url_for("droppableItems.html")
+
+          draggable = long_wait.until {
+            driver.find_element(:id => "draggable")
+          }
+
+          droppable = driver.find_element(:id => "droppable")
+
+          driver.mouse.down    draggable
+          driver.mouse.move_to droppable
+          driver.mouse.up      droppable
+
+          text = droppable.find_element(:tag_name => "p").text
+          text.should == "Dropped!"
+        end
+
+        it "double clicks an element" do
+          driver.navigate.to url_for("javascriptPage.html")
+          element = driver.find_element(:id, 'doubleClickField')
+
+          driver.mouse.double_click element
+
+          wait(5).until {
+            element.attribute(:value) == 'DoubleClicked'
+          }
+        end
+
+        not_compliant_on :browser => :phantomjs do
+          it "context clicks an element" do
+            driver.navigate.to url_for("javascriptPage.html")
+            element = driver.find_element(:id, 'doubleClickField')
+
+            driver.mouse.context_click element
+
+            wait(5).until {
+              element.attribute(:value) == 'ContextClicked'
+            }
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/integration/selenium/webdriver/navigation_spec.rb

@@ -0,0 +1,46 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+describe "Navigation" do
+  let(:wait) { Selenium::WebDriver::Wait.new :timeout => 10 }
+
+  not_compliant_on :browser => :safari do
+    it "should navigate back and forward" do
+      form_title   = "We Leave From Here"
+      result_title = "We Arrive Here"
+      form_url     = url_for "formPage.html"
+      result_url   = url_for "resultPage.html"
+
+      driver.navigate.to form_url
+      driver.title.should == form_title
+
+      driver.find_element(:id, 'imageButton').submit
+      wait.until { driver.title != form_title }
+
+      driver.current_url.should include(result_url)
+      driver.title.should == result_title
+
+      driver.navigate.back
+
+      driver.current_url.should include(form_url)
+      driver.title.should == form_title
+
+      driver.navigate.forward
+      driver.current_url.should include(result_url)
+      driver.title.should == result_title
+    end
+
+    it "should refresh the page" do
+      changed_title = "Changed"
+
+      driver.navigate.to url_for("javascriptPage.html")
+      driver.find_element(:link_text, "Change the page title!").click
+      driver.title.should == changed_title
+
+      driver.navigate.refresh
+      wait.until { driver.title != changed_title }
+
+      driver.title.should == "Testing Javascript"
+    end
+  end
+end
+

data/spec/integration/selenium/webdriver/opera/driver_spec.rb

@@ -0,0 +1,47 @@
+module Selenium
+  module WebDriver
+    module Opera
+
+      describe Driver do
+
+        before(:all) { GlobalTestEnv.quit_driver rescue nil }
+
+        it 'raises ArgumentError if sent an unknown capability as an argument' do
+          lambda {
+            Selenium::WebDriver.for :opera, :foo => 'bar'
+          }.should raise_error(ArgumentError)
+        end
+
+        it 'accepts an array of custom command-line arguments' do
+          begin
+            driver = Selenium::WebDriver.for :opera, :arguments => ['-geometry 800x600']
+          ensure
+            driver.quit if driver
+          end
+        end
+
+        it 'raises ArgumentError if :arguments is not an Array' do
+          lambda {
+            Selenium::WebDriver.for :opera, :arguments => '-foo'
+          }.should raise_error(ArgumentError)
+        end
+
+        it 'accepts a valid logging level' do
+          begin
+            driver = Selenium::WebDriver.for :opera, :logging_level => :config
+            # TODO(andreastt): Validate output to console
+          ensure
+            driver.quit if driver
+          end
+        end
+
+        it 'raises ArgumentError if :logging_level uses an invalid logging level' do
+          lambda {
+            Selenium::WebDriver.for :opera, :logging_level => :hoobaflooba
+          }.should raise_error(ArgumentError)
+        end
+      end
+
+    end
+  end
+end

data/spec/integration/selenium/webdriver/options_spec.rb

@@ -0,0 +1,77 @@
+require File.expand_path("../spec_helper", __FILE__)
+require 'pry'
+
+module Selenium
+  module WebDriver
+    describe Options do
+
+      describe 'logs' do
+        compliant_on :driver => [:firefox] do
+          it 'can fetch available log types' do
+            driver.manage.logs.available_types.should == [:browser, :driver]
+          end
+
+          it 'can get the browser log' do
+            driver.navigate.to url_for("simpleTest.html")
+
+            entries = driver.manage.logs.get(:browser)
+            entries.should_not be_empty
+            entries.first.should be_kind_of(LogEntry)
+          end
+
+          it 'can get the driver log' do
+            driver.navigate.to url_for("simpleTest.html")
+
+            entries = driver.manage.logs.get(:driver)
+            entries.should_not be_empty
+            entries.first.should be_kind_of(LogEntry)
+          end
+        end
+      end
+
+      describe "cookie management" do
+        it "should get all" do
+          driver.navigate.to url_for("xhtmlTest.html")
+          driver.manage.add_cookie :name => "foo", :value => "bar"
+
+          cookies = driver.manage.all_cookies
+
+          cookies.should have(1).things
+          cookies.first[:name].should == "foo"
+          cookies.first[:value].should == "bar"
+        end
+
+        it "should delete one" do
+          driver.navigate.to url_for("xhtmlTest.html")
+
+          driver.manage.add_cookie :name => "foo", :value => "bar"
+          driver.manage.delete_cookie("foo")
+        end
+
+        it "should delete all" do
+          driver.navigate.to url_for("xhtmlTest.html")
+
+          driver.manage.add_cookie :name => "foo", :value => "bar"
+          driver.manage.delete_all_cookies
+          driver.manage.all_cookies.should be_empty
+        end
+
+        not_compliant_on :browser => [:ie, :android, :iphone, :safari] do
+          it "should use DateTime for expires" do
+            driver.navigate.to url_for("xhtmlTest.html")
+
+            expected = DateTime.new(2039)
+            driver.manage.add_cookie :name => "foo",
+                                     :value   => "bar",
+                                     :expires => expected
+
+            actual = driver.manage.cookie_named("foo")[:expires]
+            actual.should be_kind_of(DateTime)
+            actual.should == expected
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/integration/selenium/webdriver/remote/driver_spec.rb

@@ -0,0 +1,19 @@
+module Selenium
+  module WebDriver
+    module Remote
+
+      describe Driver do
+        it "should expose session_id" do
+          driver.session_id.should be_kind_of(String)
+        end
+
+        it "should expose remote status" do
+          driver.should be_kind_of(DriverExtensions::HasRemoteStatus)
+          driver.remote_status.should be_kind_of(Hash)
+        end
+      end
+
+    end # Remote
+  end # WebDriver
+end # Selenium
+

data/spec/integration/selenium/webdriver/remote/element_spec.rb

@@ -0,0 +1,26 @@
+module Selenium
+  module WebDriver
+    describe Element do
+      before do
+        driver.file_detector = lambda { |str| __FILE__ }
+      end
+
+      after do
+        driver.file_detector = nil
+      end
+
+      not_compliant_on :browser => :phantomjs do
+        it "uses the file detector" do
+          driver.navigate.to url_for("upload.html")
+
+          driver.find_element(:id => "upload").send_keys("random string")
+          driver.find_element(:id => "go").submit
+
+          driver.switch_to.frame("upload_target")
+          body = driver.find_element(:xpath => "//body")
+          body.text.should include("uses the set file detector")
+        end
+      end
+    end
+  end # WebDriver
+end # Selenium

data/spec/integration/selenium/webdriver/spec_helper.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'time'
+require 'rspec'
+require 'ci/reporter/rspec'
+
+require 'selenium-webdriver'
+require 'selenium/webdriver/spec_support'
+
+include Selenium
+
+GlobalTestEnv = WebDriver::SpecSupport::TestEnvironment.new
+
+class Object
+  include WebDriver::SpecSupport::Guards
+end
+
+RSpec.configure do |c|
+  c.include(WebDriver::SpecSupport::Helpers)
+  c.before(:suite) do
+    if GlobalTestEnv.driver == :remote
+      GlobalTestEnv.remote_server.start
+    end
+  end
+
+  c.after(:suite) do
+    GlobalTestEnv.quit_driver
+  end
+
+  c.filter_run :focus => true if ENV['focus']
+end
+
+WebDriver::Platform.exit_hook { GlobalTestEnv.quit }
+
+$stdout.sync = true
+GlobalTestEnv.unguarded = !!ENV['noguards']
+WebDriver::SpecSupport::Guards.print_env

data/spec/integration/selenium/webdriver/spec_support.rb

@@ -0,0 +1,12 @@
+require 'selenium/server'
+require 'selenium/webdriver/spec_support/test_environment'
+require 'selenium/webdriver/spec_support/guards'
+require 'selenium/webdriver/spec_support/helpers'
+
+module Selenium
+  module WebDriver
+    module SpecSupport
+      autoload :RackServer, 'selenium/webdriver/spec_support/rack_server'
+    end
+  end
+end

data/spec/integration/selenium/webdriver/spec_support/guards.rb

@@ -0,0 +1,110 @@
+module Selenium
+  module WebDriver
+    module SpecSupport
+      module Guards
+
+        class << self
+          def print_env
+            puts "\nRunning Ruby specs:\n\n"
+
+            env = current_env.merge(:ruby => defined?(RUBY_DESCRIPTION) ? RUBY_DESCRIPTION : "ruby-#{RUBY_VERSION}")
+
+            just = current_env.keys.map { |e| e.to_s.size }.max
+            env.each do |key, value|
+              puts "#{key.to_s.rjust(just)}: #{value}"
+            end
+
+            puts "\n"
+          end
+
+          def guards
+            @guards ||= Hash.new { |hash, key| hash[key] = [] }
+          end
+
+          def record(guard_name, options, data)
+            options.each do |opts|
+              opts = current_env.merge(opts)
+              key = opts.values_at(*current_env.keys).join('.')
+              guards[key] << [guard_name, data]
+            end
+          end
+
+          def report
+            key = [
+              GlobalTestEnv.browser,
+              GlobalTestEnv.driver,
+              Platform.os,
+              GlobalTestEnv.native_events?
+            ].join(".")
+
+            gs = guards[key]
+
+            print "\n\nSpec guards for this implementation: "
+
+            if gs.empty?
+             puts "none."
+            else
+              puts
+              gs.each do |guard_name, data|
+                puts "\t#{guard_name.to_s.ljust(20)}: #{data.inspect}"
+              end
+            end
+          end
+
+          def current_env
+            {
+              :browser        => GlobalTestEnv.browser,
+              :driver         => GlobalTestEnv.driver,
+              :platform       => Platform.os,
+              :native         => GlobalTestEnv.native_events?,
+              :window_manager => !!ENV['DESKTOP_SESSION']
+            }
+          end
+
+          #
+          # not_compliant_on :browser => [:firefox, :chrome]
+          #   - guard this spec for both firefox and chrome
+          #
+          # not_compliant_on {:browser => :chrome, :platform => :macosx}, {:browser => :opera}
+          #   - guard this spec for Chrome on OSX and Opera on any OS
+
+          def env_matches?(opts)
+            res = opts.any? { |env|
+              env.all? { |key, value|
+                if value.kind_of?(Array)
+                  value.include? current_env[key]
+                else
+                  value == current_env[key]
+                end
+              }
+            }
+
+            p res => [opts, current_env] if @debug_guard
+            res
+          end
+        end
+
+        def debug_guard(&blk)
+          @debug_guard = true
+          yield
+        ensure
+          @debug_guard = false
+        end
+
+        def not_compliant_on(*opts, &blk)
+          Guards.record(:not_compliant, opts, :file => caller.first)
+          yield if GlobalTestEnv.unguarded? || !Guards.env_matches?(opts)
+        end
+
+        def compliant_on(*opts, &blk)
+          Guards.record(:compliant_on, opts, :file => caller.first)
+          yield if GlobalTestEnv.unguarded? || Guards.env_matches?(opts)
+        end
+
+        alias_method :not_compliant_when, :not_compliant_on
+        alias_method :compliant_when,     :compliant_on
+
+      end # Guards
+    end # SpecSupport
+  end # WebDriver
+end # Selenium

data/spec/integration/selenium/webdriver/spec_support/helpers.rb

@@ -0,0 +1,51 @@
+module Selenium
+  module WebDriver
+    module SpecSupport
+      module Helpers
+
+        def driver
+          GlobalTestEnv.driver_instance
+        end
+
+        def reset_driver!
+          GlobalTestEnv.reset_driver!
+        end
+
+        def url_for(filename)
+          GlobalTestEnv.url_for filename
+        end
+
+        def fix_windows_path(path)
+          return path unless WebDriver::Platform.os == :windows
+
+          if GlobalTestEnv.browser == :ie
+            path = path[%r[file://(.*)], 1]
+            path.gsub!("/", '\\')
+
+            "file://#{path}"
+          else
+            path.sub(%r[file:/{0,2}], "file:///")
+          end
+        end
+
+        def long_wait
+          @long_wait ||= Wait.new(:timeout => 30)
+        end
+
+        def short_wait
+          @short_wait ||= Wait.new(:timeout => 3)
+        end
+
+        def wait_for_alert
+          wait = Wait.new(:timeout => 5, :ignore => Error::NoAlertPresentError)
+          wait.until { driver.switch_to.alert }
+        end
+
+        def wait(timeout = 10)
+          Wait.new(:timeout => timeout)
+        end
+
+      end # Helpers
+    end # SpecSupport
+  end # WebDriver
+end # Selenium