mini_autobot 0.0.1

data/bin/mini_autobot

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

data/lib/mini_autobot.rb

@@ -0,0 +1,44 @@
+require 'bundler/setup'
+
+envs = [:default]
+envs << ENV['AUTOBOT_BUNDLE'].to_sym if ENV.key?('AUTOBOT_BUNDLE')
+envs << ENV['APPLICATION_ENV'].to_sym if ENV.key?('APPLICATION_ENV')
+
+Bundler.setup(*envs)
+require 'minitest'
+require 'yaml'
+require 'erb'
+require 'faker'
+require 'selenium/webdriver'
+require 'rest-client'
+
+require 'cgi'
+require 'pathname'
+
+require 'active_support/core_ext/date_time/conversions'
+require 'active_support/core_ext/hash'
+require 'active_support/core_ext/module/attr_internal'
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/numeric/time'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/object/conversions'
+require 'active_support/core_ext/object/try'
+require 'active_support/core_ext/object/with_options'
+require 'active_support/core_ext/string/access'
+require 'active_support/core_ext/string/conversions'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/string/starts_ends_with'
+require 'active_support/core_ext/string/strip'
+require 'active_support/inflector'
+require 'active_support/logger'
+
+require_relative 'minitap/minitest5_rent'
+
+ActiveSupport::Inflector.inflections(:en) do |inflector|
+  inflector.acronym 'PDP'
+  inflector.acronym 'SRP'
+end
+
+Time::DATE_FORMATS[:month_day_year] = "%m/%d/%Y"
+
+require_relative 'mini_autobot/init'

data/lib/mini_autobot/connector.rb

@@ -0,0 +1,288 @@
+module MiniAutobot
+
+  # 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 MiniAutobot.settings.reuse_driver? && !force
+
+      if Thread.current[:active_connector]
+        self.finalization_queue << Thread.current[:active_connector]
+        Thread.current[:active_connector] = nil
+      end
+
+      return unless MiniAutobot.settings.auto_finalize?
+
+      Thread.new do
+        while connector = self.finalization_queue.pop
+          begin
+            connector.finalize!
+          rescue => e
+            MiniAutobot.logger.error("Could not finalize Connector(##{connector.object_id}): #{e.message}")
+          end
+        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(MiniAutobot.root.join('config/mini_autobot', 'connectors'), connector_id)
+      env_cfg = self.load(MiniAutobot.root.join('config/mini_autobot', 'environments'), env_id)
+      cfg = Config.new(connector_cfg, env_cfg)
+
+      if Thread.current[:active_connector] && !MiniAutobot.settings.reuse_driver?
+        self.finalization_queue << 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 = MiniAutobot.settings.connector
+      env = MiniAutobot.settings.env
+      MiniAutobot.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)
+
+          MiniAutobot.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]
+          MiniAutobot.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
+        MiniAutobot.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
+        MiniAutobot.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/mini_autobot/console.rb

@@ -0,0 +1,15 @@
+module MiniAutobot
+  class Console < TestCase
+
+    def self.bootstrap!
+      MiniAutobot.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/mini_autobot/emails.rb

@@ -0,0 +1,5 @@
+module MiniAutobot
+  module Emails; end
+end
+
+require_relative 'emails/mailbox'

data/lib/mini_autobot/emails/mailbox.rb

@@ -0,0 +1,15 @@
+require 'net/imap'
+
+module MiniAutobot
+  module Emails
+
+    class Mailbox
+
+      def initialize(**opts)
+      end
+
+    end
+
+  end
+end
+

data/lib/mini_autobot/endeca/base.rb

@@ -0,0 +1,6 @@
+module MiniAutobot
+  module Endeca
+    class Base
+    end
+  end
+end

data/lib/mini_autobot/init.rb

@@ -0,0 +1,63 @@
+# The base module for everything MiniAutobot and is the container for other
+# modules and classes in the hierarchy:
+#
+# * `Connector` provides support for drivers and connector profiles;
+# * `Emails` introduces email-specific drivers for MiniAutobot;
+# * `PageObjects` provides a hierarchy of page objects, page modules, widgets,
+#   and overlays;
+# * `Settings` provides support for internal MiniAutobot settings; and
+# * `Utils` provides an overarching module for miscellaneous helper modules.
+module MiniAutobot
+
+  def self.logger
+    @@logger ||= MiniAutobot::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(MiniAutobot.root.join('config/mini_autobot', 'data.yml'))
+  #
+  # will return the contents of `automation_root/config/mini_autobot/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 'emails'
+
+require_relative 'test_case'
+require_relative 'console'