fastlane-plugin-appcenter 1.6.0 → 1.9.0

data/lib/fastlane/plugin/appcenter/helper/appcenter_helper.rb

@@ -1,18 +1,31 @@
+class File
+  def each_chunk(chunk_size)
+    yield read(chunk_size) until eof?
+  end
+end
+
 module Fastlane
   module Helper
     class AppcenterHelper
 
+      # Time to wait between 2 status polls in seconds
+      RELEASE_UPLOAD_STATUS_POLL_INTERVAL = 1
+
+      # Maximum number of retries for a request
+      MAX_REQUEST_RETRIES = 2
+
+      # Delay between retries in seconds
+      REQUEST_RETRY_INTERVAL = 5
+
       # basic utility method to check file types that App Center will accept,
       # accounting for file types that can and should be zip-compressed
       # before they are uploaded
       def self.file_extname_full(path)
-        is_zip = File.extname(path) == ".zip"
-
-        # if file is not .zip'ed, these do not change basename and extname
-        unzip_basename = File.basename(path, ".zip")
-        unzip_extname = File.extname(unzip_basename)
+        %w(.app.zip .dSYM.zip).each do |suffix|
+          return suffix if path.to_s.downcase.end_with? suffix.downcase
+        end
 
-        is_zip ? unzip_extname + ".zip" : unzip_extname
+        File.extname path
       end
 
       # create request
@@ -20,10 +33,16 @@ module Fastlane
         require 'faraday'
         require 'faraday_middleware'
 
+        default_api_url = "https://api.appcenter.ms"
+        if ENV['APPCENTER_ENV']&.upcase == 'INT'
+          default_api_url = "https://api-gateway-core-integration.dev.avalanch.es"
+        end
         options = {
-          url: upload_url || ENV.fetch('APPCENTER_UPLOAD_URL', "https://api.appcenter.ms")
+          url: upload_url || default_api_url
         }
 
+        UI.message("DEBUG: BASE URL #{options[:url]}") if ENV['DEBUG']
+
         Faraday.new(options) do |builder|
           if upload_url
             builder.request :multipart unless dsym
@@ -43,16 +62,20 @@ module Fastlane
       # upload_url
       def self.create_release_upload(api_token, owner_name, app_name, body)
         connection = self.connection
+        url = "v0.1/apps/#{owner_name}/#{app_name}/uploads/releases"
+        body ||= {}
 
-        response = connection.post("v0.1/apps/#{owner_name}/#{app_name}/release_uploads") do |req|
+        UI.message("DEBUG: POST #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: POST body: #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
+        response = connection.post(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
-          req.body = body.nil? && {} || body
+          req.body = body
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
         case response.status
         when 200...300
-          UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
           response.body
         when 401
           UI.user_error!("Auth Error, provided invalid token")
@@ -61,7 +84,7 @@ module Fastlane
           UI.error("Not found, invalid owner or application name")
           false
         when 500...600
-          UI.crash!("Internal Service Error, please try again later")
+          UI.abort_with_message!("Internal Service Error, please try again later")
         else
           UI.error("Error #{response.status}: #{response.body}")
           false
@@ -76,20 +99,27 @@ module Fastlane
       def self.create_mapping_upload(api_token, owner_name, app_name, file_name, build_number, version)
         connection = self.connection
 
-        response = connection.post("v0.1/apps/#{owner_name}/#{app_name}/symbol_uploads") do |req|
+        url = "v0.1/apps/#{owner_name}/#{app_name}/symbol_uploads"
+        body = {
+          symbol_type: "AndroidProguard",
+          file_name: file_name,
+          build: build_number,
+          version: version,
+        }
+
+        UI.message("DEBUG: POST #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: POST body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
+
+        response = connection.post(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
-          req.body = {
-            symbol_type: "AndroidProguard",
-            file_name: file_name,
-            build: build_number,
-            version: version,
-          }
+          req.body = body
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
         case response.status
         when 200...300
-          UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
           response.body
         when 401
           UI.user_error!("Auth Error, provided invalid token")
@@ -111,17 +141,24 @@ module Fastlane
       def self.create_dsym_upload(api_token, owner_name, app_name)
         connection = self.connection
 
-        response = connection.post("v0.1/apps/#{owner_name}/#{app_name}/symbol_uploads") do |req|
+        url = "v0.1/apps/#{owner_name}/#{app_name}/symbol_uploads"
+        body = {
+          symbol_type: 'Apple'
+        }
+
+        UI.message("DEBUG: POST #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: POST body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
+
+        response = connection.post(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
-          req.body = {
-            symbol_type: 'Apple'
-          }
+          req.body = body
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
         case response.status
         when 200...300
-          UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
           response.body
         when 401
           UI.user_error!("Auth Error, provided invalid token")
@@ -139,17 +176,24 @@ module Fastlane
       def self.update_symbol_upload(api_token, owner_name, app_name, symbol_upload_id, status)
         connection = self.connection
 
-        response = connection.patch("v0.1/apps/#{owner_name}/#{app_name}/symbol_uploads/#{symbol_upload_id}") do |req|
+        url = "v0.1/apps/#{owner_name}/#{app_name}/symbol_uploads/#{symbol_upload_id}"
+        body = {
+          status: status
+        }
+
+        UI.message("DEBUG: PATCH #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: PATCH body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
+
+        response = connection.patch(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
-          req.body = {
-            "status" => status
-          }
+          req.body = body
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
         case response.status
         when 200...300
-          UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
           response.body
         when 401
           UI.user_error!("Auth Error, provided invalid token")
@@ -166,6 +210,9 @@ module Fastlane
       def self.upload_symbol(api_token, owner_name, app_name, symbol, symbol_type, symbol_upload_id, upload_url)
         connection = self.connection(upload_url, true)
 
+        UI.message("DEBUG: PUT #{upload_url}") if ENV['DEBUG']
+        UI.message("DEBUG: PUT body <data>\n") if ENV['DEBUG']
+
         response = connection.put do |req|
           req.headers['x-ms-blob-type'] = "BlockBlob"
           req.headers['Content-Length'] = File.size(symbol).to_s
@@ -173,77 +220,182 @@ module Fastlane
           req.body = Faraday::UploadIO.new(symbol, 'application/octet-stream') if symbol && File.exist?(symbol)
         end
 
-        logType = "dSYM" if (symbol_type == "Apple")
-        logType = "mapping" if (symbol_type == "Android")
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
+        log_type = "dSYM" if symbol_type == "Apple"
+        log_type = "mapping" if symbol_type == "Android"
 
         case response.status
         when 200...300
           self.update_symbol_upload(api_token, owner_name, app_name, symbol_upload_id, 'committed')
-          UI.success("#{logType} uploaded")
+          UI.success("#{log_type} uploaded")
         when 401
           UI.user_error!("Auth Error, provided invalid token")
           false
         else
-          UI.error("Error uploading #{logType} #{response.status}: #{response.body}")
+          UI.error("Error uploading #{log_type} #{response.status}: #{response.body}")
           self.update_symbol_upload(api_token, owner_name, app_name, symbol_upload_id, 'aborted')
-          UI.error("#{logType} upload aborted")
+          UI.error("#{log_type} upload aborted")
           false
         end
       end
 
-      # upload binary for specified upload_url
-      # if succeed, then commits the release
-      # otherwise aborts
-      def self.upload_build(api_token, owner_name, app_name, file, upload_id, upload_url, timeout)
-        connection = self.connection(upload_url)
+      # sets metadata for new upload in App Center
+      # returns:
+      # chunk size
+      def self.set_release_upload_metadata(set_metadata_url, api_token, owner_name, app_name, upload_id, timeout)
+        connection = self.connection(set_metadata_url)
 
-        options = {}
-        options[:upload_id] = upload_id
-        # ipa field is used for .apk, .aab and .ipa files
-        options[:ipa] = Faraday::UploadIO.new(file, 'application/octet-stream') if file && File.exist?(file)
+        UI.message("DEBUG: POST #{set_metadata_url}") if ENV['DEBUG']
+        UI.message("DEBUG: POST body <data>\n") if ENV['DEBUG']
+        response = connection.post do |req|
+          req.options.timeout = timeout
+          req.headers['internal-request-source'] = "fastlane"
+        end
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
 
+        case response.status
+        when 200...300
+          chunk_size = response.body['chunk_size']
+          unless chunk_size.is_a? Integer
+            UI.error("Set metadata didn't return chunk size: #{response.status}: #{response.body}")
+            false
+          else
+            UI.message("Metadata set")
+            chunk_size
+          end
+        when 401
+          UI.user_error!("Auth Error, provided invalid token")
+          false
+        else
+          UI.error("Error setting metadata: #{response.status}: #{response.body}")
+          false
+        end
+      end
+
+      # Verifies a successful upload to App Center
+      # returns:
+      # successful upload response body.
+      def self.finish_release_upload(finish_url, api_token, owner_name, app_name, upload_id, timeout)
+        connection = self.connection(finish_url)
+
+        UI.message("DEBUG: POST #{finish_url}") if ENV['DEBUG']
         response = connection.post do |req|
           req.options.timeout = timeout
           req.headers['internal-request-source'] = "fastlane"
-          req.body = options
         end
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
 
         case response.status
         when 200...300
-          UI.message("Binary uploaded")
-          self.update_release_upload(api_token, owner_name, app_name, upload_id, 'committed')
+          if response.body['error'] == false
+            UI.message("Upload finished")
+            self.update_release_upload(api_token, owner_name, app_name, upload_id, 'uploadFinished')
+          else
+            UI.error("Error finishing upload: #{response.body['message']}")
+            false
+          end
         when 401
           UI.user_error!("Auth Error, provided invalid token")
           false
         else
-          UI.error("Error uploading binary #{response.status}: #{response.body}")
-          self.update_release_upload(api_token, owner_name, app_name, upload_id, 'aborted')
-          UI.error("Release aborted")
+          UI.error("Error finishing upload: #{response.status}: #{response.body}")
           false
         end
       end
 
+      # upload binary for specified upload_url
+      # if succeed, then commits the release
+      # otherwise aborts
+      def self.upload_build(api_token, owner_name, app_name, file, upload_id, upload_url, content_type, chunk_size, timeout)
+        block_number = 1
+
+        File.open(file).each_chunk(chunk_size) do |chunk|
+          upload_chunk_url = "#{upload_url}&block_number=#{block_number}"
+          retries = 0
+
+          while retries <= MAX_REQUEST_RETRIES
+            begin
+              connection = self.connection(upload_chunk_url, true)
+
+              UI.message("DEBUG: POST #{upload_chunk_url}") if ENV['DEBUG']
+              UI.message("DEBUG: POST body <data>\n") if ENV['DEBUG']
+              response = connection.post do |req|
+                req.options.timeout = timeout
+                req.headers['internal-request-source'] = "fastlane"
+                req.headers['Content-Length'] = chunk.length.to_s
+                req.body = chunk
+              end
+              UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+              status = response.status
+              message = response.body
+            rescue Faraday::Error => e
+
+              # Low level HTTP errors, we will retry them
+              status = 0
+              message = e.message
+            end
+
+            case status
+            when 200...300
+              if response.body['error'] == false
+                UI.message("Chunk uploaded")
+                block_number += 1
+                break
+              else
+                UI.error("Error uploading binary #{response.body['message']}")
+                return false
+              end
+            when 401
+              UI.user_error!("Auth Error, provided invalid token")
+              return false
+            when 400...407, 409...428, 430...499
+              UI.user_error!("Client error: #{response.status}: #{response.body}")
+              return false
+            else
+              if retries < MAX_REQUEST_RETRIES
+                UI.message("DEBUG: Retryable error uploading binary #{status}: #{message}")
+                retries += 1
+                sleep(REQUEST_RETRY_INTERVAL)
+              else
+                UI.error("Error uploading binary #{status}: #{message}")
+                return false
+              end
+            end
+          end
+        end
+        UI.message("Binary uploaded")
+      end
+
       # Commits or aborts the upload process for a release
       def self.update_release_upload(api_token, owner_name, app_name, upload_id, status)
         connection = self.connection
 
-        response = connection.patch("v0.1/apps/#{owner_name}/#{app_name}/release_uploads/#{upload_id}") do |req|
+        url = "v0.1/apps/#{owner_name}/#{app_name}/uploads/releases/#{upload_id}"
+        body = {
+          upload_status: status,
+          id: upload_id
+        }
+
+        UI.message("DEBUG: PATCH #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: PATCH body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
+
+        response = connection.patch(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
-          req.body = {
-            "status" => status
-          }
+          req.body = body
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
         case response.status
         when 200...300
-          UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
           response.body
         when 401
           UI.user_error!("Auth Error, provided invalid token")
           false
         when 500...600
-          UI.crash!("Internal Service Error, please try again later")
+          UI.abort_with_message!("Internal Service Error, please try again later")
         else
           UI.error("Error #{response.status}: #{response.body}")
           false
@@ -253,15 +405,21 @@ module Fastlane
       # get existing release
       def self.get_release(api_token, owner_name, app_name, release_id)
         connection = self.connection
-        response = connection.get("v0.1/apps/#{owner_name}/#{app_name}/releases/#{release_id}") do |req|
+
+        url = "v0.1/apps/#{owner_name}/#{app_name}/releases/#{release_id}"
+
+        UI.message("DEBUG: GET #{url}") if ENV['DEBUG']
+
+        response = connection.get(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
         case response.status
         when 200...300
           release = response.body
-          UI.message("DEBUG: #{JSON.pretty_generate(release)}") if ENV['DEBUG']
           release
         when 404
           UI.error("Not found, invalid release url")
@@ -275,19 +433,58 @@ module Fastlane
         end
       end
 
+      # Polls the upload for a release id. When a release is uploaded, we have to check
+      # for a successful extraction before we can continue.
+      # returns:
+      # release_distinct_id
+      def self.poll_for_release_id(api_token, url)
+        connection = self.connection
+
+        while true
+          UI.message("DEBUG: GET #{url}") if ENV['DEBUG']
+          response = connection.get(url) do |req|
+            req.headers['X-API-Token'] = api_token
+            req.headers['internal-request-source'] = "fastlane"
+          end
+
+          UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
+          case response.status
+          when 200...300
+            case response.body['upload_status']
+            when "readyToBePublished"
+              return response.body['release_distinct_id']
+            when "error"
+              UI.error("Error fetching release: #{response.body['error_details']}")
+              return false
+            else
+              sleep(RELEASE_UPLOAD_STATUS_POLL_INTERVAL)
+            end
+          else
+            UI.error("Error fetching information about release #{response.status}: #{response.body}")
+            return false
+          end
+        end
+      end
+
       # get distribution group or store
       def self.get_destination(api_token, owner_name, app_name, destination_type, destination_name)
         connection = self.connection
 
-        response = connection.get("v0.1/apps/#{owner_name}/#{app_name}/distribution_#{destination_type}s/#{ERB::Util.url_encode(destination_name)}") do |req|
+        url = "v0.1/apps/#{owner_name}/#{app_name}/distribution_#{destination_type}s/#{ERB::Util.url_encode(destination_name)}"
+
+        UI.message("DEBUG: GET #{url}") if ENV['DEBUG']
+
+        response = connection.get(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
         case response.status
         when 200...300
           destination = response.body
-          UI.message("DEBUG: received #{destination_type} #{JSON.pretty_generate(destination)}") if ENV['DEBUG']
           destination
         when 404
           UI.error("Not found, invalid distribution #{destination_type} name")
@@ -305,14 +502,22 @@ module Fastlane
       def self.update_release(api_token, owner_name, app_name, release_id, release_notes = '')
         connection = self.connection
 
-        response = connection.put("v0.1/apps/#{owner_name}/#{app_name}/releases/#{release_id}") do |req|
+        url = "v0.1/apps/#{owner_name}/#{app_name}/releases/#{release_id}"
+        body = {
+          release_notes: release_notes
+        }
+
+        UI.message("DEBUG: PUT #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: PUT body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
+
+        response = connection.put(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
-          req.body = {
-            release_notes: release_notes
-          }
+          req.body = body
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
         case response.status
         when 200...300
           # get full release info
@@ -321,8 +526,6 @@ module Fastlane
 
           download_url = release['download_url']
 
-          UI.message("DEBUG: #{JSON.pretty_generate(release)}") if ENV['DEBUG']
-
           Actions.lane_context[Fastlane::Actions::SharedValues::APPCENTER_DOWNLOAD_LINK] = download_url
           Actions.lane_context[Fastlane::Actions::SharedValues::APPCENTER_BUILD_INFORMATION] = release
 
@@ -345,19 +548,25 @@ module Fastlane
       def self.update_release_metadata(api_token, owner_name, app_name, release_id, dsa_signature)
         return if dsa_signature.to_s == ''
 
-        release_metadata = {
-          dsa_signature: dsa_signature
+        url = "v0.1/apps/#{owner_name}/#{app_name}/releases/#{release_id}"
+        body = {
+          metadata: {
+            dsa_signature: dsa_signature
+          }
         }
 
+        UI.message("DEBUG: PATCH #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: PATCH body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
+
         connection = self.connection
-        response = connection.patch("v0.1/apps/#{owner_name}/#{app_name}/releases/#{release_id}") do |req|
+        response = connection.patch(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
-          req.body = {
-            metadata: release_metadata
-          }
+          req.body = body
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
         case response.status
         when 200...300
           UI.message("Release Metadata was successfully updated for release '#{release_id}'")
@@ -372,25 +581,32 @@ module Fastlane
           false
         end
       end
-      
+
       # add release to distribution group or store
       def self.add_to_destination(api_token, owner_name, app_name, release_id, destination_type, destination_id, mandatory_update = false, notify_testers = false)
         connection = self.connection
 
-        UI.message("DEBUG: getting #{release_id}") if ENV['DEBUG']
+        url = "v0.1/apps/#{owner_name}/#{app_name}/releases/#{release_id}/#{destination_type}s"
+        body = {
+          id: destination_id
+        }
 
-        body = { "id" => destination_id }
         if destination_type == "group"
           body["mandatory_update"] = mandatory_update
           body["notify_testers"] = notify_testers
         end
 
-        response = connection.post("v0.1/apps/#{owner_name}/#{app_name}/releases/#{release_id}/#{destination_type}s") do |req|
+        UI.message("DEBUG: POST #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: POST body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
+
+        response = connection.post(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
           req.body = body
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
         case response.status
         when 200...300
           # get full release info
@@ -399,8 +615,6 @@ module Fastlane
 
           download_url = release['download_url']
 
-          UI.message("DEBUG: received release #{JSON.pretty_generate(release)}") if ENV['DEBUG']
-
           Actions.lane_context[Fastlane::Actions::SharedValues::APPCENTER_DOWNLOAD_LINK] = download_url
           Actions.lane_context[Fastlane::Actions::SharedValues::APPCENTER_BUILD_INFORMATION] = release
 
@@ -423,11 +637,17 @@ module Fastlane
       def self.get_app(api_token, owner_name, app_name)
         connection = self.connection
 
-        response = connection.get("v0.1/apps/#{owner_name}/#{app_name}") do |req|
+        url = "v0.1/apps/#{owner_name}/#{app_name}"
+
+        UI.message("DEBUG: GET #{url}") if ENV['DEBUG']
+
+        response = connection.get(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
         case response.status
         when 200...300
           UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
@@ -448,23 +668,28 @@ module Fastlane
       def self.create_app(api_token, owner_type, owner_name, app_name, app_display_name, os, platform)
         connection = self.connection
 
-        endpoint = owner_type == "user" ? "v0.1/apps" : "v0.1/orgs/#{owner_name}/apps"
+        url = owner_type == "user" ? "v0.1/apps" : "v0.1/orgs/#{owner_name}/apps"
+        body = {
+          display_name: app_display_name,
+          name: app_name,
+          os: os,
+          platform: platform
+        }
+
+        UI.message("DEBUG: POST #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: POST body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
 
-        response = connection.post(endpoint) do |req|
+        response = connection.post(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
-          req.body = {
-            "display_name" => app_display_name,
-            "name" => app_name,
-            "os" => os,
-            "platform" => platform
-          }
+          req.body = body
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
         case response.status
         when 200...300
           created = response.body
-          UI.message("DEBUG: #{JSON.pretty_generate(created)}") if ENV['DEBUG']
           UI.success("Created #{os}/#{platform} app with name \"#{created['name']}\" and display name \"#{created['display_name']}\" for #{owner_type} \"#{owner_name}\"")
           true
         when 401
@@ -479,16 +704,19 @@ module Fastlane
       def self.fetch_distribution_groups(api_token:, owner_name:, app_name:)
         connection = self.connection
 
-        endpoint = "/v0.1/apps/#{owner_name}/#{app_name}/distribution_groups"
+        url = "/v0.1/apps/#{owner_name}/#{app_name}/distribution_groups"
 
-        response = connection.get(endpoint) do |req|
+        UI.message("DEBUG: GET #{url}") if ENV['DEBUG']
+
+        response = connection.get(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
         case response.status
         when 200...300
-          UI.message("DEBUG: #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
           response.body
         when 401
           UI.user_error!("Auth Error, provided invalid token")
@@ -505,16 +733,19 @@ module Fastlane
       def self.fetch_devices(api_token:, owner_name:, app_name:, distribution_group:)
         connection = self.connection(nil, false, true)
 
-        endpoint = "/v0.1/apps/#{owner_name}/#{app_name}/distribution_groups/#{ERB::Util.url_encode(distribution_group)}/devices/download_devices_list"
+        url = "/v0.1/apps/#{owner_name}/#{app_name}/distribution_groups/#{ERB::Util.url_encode(distribution_group)}/devices/download_devices_list"
 
-        response = connection.get(endpoint) do |req|
+        UI.message("DEBUG: GET #{url}") if ENV['DEBUG']
+
+        response = connection.get(url) do |req|
           req.headers['X-API-Token'] = api_token
           req.headers['internal-request-source'] = "fastlane"
         end
 
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
         case response.status
         when 200...300
-          UI.message("DEBUG: #{response.body.inspect}") if ENV['DEBUG']
           response.body
         when 401
           UI.user_error!("Auth Error, provided invalid token")
@@ -528,17 +759,87 @@ module Fastlane
         end
       end
 
-      # Note: This does not support testing environment (INT)
+      def self.fetch_releases(api_token:, owner_name:, app_name:)
+        connection = self.connection(nil, false, true)
+
+        url = "/v0.1/apps/#{owner_name}/#{app_name}/releases"
+
+        UI.message("DEBUG: GET #{url}") if ENV['DEBUG']
+
+        response = connection.get(url) do |req|
+          req.headers['X-API-Token'] = api_token
+          req.headers['internal-request-source'] = "fastlane"
+        end
+
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
+        case response.status
+        when 200...300
+          JSON.parse(response.body)
+        when 401
+          UI.user_error!("Auth Error, provided invalid token")
+          false
+        when 404
+          UI.error("Not found, invalid owner or application name")
+          false
+        else
+          UI.error("Error #{response.status}: #{response.body}")
+          false
+        end
+      end
+
       def self.get_release_url(owner_type, owner_name, app_name, release_id)
         owner_path = owner_type == "user" ? "users/#{owner_name}" : "orgs/#{owner_name}"
+        if ENV['APPCENTER_ENV']&.upcase == 'INT'
+          return "https://portal-server-core-integration.dev.avalanch.es/#{owner_path}/apps/#{app_name}/distribute/releases/#{release_id}"
+        end
+
         return "https://appcenter.ms/#{owner_path}/apps/#{app_name}/distribute/releases/#{release_id}"
       end
 
-      # Note: This does not support testing environment (INT)
       def self.get_install_url(owner_type, owner_name, app_name)
         owner_path = owner_type == "user" ? "users/#{owner_name}" : "orgs/#{owner_name}"
+        if ENV['APPCENTER_ENV']&.upcase == 'INT'
+          return "https://install.portal-server-core-integration.dev.avalanch.es/#{owner_path}/apps/#{app_name}"
+        end
+
         return "https://install.appcenter.ms/#{owner_path}/apps/#{app_name}"
       end
+
+      # add new created app to existing distribution group
+      def self.add_new_app_to_distribution_group(api_token:, owner_name:, app_name:, destination_name:)
+        url = URI.escape("/v0.1/orgs/#{owner_name}/distribution_groups/#{destination_name}/apps")
+        body = {
+          apps: [
+            { name: app_name }
+          ]
+        }
+
+        UI.message("DEBUG: POST #{url}") if ENV['DEBUG']
+        UI.message("DEBUG: POST body #{JSON.pretty_generate(body)}\n") if ENV['DEBUG']
+
+        response = connection.post(url) do |req|
+          req.headers['X-API-Token'] = api_token
+          req.headers['internal-request-source'] = "fastlane"
+          req.body = body
+        end
+
+        UI.message("DEBUG: #{response.status} #{JSON.pretty_generate(response.body)}\n") if ENV['DEBUG']
+
+        case response.status
+        when 200...300
+          created = response.body
+          UI.success("Added new app #{app_name} to distribution group #{destination_name}")
+        when 401
+          UI.user_error!("Auth Error, provided invalid token")
+        when 404
+          UI.error("Not found, invalid distribution group name #{destination_name}")
+        when 409
+          UI.success("App already added to distribution group #{destination_name}")
+        else
+          UI.error("Error adding app to distribution group #{response.status}: #{response.body}")
+        end
+      end
     end
   end
 end