bugsnag-maze-runner 6.27.0 → 7.22.1

data/lib/maze/generator.rb

@@ -0,0 +1,55 @@
+# A thread-safe generator of values, backed by an Enumerator.
+module Maze
+  class Generator
+    def initialize(enumerator)
+      # A SizedQueue allows a set number of values to always be ready for clients
+      # and will be automatically topped up from the enumerator.
+      @queue = SizedQueue.new(10)
+
+      # The queue filler continually adds to the queue (when there is room), taking
+      # values from the Enumerator.  This ensure the enumerator is always run inside
+      # the same thread
+      @queue_filler = create_queue_filler(enumerator)
+
+      while @queue.empty? && enumerator.size != 0
+        # Wait for the queue to start filling
+      end
+    end
+
+    # @return The next value
+    def next
+      @queue.pop
+    end
+
+    # @return Whether the generator has been closed
+    def closed?
+      @queue.closed?
+    end
+
+    # Cleans up resources used by the generator
+    def close
+      @queue_filler.exit
+      @queue.close
+    end
+
+    private
+
+    # Create a thread that will constantly append to @queue with values from the
+    # given enumerator
+    #
+    # @param enumerator [Enumerator]
+    # @return [Thread]
+    def create_queue_filler(enumerator)
+      # By passing the enumerator as an argument to Thread.new, it creates a copy
+      # local to that thread and therefore we're not sharing an enumerator across
+      # threads
+      Thread.new(enumerator) do |inner|
+        loop do
+          # Add to the queue until it fills up, this will then block until there's
+          # room in the queue again
+          @queue << inner.next
+        end
+      end
+    end
+  end
+end

data/lib/maze/helper.rb

@@ -94,9 +94,7 @@ module Maze
         else
           os = case Maze.config.farm
                when :bs
-                 Maze.config.capabilities['os']
-               when :sl
-                 Maze.driver.capabilities['platformName']
+                 Maze.config.capabilities['platformName']
                else
                  Maze.config.os
                end
@@ -108,6 +106,12 @@ module Maze
         os
       end
 
+      # Logs the given message and exits the program with a failure status
+      def error_exit(message)
+        $logger.error message
+        exit false
+      end
+
       # Returns the name of the scenario to
       # @param string [String] a string to convert to a file name
       def to_friendly_filename(string)

data/lib/maze/hooks/appium_hooks.rb

@@ -3,213 +3,52 @@ module Maze
   module Hooks
     # Hooks for Appium mode use
     class AppiumHooks < InternalHooks
-      def before_all
-        # Setup Appium capabilities.  Note that the 'app' capability is
-        # set in a hook as it will change if uploaded to BrowserStack.
-
-        config = Maze.config
-        case config.farm
-        when :bs
-          tunnel_id = SecureRandom.uuid
-          config.app = Maze::BrowserStackUtils.upload_app config.username,
-                                                          config.access_key,
-                                                          config.app
-          Maze::BrowserStackUtils.start_local_tunnel config.bs_local,
-                                                     tunnel_id,
-                                                     config.access_key
-        when :sl
-          config.app = Maze::SauceLabsUtils.upload_app config.username,
-                                                       config.access_key,
-                                                       config.app
-          tunnel_id = SecureRandom.uuid
-          Maze::SauceLabsUtils.start_sauce_connect config.sl_local,
-                                                   tunnel_id,
-                                                   config.username,
-                                                   config.access_key
-        when :bb
-          if ENV['BUILDKITE']
-            credentials = Maze::BitBarUtils.account_credentials config.tms_uri
-            config.username = credentials[:username]
-            config.access_key = credentials[:access_key]
-          end
-          config.app = Maze::BitBarUtils.upload_app config.access_key,
-                                                    config.app
-          Maze::SmartBearUtils.start_local_tunnel config.sb_local,
-                                                  config.username,
-                                                  config.access_key
-        when :local
-          # Attempt to start the local appium server
-          appium_uri = URI(config.appium_server_url)
-          Maze::AppiumServer.start(address: appium_uri.host, port: appium_uri.port) if config.start_appium
-        end
+      @client
 
-        start_driver(config, tunnel_id)
-
-        # Ensure the device is unlocked
-        Maze.driver.unlock
-
-        # Write links to device farm sessions, where applicable
-        write_session_link
+      def before_all
+        @client = Maze::Client::Appium.start
       end
 
-      def before
-        Maze.driver.start_driver if Maze.config.farm != :none && Maze.config.appium_session_isolation
-
-        # Launch the app on macOS, if Appium is being used
-        Maze.driver.get(Maze.config.app) if Maze.driver && Maze.config.os == 'macos'
+      def before(scenario)
+        @client.start_scenario
       end
 
-      def after
-        if Maze.config.appium_session_isolation
-          Maze.driver.driver_quit
-        elsif Maze.config.os == 'macos'
+      def after(scenario)
+
+        if Maze.config.os == 'macos'
           # Close the app - without the sleep, launching the app for the next scenario intermittently fails
           system("killall -KILL #{Maze.config.app} && sleep 1")
-        elsif [:bb].include? Maze.config.farm
-          Maze.driver.launch_app
-        else
-          Maze.driver.reset
-        end
-      end
-
-      def at_exit
-        # Stop the Appium session and server
-        Maze.driver.driver_quit unless Maze.config.appium_session_isolation
-        Maze::AppiumServer.stop if Maze::AppiumServer.running
-
-        if Maze.config.farm == :local && Maze.config.os == 'macos'
-          # Acquire and output the logs for the current session
-          Maze::Runner.run_command("log show --predicate '(process == \"#{Maze.config.app}\")' --style syslog --start '#{Maze.start_time}' > #{Maze.config.app}.log")
-        elsif Maze.config.farm == :bs
-          Maze::BrowserStackUtils.stop_local_tunnel
-        elsif Maze.config.farm == :sl
-          $logger.info 'Stopping Sauce Connect'
-          Maze::SauceLabsUtils.stop_sauce_connect
-        elsif Maze.config.farm == :bb
-          Maze::SmartBearUtils.stop_local_tunnel
-          Maze::BitBarUtils.release_account(Maze.config.tms_uri) if ENV['BUILDKITE']
-        end
-      end
+        elsif [:bb, :bs, :local].include? Maze.config.farm
+          write_device_logs(scenario) if scenario.failed?
 
-      def write_session_link
-        config = Maze.config
-        if config.farm == :bs && (config.device || config.browser)
-          # Log a link to the BrowserStack session search dashboard
-          build = Maze.driver.capabilities[:build]
-          url = "https://app-automate.browserstack.com/dashboard/v2/search?query=#{build}&type=builds"
-          if ENV['BUILDKITE']
-            $logger.info Maze::LogUtil.linkify url, 'BrowserStack session(s)'
-          else
-            $logger.info "BrowserStack session(s): #{url}"
-          end
+          # appium_lib 12 says that reset is deprecated and activate_app/terminate_app should be used
+          # instead.  However, they do not clear out app data, which we need between scenarios.
+          # install_app/remove_app might also be an option to consider.
+          Maze.driver.reset
         end
       end
 
-      def device_capabilities(config, tunnel_id = nil)
-        case config.farm
-        when :bs
-          capabilities = Maze::Capabilities.for_browser_stack_device config.device,
-                                                                     tunnel_id,
-                                                                     config.appium_version,
-                                                                     config.capabilities_option
-          capabilities['app'] = config.app
-        when :sl
-          capabilities = Maze::Capabilities.for_sauce_labs_device config.device,
-                                                                  config.os,
-                                                                  config.os_version,
-                                                                  tunnel_id,
-                                                                  config.appium_version,
-                                                                  config.capabilities_option
-          capabilities['app'] = "storage:#{config.app}"
-        when :local
-          capabilities = Maze::Capabilities.for_local config.os,
-                                                      config.capabilities_option,
-                                                      config.apple_team_id,
-                                                      config.device_id
-          capabilities['app'] = config.app
-        when :bb
-          capabilities = Maze::Capabilities.for_bitbar_device config.access_key,
-                                                              config.device,
-                                                              config.os,
-                                                              config.os_version,
-                                                              config.capabilities_option
-          capabilities['bitbar_app'] = config.app
-          capabilities['bundleId'] = config.app_bundle_id
-        end
-        capabilities
+      def after_all
+        @client&.log_run_outro
       end
 
-      def create_driver(config)
-        if Maze.config.resilient
-          $logger.info 'Creating ResilientAppium driver instance'
-          Maze::Driver::ResilientAppium.new config.appium_server_url,
-                                            config.capabilities,
-                                            config.locator
-        else
-          $logger.info 'Creating Appium driver instance'
-          Maze::Driver::Appium.new config.appium_server_url,
-                                   config.capabilities,
-                                   config.locator
-        end
+      def at_exit
+        @client&.stop_session
       end
 
-      def start_driver(config, tunnel_id = nil)
-        retry_failure = config.device_list.nil? || config.device_list.empty?
-        until Maze.driver
-          begin
-            config.capabilities = device_capabilities(config, tunnel_id)
-            driver = create_driver(config)
-
-            start_driver_closure = Proc.new do
-              begin
-                driver.start_driver
-                true
-              rescue => start_error
-                raise start_error unless retry_failure
-                false
-              end
-            end
+      private
 
-            unless config.appium_session_isolation
-              if retry_failure
-                wait = Maze::Wait.new(interval: 10, timeout: 60)
-                success = wait.until(&start_driver_closure)
+      # Pulls the device logs using Appium and writes them to file in the maze_output folder
+      def write_device_logs(scenario)
+        log_name = case Maze::Helper.get_current_platform
+                   when 'android'
+                     'logcat'
+                   when 'ios'
+                     'syslog'
+                   end
+        logs = Maze.driver.get_log(log_name)
 
-                unless success
-                  $logger.error 'Appium driver failed to start after 6 attempts in 60 seconds'
-                  raise RuntimeError.new('Appium driver failed to start in 60 seconds')
-                end
-              else
-                start_driver_closure.call
-              end
-            end
-
-            # Infer OS version if necessary when running locally
-            if Maze.config.farm == :local && Maze.config.os_version.nil?
-              version = case Maze.config.os
-              when 'android'
-                driver.session_capabilities['platformVersion'].to_f
-              when 'ios'
-                driver.session_capabilities['sdkVersion'].to_f
-              end
-              $logger.info "Inferred OS version to be #{version}"
-              Maze.config.os_version = version
-            end
-
-            Maze.driver = driver
-          rescue Selenium::WebDriver::Error::UnknownError => original_exception
-            $logger.warn "Attempt to acquire #{config.device} device from farm #{config.farm} failed"
-            $logger.warn "Exception: #{original_exception.message}"
-            if config.device_list.empty?
-              $logger.error 'No further devices to try - raising original exception'
-              raise original_exception
-            else
-              config.device = config.device_list.first
-              config.device_list = config.device_list.drop(1)
-              $logger.warn "Retrying driver initialisation using next device: #{config.device}"
-            end
-          end
-        end
+        Maze::MazeOutput.new(scenario).write_device_logs(logs)
       end
     end
   end

data/lib/maze/hooks/browser_hooks.rb

@@ -4,64 +4,11 @@ module Maze
     # Hooks for Browser mode use
     class BrowserHooks < InternalHooks
       def before_all
-        config = Maze.config
-        case config.farm
-        when :bs
-          # BrowserStack browser
-          tunnel_id = SecureRandom.uuid
-          config.capabilities = Maze::Capabilities.for_browser_stack_browser config.browser,
-                                                                             tunnel_id,
-                                                                             config.capabilities_option
-          Maze::BrowserStackUtils.start_local_tunnel config.bs_local,
-                                                     tunnel_id,
-                                                     config.access_key
-        when :cbt
-          # CrossBrowserTesting browser
-          tunnel_id = SecureRandom.uuid
-          config.capabilities = Maze::Capabilities.for_cbt_browser config.browser,
-                                                                   tunnel_id,
-                                                                   config.capabilities_option
-          Maze::SmartBearUtils.start_local_tunnel config.sb_local,
-                                                  config.username,
-                                                  config.access_key,
-                                                  tunnel_id
-        end
-
-        # Create and start the relevant driver
-        case config.farm
-        when :cbt
-          selenium_url = "http://#{config.username}:#{config.access_key}@hub.crossbrowsertesting.com:80/wd/hub"
-          Maze.driver = Maze::Driver::Browser.new :remote, selenium_url, config.capabilities
-        when :bs
-          selenium_url = "http://#{config.username}:#{config.access_key}@hub.browserstack.com/wd/hub"
-          Maze.driver = Maze::Driver::Browser.new :remote, selenium_url, config.capabilities
-        when :local
-          Maze.driver = Maze::Driver::Browser.new Maze.config.browser.to_sym
-        end
-
-        # Write links to device farm sessions, where applicable
-        write_session_link
+        @client = Maze::Client::Selenium.start
       end
 
       def at_exit
-        if Maze.config.farm == :bs
-          Maze::BrowserStackUtils.stop_local_tunnel
-          Maze.driver.driver_quit
-        end
-      end
-
-      def write_session_link
-        config = Maze.config
-        if config.farm == :bs
-          # Log a link to the BrowserStack session search dashboard
-          build = Maze.driver.capabilities[:build]
-          url = "https://automate.browserstack.com/dashboard/v2/search?query=#{build}&type=builds"
-          if ENV['BUILDKITE']
-            $logger.info Maze::LogUtil.linkify url, 'BrowserStack session(s)'
-          else
-            $logger.info "BrowserStack session(s): #{url}"
-          end
-        end
+        @client.stop_session
       end
     end
   end

data/lib/maze/hooks/error_code_hook.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Maze
+  module Hooks
+    # Registers an exit hook that will process the reason for an early exit and provide a suitable error code.
+    # Error code sets and specific code meanings are as follows:
+    #   1*: An error has occurred within browser or device drivers:
+    #     10: An unknown error has occurred
+    #     11: An expected UI element was missing
+    #     12: A UI element was missing at time of interaction
+    #     13: A command sent to the remote server timed out
+    #     14: An element was present but did not accept interaction
+    #   2*: Errors relating to potential network, test server, or payload issues
+    #     21: Expected payload(s) was not received
+    #     22: A command was not read by the test fixture
+    class ErrorCodeHook
+      class << self
+
+        attr_accessor :exit_code
+        attr_accessor :last_test_error_class
+
+        def register_exit_code_hook
+          return if @registered
+          at_exit do
+            exit_hook
+          end
+          @registered = true
+        end
+
+        private
+
+        def exit_hook
+          override_exit_code = nil
+
+          maze_errors = Maze::Error::ERROR_CODES
+          if maze_errors.include?(last_test_error_class)
+            override_exit_code = maze_errors[last_test_error_class][:error_code]
+          end
+
+          # Check if a specific error code has been registered elsewhere
+          override_exit_code = @exit_code if @exit_code
+
+          # If an override code is specified, use it, otherwise we'll use the native exit code
+          exit(override_exit_code) unless override_exit_code.nil?
+        end
+      end
+    end
+  end
+end

data/lib/maze/hooks/hooks.rb

@@ -49,9 +49,9 @@ module Maze
     class InternalHooks
       def before_all; end
 
-      def before; end
+      def before(_scenario); end
 
-      def after; end
+      def after(_scenario); end
 
       def after_all; end
 

data/lib/maze/http_request.rb

@@ -0,0 +1,21 @@
+require 'delegate'
+
+module Maze
+  class HttpRequest < SimpleDelegator
+    def body
+      @body ||= decode_body
+    end
+
+    private
+
+    def decode_body
+      delegate = __getobj__
+      if %r{^gzip$}.match(delegate['Content-Encoding'])
+        gz_element = Zlib::GzipReader.new(StringIO.new(delegate.body))
+        gz_element.read
+      else
+        delegate.body
+      end
+    end
+  end
+end

data/lib/maze/logger.rb

@@ -7,8 +7,10 @@ require 'singleton'
 module Maze
   # A logger, with level configured according to the environment
   class Logger < Logger
-
     include Singleton
+
+    attr_accessor :datetime_format
+
     def initialize
       if ENV['VERBOSE'] || ENV['DEBUG']
         super(STDOUT, level: Logger::DEBUG)
@@ -17,7 +19,14 @@ module Maze
       else
         super(STDOUT, level: Logger::INFO)
       end
-      self.datetime_format = '%Y-%m-%d %H:%M:%S'
+
+      @datetime_format = '%H:%M:%S'
+
+      @formatter = proc do |severity, time, _name, message|
+        formatted_time = time.strftime(@datetime_format)
+
+        "\e[2m[#{formatted_time}]\e[0m #{severity.rjust(5)}: #{message}\n"
+      end
     end
   end
 
@@ -66,7 +75,11 @@ module Maze
       # @param url [String] Link URL
       # @param text [String] Link text
       def linkify(url, text)
-        "\033]1339;url='#{url}';content='#{text}'\a"
+        if ENV['BUILDKITE']
+          "\033]1339;url='#{url}';content='#{text}'\a"
+        else
+          "#{text}: #{url}"
+        end
       end
     end
   end

data/lib/maze/maze_output.rb

@@ -0,0 +1,88 @@
+module Maze
+  # Responsible for writing files to the maze_output directory
+  class MazeOutput
+
+    # @param scenario The Cucumber scenario
+    def initialize(scenario)
+      @scenario = scenario
+    end
+
+    # Writes each list of requests to a separate file under, e.g:
+    # maze_output/failed/scenario_name/errors.log
+    def write_requests
+      path = output_folder
+      FileUtils.makedirs(path)
+
+      request_types = %w[errors sessions builds uploads logs sourcemaps traces invalid]
+
+      request_types.each do |request_type|
+        list = Maze::Server.list_for(request_type).all
+        next if list.empty?
+
+        filename = "#{request_type}.log"
+        filepath = File.join(path, filename)
+
+        counter = 1
+        File.open(filepath, 'w+') do |file|
+          list.each do |request|
+            file.puts "=== Request #{counter} of #{list.size} ==="
+            if request[:invalid]
+              invalid_request = true
+              uri = request[:request][:request_uri]
+              headers = request[:request][:header]
+              body = request[:request][:body]
+            else
+              invalid_request = false
+              uri = request[:request].request_uri
+              headers = request[:request].header
+              body = request[:body]
+            end
+            file.puts "URI: #{uri}"
+            file.puts "HEADERS:"
+            headers.each do |key, values|
+              file.puts "  #{key}: #{values.map {|v| "'#{v}'"}.join(' ')}"
+            end
+            file.puts
+            file.puts "BODY:"
+            if !invalid_request && headers["content-type"].first == 'application/json'
+              file.puts JSON.pretty_generate(body)
+            else
+              file.puts body
+            end
+            file.puts
+            if request.include?(:reason)
+              file.puts "REASON:"
+              file.puts request[:reason]
+              file.puts
+            end
+            counter += 1
+          end
+        end
+      end
+    end
+
+    # Pulls the logs from the device if the scenario fails
+    # @param logs [Array<String>] The lines of log to be written
+    def write_device_logs(logs)
+
+      dir = output_folder
+      FileUtils.makedirs(dir)
+      filepath = File.join(dir, 'device.log')
+
+      File.open(filepath, 'w+') do |file|
+        logs.each { |line| file.puts line }
+      end
+    end
+
+    private
+
+    # Determines the output folder for the scenario
+    def output_folder
+      folder1 = File.join(Dir.pwd, 'maze_output')
+      folder2 = @scenario.failed? ? 'failed' : 'passed'
+      folder3 = Maze::Helper.to_friendly_filename(@scenario.name)
+
+      File.join(folder1, folder2, folder3)
+    end
+  end
+end