browsery 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3b97ab89ccad6c43965274d2c5efe2c4bb84aa3d
-  data.tar.gz: e1bdef1b837d8fc596d12f5e3f78f004c42e7f12
+  metadata.gz: 85407a347010a7b4f68d5ec210f81a1489cc5362
+  data.tar.gz: 65a5ea4757e1043921bb2b5de62de5266450f412
 SHA512:
-  metadata.gz: 51bf6b17cdc2618a43b89ee78b657b79b320e5fe2359a0978c92cd8cb9fe05221f9a7f130e2bf9072c5a7571b2a28277446801f6a594914c675e73320e6d7ba1
-  data.tar.gz: fe06da52aff275f304086bca76ac28858bc5e2fe79d9efdcf36c7ded0545b7a3e26f234467123127fdb8c1ae0eb6f517216ca87081bc2ea64a545ae6ff813795
+  metadata.gz: 8ea9d2d380ae17da3f9901d5f1799c4258a7c14904dd9c919a031b79d12143b2208c237c684456b3630aad58c729a25dc0e762ec62672d10e6b0a556b7f8357e
+  data.tar.gz: 7c9201d74f3d8d1acaa033f20316b1846c58f0bf9978164039555456b8bbee45b4751992701a3429517609bd996e47230a17c4087cdb956567a729fed53bf2a2

data/.ruby-version

@@ -0,0 +1 @@
+2.2.3

data/bin/browsery

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'browsery'
+
+Browsery::Runner.after_run { Browsery::Connector.finalize!(:force) }
+Browsery::Runner.run!(ARGV)

data/browsery.gemspec

@@ -17,6 +17,14 @@ Gem::Specification.new do |s|
   s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
   s.require_paths = ["lib"]
 
+  s.add_dependency 'activesupport', '~> 4.2'
+  s.add_dependency 'faker', '~> 1.4'
+  s.add_dependency 'minitap', '~> 0.5.3'
+  s.add_dependency 'pry', '~> 0.10'
+  s.add_dependency 'minitest', '~>5.4.0'
+  s.add_dependency 'selenium-webdriver', '~> 2.46'
+  s.add_dependency 'rest-client', '~> 1.8'
+
   s.add_development_dependency 'rake'
   s.add_development_dependency 'yard'
 end

data/lib/browsery.rb

@@ -0,0 +1,22 @@
+require 'bundler/setup'
+
+envs = [:default]
+
+Bundler.setup(*envs)
+require 'minitest'
+require 'yaml'
+require 'erb'
+require 'faker'
+require 'selenium/webdriver'
+require 'rest-client'
+require 'json'
+require 'cgi'
+require 'pathname'
+require 'active_support/logger'
+
+require_relative 'minitap/minitest5_browsery'
+require_relative 'selenium/webdriver/common/element_browsery'
+
+Time::DATE_FORMATS[:month_day_year] = "%m/%d/%Y"
+
+require_relative 'browsery/init'

data/lib/browsery/connector.rb

@@ -0,0 +1,287 @@
+module Browsery
+
+  # A connector provides a thin layer that combines configuration files and
+  # access to the WebDriver. It's a thin layer in that, other than #initialize,
+  # it is a drop-in replacement for WebDriver calls.
+  #
+  # For example, if you usually access a method as `@driver.find_element`, you
+  # can still access them as the same method under `@connector.find_element`.
+  class Connector
+
+    # Simple configuration container for all profiles. Struct is not used here
+    # because it contaminates the class with Enumerable methods, which will
+    # cause #method_missing in Connector to get confused.
+    class Config
+      attr_accessor :connector, :env
+
+      def ==(other)
+        self.class == other.class && self.connector == other.connector && self.env == other.env
+      end
+
+      alias_method :eql?, :==
+
+      # Hashing mechanism should only look at the connector and environment values
+      def hash
+        @connector.hash ^ @env.hash
+      end
+
+      # Initialize a new configuration object. This object should never be
+      # instantiated directly.
+      #
+      # @api private
+      def initialize(connector, env)
+        @connector = connector
+        @env = env
+      end
+
+    end
+
+    class <<self # :nodoc:
+      protected
+      attr_accessor :finalization_queue
+    end
+
+    self.finalization_queue = Queue.new
+
+    # Finalize connectors in the pool that are no longer used, and then clear
+    # the pool if it should be empty.
+    def self.finalize!(force = false)
+      return if Browsery.settings.reuse_driver? && !force
+
+      if Thread.current[:active_connector]
+        self.finalization_queue << Thread.current[:active_connector]
+        Thread.current[:active_connector] = nil
+      end
+
+      return unless Browsery.settings.auto_finalize?
+
+      while self.finalization_queue.size > 0
+        connector = self.finalization_queue.pop
+        begin
+          connector.finalize!
+        rescue => e
+          Browsery.logger.error("Could not finalize Connector(##{connector.object_id}): #{e.message}")
+        end
+      end
+    end
+
+    # Given a connector profile and an environment profile, this method will
+    # instantiate a connector object with the correct WebDriver instance and
+    # settings.
+    #
+    # @raise ArgumentError
+    # @param connector [#to_s] the name of the connector profile to use.
+    # @param env [#to_s] the name of the environment profile to use.
+    # @return [Connector] an initialized connector object
+    def self.get(connector_id, env_id)
+      # Ensure arguments are at least provided
+      raise ArgumentError, "A connector must be provided" if connector_id.blank?
+      raise ArgumentError, "An environment must be provided" if env_id.blank?
+
+      # Find the connector and environment profiles
+      connector_cfg = self.load(Browsery.root.join('config/browsery', 'connectors'), connector_id)
+      env_cfg = self.load(Browsery.root.join('config/browsery', 'environments'), env_id)
+      cfg = Config.new(connector_cfg, env_cfg)
+
+      if Thread.current[:active_connector] && !Browsery.settings.reuse_driver?
+        self.finalization_queue << Thread.current[:active_connector]
+        Thread.current[:active_connector] = nil
+      end
+
+      # If the current thread already has an active connector, and the connector
+      # is of the same type requested, reuse it after calling `reset!`
+      active_connector = Thread.current[:active_connector]
+      if active_connector.present?
+        if active_connector.config == cfg
+          active_connector.reset!
+        else
+          self.finalization_queue << active_connector
+          active_connector = nil
+        end
+      end
+
+      # Reuse or instantiate
+      Thread.current[:active_connector] = active_connector || Connector.new(cfg)
+    end
+
+    # Retrieve the default connector for the current environment.
+    #
+    # @raise ArgumentError
+    # @return [Connector] an initialized connector object
+    def self.get_default
+      connector = Browsery.settings.connector
+      env = Browsery.settings.env
+      Browsery.logger.debug("Retrieving connector with settings (#{connector}, #{env})")
+
+      # Get a connector instance and use it in the new page object
+      self.get(connector, env)
+    end
+
+    # Equivalent to @driver.browser
+    def self.browser_name
+      Thread.current[:active_connector].browser
+    end
+
+    # Load profile from a specific path using the selector(s) specified.
+    #
+    # @raise ArgumentError
+    # @param path [#to_path, #to_s] the path in which to find the profile
+    # @param selector [String] semicolon-delimited selector set
+    # @return [Hash] immutable configuration values
+    def self.load(path, selector)
+      overrides = selector.to_s.split(/:/)
+      name      = overrides.shift
+      filepath  = path.join("#{name}.yml")
+      raise ArgumentError, "Cannot load profile #{name.inspect} because #{filepath.inspect} does not exist" unless filepath.exist?
+
+      cfg = YAML.load(ERB.new(File.read(filepath)).result)
+      cfg = self.resolve(cfg, overrides)
+      cfg.freeze
+    end
+
+    # Resolve a set of profile overrides.
+    #
+    # @param cfg [Hash] the configuration structure optionally containing a
+    #   key of `:overrides`
+    # @param overrides [Enumerable<String>]
+    # @return [Hash] the resolved configuration
+    def self.resolve(cfg, overrides)
+      cfg = cfg.dup.with_indifferent_access
+
+      if options = cfg.delete(:overrides)
+        # Evaluate each override in turn, allowing each override to--well,
+        # override--anything coming before it
+        overrides.each do |override|
+          if tree = options[override]
+            cfg.deep_merge!(tree)
+          end
+        end
+      end
+
+      cfg
+    end
+
+    attr_reader :config
+
+    # Perform cleanup on the connector and driver.
+    def finalize!
+      @driver.quit
+      true
+    end
+
+    # Initialize a new connector with a set of configuration files.
+    #
+    # @see Connector.get
+    # @api private
+    def initialize(config)
+      @config = config
+
+      # Load and configure the WebDriver, if necessary
+      if concon = config.connector
+        driver_config = { }
+        driver = concon[:driver]
+        raise ArgumentError, "Connector driver must not be empty" if driver.nil?
+
+        # Handle hub-related options, like hub URLs (for remote execution)
+        if hub = concon[:hub]
+          builder = URI.parse(hub[:url])
+          builder.user     = hub[:user] if hub.has_key?(:user)
+          builder.password = hub[:pass] if hub.has_key?(:pass)
+
+          Browsery.logger.debug("Connector(##{self.object_id}): targeting remote #{builder.to_s}")
+          driver_config[:url] = builder.to_s
+        end
+
+        # Handle driver-related timeouts
+        if timeouts = concon[:timeouts]
+          client = Selenium::WebDriver::Remote::Http::Default.new
+          client.timeout = timeouts[:driver]
+          driver_config[:http_client] = client
+        end
+
+        # Handle archetypal capability lists
+        if archetype = concon[:archetype]
+          Browsery.logger.debug("Connector(##{self.object_id}): using #{archetype.inspect} as capabilities archetype")
+          caps = Selenium::WebDriver::Remote::Capabilities.send(archetype)
+          if caps_set = concon[:capabilities]
+            caps.merge!(caps_set)
+          end
+          driver_config[:desired_capabilities] = caps
+        end
+
+        # Load Firefox profile if specified - applicable only when using the firefoxdriver
+        if profile = concon[:profile]
+          driver_config[:profile] = profile
+        end
+
+        # Initialize the driver and declare explicit browser timeouts
+        Browsery.logger.debug("Connector(##{self.object_id}): using WebDriver(#{driver.inspect}, #{driver_config.inspect})")
+        @driver = Selenium::WebDriver.for(driver.to_sym, driver_config)
+
+        # Resize browser window for local browser with 'resolution'
+        if concon[:resolution]
+          width = concon[:resolution].split(/x/)[0].to_i
+          height = concon[:resolution].split(/x/)[1].to_i
+          @driver.manage.window.resize_to(width, height)
+        end
+
+        # setTimeout is undefined for safari driver so skip these steps for it
+        unless @driver.browser == :safari
+          if timeouts = concon[:timeouts]
+            @driver.manage.timeouts.implicit_wait  = timeouts[:implicit_wait]  if timeouts[:implicit_wait]
+            @driver.manage.timeouts.page_load      = timeouts[:page_load]      if timeouts[:page_load]
+            @driver.manage.timeouts.script_timeout = timeouts[:script_timeout] if timeouts[:script_timeout]
+          end
+        end
+      end
+    end
+
+    # Forward any other method call to the configuration container; if that
+    # fails, forward it to the WebDriver. The WebDriver will take care of any
+    # method resolution errors.
+    #
+    # @param name [#to_sym] symbol representing the method call
+    # @param args [*Object] arguments to be passed along
+    def method_missing(name, *args, &block)
+      if @config.respond_to?(name)
+        @config.send(name, *args, *block)
+      else
+        Browsery.logger.debug("Connector(##{self.object_id})->#{name}(#{args.map { |a| a.inspect }.join(', ')})")
+        @driver.send(name, *args, &block)
+      end
+    end
+
+    # Resets the current session by deleting all cookies and clearing all local
+    # and session storage. Local and session storage are only cleared if the
+    # underlying driver supports it, and even then, only if the storage
+    # supports atomic clearing.
+    #
+    # @return [Boolean]
+    def reset!
+      @driver.manage.delete_all_cookies
+      @driver.try(:local_storage).try(:clear)
+      @driver.try(:session_storage).try(:clear)
+      true
+    end
+
+    # Forward unhandled message checks to the configuration and driver.
+    #
+    # @param name [#to_sym]
+    # @return [Boolean]
+    def respond_to?(name)
+      super || @config.respond_to?(name) || @driver.respond_to?(name)
+    end
+
+    # Compose a URL from the provided +path+ and the environment profile. The
+    # latter contains things like the hostname, port, SSL settings.
+    #
+    # @param path [#to_s] the path to append after the root URL.
+    # @return [URI] the composed URL.
+    def url_for(path)
+      root = @config.env[:root]
+      raise ArgumentError, "The 'root' attribute is missing from the environment profile" unless root
+      URI.join(root, path)
+    end
+
+  end
+end

data/lib/browsery/console.rb

@@ -0,0 +1,15 @@
+module Browsery
+  class Console < TestCase
+
+    def self.bootstrap!
+      Browsery.settings.tags << [:__dummy__]
+    end
+
+    test :dummy, tags: [:__dummy__, :non_regression], serial: 'DUMMY' do
+      require 'pry'
+      assert_respond_to binding, :pry
+      binding.pry
+    end
+
+  end
+end

data/lib/browsery/init.rb

@@ -0,0 +1,60 @@
+# The base module for everything Browsery and is the container for other
+# modules and classes in the hierarchy:
+#
+# * `Connector` provides support for drivers and connector profiles;
+# * `PageObjects` provides a hierarchy of page objects, page modules, widgets,
+#   and overlays;
+# * `Settings` provides support for internal Browsery settings; and
+# * `Utils` provides an overarching module for miscellaneous helper modules.
+module Browsery
+
+  def self.logger
+    @@logger ||= Browsery::Logger.new($stdout)
+  end
+
+  def self.logger=(value)
+    @@logger = value
+  end
+
+  def self.settings
+    @@settings ||= Settings.new
+  end
+
+  def self.settings=(options)
+    self.settings.merge!(options)
+  end
+
+  # Root directory of the automation repository.
+  # Automation repo can use it to refer to files within itself,
+  # and this gem also uses it to refer to config files of automation,
+  # for example:
+  #
+  #   File.read(Browsery.root.join('config/browsery', 'data.yml'))
+  #
+  # will return the contents of `automation_root/config/browsery/data.yml`.
+  #
+  # @return [Pathname] A reference to the root directory, ready to be used
+  #         in directory and file path calculations.
+  def self.root
+    @@__root__ ||= Pathname.new(File.expand_path('.'))
+  end
+
+  # Absolute path of root directory of this gem
+  # can be used both within this gem and in automation repo
+  def self.gem_root
+    @@__gem_root__ ||= Pathname.new(File.realpath(File.join(File.dirname(__FILE__), '..', '..')))
+  end
+
+end
+
+require_relative 'runner'
+require_relative 'logger'
+require_relative 'utils'
+
+require_relative 'connector'
+require_relative 'page_objects'
+require_relative 'parallel'
+require_relative 'settings'
+
+require_relative 'test_case'
+require_relative 'console'

data/lib/browsery/logger.rb

@@ -0,0 +1,12 @@
+module Browsery
+  class Logger < ActiveSupport::Logger
+
+    LOG_FILE_MODE = File::WRONLY | File::APPEND | File::CREAT
+
+    def initialize(file, *args)
+      file = File.open(Browsery.root.join('logs', file), LOG_FILE_MODE) unless file.respond_to?(:write)
+      super(file, *args)
+    end
+
+  end
+end

data/lib/browsery/page_objects.rb

@@ -0,0 +1,23 @@
+module Browsery
+
+  # This is the overarching module that contains page objects, modules, and
+  # widgets.
+  #
+  # When new modules or classes are added, an `autoload` clause must be added
+  # into this module so that requires are taken care of automatically.
+  module PageObjects
+
+    # Exception to capture validation problems when instantiating a new page
+    # object. The message contains the page object being instantiated as well
+    # as the original, underlying error message if any.
+    class InvalidePageState < Exception; end
+
+  end
+
+end
+
+# Major classes and modules
+require_relative 'page_objects/element_container'
+require_relative 'page_objects/base'
+require_relative 'page_objects/overlay/base'
+require_relative 'page_objects/widgets/base'