bugsnag-maze-runner 6.27.0 → 7.23.0

data/lib/maze/docker.rb

@@ -54,6 +54,45 @@ module Maze
         @services_started = true
       end
 
+      # Execute a command in an already running docker container. Use {start_service}
+      # to build and run the service before calling this method
+      #
+      # This is equivalent to the Docker Compose 'exec' command:
+      # https://docs.docker.com/engine/reference/commandline/compose_exec/
+      #
+      # @param service [String] The name of the service. This must already be running
+      # @param command [String] The command to run
+      # @param detach [Boolean] Optional. Whether to run detached
+      def exec(service, command, detach: false)
+        flags = detach ? " --detach" : ""
+
+        run_docker_compose_command("exec #{flags} #{service} /bin/sh -c '#{command}'")
+      end
+
+      # Copy a file or directory from a container to the local filesystem
+      #
+      # This is equivalent to the Docker Compose 'cp' command:
+      # https://docs.docker.com/engine/reference/commandline/compose_cp/
+      #
+      # @param service [String] The name of the service to copy from. This must already be running
+      # @param from [String] The path to the file/directory that should be copied
+      # @param to [String] The path to copy the file/directory to
+      def copy_from_container(service, from:, to:)
+        run_docker_compose_command("cp #{service}:#{from} #{to}", success_codes: [0])
+      end
+
+      # Copy a file or directory from the local filesystem to a container
+      #
+      # This is equivalent to the Docker Compose 'cp' command:
+      # https://docs.docker.com/engine/reference/commandline/compose_cp/
+      #
+      # @param service [String] The name of the service to copy to. This must already be running
+      # @param from [String] The path to the file/directory that should be copied
+      # @param to [String] The path to copy the file/directory to
+      def copy_to_container(service, from:, to:)
+        run_docker_compose_command("cp #{from} #{service}:#{to}", success_codes: [0])
+      end
+
       # Kills a running service
       #
       # @param service [String] The name of the service to kill
@@ -91,7 +130,7 @@ module Maze
       def get_docker_compose_command(command)
         project_name = compose_project_name.nil? ? '' : "-p #{compose_project_name}"
 
-        "docker-compose #{project_name} -f #{COMPOSE_FILENAME} #{command}"
+        "docker compose #{project_name} -f #{COMPOSE_FILENAME} #{command}"
       end
 
       def run_docker_compose_command(command, success_codes: nil)

data/lib/maze/driver/appium.rb

@@ -10,6 +10,10 @@ module Maze
     # Provide a thin layer of abstraction above @see Appium::Driver
     class Appium < Appium::Driver
 
+      # @!attribute [rw] app_id
+      #   @return [String] The app_id derived from session_capabilities (appPackage on Android, bundleID on iOS)
+      attr_accessor :app_id
+
       # @!attribute [r] device_type
       #   @return [String] The device, from the list of device capabilities, used for this test
       attr_reader :device_type
@@ -25,11 +29,10 @@ module Maze
       # @param locator [Symbol] the primary locator strategy Appium should use to find elements
       def initialize(server_url, capabilities, locator = :id)
         # Sets up identifiers for ease of connecting jobs
-        name_capabilities = project_name_capabilities
+        capabilities ||= {}
 
         @element_locator = locator
         @capabilities = capabilities
-        @capabilities.merge! name_capabilities
 
         # Timers
         @find_element_timer = Maze.timers.add 'Appium - find element'
@@ -43,10 +46,6 @@ module Maze
             server_url: server_url
           }
         }, true)
-
-        $logger.info 'Appium driver initialized for:'
-        $logger.info "    project : #{name_capabilities[:project]}"
-        $logger.info "    build   : #{name_capabilities[:build]}"
       end
 
       # Starts the Appium driver
@@ -187,24 +186,6 @@ module Maze
         reset
       end
 
-      # Determines and returns sensible project, build, and name capabilities
-      #
-      # @return [Hash] A hash containing the 'project' and 'build' capabilities
-      def project_name_capabilities
-        # Default to values for running locally
-        project = 'local'
-        build = SecureRandom.uuid
-
-        if ENV['BUILDKITE']
-          # Project
-          project = ENV['BUILDKITE_PIPELINE_NAME']
-        end
-        {
-          project: project,
-          build: build
-        }
-      end
-
       def device_info
         driver.execute_script('mobile:deviceInfo')
       end

data/lib/maze/driver/browser.rb

@@ -11,12 +11,10 @@ module Maze
       attr_reader :capabilities
 
       def initialize(driver_for, selenium_url=nil, capabilities=nil)
-        capabilities.merge! project_name_capabilities
+        capabilities ||= {}
         @capabilities = capabilities
         @driver_for = driver_for
         @selenium_url = selenium_url
-
-        start_driver
       end
 
       def find_element(*args)
@@ -62,24 +60,6 @@ module Maze
         JAVASCRIPT
       end
 
-      # Determines and returns sensible project and build capabilities
-      #
-      # @return [Hash] A hash containing the 'project' and 'build' capabilities
-      def project_name_capabilities
-        # Default to values for running locally
-        project = 'local'
-        build = SecureRandom.uuid
-
-        if ENV['BUILDKITE']
-          # Project
-          project = ENV['BUILDKITE_PIPELINE_NAME']
-        end
-        {
-          project: project,
-          build: build
-        }
-      end
-
       # Restarts the underlying-driver in the case an unrecoverable error occurs
       #
       # @param attempts [Integer] The number of times we should retry a failed attempt (defaults to 6)
@@ -91,8 +71,6 @@ module Maze
         start_driver(attempts)
       end
 
-      private
-
       # Attempts to create a new selenium driver a given number of times
       #
       # @param attempts [Integer] The number of times we should retry a failed attempt (defaults to 6)
@@ -114,15 +92,23 @@ module Maze
         end
       end
 
+      private
+
       # Creates and starts the selenium driver
       def create_driver(driver_for, selenium_url=nil)
         begin
           $logger.info "Starting Selenium driver"
           time = Time.now
           if driver_for == :remote
-            driver = ::Selenium::WebDriver.for :remote,
-                                                url: selenium_url,
-                                                desired_capabilities: @capabilities
+            if Maze.config.legacy_driver?
+              driver = ::Selenium::WebDriver.for :remote,
+                                                 url: selenium_url,
+                                                 desired_capabilities: @capabilities
+            else
+              driver = ::Selenium::WebDriver.for :remote,
+                                                 url: selenium_url,
+                                                 capabilities: @capabilities
+            end
           else
             driver = ::Selenium::WebDriver.for driver_for
           end

data/lib/maze/errors.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require 'appium_lib'
+
 module Maze
   module Error
     # An error raised when an appium element cannot be found
@@ -16,5 +20,33 @@ module Maze
         super(message)
       end
     end
+
+    ERROR_CODES = {
+      ::Selenium::WebDriver::Error::UnknownError => {
+        retry: true,
+        error_code: 10
+      },
+      ::Selenium::WebDriver::Error::WebDriverError => {
+        retry: true,
+        error_code: 10
+      },
+      Maze::Error::AppiumElementNotFoundError => {
+        retry: true,
+        error_code: 11
+      },
+      ::Selenium::WebDriver::Error::NoSuchElementError => {
+        retry: true,
+        error_code: 12
+      },
+      ::Selenium::WebDriver::Error::TimeoutError => {
+        retry: true,
+        error_code: 13
+      },
+      ::Selenium::WebDriver::Error::StaleElementReferenceError => {
+        retry: true,
+        error_code: 14
+      },
+    }.freeze
+
   end
 end

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