standard_automation_library 0.2.1.pre.temp

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7109f4282fc5a8de77dde35d046bd9897b6ebbb1b9dd6db5fce801c9c28777fe
+  data.tar.gz: a7f2358fd522aa99a59e8888af8d15b8477f69e61e1e1f5468a453828f3654f9
+SHA512:
+  metadata.gz: cf0d61a48eb75c84e776792a762c5bd1b8f3e4c7049a858cb7b82e007d2f1e1d9a08a6377af507d09dd39a6e08892b1d10c3dd4f67d9d859924d0a9aa402b9bd
+  data.tar.gz: f586cd1dd604c05fc56f01dd6583ce8ca39db68e2bb92506d9dfca7cecac386d4dac1ae0182cf36465821c344489d83f7f769b4a4fdcf378a4aa9b6e829414f0

data/lib/standard_automation_library/api_clients/app_center.rb

@@ -0,0 +1,104 @@
+require 'json'
+require 'open-uri'
+
+require_relative '../util/network'
+
+# App Center api client
+# See https://openapi.appcenter.ms for API reference.
+class AppCenter
+  # @param api_key [String] App Center API key
+  def initialize(api_key, base_url = 'https://api.appcenter.ms/v0.1', is_dry_run: false)
+    @api_key = api_key
+    @base_url = base_url
+    @is_dry_run = is_dry_run
+  end
+
+  # User must already be a member of the organization to be added to a team.
+  def assign_to_team(org_name, team_name, email_address)
+    if @is_dry_run
+      puts "Would have assigned #{email_address} to App Center team '#{team_name}' in org '#{org_name}'"
+      return
+    end
+    response = Network.post(
+      "#{@base_url}/orgs/#{org_name}/teams/#{team_name}/users",
+      {
+        'Content-Type' => 'application/json',
+        'X-API-Token' => @api_key
+      },
+      { 'user_email' => email_address }.to_json
+    )
+
+    # raise an error unless the response is a 201 meaning the user was added to the team
+    # or a 409 meaning that the user is already a member of the team.
+    raise "#{response.code}: #{response.body}" unless %w[201 409].include?(response.code)
+  end
+
+  def get_release_information(owner_name, app_name, version: nil, version_code: nil)
+    # first get the specifc build that matches the version code criteria if supplied
+    # secondly get the most recent release that matches the version criteria if supplied
+    # otherwise just use the most recent release.
+    releases_json_response = Network.json_response(
+      "#{@base_url}/apps/#{owner_name}/#{app_name}/releases",
+      'X-API-Token' => @api_key
+    )
+
+    release_json = if version_code
+                     releases_json_response.find { |item| item['version'] == version_code }
+                   elsif version.nil?
+                     releases_json_response.first
+                   else
+                     releases_json_response.select { |item| item['short_version'] == version }
+                                           .max_by { |item| item['version'] }
+                   end
+
+    error_message = "No release for owner_name: #{owner_name}, app_name: #{app_name}, " \
+                    "version: #{version} and version code: #{version_code}"
+    raise error_message if release_json.nil?
+
+    # next, use the release id to query for specific information about that release
+    Network.json_response(
+      "#{@base_url}/apps/#{owner_name}/#{app_name}/releases/#{release_json['id']}",
+      'X-API-Token' => @api_key
+    )
+  end
+
+  # Download the the most recent application file matching the given owner_name, app_name, and optional (short) version
+  # Return the full version of the downloaded app. That means a 4 part version for iOS or the version code for android.
+  def download_latest_build(owner_name, app_name, output_path, version: nil)
+    specific_release_json = get_release_information(owner_name, app_name, version: version)
+
+    Network.download_file(specific_release_json['download_url'], output_path)
+
+    # return the full version of the downloaded app
+    specific_release_json['version']
+  end
+
+  def download_specific_build(owner_name, app_name, output_path, version_code)
+    specific_release_json = get_release_information(owner_name, app_name, version_code: version_code)
+
+    Network.download_file(specific_release_json['download_url'], output_path)
+
+    # return the version name of the downloaded app
+    specific_release_json['short_version']
+  end
+
+  def send_invitation(org_name, email_address)
+    if @is_dry_run
+      puts "Would have sent App Center invitation to #{email_address} for org '#{org_name}'"
+      return
+    end
+    response = Network.post(
+      "#{@base_url}/orgs/#{org_name}/invitations",
+      {
+        'Content-Type' => 'application/json',
+        'X-API-Token' => @api_key
+      },
+      { 'user_email' => email_address, 'role' => 'member' }.to_json
+    )
+
+    # raise an error unless the response is a 204 meaning the invitation was sent or
+    # a 409 meaning that the user has already been invited or is already part of the
+    # organization.
+    raise "#{response.code}: #{response.body}" unless %w[204 409].include?(response.code)
+  end
+end

data/lib/standard_automation_library/api_clients/bugsnag.rb

@@ -0,0 +1,94 @@
+require 'bugsnag/api'
+
+# Service for connecting to bugsnag API
+class BugsnagClient
+  def initialize(platform, auth_token)
+    @platform = platform
+    @client = Bugsnag::Api::Client.new(auth_token: auth_token)
+  end
+
+  def my_organization
+    @client.organizations[0]
+  end
+
+  def my_projects
+    @client.projects(my_organization.id, { q: @platform }) ## Bugsnag projects
+  end
+
+  def my_project
+    my_projects.select { |p| p.name == @platform }[0] ## We only have one bugsnag project
+  end
+
+  def top_errors(
+    app_version,
+    events_since: '1d',
+    error_status: 'open',
+    release_stage: 'production',
+    unhandled: 'true',
+    sort_by: 'events',
+    count: '5'
+  )
+    error_options = {
+      'filters[event.since]': events_since,
+      'filters[error.status]': error_status,
+      'filters[app.release_stage]': release_stage,
+      'filters[release.seen_in]': app_version,
+      'filters[event.unhandled]': unhandled,
+      sort: sort_by,
+      per_page: count,
+      base: Time.now.utc.iso8601
+    }
+    @client.errors(my_project.id, nil, error_options)
+  end
+
+  def error_details(error_id)
+    @client.errors(my_project.id, error_id)
+  end
+
+  def release_groups(
+    current_version,
+    release_stage: 'production',
+    count: 5,
+    minimum_total_sessions: 50
+  )
+    options = {
+      release_stage_name: release_stage,
+      top_only: false,
+      visible_only: true,
+      per_page: count + 5 # grab a few extra to account for history and unreleased
+    }
+    result = @client.get("/projects/#{my_project.id}/release_groups", options).map do |release_group|
+      {
+        version: Gem::Version.new(release_group.app_version),
+        recent_sessions: release_group.sessions_count_in_last_24h,
+        session_errors: release_group.unhandled_sessions_count,
+        session_total: release_group.total_sessions_count,
+        user_errors: release_group.accumulative_daily_users_with_unhandled,
+        user_total: release_group.accumulative_daily_users_seen
+      }
+    end.each do |release_group|
+      release_group[:session_failure_rate] = release_group[:session_errors] / release_group[:session_total].to_f
+      release_group[:user_failure_rate] = release_group[:user_errors] / release_group[:user_total].to_f
+    end.each do |release_group|
+      release_group[:session_stability] = (1 - release_group[:session_failure_rate]) * 100
+      release_group[:user_stability] = (1 - release_group[:user_failure_rate]) * 100
+    end.sort_by do |release_group|
+      release_group[:version]
+    end
+
+    selected_releases = result.select do |release_group|
+      release_group[:version] <= Gem::Version.new(current_version) &&
+        release_group[:session_total] >= minimum_total_sessions # filter test releases
+    end
+
+    total_recent_sessions = selected_releases.sum { |release_group| release_group[:recent_sessions] }
+
+    selected_releases.each_with_index do |current, index|
+      current[:adoption_rate] = (current[:recent_sessions] / total_recent_sessions.to_f) * 100
+      previous = selected_releases[index - 1] unless index.zero?
+      current[:session_stability_change] =
+        previous ? current[:session_stability] - previous[:session_stability] : nil
+      current[:user_stability_change] = previous ? current[:user_stability] - previous[:user_stability] : nil
+    end.reverse.take(count)
+  end
+end

data/lib/standard_automation_library/api_clients/github.rb

@@ -0,0 +1,371 @@
+require 'octokit'
+require 'set'
+
+# This class is a wrapper around the github api gem octokit
+class GitHub
+  PULL_REQUEST_STATE_OPEN = 'open'.freeze
+
+  # the api_base_server_url for github.com is https://api.github.com
+  def initialize(repo, api_key, api_server_base_url: 'https://git.autodesk.com/api/v3/', is_dry_run: false)
+    @repo = repo
+    @client = Octokit::Client.new(access_token: api_key, api_endpoint: api_server_base_url)
+    @client.auto_paginate = true
+    @is_dry_run = is_dry_run
+    @username = nil
+    @user_id_cache = {}
+    @org_name = @repo.split('/')[0]
+  end
+
+  attr_accessor :client
+
+  # Get the username of the account associated with the api_key supplied to this client.
+  def username
+    @username = @client.user[:login] if @username.nil?
+    @username
+  end
+
+  def pull_request_state_open
+    PULL_REQUEST_STATE_OPEN
+  end
+
+  def repository?
+    @client.repository?(@repo)
+  end
+
+  def search_users(query)
+    @client.search_users(query)
+  end
+
+  # Find a user ID for a given name. Return the value immediately if already cached.
+  # Optionally enforce that the user is part of the organization that the specified repo
+  # is in. This helps disambiguate users on github.com
+  def find_user_id(name, enforce_org_membership: true)
+    return @user_id_cache[name] if @user_id_cache[name]
+
+    logins = search_users("fullname:#{name} type:users")[:items].map { |user_item| user_item[:login] }
+
+    org_member_logins = logins.select { |user_id| !enforce_org_membership || organization_member?(@org_name, user_id) }
+    raise "More than one github user id found for name '#{name}': #{org_member_logins}" if org_member_logins.size > 1
+
+    if org_member_logins.size == 1
+      @user_id_cache[name] = org_member_logins[0]
+      return @user_id_cache[name]
+    end
+    nil
+  end
+
+  # Fetch user data based on user login
+  def fetch_user(user_login)
+    @client.user(user_login)
+  end
+
+  def organization_member?(org_name, user_id)
+    @client.organization_member?(org_name, user_id)
+  end
+
+  # Branches #
+
+  def delete_branch(branch_name)
+    if @is_dry_run
+      puts "Would have deleted branch #{branch_name} from GitHub."
+      true
+    else
+      @client.delete_branch(@repo, branch_name)
+    end
+  end
+
+  def branch_protected?(branch_name)
+    @client.branch(@repo, branch_name).protected
+  end
+
+  # Releases #
+
+  # Creates a new release on github. If a release already exists with the same name delete that
+  # release before creating it again.
+  def create_or_update_draft_release(release_name, release_notes, git_tag_name, upload_asset_file_paths, git_ref)
+    if @is_dry_run
+      puts "Would have created github release with release name: #{release_name}, release notes: #{release_notes}, " \
+           "git tag name: #{git_tag_name}, asset_file_paths: #{upload_asset_file_paths}, and git_ref: #{git_ref}"
+      return
+    end
+    release = @client.list_releases(@repo).select { |item| item.name == release_name }.first
+
+    if release&.draft == false
+      puts "Release #{release_name} is not a draft. Do nothing"
+      return
+    end
+
+    @client.delete_release(release.url) if release
+
+    # Create Release
+    new_release = @client.create_release(
+      @repo,
+      git_tag_name,
+      target_commitish: git_ref,
+      name: release_name,
+      body: release_notes,
+      draft: true,
+      prerelease: false
+    )
+
+    # Upload assests
+    upload_asset_file_paths.each do |file_path|
+      absolute_path = File.absolute_path(file_path)
+      raise "File does not exist at path #{file_path}" unless File.exist?(absolute_path)
+
+      @client.upload_asset(new_release['url'], absolute_path)
+    end
+  end
+
+  # Publish a preexisting draft release on Github
+  def publish_release(release_name)
+    release = @client.list_releases(@repo).select { |item| item.name == release_name }.first
+    raise "No release found with release_name = #{release_name}" unless release
+
+    if @is_dry_run
+      puts "Would have released release #{release_name} on GitHub."
+    else
+      result = @client.update_release(release.url, draft: false)
+      puts 'Release is still a draft' if result[:draft] == true
+      nil
+    end
+  end
+
+  # Pull Request #
+  def create_pull_request(source_branch, target_branch, title, description = nil)
+    if @is_dry_run
+      puts "Would have created a pull request between branch #{source_branch} and branch #{target_branch} " \
+           "with title: #{title} and description: #{description}"
+      return DummyPR.new
+    end
+    begin
+      @client.create_pull_request(@repo, target_branch, source_branch, title, description)
+    rescue Octokit::UnprocessableEntity => e
+      if e.message.include? 'pull request already exists'
+        pull_request_by_source_and_target_branches(source_branch, target_branch, PULL_REQUEST_STATE_OPEN)
+      end
+    end
+  end
+
+  def approve_pull_request(pr_number)
+    if @is_dry_run
+      puts "Would have approved PR ##{pr_number}"
+    else
+      options = { event: 'APPROVE' }
+      @client.create_pull_request_review(@repo, pr_number, options)
+      nil
+    end
+  end
+
+  def pull_request_approved?(pr_number)
+    list_of_approvals = @client.pull_request_reviews(@repo, pr_number).select { |item| item[:state] == 'APPROVED' }
+    !list_of_approvals.empty?
+  end
+
+  # Given a list of globular patterns that match filepaths return a list
+  # of filepaths that don't match the provided glob patterns
+  def get_nonmatching_changes(pr_number, matching_glob_list)
+    changes = @client.pull_request_files(@repo, pr_number).map(&:filename)
+    matching_glob_list.each do |matching_glob|
+      changes.reject! { |filepath| File.fnmatch(matching_glob, filepath, File::FNM_DOTMATCH) }
+    end
+    changes
+  end
+
+  def pull_request(pr_number)
+    @client.pull_request(@repo, pr_number)
+  end
+
+  # Finds the first pull request that matches the source and target branch matching criteria.
+  # Wildcard characters '*' can be used as matching criteria.
+  def pull_request_by_source_and_target_branches(source_branch, target_branch, state)
+    @client.pull_requests(@repo, state: state).find do |item|
+      source_branch_matches = [item.head.ref, '*'].include?(source_branch)
+      target_branch_matches = [item.base.ref, '*'].include?(target_branch)
+      source_branch_matches && target_branch_matches
+    end
+  end
+
+  def add_comment_to_pr(pr_number, comment)
+    if @is_dry_run
+      puts "Would have added comment '#{comment}' to PR ##{pr_number}"
+    else
+      @client.add_comment(@repo, pr_number, comment)
+      nil
+    end
+  end
+
+  def assign_pr(pr_number, username_list, replace: false)
+    clean_username_list = username_list.compact.uniq
+    if @is_dry_run
+      puts "Would have assigned users: #{clean_username_list.join(', ')} to PR ##{pr_number}. Replace: #{replace}"
+    elsif replace
+      @client.update_issue(@repo, pr_number, assignees: clean_username_list)
+    else
+      pull_request = pull_request(pr_number)
+      assignees = pull_request['assignees'].map { |item| item['login'] }
+      all_assignees = assignees + clean_username_list
+      @client.update_issue(@repo, pr_number, assignees: all_assignees)
+    end
+  end
+
+  def merge_pull_request(pr_number, commit_title, commit_message, sha, merge_method)
+    options = {
+      'commit_title' => commit_title,
+      'sha' => sha,
+      'merge_method' => merge_method
+    }
+    if @is_dry_run
+      puts "Would have merged pull request ##{pr_number} with options: #{options} " \
+           ", commit message: #{commit_message}, and merge method: #{merge_method}"
+    else
+      @client.merge_pull_request(@repo, pr_number, commit_message || '', options)
+      nil
+    end
+  end
+
+  def pull_request_is_merged?(pr_number)
+    @client.pull_merged?(@repo, pr_number)
+  end
+
+  def pull_request_commits(pr_number)
+    @client.pull_request_commits(@repo, pr_number)
+  end
+
+  # Pull Request Labels #
+
+  # Adds git labels to the provided PR
+  #
+  # @param pr_number [Integer] The number of the PR to add the labels to
+  # @param labels [[String]] An array of Strings
+  # @return [nil]
+  def add_labels_to_pr(pr_number:, labels:)
+    if @is_dry_run
+      puts "Would have added labels: #{labels.join(', ')} to PR ##{pr_number}"
+    else
+      @client.add_labels_to_an_issue(@repo, pr_number, labels)
+      nil
+    end
+  end
+
+  def remove_label_from_pr(pr_number, label)
+    if @is_dry_run
+      puts "Would have removed label: #{label} from PR ##{pr_number}"
+    else
+      @client.remove_label(@repo, pr_number, label)
+      nil
+    end
+  end
+
+  # Checks if the provided PR has given labels
+  #
+  # @param pr_number [Integer] The number of the PR
+  # @param labels [[String]] An array of labels to check
+  # @return [TrueClass, FalseClass]
+  def pull_request_has_labels?(pr_number:, labels:)
+    pr_labels = @client.labels_for_issue(@repo, pr_number).select { |item| labels.include?(item[:name]) }
+    pr_labels.length == labels.length
+  end
+
+  def pull_request_is_open?(pr_number)
+    @client.pull_request(@repo, pr_number)[:state] == PULL_REQUEST_STATE_OPEN
+  end
+
+  # Milestones #
+
+  def milestone(milestone_name, options = {})
+    @client.list_milestones(@repo, options).select { |item| item[:title] == milestone_name }.first
+  end
+
+  # Status Checks #
+
+  # Get most recent statuses for each context.
+  # See https://developer.github.com/v3/repos/statuses/#get-the-combined-status-for-a-specific-ref
+  def status_checks_for_ref(git_ref)
+    @client.combined_status(@repo, git_ref)
+  end
+
+  # Get the a set of context names for the required status checks for the given branch.
+  # This API requires that the account associated with the API key being used have
+  # admin access to the repository.
+  def required_status_checks_for_branch(branch_name)
+    branch_protection_info = @client.branch_protection(@repo, branch_name)
+    return Set.new if branch_protection_info.nil? || branch_protection_info.required_status_checks.empty?
+
+    Set.new(branch_protection_info.required_status_checks.contexts)
+  rescue Octokit::NotFound => e
+    raise "Branch protection not found for branch_name = #{branch_name}" if e.message.include? 'Branch not found'
+    if e.message.include? 'Not Found'
+      raise 'Branch protection resource not found. Check that the API key has the appropriate permissions.'
+    end
+
+    raise e.message
+  end
+
+  # Add a new status to a commit sha. Possible state options are: "error", "failure",
+  # "pending", "success". Context is the name of the status check
+  def add_status(git_commit_sha, state, context, description)
+    valid_states = %w[error failure pending success]
+    raise "Github status state must be one of #{valid_states.join(', ')}" unless Set.new(valid_states).include?(state)
+
+    options = {
+      context: context,
+      description: description
+    }
+    if @is_dry_run
+      puts "Would have created status for git sha: #{git_commit_sha} with state: #{state} and options: #{options}"
+    else
+      @client.create_status(@repo, git_commit_sha, state, options)
+      nil
+    end
+  end
+
+  # Return a set of status check context names which have not successfully completed
+  def unsatisfied_required_status_checks(branch_name, git_ref)
+    current_statuses = status_checks_for_ref(git_ref)['statuses']
+
+    successful_statuses_set = Set.new
+    current_statuses.select { |status| status.state == 'success' }.each do |current_status|
+      successful_statuses_set.add(current_status.context)
+    end
+
+    required_status_check_set = required_status_checks_for_branch(branch_name)
+    required_status_check_set.subtract(successful_statuses_set)
+
+    required_status_check_set
+  end
+
+  # Contents #
+
+  def content(path, git_ref)
+    @client.contents(@repo, path: path, ref: git_ref)
+  end
+
+  def content_size(path, git_ref)
+    content(path, git_ref)[:size].to_i
+  end
+end
+
+# Class for impersonating a pull request response when is_dry_run is true
+class DummyPR < Object
+  def number
+    '9999999'
+  end
+
+  def html_url
+    'https://github.com/fake_pr_link'
+  end
+
+  def [](key)
+    case key
+    when :number
+      '9999999'
+    when :html_url
+      'https://github.com/fake_pr_link'
+    when :base
+      { ref: 'TARGET_BRANCH' }
+    else
+      raise "Unsupported key #{key} for DummyPR"
+    end
+  end
+end