mini_autobot 0.0.1

data/lib/mini_autobot/logger.rb

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

data/lib/mini_autobot/page_objects.rb

@@ -0,0 +1,22 @@
+module MiniAutobot
+
+  # 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/base'
+require_relative 'page_objects/overlay/base'
+require_relative 'page_objects/widgets/base'

data/lib/mini_autobot/page_objects/base.rb

@@ -0,0 +1,264 @@
+require 'minitest/assertions'
+
+module MiniAutobot
+  module PageObjects
+
+    # The base page object. All page objects should be a subclass of this.
+    # Every subclass must implement the following class methods:
+    #
+    #   expected_path
+    #
+    # All methods added here will be available to all subclasses, so do so
+    # sparingly.  This class has access to assertions, which should only be
+    # used to validate the page.
+    class Base
+      include Minitest::Assertions
+      include Utils::Castable
+      include Utils::Loggable
+      include Utils::PageObjectHelper
+      include Utils::OverlayAndWidgetHelper
+
+      attr_accessor :assertions
+      attr_accessor :failures
+      attr_reader :driver
+
+      # Given a set of arguments (no arguments by default), return the expected
+      # path to the page, which must only have file path and query-string.
+      #
+      # @param args [String] one or more arguments to be used in calculating
+      #   the expected path, if any.
+      # @return [String] the expected path.
+      def self.expected_path(*args)
+        raise NotImplementedError, "expected_path is not defined for #{self}"
+      end
+
+      # Initializes a new page object from the driver. When a page is initialized,
+      # no validation occurs. As such, do not call this method directly. Rather,
+      # use PageObjectHelper#page in a test case, or #cast in another page object.
+      #
+      # @param driver [Selenium::WebDriver] The WebDriver instance.
+      def initialize(driver)
+        @driver = driver
+
+        @assertions = 0
+        @failures   = []
+      end
+
+      # Returns the current path loaded in the driver.
+      #
+      # @return [String] The current path, without hostname.
+      def current_path
+        current_url.path
+      end
+
+      # Returns the current URL loaded in the driver.
+      #
+      # @return [String] The current URL, including hostname.
+      def current_url
+        URI.parse(driver.current_url)
+      end
+
+      ## interface for Overlay And Widget Helper version of get_widgets! and get_overlay!
+      def page_object
+        self
+      end
+
+      # Instructs the driver to visit the {expected_path}.
+      #
+      # @param args [*Object] optional parameters to pass into {expected_path}.
+      def go!(*args)
+        driver.get(driver.url_for(self.class.expected_path(*args)))
+      end
+
+      # Check that the page includes a certain string.
+      #
+      # @param value [String] the string to search
+      # @return [Boolean]
+      def include?(value)
+        driver.page_source.include?(value)
+      end
+
+      # Retrieves all META tags with a `name` attribute on the current page.
+      def meta
+        tags = driver.all(:css, 'meta[name]')
+        tags.inject(Hash.new) do |vals, tag|
+          vals[tag.attribute(:name)] = tag.attribute(:content) if tag.attribute(:name)
+          vals
+        end
+      end
+
+      def headline
+        driver.find_element(:css, 'body div.site-content h1').text
+      end
+
+      # Get page title from any page
+      def title
+        driver.title
+      end
+
+      # By default, any driver state is accepted for any page. This method
+      # should be overridden in subclasses.
+      def validate!
+        true
+      end
+
+      # Wait for all dom events to load
+      def wait_for_dom(timeout = 15)
+        uuid = SecureRandom.uuid
+        # make sure body is loaded before appending anything to it
+        wait(timeout: timeout, msg: "Timeout after waiting #{timeout} for body to load").until do
+          is_element_present?(:css, 'body')
+        end
+        driver.execute_script <<-EOS
+            _.defer(function() {
+            $('body').append("<div id='#{uuid}'></div>");
+            });
+        EOS
+        wait(timeout: timeout, msg: "Timeout after waiting #{timeout} for all dom events to finish").until do
+          is_element_present?(:css, "div[id='#{uuid}']")
+        end
+      end
+
+      # Wait on all AJAX requests to finish
+      def wait_for_ajax(timeout = 15)
+        wait(timeout: timeout, msg: "Timeout after waiting #{timeout} for all ajax requests to finish").until do
+          driver.execute_script 'return window.jQuery != undefined && jQuery.active == 0'
+        end
+      end
+
+      # Explicitly wait for a certain condition to be true:
+      #   wait.until { driver.find_element(:css, 'body.tmpl-srp') }
+      # when timeout is not specified, default timeout 5 sec will be used
+      # when timeout is larger than 15, max timeout 15 sec will be used
+      def wait(opts = {})
+        if !opts[:timeout].nil? && opts[:timeout] > 15
+          puts "WARNING: #{opts[:timeout]} sec timeout is NOT supported by wait method,
+                max timeout 15 sec will be used instead"
+          opts[:timeout] = 15
+        end
+        Selenium::WebDriver::Wait.new(opts)
+      end
+
+      # Wrap blocks acting on Selenium elements and catch errors they
+      # raise. This probably qualifies as a Dumb LISPer Trick. If there's a
+      # better Ruby-ish way to do this, I welcome it. [~jacord]
+      def with_rescue(lbl, &blk)
+        yield ## run the block
+        ## rescue errors. Rerunning may help, but we can also test for specific
+        ## problems.
+      rescue Selenium::WebDriver::Error::ElementNotVisibleError => e
+        ## The element is in the DOM but e.visible? is 'false'. Retry may help.
+        logger.debug "Retrying #{lbl}: #{e.class}"
+        yield
+      rescue Selenium::WebDriver::Error::StaleElementReferenceError => e
+        ## The page has changed and invalidated your element. Retry may help.
+        logger.debug "Retrying #{lbl}: #{e.class}"
+        yield
+      rescue Selenium::WebDriver::Error::NoSuchElementError => e
+        ## Raised by get_element(s). Retry MAY help, but check first for HTTP
+        ## 500, which may be best handled higher up the stack.
+        logger.debug "Recovering from NoSuchElementError during #{lbl}"
+        raise_on_error_page
+        ## If we got past the above, retry the block.
+        logger.debug "Retrying #{lbl}: #{e.class}"
+        yield
+      end
+
+      ## Wrap an action, wait for page title change. This function eliminates
+      ## some error-prone boilerplate around fetching page titles
+      def with_page_title_wait(&blk)
+        title = driver.title
+        yield
+        wait_for_title_change(title)
+      end
+
+      # returns the all the page source of a page, useful for debugging
+      #
+      def page_source
+        driver.page_source
+      end
+
+      ## PageObject validate! helper. Raises RuntimeError if one of our error
+      ## pages is displaying. This can prevent a test from taking the entire
+      ## implicit_wait before announcing error. [~jacord]
+      def raise_on_error_page
+        logger.debug "raise_on_error_page"
+        title = ''
+        begin
+          title = driver.title
+        rescue ReadTimeout
+          logger.debug 'ReadTimeout exception was thrown while trying to execute driver.title'
+          logger.debug 'ignore exception and proceed'
+        end
+        title = driver.title
+        logger.debug "Page Title: '#{title}'"
+        raise "HTTP 500 Error" if %r/Internal Server Error/ =~ title
+        raise "HTTP 503 Error" if %r/503 Service Temporarily Unavailable/ =~ title
+        raise "HTTP 404 Error" if %r/Error 404: Page Not Found/ =~ title
+
+        header = driver.find_element('body h1') rescue nil
+
+        unless header.nil?
+          raise "HTTP 500 Error" if header.text == 'Internal Server Error'
+        end
+
+      end
+
+      # click on a link on any page, cast a new page and return it
+      def click_on_link!(link_text, page_name)
+        driver.find_element(:link, link_text).location_once_scrolled_into_view
+        driver.find_element(:link, link_text).click
+        # check user angent, if it's on IE, wait 2sec for the title change
+        sleep 2 if driver.browser == :ie # todo remove this if every page has wait for title change in validate!
+        #sleep 5 #wait for 5 secs
+        logger.debug "click_on_link '#{link_text}'"
+        cast(page_name)
+      end
+
+      def wait_for_title_change(title)
+        title = driver.title if title.nil?
+        logger.debug("Waiting for title change from '#{title}'")
+        wait(timeout: 15, message: "Waited 15 sec for page transition")
+          .until { driver.title != title }
+        logger.debug("Arrived at #{driver.title}")
+      end
+
+      def wait_for_link(link_text)
+        message = "waited 15 sec, can't find link #{link_text} on page"
+        wait(timeout: 15, message: message).until{ driver.find_element(:link, link_text) }
+
+        unless driver.find_element(:link, link_text).displayed?
+          driver.navigate.refresh
+        end
+      end
+
+      # example usage:
+      # original_url = driver.current_url
+      # driver.find_element(*LINK_REGISTER).click # do some action that should cause url to change
+      # wait_for_url_change(original_url)
+      def wait_for_url_change(original_url)
+        time = 15
+        message = "waited #{time} sec, url is still #{original_url}, was expecting it to change"
+        wait(timeout: time, message: message).until { driver.current_url != original_url }
+      end
+
+      def go_to_page!(url, page_type = :base)
+        driver.navigate.to(url)
+        cast(page_type)
+      end
+
+      def go_to_subpage!(url_path, page_type = :base)
+        # build url string
+        base_url = driver.current_url
+
+        # This is to safeguard ie, but we should handle this more intelligently in the future
+        base_url.slice!('qateam:wap88@')
+
+        url = base_url + url_path
+        driver.navigate.to(url)
+        cast(page_type)
+      end
+
+    end
+  end
+end

data/lib/mini_autobot/page_objects/overlay/base.rb

@@ -0,0 +1,76 @@
+module MiniAutobot
+  module PageObjects
+    module Overlay
+
+      # A Overlay represents a portion (an element) of a page that is repeated
+      # or reproduced multiple times, either on the same page, or across multiple
+      # page objects or page modules.
+      class Base
+        include Utils::Castable
+        include Utils::PageObjectHelper
+        include Utils::OverlayAndWidgetHelper
+
+        attr_reader :driver
+
+        def initialize(page)
+          @driver = page.driver
+          @page = page
+
+          # works here but not in initialize of base of page objects
+          # because a page instance is already present when opening an overlay
+        end
+
+        ## for overlay that include Utils::OverlayAndWidgetHelper
+        def page_object
+          @page
+        end
+
+        # By default, any driver state is accepted for any page. This method
+        # should be overridden in subclasses.
+        def validate!
+          true
+        end
+
+        # Wait for all dom events to load
+        def wait_for_dom(timeout = 15)
+          uuid = SecureRandom.uuid
+          # make sure body is loaded before appending anything to it
+          wait(timeout: timeout, msg: "Timeout after waiting #{timeout} for body to load").until do
+            is_element_present?(:css, 'body')
+          end
+          driver.execute_script <<-EOS
+            _.defer(function() {
+            $('body').append("<div id='#{uuid}'></div>");
+            });
+          EOS
+          wait(timeout: timeout, msg: "Timeout after waiting #{timeout} for all dom events to finish").until do
+            is_element_present?(:css, "div[id='#{uuid}']")
+          end
+        end
+
+        # Wait on all AJAX requests to finish
+        def wait_for_ajax(timeout = 15)
+          wait(timeout: timeout, msg: "Timeout after waiting #{timeout} for all ajax requests to finish").until do
+            driver.execute_script 'return window.jQuery != undefined && jQuery.active == 0'
+          end
+        end
+
+        # Explicitly wait for a certain condition to be true:
+        #   wait.until { driver.find_element(:css, 'body.tmpl-srp') }
+        # when timeout is not specified, default timeout 5 sec will be used
+        # when timeout is larger than 15, max timeout 15 sec will be used
+        def wait(opts = {})
+          if !opts[:timeout].nil? && opts[:timeout] > 15
+            puts "WARNING: #{opts[:timeout]} sec timeout is NOT supported by wait method,
+                max timeout 15 sec will be used instead"
+            opts[:timeout] = 15
+          end
+          Selenium::WebDriver::Wait.new(opts)
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/mini_autobot/page_objects/widgets/base.rb

@@ -0,0 +1,47 @@
+module MiniAutobot
+  module PageObjects
+    module Widgets
+
+      # A widget represents a portion (an element) of a page that is repeated
+      # or reproduced multiple times, either on the same page, or across multiple
+      # page objects or page modules.
+      class Base
+        include Utils::Castable
+        include Utils::PageObjectHelper
+        include Utils::OverlayAndWidgetHelper
+
+        attr_reader :driver, :element, :page
+
+        def initialize(page, element)
+          @driver = page.driver
+          @page = page
+          @element = element
+        end
+
+        ## for widgets that include Utils::OverlayAndWidgetHelper
+        def page_object
+          @page
+        end
+
+        attr_reader :driver
+        attr_reader :element
+
+        # Explicitly wait for a certain condition to be true:
+        #   wait.until { driver.find_element(:css, 'body.tmpl-srp') }
+        # when timeout is not specified, default timeout 5 sec will be used
+        # when timeout is larger than 15, max timeout 15 sec will be used
+        def wait(opts = {})
+          if !opts[:timeout].nil? && opts[:timeout] > 15
+            puts "WARNING: #{opts[:timeout]} sec timeout is NOT supported by wait method,
+                max timeout 15 sec will be used instead"
+            opts[:timeout] = 15
+          end
+          Selenium::WebDriver::Wait.new(opts)
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/mini_autobot/parallel.rb

@@ -0,0 +1,197 @@
+module MiniAutobot
+  class Parallel
+
+    attr_reader :all_tests, :simultaneous_jobs
+
+    def initialize(simultaneous_jobs, all_tests)
+      @start_time = Time.now
+      clean_result!
+
+      @simultaneous_jobs = simultaneous_jobs
+      @all_tests = all_tests
+
+      connector = MiniAutobot.settings.connector
+      @on_sauce = true if connector.include? 'saucelabs'
+      @platform = connector.split(':')[2] || ''
+
+      @pids = []
+      @static_run_command = "mini_autobot -c #{MiniAutobot.settings.connector} -e #{MiniAutobot.settings.env}"
+      tap_reporter_path = MiniAutobot.gem_root.join('lib/tapout/custom_reporters/fancy_tap_reporter.rb')
+      @pipe_tap = "--tapy | tapout --no-color -r #{tap_reporter_path.to_s} fancytap"
+    end
+
+    # return true only if specified to run on mac in connector
+    # @return [boolean]
+    def run_on_mac?
+      return true if @platform.include?('osx')
+      return false
+    end
+
+    # remove all results files under logs/tap_results/
+    def clean_result!
+      IO.popen 'rm logs/tap_results/*'
+      puts "Cleaning result files.\n"
+    end
+
+    def count_autobot_process
+      counting_process = IO.popen "ps -ef | grep '#{@static_run_command}' -c"
+      count_of_processes = counting_process.readlines[0].to_i
+      count_of_processes
+    end
+
+    # run multiple commands with logging to start multiple tests in parallel
+    # @param [Integer, Array]
+    # n = number of tests will be running in parallel
+    def run_in_parallel!
+      # set number of tests to be running in parallel
+      if simultaneous_jobs.nil?
+        if run_on_mac?
+          @simultaneous_jobs = 10 # saucelabs account limit for parallel is 10 for mac
+        else
+          @simultaneous_jobs = 15 # saucelabs account limit for parallel is 15 for non-mac
+        end
+      end
+
+      size = all_tests.size
+      if size <= simultaneous_jobs
+        run_test_set(all_tests)
+        puts "CAUTION! All #{size} tests are starting at the same time!"
+        puts "will not really run it since computer will die" if size > 30
+        sleep 20
+      else
+        first_test_set = all_tests[0, simultaneous_jobs]
+        all_to_run = all_tests[(simultaneous_jobs + 1)...(all_tests.size - 1)]
+        run_test_set(first_test_set)
+        keep_running_full(all_to_run)
+      end
+
+      wait_all_done_saucelabs if @on_sauce
+      wait_for_pids(@pids) unless ENV['JENKINS_HOME']
+      puts "\nAll Complete! Started at #{@start_time} and finished at #{Time.now}\n"
+      exit
+    end
+
+    def wait_for_pids(pids)
+      running_pids = pids # assume all pids are running at this moment
+      while running_pids.size > 1
+        sleep 5
+        puts "running_pids = #{running_pids}"
+        running_pids.each do |pid|
+          unless process_running?(pid)
+            puts "#{pid} is not running, removing it from pool"
+            running_pids.delete(pid)
+          end
+        end
+      end
+    end
+
+    def process_running?(pid)
+      begin
+        Process.getpgid(pid)
+        true
+      rescue Errno::ESRCH
+        false
+      end
+    end
+
+    # runs each test from a test set in a separate child process
+    def run_test_set(test_set)
+      test_set.each do |test|
+        run_command = "#{@static_run_command} -n #{test} #{@pipe_tap} > logs/tap_results/#{test}.t"
+        pipe = IO.popen(run_command)
+        puts "Running #{test}  #{pipe.pid}"
+        @pids << pipe.pid
+      end
+    end
+
+    def keep_running_full(all_to_run)
+      full_count = simultaneous_jobs + 2
+      running_count = count_autobot_process
+      while running_count >= full_count
+        sleep 5
+        running_count = count_autobot_process
+      end
+      to_run_count = full_count - running_count
+      tests_to_run = all_to_run.slice!(0, to_run_count)
+      run_test_set(tests_to_run)
+      if all_to_run.size > 0
+        keep_running_full(all_to_run)
+      else
+        return
+      end
+    end
+
+    def wait_all_done_saucelabs
+      size = all_tests.size
+      job_statuses = saucelabs_last_n_statuses(size)
+      while job_statuses.include?('in progress')
+        puts "There are tests still running, waiting..."
+        sleep 20
+        job_statuses = saucelabs_last_n_statuses(size)
+      end
+    end
+
+    # call saucelabs REST API to get last #{limit} jobs' statuses
+    # possible job status: complete, error, in progress
+    def saucelabs_last_n_statuses(limit)
+      connector = MiniAutobot.settings.connector # eg. saucelabs:phu:win7_ie11
+      overrides = connector.to_s.split(/:/)
+      file_name = overrides.shift
+      path = MiniAutobot.root.join('config/mini_autobot', 'connectors')
+      filepath  = path.join("#{file_name}.yml")
+      raise ArgumentError, "Cannot load profile #{file_name.inspect} because #{filepath.inspect} does not exist" unless filepath.exist?
+      cfg = YAML.load(File.read(filepath))
+      cfg = Connector.resolve(cfg, overrides)
+      cfg.freeze
+      username = cfg["hub"]["user"]
+      access_key = cfg["hub"]["pass"]
+
+      require 'json'
+
+      # call api to get most recent #{limit} jobs' ids
+      http_auth = "https://#{username}:#{access_key}@saucelabs.com/rest/v1/#{username}/jobs?limit=#{limit}"
+      response = get_response_with_retry(http_auth) # response was originally an array of hashs, but RestClient converts it to a string
+      # convert response back to array
+      response[0] = ''
+      response[response.length-1] = ''
+      array_of_hash = response.split(',')
+      id_array = Array.new
+      array_of_hash.each do |hash|
+        hash = hash.gsub(':', '=>')
+        hash = eval(hash)
+        id_array << hash['id'] # each hash contains key 'id' and value of id
+      end
+
+      # call api to get job statuses
+      statuses = Array.new
+      id_array.each do |id|
+        http_auth = "https://#{username}:#{access_key}@saucelabs.com/rest/v1/#{username}/jobs/#{id}"
+        response = get_response_with_retry(http_auth)
+        begin
+          # convert response back to hash
+          str = response.gsub(':', '=>')
+          # this is a good example why using eval is dangerous, the string has to contain only proper Ruby syntax, here it has 'null' instead of 'nil'
+          formatted_str = str.gsub('null', 'nil')
+          hash = eval(formatted_str)
+          statuses << hash['status']
+        rescue SyntaxError
+          puts "SyntaxError, response from saucelabs has syntax error"
+        end
+      end
+      return statuses
+    end
+
+    def get_response_with_retry(url)
+      retries = 5 # number of retries
+      begin
+        response = RestClient.get(url) # returns a String
+      rescue
+        puts "Failed at getting response from #{url} via RestClient \n Retrying..."
+        retries -= 1
+        retry if retries > 0
+        response = RestClient.get(url) # retry the last time, fail if it still throws exception
+      end
+    end
+
+  end
+end