mediawiki_selenium 0.4.3 → 1.0.0.pre.1

data/lib/mediawiki_selenium/initializer.rb

@@ -0,0 +1,19 @@
+require "thor"
+
+module MediawikiSelenium
+  # Creates the directory structure and configuration for a brand new
+  # MediaWiki related test suite.
+  #
+  class Initializer < Thor
+    include Thor::Actions
+
+    def self.source_root
+      File.expand_path("../../../templates", __FILE__)
+    end
+
+    desc "install", "Creates tests/browser directory structure and default configuration"
+    def install
+      directory("tests")
+    end
+  end
+end

data/lib/mediawiki_selenium/page_factory.rb

@@ -0,0 +1,38 @@
+require "page-object"
+
+module MediawikiSelenium
+  # Handles on-demand browser instantiation and assignment of the `@browser`
+  # instance variable before delegating to `PageObject::PageFactory` methods.
+  #
+  module PageFactory
+    include ::PageObject::PageFactory
+
+    # Instantiates a new browser before delegating to
+    # `PageObject::PageFactory#on_page`. All page URLs are also qualified
+    # using {Environment#wiki_url}.
+    #
+    # @see http://www.rubydoc.info/github/cheezy/page-object
+    #
+    def on_page(page_class, params = { using_params: {} }, visit = false)
+      @browser = browser if visit
+
+      super(page_class, params, false).tap do |page|
+        if page.respond_to?(:goto)
+          wiki_url = method(:wiki_url)
+
+          page.define_singleton_method(:page_url_value) do
+            wiki_url.call(super())
+          end
+
+          page.goto if visit
+        end
+
+        yield page if block_given?
+      end
+    end
+
+    # @see #on_page
+    alias on on_page
+
+  end
+end

data/lib/mediawiki_selenium/remote_browser_factory.rb

@@ -0,0 +1,87 @@
+require "rest_client"
+require "uri"
+
+module MediawikiSelenium
+  # Constructs remote browser sessions to be run via Sauce Labs. Adds the
+  # following configuration bindings to the factory.
+  #
+  #  - sauce_ondemand_username
+  #  - sauce_ondemand_access_key
+  #  - platform
+  #  - version
+  #
+  module RemoteBrowserFactory
+    REQUIRED_CONFIG = [:sauce_ondemand_username, :sauce_ondemand_access_key]
+    URL = "http://ondemand.saucelabs.com/wd/hub"
+
+    class << self
+      def extend_object(factory)
+        return if factory.is_a?(self)
+
+        super
+
+        factory.bind(:sauce_ondemand_username, :sauce_ondemand_access_key) do |user, key, options|
+          options[:url] = URI.parse(URL)
+
+          options[:url].user = user
+          options[:url].password = key
+        end
+
+        factory.bind(:platform) do |platform, options|
+          options[:desired_capabilities].platform = platform
+        end
+
+        factory.bind(:version) do |version, options|
+          options[:desired_capabilities].version = version
+        end
+      end
+    end
+
+    # Submits status and Jenkins build info to Sauce Labs.
+    #
+    def teardown(env, status)
+      each do |browser|
+        sid = browser.driver.session_id
+        url = browser.driver.send(:bridge).http.send(:server_url)
+        username = url.user
+        key = url.password
+
+        RestClient::Request.execute(
+          method: :put,
+          url: "https://saucelabs.com/rest/v1/#{username}/jobs/#{sid}",
+          user: username,
+          password: key,
+          headers: { content_type: "application/json" },
+          payload: {
+            public: true,
+            passed: status == :passed,
+            build: env.lookup(:build_number, default: nil),
+          }.to_json
+        )
+      end
+    end
+
+    protected
+
+    def finalize_options!(options)
+      case @browser_name
+      when :firefox
+        options[:desired_capabilities][:firefox_profile] = options.delete(:profile)
+      when :chrome
+        options[:desired_capabilities]["chromeOptions"] ||= {}
+        options[:desired_capabilities]["chromeOptions"]["prefs"] = options.delete(:prefs)
+        options[:desired_capabilities]["chromeOptions"]["args"] = options.delete(:args)
+      end
+    end
+
+    def new_browser(options)
+      Watir::Browser.new(:remote, options).tap do |browser|
+        browser.driver.file_detector = lambda do |args|
+          # args => ["/path/to/file"]
+          str = args.first.to_s
+          str if File.exist?(str)
+        end
+      end
+    end
+  end
+end

data/lib/mediawiki_selenium/step_definitions.rb

@@ -0,0 +1,5 @@
+require "mediawiki_selenium/step_definitions/login_steps"
+require "mediawiki_selenium/step_definitions/navigation_steps"
+require "mediawiki_selenium/step_definitions/preferences_steps"
+require "mediawiki_selenium/step_definitions/resource_loader_steps"
+require "mediawiki_selenium/step_definitions/upload_file_steps"

data/lib/mediawiki_selenium/support.rb

@@ -0,0 +1,3 @@
+require "mediawiki_selenium/support/env"
+require "mediawiki_selenium/support/hooks"
+require "mediawiki_selenium/support/sauce"

data/lib/mediawiki_selenium/support/env.rb

@@ -11,138 +11,14 @@ https://git.wikimedia.org/blob/mediawiki%2Fselenium/HEAD/CREDITS.
 
 # before all
 require "bundler/setup"
-require "page-object"
 require "page-object/page_factory"
-require "rest_client"
 require "watir-webdriver"
 
 require "mediawiki_selenium/support/modules/api_helper"
-require "mediawiki_selenium/support/modules/sauce_helper"
 require "mediawiki_selenium/support/modules/strict_pending"
 
-World(PageObject::PageFactory)
+World { MediawikiSelenium::Environment.load_default }
+
 World(MediawikiSelenium::ApiHelper)
-World(MediawikiSelenium::SauceHelper)
+World(MediawikiSelenium::PageFactory)
 World(MediawikiSelenium::StrictPending)
-
-def browser(test_name, configuration = nil)
-  if environment == :saucelabs
-    sauce_browser(test_name, configuration)
-  else
-    local_browser(configuration)
-  end
-end
-def browser_name
-  if ENV["BROWSER"]
-    ENV["BROWSER"].to_sym
-  else
-    :firefox
-  end
-end
-def environment
-  if ENV["SAUCE_ONDEMAND_USERNAME"] and ENV["SAUCE_ONDEMAND_ACCESS_KEY"] and ENV["BROWSER"] != "phantomjs" and ENV["HEADLESS"] != "true"
-    :saucelabs
-  else
-    :local
-  end
-end
-def local_browser(configuration)
-  if ENV["BROWSER_TIMEOUT"] && browser_name == :firefox
-    timeout = ENV["BROWSER_TIMEOUT"].to_i
-
-    client = Selenium::WebDriver::Remote::Http::Default.new
-    client.timeout = timeout
-
-    profile = Selenium::WebDriver::Firefox::Profile.new
-    profile["dom.max_script_run_time"] = timeout
-    profile["dom.max_chrome_script_run_time"] = timeout
-    browser = Watir::Browser.new browser_name, :http_client => client, :profile => profile
-  elsif configuration && configuration[:language] && browser_name == :firefox
-    profile = Selenium::WebDriver::Firefox::Profile.new
-    profile["intl.accept_languages"] = configuration[:language]
-    browser = Watir::Browser.new browser_name, profile: profile
-  elsif configuration && configuration[:language] && browser_name == :chrome
-    prefs = {intl: {accept_languages: configuration[:language]}}
-    browser = Watir::Browser.new browser_name, prefs: prefs
-  elsif configuration && configuration[:language] && browser_name == :phantomjs
-    capabilities = Selenium::WebDriver::Remote::Capabilities.phantomjs
-    capabilities["phantomjs.page.customHeaders.Accept-Language"] = configuration[:language]
-    browser = Watir::Browser.new browser_name, desired_capabilities: capabilities
-  elsif configuration && configuration[:user_agent] && browser_name == :firefox
-    profile = Selenium::WebDriver::Firefox::Profile.new
-    profile["general.useragent.override"] = configuration[:user_agent]
-    browser = Watir::Browser.new browser_name, profile: profile
-  else
-    browser = Watir::Browser.new browser_name
-  end
-
-  browser.window.resize_to 1280, 1024
-  set_cookie(browser)
-  browser
-end
-def sauce_api(json, session_id)
-RestClient::Request.execute(
-  :method => :put,
-  :url => "https://saucelabs.com/rest/v1/#{ENV['SAUCE_ONDEMAND_USERNAME']}/jobs/#{session_id}",
-  :user => ENV["SAUCE_ONDEMAND_USERNAME"],
-  :password => ENV["SAUCE_ONDEMAND_ACCESS_KEY"],
-  :headers => {:content_type => "application/json"},
-  :payload => json
-)
-end
-def sauce_browser(test_name, configuration)
-  abort "Environment variables BROWSER, PLATFORM and VERSION have to be set" if (ENV["BROWSER"] == nil) or (ENV["PLATFORM"] == nil) or (ENV["VERSION"] == nil)
-
-  client = Selenium::WebDriver::Remote::Http::Default.new
-
-  if ENV["BROWSER_TIMEOUT"] && ENV["BROWSER"] == "firefox"
-    timeout = ENV["BROWSER_TIMEOUT"].to_i
-    client.timeout = timeout
-
-    profile = Selenium::WebDriver::Firefox::Profile.new
-    profile["dom.max_script_run_time"] = timeout
-    profile["dom.max_chrome_script_run_time"] = timeout
-    caps = Selenium::WebDriver::Remote::Capabilities.firefox(:firefox_profile => profile)
-  elsif configuration && configuration[:language] && ENV["BROWSER"] == "firefox"
-    profile = Selenium::WebDriver::Firefox::Profile.new
-    profile["intl.accept_languages"] = configuration[:language]
-    caps = Selenium::WebDriver::Remote::Capabilities.firefox(:firefox_profile => profile)
-  elsif configuration && configuration[:language] && ENV["BROWSER"] == "chrome"
-    profile = Selenium::WebDriver::Chrome::Profile.new
-    profile["intl.accept_languages"] = configuration[:language]
-    caps = Selenium::WebDriver::Remote::Capabilities.chrome("chrome.profile" => profile.as_json["zip"])
-  elsif configuration && configuration[:user_agent] && ENV["BROWSER"] == "firefox"
-    profile = Selenium::WebDriver::Firefox::Profile.new
-    profile["general.useragent.override"] = configuration[:user_agent]
-    caps = Selenium::WebDriver::Remote::Capabilities.firefox(:firefox_profile => profile)
-  else
-    caps = Selenium::WebDriver::Remote::Capabilities.send(ENV["BROWSER"])
-  end
-
-  caps.platform = ENV["PLATFORM"]
-  caps.version = ENV["VERSION"]
-  caps[:name] = "#{test_name} #{ENV['JOB_NAME']}##{ENV['BUILD_NUMBER']}"
-
-  browser = Watir::Browser.new(
-    :remote,
-    http_client: client,
-    url: "http://#{ENV['SAUCE_ONDEMAND_USERNAME']}:#{ENV['SAUCE_ONDEMAND_ACCESS_KEY']}@ondemand.saucelabs.com:80/wd/hub",
-    desired_capabilities: caps)
-  browser.wd.file_detector = lambda do |args|
-    # args => ["/path/to/file"]
-    str = args.first.to_s
-    str if File.exist?(str)
-  end
-
-  browser
-end
-def set_cookie(browser)
-  # implement this method in env.rb of the repository where it is needed
-end
-def test_name(scenario)
-  if scenario.respond_to? :feature
-    "#{scenario.feature.title}: #{scenario.title}"
-  elsif scenario.respond_to? :scenario_outline
-    "#{scenario.scenario_outline.feature.title}: #{scenario.scenario_outline.title}: #{scenario.name}"
-  end
-end

data/lib/mediawiki_selenium/support/hooks.rb

@@ -13,12 +13,6 @@ Before("@custom-browser") do |scenario|
   @scenario = scenario
 end
 
-Before("@login") do
-  ENV["MEDIAWIKI_PASSWORD"] = ENV[ENV["MEDIAWIKI_PASSWORD_VARIABLE"]] if ENV["MEDIAWIKI_PASSWORD_VARIABLE"]
-  puts "MEDIAWIKI_USER environment variable is not defined! Please export a value for that variable before proceeding." unless ENV["MEDIAWIKI_USER"]
-  puts "MEDIAWIKI_PASSWORD environment variable is not defined! Please export a value for that variable before proceeding." unless ENV["MEDIAWIKI_PASSWORD"]
-end
-
 AfterConfiguration do |config|
   # Install a formatter that can be used to show feature-related warnings
   pretty_format, io = config.formats.find { |(format, io)| format == "pretty" }
@@ -68,44 +62,39 @@ Before do |scenario|
 end
 
 Before do |scenario|
+  # Create a unique random string for this scenario
   @random_string = Random.new.rand.to_s
 
-  # CirrusSearch and VisualEditor need this
-  if ENV["REUSE_BROWSER"] == "true" && $browser
-    @browser = $browser
-  elsif scenario.source_tag_names.include? "@custom-browser"
-    # browser will be started in Cucumber step
-  else
-    @browser = browser(test_name(scenario))
-    $browser = @browser # CirrusSearch and VisualEditor need this
+  # Annotate sessions with the scenario name and Jenkins build info
+  browser_factory.bind do |options|
+    options[:desired_capabilities][:name] = test_name(scenario)
   end
 
-  $session_id = sauce_session_id
+  browser_factory.bind(:job_name) do |job, options|
+    options[:desired_capabilities][:name] += " #{job}"
+  end
+
+  browser_factory.bind(:build_number) do |build, options|
+    options[:desired_capabilities][:name] += "##{build}"
+  end
 end
 
 After do |scenario|
-  if @browser && scenario.failed? && (ENV["SCREENSHOT_FAILURES"] == "true")
+  if scenario.respond_to?(:status)
     require "fileutils"
-    screen_dir = ENV["SCREENSHOT_FAILURES_PATH"] || "screenshots"
-    FileUtils.mkdir_p screen_dir
-    name = test_name(scenario).gsub(/ /, '_')
-    path = "#{screen_dir}/#{name}.png"
-    @browser.screenshot.save path
-    embed path, "image/png"
-  end
 
-  if environment == :saucelabs
-    sid = $session_id || sauce_session_id
+    teardown(scenario.status) do |browser|
+      if scenario.failed? && lookup(:screenshot_failures, default: false) == "true"
+        screen_dir = lookup(:screenshot_failures_path, default: "screenshots")
+        FileUtils.mkdir_p screen_dir
+        name = test_name(scenario).gsub(/ /, '_')
+        path = "#{screen_dir}/#{name}.png"
+        browser.screenshot.save path
+        embed path, "image/png"
+      end
 
-    unless sid.nil?
-      sauce_api(%Q{{"passed": #{scenario.passed?}}}, sid)
-      sauce_api(%Q{{"public": true}}, sid)
-      sauce_api(%Q{{"build": #{ENV["BUILD_NUMBER"]}}}, sid) if ENV["BUILD_NUMBER"]
     end
-  end
-
-  if @browser
-    # CirrusSearch and VisualEditor need this
-    @browser.close unless ENV["KEEP_BROWSER_OPEN"] == "true" || ENV["REUSE_BROWSER"] == "true"
+  else
+    teardown
   end
 end

data/lib/mediawiki_selenium/support/modules/api_helper.rb

@@ -5,16 +5,55 @@ module MediawikiSelenium
   # definitions.
   #
   module ApiHelper
-    # A pre-authenticated API client.
+    # An authenticated MediaWiki API client.
     #
     # @return [MediawikiApi::Client]
     #
     def api
-      return @api if defined?(@api)
+      @_api_cache ||= {}
 
-      @api = MediawikiApi::Client.new(ENV["MEDIAWIKI_API_URL"])
-      @api.log_in(*ENV.values_at("MEDIAWIKI_USER", "MEDIAWIKI_PASSWORD")) unless @api.logged_in?
-      @api
+      url = lookup(:mediawiki_api_url, default: api_url_from(lookup(:mediawiki_url)))
+
+      @_api_cache[[url, user]] ||= MediawikiApi::Client.new(url).tap do |client|
+        client.log_in(user, password)
+      end
+    end
+
+    # Ensures the given alternative account exists by attempting to create it
+    # via the API.  Any errors related to the account already existing are
+    # swallowed.
+    #
+    # @param id [Symbol] ID of alternative user.
+    #
+    def ensure_account(id)
+      begin
+        api.create_account(user(id), password(id))
+      rescue MediawikiApi::ApiError => e
+        raise e unless e.code == "userexists"
+      end
+    end
+
+    # Extends parent implementation to also override the API URL. If no API
+    # URL is explicitly defined for the given alternative, one is constructed
+    # relative to the wiki URL.
+    #
+    # @yield [wiki_url, api_url]
+    # @yieldparam wiki_url [String] Alternative wiki URL.
+    # @yieldparam api_url [String] Alternative API URL.
+    #
+    # @see Environment#on_wiki
+    #
+    def on_wiki(id, &blk)
+      super(id) do |wiki_url|
+        api_url = lookup(:mediawiki_api_url, id: id, default: -> { api_url_from(wiki_url) })
+        return with(mediawiki_url: wiki_url, mediawiki_api_url: api_url, &blk)
+      end
+    end
+
+    private
+
+    def api_url_from(wiki_url)
+      URI.parse(wiki_url).merge("/w/api.php").to_s
     end
   end
 end

data/lib/mediawiki_selenium/support/pages.rb

@@ -0,0 +1,4 @@
+require "mediawiki_selenium/support/pages/api_page"
+require "mediawiki_selenium/support/pages/login_page"
+require "mediawiki_selenium/support/pages/random_page"
+require "mediawiki_selenium/support/pages/reset_preferences_page"