bugsnag-maze-runner 6.27.0 → 7.22.1

data/lib/maze/client/bb_api_client.rb

@@ -0,0 +1,102 @@
+module Maze
+  # Utils supporting the BitBar device farm integration
+  module Client
+    class BitBarApiClient
+      BASE_URI = 'https://cloud.bitbar.com/api'
+      USER_SPECIFIC_URI = "#{BASE_URI}/v2/me"
+
+      def initialize(access_key)
+        @access_key = access_key
+      end
+
+      # Get a list of all available device groups
+      def get_device_group_list
+        query_api('device-groups')
+      end
+
+      # Get a list of all available devices in a device group
+      def get_device_list_for_group(device_group_id)
+        path = "device-groups/#{device_group_id}/devices"
+        query_api(path)
+      end
+
+      # Get the id of a device group given its name
+      def get_device_group_id(device_group_name)
+        query = {
+          'filter': "displayName_eq_#{device_group_name}"
+        }
+        device_groups = query_api('device-groups', query)
+        if device_groups['data'].nil? || device_groups['data'].size == 0
+          nil
+        else
+          device_groups['data'][0]['id']
+        end
+      end
+
+      def find_device_in_group(device_group_id)
+        path = "device-groups/#{device_group_id}/devices"
+        query = {
+          'filter': "online_eq_true"
+        }
+        all_devices = query_api(path, query)
+
+        $logger.debug "All available devices in group #{device_group_id}: #{JSON.pretty_generate(all_devices)}"
+        filtered_devices = all_devices['data'].reject { |device| device['locked'] }
+        return filtered_devices.size, filtered_devices.sample
+      end
+
+      def find_device(device_name)
+        path = "devices"
+        query = {
+          'filter': "displayName_eq_#{device_name};online_eq_true",
+        }
+        all_devices = query_api(path, query, BASE_URI)['data']
+        if all_devices.size == 0
+          Maze::Helper.error_exit "No devices found with name '#{device_name}'"
+        else
+          $logger.debug "All available devices with name #{device_name}: #{JSON.pretty_generate(all_devices)}"
+          filtered_devices = all_devices.reject { |device| device['locked'] }
+          if filtered_devices.size == 0
+            Maze::Helper.error_exit "None of the #{all_devices.size} devices with name '#{device_name}' are currently available"
+          else
+            $logger.info "#{filtered_devices.size} of #{all_devices.size} devices with name '#{device_name}' are available"
+          end
+
+          return filtered_devices.sample
+        end
+      end
+
+      def get_device_session_ui_link(session_id)
+        query = {
+          'filter': "clientSideId_eq_#{session_id}"
+        }
+        data = query_api('device-sessions', query)['data']
+        if data.size == 1
+          data[0]['uiLink']
+        else
+          $logger.warn "Failed to get UI link for session #{session_id}.  Expected exactly 1 device-session, found #{data.size}"
+        end
+      end
+
+      private
+
+      # Queries the BitBar REST API
+      def query_api(path, query=nil, uri=USER_SPECIFIC_URI)
+        if query
+          encoded_query = URI.encode_www_form(query)
+          uri = URI("#{uri}/#{path}?#{encoded_query}")
+        else
+          uri = URI("#{uri}/#{path}")
+        end
+        request = Net::HTTP::Get.new(uri)
+        request.basic_auth(@access_key, '')
+        res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        JSON.parse(res.body)
+      end
+    end
+  end
+end
+

data/lib/maze/client/bb_client_utils.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+require 'open3'
+require 'fileutils'
+require 'json'
+
+module Maze
+  # Utils supporting the BitBar device farm integration
+  module Client
+    class BitBarClientUtils
+      BB_READY_FILE = 'bb.ready'
+      BB_KILL_FILE = 'bb.kill'
+      BB_USER_PREFIX = 'BB_USER_'
+      BB_KEY_PREFIX = 'BB_KEY_'
+
+      class << self
+
+        # Uploads an app to BitBar for later consumption
+        # @param api_key [String] The BitBar API key
+        # @param app [String] A path to the application file
+        def upload_app(api_key, app)
+          uuid_regex = /\A[0-9]+\z/
+
+          if uuid_regex.match? app
+            $logger.info "Using pre-uploaded app with ID #{app}"
+            app_uuid = app
+          else
+            expanded_app = Maze::Helper.expand_path(app)
+            $logger.info "Uploading app: #{expanded_app}"
+
+            # Upload the app to BitBar
+            uri = URI('https://cloud.bitbar.com/api/me/files')
+            request = Net::HTTP::Post.new(uri)
+            request.basic_auth(api_key, '')
+            request.set_form({ 'file' => File.new(expanded_app, 'rb') }, 'multipart/form-data')
+
+            res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+              http.request(request)
+            end
+
+            # Pull the UUID from the response
+            begin
+              response = JSON.parse res.body
+              if response.key?('id')
+                app_uuid = response['id'].to_s
+                $logger.info "Uploaded app ID: #{app_uuid}"
+                $logger.info 'You can use this ID to avoid uploading the same app more than once.'
+              else
+                $logger.error "Unexpected response body: #{response}"
+                raise 'App upload failed'
+              end
+            rescue JSON::ParserError
+              $logger.error "Expected JSON response, received: #{res}"
+              raise
+            end
+          end
+          app_uuid
+        end
+
+        # Requests an unused account id from the test-management-service
+        # @param tms_uri [String] The URI of the test-management-service
+        #
+        # @returns
+        def account_credentials(tms_uri)
+          Maze::Wait.new(interval: 10, timeout: 1800).until do
+            output = request_account_index(tms_uri)
+            case output.code
+            when '200'
+              body = JSON.parse(output.body, {symbolize_names: true})
+              @account_id = account_id = body[:id]
+              $logger.info "Using account #{account_id}, expiring at #{body[:expiry]}"
+              {
+                username: ENV["#{BB_USER_PREFIX}#{account_id}"],
+                access_key: ENV["#{BB_KEY_PREFIX}#{account_id}"]
+              }
+            when '409'
+              # All accounts are in use, wait for one to become available
+              $logger.info 'All accounts are currently in use, retrying in 30s'
+              false
+            else
+              # Something has gone wrong, throw an error
+              $logger.error "Unexpected status code (#{output.code}) received from test-management server: #{output.body}"
+              raise
+            end
+          end
+        end
+
+        # Makes the HTTP call to acquire an account id
+        # @param tms_uri [String] The URI of the test-management-service
+        #
+        # @returns
+        def request_account_index(tms_uri)
+          uri = URI("#{tms_uri}/account/request")
+          request = Net::HTTP::Get.new(uri)
+          request['Authorization'] = Maze.config.tms_token
+          res = Net::HTTP.start(uri.hostname, uri.port) do |http|
+            http.request(request)
+          end
+          res
+        end
+
+        # Informs the test-management-service that in-use account id is no longer in use
+        # @param tms_uri [String] The URI of the test-management-service
+        def release_account(tms_uri)
+          $logger.info "Release account #{@account_id}"
+          uri = URI("#{tms_uri}/account/release?account_id=#{@account_id}")
+          request = Net::HTTP::Get.new(uri)
+          request['Authorization'] = Maze.config.tms_token
+          res = Net::HTTP.start(uri.hostname, uri.port) do |http|
+            http.request(request)
+          end
+        end
+
+        # Starts the BitBar local tunnel
+        #
+        # @param sb_local [String] path to the SBSecureTunnel binary
+        # @param username [String] Username to start the tunnel with
+        # @param access_key [String] access key
+        def start_local_tunnel(sb_local, username, access_key)
+          # Make sure the ready/kill files are already deleted
+          File.delete(BB_READY_FILE) if File.exist?(BB_READY_FILE)
+          File.delete(BB_KILL_FILE) if File.exist?(BB_KILL_FILE)
+
+          $logger.info 'Starting SBSecureTunnel'
+          command = "#{sb_local} --username #{username} --authkey #{access_key} --acceptAllCerts " \
+                  "--ready #{BB_READY_FILE} --kill #{BB_KILL_FILE}"
+
+          output = start_tunnel_thread(command)
+
+          success = Maze::Wait.new(timeout: 30).until do
+            File.exist?(BB_READY_FILE)
+          end
+          unless success
+            $logger.error "Failed: #{output}"
+          end
+        end
+
+        # Stops the local tunnel
+        def stop_local_tunnel
+          FileUtils.touch(BB_KILL_FILE)
+
+          success = Maze::Wait.new(timeout: 30).until do
+            @tunnel_thread.nil? || !@tunnel_thread.alive?
+          end
+
+          if success
+            $logger.info("Shutdown SBSecureTunnel")
+          else
+            $logger.error("Failed to shutdown SBSecureTunnel!")
+          end
+
+          @tunnel_thread = nil
+          File.delete(BB_READY_FILE) if File.exist?(BB_READY_FILE)
+          File.delete(BB_KILL_FILE) if File.exist?(BB_KILL_FILE)
+        end
+
+        private
+
+        def start_tunnel_thread(cmd)
+          executor = lambda do
+            Open3.popen2e(Maze::Runner.environment, cmd) do |_stdin, stdout_and_stderr, wait_thr|
+
+              output = []
+              stdout_and_stderr.each do |line|
+                output << line
+              end
+
+              exit_status = wait_thr.value.to_i
+              $logger.debug "Exit status: #{exit_status}"
+
+              output.each { |line| $logger.warn('SBSecureTunnel') {line.chomp} } unless exit_status == 0
+
+              return [output, exit_status]
+            end
+          end
+
+          @tunnel_thread = Thread.new(&executor)
+        end
+      end
+    end
+  end
+end

data/lib/maze/client/bs_client_utils.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Maze
+  module Client
+    # Utils supporting the BrowserStack device farm integration
+    class BrowserStackClientUtils
+      class << self
+
+        # Uploads an app to BrowserStack for later consumption
+        # @param username [String] the BrowserStack username
+        # @param access_key [String] the BrowserStack access key
+        # @param app_id_file [String] the file to write the uploaded app url to BrowserStack
+        def upload_app(username, access_key, app, app_id_file=nil)
+          if app.start_with? 'bs://'
+            app_url = app
+            $logger.info "Using pre-uploaded app from #{app}"
+          else
+            expanded_app = Maze::Helper.expand_path(app)
+
+            uri = URI('https://api-cloud.browserstack.com/app-automate/upload')
+            request = Net::HTTP::Post.new(uri)
+            request.basic_auth(username, access_key)
+            request.set_form({ 'file' => File.new(expanded_app, 'rb') }, 'multipart/form-data')
+
+            upload_tries = 0
+            allowed_tries = 10
+
+            while upload_tries < allowed_tries
+              begin
+                $logger.info "Uploading app: #{expanded_app}"
+                res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+                  http.request(request)
+                end
+
+                body = res.body
+                response = JSON.parse body
+                if response.include?('error')
+                  $logger.error "Upload failed due to error: #{response['error']}"
+                elsif !response.include?('app_url')
+                  $logger.error "Upload failed, response did not include an app_url: #{res}"
+                else
+                  # Successful upload
+                  break
+                end
+              rescue Net::ReadTimeout
+                $logger.error "Upload failed due to ReadTimeout"
+              rescue JSON::ParserError
+                $logger.error "Unexpected JSON response, received: #{body}"
+              end
+
+              upload_tries += 1
+              if upload_tries < allowed_tries
+                $logger.info 'Retrying upload in 60s'
+                Kernel::sleep 60
+              end
+            end
+
+            if response.nil? || response.include?('error') || !response.include?('app_url')
+              raise "Failed to upload app after #{upload_tries} attempts"
+            end
+
+            app_url = response['app_url']
+            $logger.info "App uploaded to: #{app_url}"
+            $logger.info 'You can use this url to avoid uploading the same app more than once.'
+          end
+
+          unless app_id_file.nil?
+            $logger.info "Writing uploaded app url to #{app_id_file}"
+            File.write(Maze::Helper.expand_path(app_id_file), app_url)
+          end
+
+          app_url
+        end
+
+        # Starts the BrowserStack local tunnel
+        # @param bs_local [String] path to the BrowserStackLocal binary
+        # @param local_id [String] unique key for the tunnel instance
+        # @param access_key [String] BrowserStack access key
+        def start_local_tunnel(bs_local, local_id, access_key)
+          $logger.info 'Starting BrowserStack local tunnel'
+          command = "#{bs_local} -d start --key #{access_key} --local-identifier #{local_id} " \
+                      '--force-local --only-automate --force'
+
+          # Extract the pid from the output so it gets killed at the end of the run
+          output = Runner.run_command(command)[0][0]
+          begin
+            @pid = JSON.parse(output)['pid']
+            $logger.info "BrowserStackLocal daemon running under pid #{@pid}"
+          rescue JSON::ParserError
+            $logger.warn 'Unable to parse pid from output, BrowserStackLocal will be left to die its own death'
+          end
+        end
+
+        # Stops the local tunnel
+        def stop_local_tunnel
+          if @pid
+            $logger.info "Stopping BrowserStack local tunnel"
+            Process.kill('TERM', @pid)
+            @pid = nil
+          end
+        rescue Errno::ESRCH
+          # ignored
+        end
+
+        # Gets the build/session info from BrowserStack
+        # @param username [String] the BrowserStack username
+        # @param access_key [String] the BrowserStack access key
+        # @param build_name [String] the name of the BrowserStack build
+        def build_info(username, access_key, build_name)
+          # Get the ID of a build
+          uri = URI("https://api.browserstack.com/app-automate/builds.json?name=#{build_name}")
+          request = Net::HTTP::Get.new(uri)
+          request.basic_auth(username, access_key)
+
+          res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+            http.request(request)
+          end
+
+          build_info = JSON.parse(res.body)
+
+          if !build_info.empty?
+            build_id = build_info[0]['automation_build']['hashed_id']
+
+            # Get the build info
+            uri = URI("https://api.browserstack.com/app-automate/builds/#{build_id}/sessions")
+            request = Net::HTTP::Get.new(uri)
+            request.basic_auth(username, access_key)
+
+            res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+              http.request(request)
+            end
+
+            build_json = JSON.parse(res.body)
+          else
+            raise "No build found for given ID: #{build_name}"
+          end
+          build_json
+        end
+
+        # @param username [String] the BrowserStack username
+        # @param access_key [String] the BrowserStack access key
+        # @param name [String] name of the build the log is being downloaded from
+        # @param log_url [String] url to the log
+        # @param log_type [Symbol] The type of log we are downloading
+        def download_log(username, access_key, name, log_url, log_type)
+          begin
+            path = File.join(Dir.pwd, 'maze_output', log_type.to_s)
+            FileUtils.makedirs(path)
+
+            uri = URI(log_url)
+            request = Net::HTTP::Get.new(uri)
+            request.basic_auth(username, access_key)
+
+            res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+              http.request(request)
+            end
+
+            $logger.info "Saving #{log_type.to_s} log to #{path}/#{name}.log"
+            File.open("#{path}/#{name}.log", 'w+') { |file| file.write(res.body) }
+          rescue StandardError => e
+            $logger.warn "Unable to save log from #{log_url}"
+            $logger.warn e
+          end
+        end
+      end
+    end
+  end
+end

data/lib/maze/client/selenium/base_client.rb

@@ -0,0 +1,15 @@
+module Maze
+  module Client
+    module Selenium
+      class BaseClient
+        def start_session
+          raise 'Method not implemented by this class'
+        end
+
+        def stop_session
+          Maze.driver&.driver_quit
+        end
+      end
+    end
+  end
+end

data/lib/maze/client/selenium/bb_browsers.yml

@@ -0,0 +1,188 @@
+chrome_latest:
+  platform: 'Windows'
+  osVersion: '11'
+  browserName: 'chrome'
+  version: 'latest'
+  resolution: '1920x1080'
+
+chrome_108:
+  platform: 'Windows'
+  osVersion: '11'
+  browserName: 'chrome'
+  version: '108'
+  resolution: '1920x1080'
+
+chrome_107:
+  platform: 'Windows'
+  osVersion: '11'
+  browserName: 'chrome'
+  version: '107'
+  resolution: '1920x1080'
+
+chrome_106:
+  platform: 'Windows'
+  osVersion: '11'
+  browserName: 'chrome'
+  version: '106'
+  resolution: '1920x1080'
+
+chrome_105:
+  platform: 'Windows'
+  osVersion: '11'
+  browserName: 'chrome'
+  version: '105'
+  resolution: '1920x1080'
+
+chrome_104:
+  platform: 'Windows'
+  osVersion: '11'
+  browserName: 'chrome'
+  version: '104'
+  resolution: '1920x1080'
+
+chrome_103:
+  platform: 'Windows'
+  osVersion: '11'
+  browserName: 'chrome'
+  version: '103'
+  resolution: '1920x1080'
+
+chrome_72:
+  platform: 'Windows'
+  osVersion: '10'
+  browserName: 'chrome'
+  version: '72'
+  resolution: '1920x1080'
+
+chrome_43:
+  platform': 'Windows'
+  osVersion: '10'
+  browserName: 'chrome'
+  version: '43'
+  resolution: '1920x1080'
+
+firefox_latest:
+  platform: 'Windows'
+  osVersion: '11'
+  browserName: 'firefox'
+  version: 'latest'
+  resolution: '1920x1080'
+
+firefox_107:
+  platform: 'Windows'
+  osVersion: '11'
+  browserName: 'firefox'
+  version: '107'
+  resolution: '1920x1080'
+
+firefox_106:
+  platform: 'Windows'
+  osVersion: '11'
+  browserName: 'firefox'
+  version: '106'
+  resolution: '1920x1080'
+
+firefox_105:
+  platform: 'Windows'
+  osVersion: '11'
+  browserName: 'firefox'
+  version: '105'
+  resolution: '1920x1080'
+
+firefox_104:
+  platform: 'Windows'
+  osVersion: '11'
+  browserName: 'firefox'
+  version: '104'
+  resolution: '1920x1080'
+
+firefox_103:
+  platform: 'Windows'
+  osVersion: '11'
+  browserName: 'firefox'
+  version: '103'
+  resolution: '1920x1080'
+
+firefox_102:
+  platform: 'Windows'
+  osVersion: '11'
+  browserName: 'firefox'
+  version: '102'
+  resolution: '1920x1080'
+
+firefox_78:
+  platform: 'Windows'
+  osVersion: '10'
+  browserName: 'firefox'
+  version: '78'
+  resolution: '1920x1080'
+
+ie_11:
+  platform: 'Windows'
+  osVersion: '10'
+  browserName: 'internet explorer'
+  version: '11'
+  resolution: '1920x1080'
+
+edge_latest:
+  platform: 'Windows'
+  osVersion: '11'
+  browserName: 'MicrosoftEdge'
+  version: 'latest'
+  resolution: '1920x1080'
+
+edge_106:
+  platform: 'Windows'
+  osVersion: '11'
+  browserName: 'MicrosoftEdge'
+  version: '106'
+  resolution: '1920x1080'
+
+edge_105:
+  platform: 'Windows'
+  osVersion: '11'
+  browserName: 'MicrosoftEdge'
+  version: '105'
+  resolution: '1920x1080'
+
+edge_104:
+  platform: 'Windows'
+  osVersion: '11'
+  browserName: 'MicrosoftEdge'
+  version: '104'
+  resolution: '1920x1080'
+
+edge_103:
+  platform: 'Windows'
+  osVersion: '11'
+  browserName: 'MicrosoftEdge'
+  version: '103'
+  resolution: '1920x1080'
+
+edge_102:
+  platform: 'Windows'
+  osVersion: '11'
+  browserName: 'MicrosoftEdge'
+  version: '102'
+  resolution: '1920x1080'
+
+edge_101:
+  platform: 'Windows'
+  osVersion: '11'
+  browserName: 'MicrosoftEdge'
+  version: '101'
+  resolution: '1920x1080'
+
+safari_16:
+  platform: 'macOS'
+  osVersion: '13'
+  browserName: 'safari'
+  version: '16'
+  resolution: '2560x1920'
+
+safari_15:
+  platform: 'macOS'
+  osVersion: '12'
+  browserName: 'safari'
+  version: '15'
+  resolution: '2560x1920'

data/lib/maze/client/selenium/bb_client.rb

@@ -0,0 +1,38 @@
+module Maze
+  module Client
+    module Selenium
+      class BitBarClient < BaseClient
+        def start_session
+          config = Maze.config
+          if ENV['BUILDKITE']
+            credentials = Maze::Client::BitBarClientUtils.account_credentials config.tms_uri
+            config.username = credentials[:username]
+            config.access_key = credentials[:access_key]
+          end
+          capabilities = ::Selenium::WebDriver::Remote::Capabilities.new
+          capabilities['bitbar_apiKey'] = config.access_key
+          browsers = YAML.safe_load(File.read("#{__dir__}/bb_browsers.yml"))
+          capabilities.merge! browsers[config.browser]
+          capabilities.merge! JSON.parse(config.capabilities_option)
+          config.capabilities = capabilities
+
+          Maze::Client::BitBarClientUtils.start_local_tunnel config.sb_local,
+                                                             config.username,
+                                                             config.access_key
+
+          # TODO This probably needs to be settable via an environment variable
+          # selenium_url = 'https://us-west-desktop-hub.bitbar.com/wd/hub'
+          selenium_url = 'https://eu-desktop-hub.bitbar.com/wd/hub'
+          Maze.driver = Maze::Driver::Browser.new :remote, selenium_url, config.capabilities
+          Maze.driver.start_driver
+        end
+
+        def stop_session
+          super
+          Maze::Client::BitBarClientUtils.stop_local_tunnel
+          Maze::Client::BitBarClientUtils.release_account(Maze.config.tms_uri) if ENV['BUILDKITE']
+        end
+      end
+    end
+  end
+end