fastlane-plugin-waldo 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f32ec479ee63b1ab4f8927cb26ee7b49562c5ea8
-  data.tar.gz: 42c8849320d5ff492788e542866c71b45a9b3773
+  metadata.gz: 0312eb8f82f68eaaa890579f32df69021f403e15
+  data.tar.gz: 517fa6efaa6b61874e22cf5ef28446e28fcebf63
 SHA512:
-  metadata.gz: 49ea9aef680aa191a35d3b3a6a0bdf2f9ce809ffc4ce69e373e2b0d8ca2462547b1a806a92ca0669528a3c9ff4c565251f81d688ebb8c1ec6592339368d0a361
-  data.tar.gz: 2bd510d3f86f923f9ac982b26e90032e678f4aaed3bff69f4f9413c3f628cdaca7c2c4898224dbaf0cf31382d23465b482b9097637354b8a17465537f79762e4
+  metadata.gz: 96627fe481183b67111d6e3d61e6bd2c6f77e916f562308f0c9d7ad486667890ae438affcf41d8982bc9feb7b359732c93b971bacbc4ed8dd7cba962f1cd9528
+  data.tar.gz: d644bb93a1f79e0f4d30f5495df16ed71234e142c4c01d1a2c8af45b26b751028731c3b42f4a0575dd85775455a949418796c6bb57cfdaf36ff976ce7ada6400

data/lib/fastlane/plugin/waldo/actions/waldo_action.rb

@@ -2,34 +2,23 @@ module Fastlane
   module Actions
     class WaldoAction < Action
       def self.run(params)
-        params.values   # validate all inputs
-
-        platform = Actions.lane_context[Actions::SharedValues::PLATFORM_NAME]
-
-        if platform == :android
-          UI.error("You must pass an APK path to the Waldo action") and return unless params[:apk_path]
-        elsif platform == :ios || platform.nil?
-          UI.error("You must pass an IPA or app path to the Waldo action") and return unless params[:ipa_path] || params[:app_path]
-        end
-
-        UI.error("You must pass an upload token to the Waldo action") and return unless params[:upload_token]
+        return unless Helper::WaldoHelper.validate_parameters(params)
 
         FastlaneCore::PrintTable.print_values(config: params,
                                               title: "Summary for waldo #{Fastlane::Waldo::VERSION.to_s}")
 
-        Helper::WaldoHelper.upload_build(params)
+        Helper::WaldoHelper.upload_build
       end
 
       def self.authors
-        ["eBardX"]
+        ['eBardX']
       end
 
       def self.available_options
-        platform = Actions.lane_context[Actions::SharedValues::PLATFORM_NAME]
-
-        if platform == :android
-          apk_path_default = Dir["*.apk"].last || Dir[File.join("app", "build", "outputs", "apk", "app-release.apk")].last
-        elsif platform == :ios || platform.nil?
+        case Helper::WaldoHelper.get_platform
+        when :android
+          apk_path_default = Dir["*.apk"].last || Dir[File.join('app', 'build', 'outputs', 'apk', 'app-release.apk')].last
+        when :ios
           app_path_default = Dir["*.app"].sort_by { |x| File.mtime(x) }.last
           ipa_path_default = Dir["*.ipa"].sort_by { |x| File.mtime(x) }.last
         end
@@ -37,50 +26,35 @@ module Fastlane
         [
           # iOS-specific
           FastlaneCore::ConfigItem.new(key: :app_path,
-                                       env_name: "WALDO_APP_PATH",
-                                       description: "Path to your app file",
+                                       env_name: 'WALDO_APP_PATH',
+                                       description: 'Path to your app file',
                                        default_value: app_path_default,
                                        default_value_dynamic: true,
-                                       optional: true,
-                                       verify_block: proc do |value|
-                                         UI.error("Unable to find app file at path '#{value.to_s}'") unless File.exist?(value)
-                                       end),
+                                       optional: true),
           FastlaneCore::ConfigItem.new(key: :ipa_path,
-                                       env_name: "WALDO_IPA_PATH",
-                                       description: "Path to your IPA file (optional if you use the _gym_ or _xcodebuild_ action)",
+                                       env_name: 'WALDO_IPA_PATH',
+                                       description: 'Path to your IPA file (optional if you use the _gym_ or _xcodebuild_ action)',
                                        default_value: Actions.lane_context[Actions::SharedValues::IPA_OUTPUT_PATH] || ipa_path_default,
                                        default_value_dynamic: true,
-                                       optional: true,
-                                       verify_block: proc do |value|
-                                         UI.error("Unable to find IPA file at path '#{value.to_s}'") unless File.exist?(value)
-                                       end),
+                                       optional: true),
           # Android-specific
           FastlaneCore::ConfigItem.new(key: :apk_path,
-                                       env_name: "WALDO_APK_PATH",
-                                       description: "Path to your APK file (optional if you use the _gradle_ action)",
+                                       env_name: 'WALDO_APK_PATH',
+                                       description: 'Path to your APK file (optional if you use the _gradle_ action)',
                                        default_value: Actions.lane_context[Actions::SharedValues::GRADLE_APK_OUTPUT_PATH] || apk_path_default,
                                        default_value_dynamic: true,
-                                       optional: true,
-                                       verify_block: proc do |value|
-                                         UI.error("Unable to find APK file at path '#{value.to_s}'") unless File.exist?(value)
-                                       end),
+                                       optional: true),
           # General
           FastlaneCore::ConfigItem.new(key: :upload_token,
-                                       env_name: "WALDO_UPLOAD_TOKEN",
-                                       description: "Waldo upload token",
+                                       env_name: 'WALDO_UPLOAD_TOKEN',
+                                       description: 'Waldo upload token',
                                        optional: true,
-                                       sensitive: true,
-                                       verify_block: proc do |value|
-                                         UI.error("No upload token for Waldo given, pass using `upload_token: 'value'`") unless value && !value.empty?
-                                       end),
+                                       sensitive: true),
           FastlaneCore::ConfigItem.new(key: :variant_name,
-                                       env_name: "WALDO_VARIANT_NAME",
-                                       description: "Waldo variant name",
+                                       env_name: 'WALDO_VARIANT_NAME',
+                                       description: 'Waldo variant name',
                                        optional: true,
-                                       sensitive: true,
-                                       verify_block: proc do |value|
-                                         UI.error("No variant name for Waldo given, pass using `variant_name: 'value'`") unless value && !value.empty?
-                                       end)
+                                       sensitive: true)
         ]
       end
 
@@ -89,27 +63,27 @@ module Fastlane
       end
 
       def self.description
-        "Upload a new build to [Waldo](https://www.waldo.io)"
+        'Upload a new build to [Waldo](https://www.waldo.io)'
       end
 
       def self.example_code
         [
           'waldo',
-          'waldo(
-            upload_token: "..."
-          )',
-          'waldo(
-            apk_path: "./YourApp.apk",
-            upload_token: "..."
-          )',
-          'waldo(
-            ipa_path: "./YourApp.ipa",
-            upload_token: "..."
-          )',
-          'waldo(
-            app_path: "./YourApp.app",
-            upload_token: "..."
-          )'
+          "waldo(
+            upload_token: '...'
+          )",
+          "waldo(
+            apk_path: './YourApp.apk',
+            upload_token: '...'
+          )",
+          "waldo(
+            ipa_path: './YourApp.ipa',
+            upload_token: '...'
+          )",
+          "waldo(
+            app_path: './YourApp.app',
+            upload_token: '...'
+          )"
         ]
       end
 

data/lib/fastlane/plugin/waldo/helper/waldo_helper.rb

@@ -3,63 +3,86 @@ require 'net/http'
 module Fastlane
   module Helper
     class WaldoHelper
-      def self.upload_build(params)
-        UI.success('Uploading the build to Waldo. This could take a while…')
+      def self.dump_request(request)
+        len = request.body ? request.body.length : 0
 
-        begin
-          variant_name = params[:variant_name] || Actions.lane_context[Actions::SharedValues::GRADLE_BUILD_TYPE]
-          uri_string = 'https://api.waldo.io/versions'
+        puts "Request: #{request.method} #{request.path} (#{len} bytes)"
 
-          uri_string += "?variantName=#{variant_name}" if variant_name
+        request.each_capitalized do |key, value|
+          puts "  #{key}: #{value}"
+        end
 
-          uri = URI(uri_string)
+        puts '-------'
+      end
 
-          request = build_request(uri, params)
+      def self.dump_response(response)
+        puts "Response: #{response.code} #{response.message} (#{response.body.length} bytes)"
 
-          dump_request(request) if FastlaneCore::Globals.verbose?
+        response.each_capitalized do |key, value|
+          puts "  #{key}: #{value}"
+        end
 
-          Net::HTTP.start(uri.host, uri.port, :use_ssl => true) do |http|
-            http.read_timeout = 120   # 2 minutes
+        puts "#{response.body}"
+      end
 
-            parse_response(http.request(request))
-          end
-        rescue Net::ReadTimeout
-          UI.error("Upload to Waldo timed out!")
-        rescue => exc
-          UI.error("Something went wrong uploading to Waldo: #{exc.inspect.to_s}")
-        ensure
-          request.body_stream.close if request && request.body_stream
+      def self.get_authorization
+        "Upload-Token #{@upload_token}"
+      end
+
+      def self.get_flavor
+        case get_platform
+        when :android
+          "Android"
+        when :ios
+          "iOS"
+        else
+          "unknown"
         end
       end
 
-      def self.build_request(uri, params)
-        platform = Actions.lane_context[Actions::SharedValues::PLATFORM_NAME]
+      def self.get_platform
+        Actions.lane_context[Actions::SharedValues::PLATFORM_NAME] || :ios
+      end
 
-        if platform == :android
-          body_path = params[:apk_path]
-          flavor = "Android"
-        elsif platform == :ios || platform.nil?
-          if params[:app_path]
-            app_dir_path = File.dirname(params[:app_path])
-            app_name = File.basename(params[:app_path])
-            body_path = File.join(Dir.tmpdir, "#{app_name}.zip")
+      def self.get_user_agent
+        "Waldo fastlane/#{get_flavor} v#{Fastlane::Waldo::VERSION}"
+      end
 
-            Actions.sh(%(cd "#{app_dir_path}" && zip -qry "#{body_path}" "#{app_name}"))
-          else
-            body_path = params[:ipa_path]
+      def self.handle_error(message)
+        UI.error(message)
+
+        UI.error('No token for error report upload to Waldo!') unless @upload_token
+
+        upload_error(message) if @upload_token
+      end
+
+      def self.make_build_request(uri)
+        if @apk_path
+          body_path = @apk_path
+        elsif @ipa_path
+          body_path = @ipa_path
+        else
+          app_basename = File.basename(@app_path)
+          app_dirname = File.dirname(@app_path)
+
+          body_path = File.join(Dir.tmpdir, "#{app_basename}.zip")
+
+          unless zip(src_path: app_basename,
+                     zip_path: body_path,
+                     cd_path: app_dirname)
+            return nil
           end
-          flavor = "iOS"
         end
 
         request = Net::HTTP::Post.new(uri.request_uri)
 
-        request['Authorization'] = "Upload-Token #{params[:upload_token]}"
+        request['Authorization'] = get_authorization
         request['Transfer-Encoding'] = 'chunked'
-        request['User-Agent'] = "Waldo fastlane/#{flavor} v#{Fastlane::Waldo::VERSION}"
+        request['User-Agent'] = get_user_agent
 
         request.body_stream = WaldoReadIO.new(body_path)
 
-        if params[:app_path]
+        if @app_path
           request.content_type = 'application/zip'
         else
           request.content_type = 'application/octet-stream'
@@ -68,39 +91,213 @@ module Fastlane
         request
       end
 
-      def self.dump_request(request)
-        len = request.body ? request.body.length : 0
+      def self.make_build_uri
+        uri_string = 'https://api.waldo.io/versions'
 
-        puts "Request: #{request.method} #{request.path} (#{len} bytes)"
+        uri_string += "?variantName=#{@variant_name}" if @variant_name
 
-        request.each_capitalized do |key, value|
-          puts "  #{key}: #{value}"
-        end
-
-        puts "-------"
+        URI(uri_string)
       end
 
-      def self.dump_response(response)
-        puts "Response: #{response.code} #{response.message} (#{response.body.length} bytes)"
+      def self.make_error_request(uri, message)
+        request = Net::HTTP::Post.new(uri.request_uri)
 
-        response.each_capitalized do |key, value|
-          puts "  #{key}: #{value}"
-        end
+        request['Authorization'] = get_authorization
+        request['User-Agent'] = get_user_agent
 
-        puts "#{response.body}"
+        request.body = { "message": message }.to_json
+        request.content_type = 'application/json'
+
+        request
+      end
+
+      def self.make_error_uri
+          uri_string = 'https://api.waldo.io/uploadError'
+
+          URI(uri_string)
       end
 
-      def self.parse_response(response)
+      def self.parse_build_response(response)
         dump_response(response) if FastlaneCore::Globals.verbose?
 
         case response.code.to_i
         when 200..299
           UI.success('Build successfully uploaded to Waldo!')
         when 401
-          UI.error("Upload token is invalid or missing!")
+          handle_error('Token is invalid or missing for build upload to Waldo!')
+        else
+          handle_error("Build failed to upload to Waldo: #{response.code} #{response.message}")
+        end
+      end
+
+      def self.parse_error_response(response)
+        dump_response(response) if FastlaneCore::Globals.verbose?
+
+        case response.code.to_i
+        when 200..299
+          UI.success('Error report successfully uploaded to Waldo!')
+        when 401
+          UI.error('Token is invalid or missing for error report upload to Waldo!')
+        else
+          UI.error("Error report failed to upload to Waldo: #{response.code} #{response.message}")
+        end
+      end
+
+      def self.upload_build
+        begin
+          @variant_name ||= Actions.lane_context[Actions::SharedValues::GRADLE_BUILD_TYPE]
+
+          uri = make_build_uri
+
+          request = make_build_request(uri)
+
+          return unless request
+
+          UI.success('Uploading the build to Waldo. This could take a while…')
+
+          dump_request(request) if FastlaneCore::Globals.verbose?
+
+          Net::HTTP.start(uri.host, uri.port, :use_ssl => true) do |http|
+            http.read_timeout = 120   # 2 minutes
+
+            parse_build_response(http.request(request))
+          end
+        rescue Net::ReadTimeout => exc
+          handle_error('Build upload to Waldo timed out!')
+        rescue => exc
+          handle_error("Something went wrong uploading build to Waldo: #{exc.inspect.to_s}")
+        ensure
+          request.body_stream.close if request && request.body_stream
+        end
+      end
+
+      def self.upload_error(message)
+        begin
+          uri = make_error_uri
+
+          request = make_error_request(uri, message)
+
+          UI.error('Uploading error report to Waldo…')
+
+          dump_request(request) if FastlaneCore::Globals.verbose?
+
+          Net::HTTP.start(uri.host, uri.port, :use_ssl => true) do |http|
+            http.read_timeout = 30  # seconds
+
+            parse_error_response(http.request(request))
+          end
+        rescue Net::ReadTimeout => exc
+          UI.error('Error report upload to Waldo timed out!')
+        rescue => exc
+          UI.error("Something went wrong uploading error report to Waldo: #{exc.inspect.to_s}")
+        end
+      end
+
+      def self.validate_parameters(params)
+        @apk_path = params[:apk_path]
+        @app_path = params[:app_path]
+        @ipa_path = params[:ipa_path]
+        @upload_token = params[:upload_token]
+        @variant_name = params[:variant_name]
+
+        if @upload_token && @upload_token.empty?
+          @upload_token = nil                       # easier to test
+        end
+
+        unless @upload_token
+          handle_error('You must pass a nonempty upload token to the Waldo action')
+
+          return false
+        end
+
+        case get_platform
+        when :android
+          unless @apk_path
+            handle_error('You must pass an APK path to the Waldo action')
+
+            return false
+          end
+
+          @apk_path.gsub!("\\ ", ' ')
+
+          unless File.exist?(@apk_path)
+            handle_error("Unable to find APK at path '#{@apk_path.to_s}'")
+
+            return false
+          end
+
+          unless File.file?(@apk_path) && File.readable?(@apk_path)
+            handle_error("Unable to read APK at path '#{@apk_path.to_s}'")
+
+            return false
+          end
+        when :ios
+          unless @app_path || @ipa_path
+            handle_error('You must pass an IPA or app path to the Waldo action')
+
+            return false
+          end
+
+          if @app_path
+            @app_path.gsub!("\\ ", ' ')
+
+            unless File.exist?(@app_path)
+              handle_error("Unable to find app at path '#{@app_path.to_s}'")
+
+              return false
+            end
+
+            unless File.directory?(@app_path) && File.readable?(@app_path)
+              handle_error("Unable to read app at path '#{@app_path.to_s}'")
+
+              return false
+            end
+          elsif @ipa_path
+            @ipa_path.gsub!("\\ ", ' ')
+
+            unless File.exist?(@ipa_path)
+              handle_error("Unable to find IPA at path '#{@ipa_path.to_s}'")
+
+              return false
+            end
+
+            unless File.file?(@ipa_path) && File.readable?(@ipa_path)
+              handle_error("Unable to read IPA at path '#{@ipa_path.to_s}'")
+
+              return false
+            end
+          end
         else
-          UI.error("Build failed to upload to Waldo: #{response.code} #{response.message}")
+            handle_error("Unsupported platform: '#{get_platform.to_s}'")
+
+            return false
         end
+
+        if @variant_name && @variant_name.empty?
+          handle_error('Empty variant name for Waldo given')
+
+          return false
+        end
+
+        return true
+      end
+
+      def self.zip(src_path:, zip_path:, cd_path:)
+        unless FastlaneCore::CommandExecutor.which('zip')
+            handle_error("Command not found: 'zip'")
+
+            return false
+        end
+
+        FileUtils.cd(cd_path) do
+          unless Actions.sh(%(zip -qry "#{zip_path}" "#{src_path}")).empty?
+            handle_error("Unable to zip app at path '#{src_path.to_s}' into '#{zip_path.to_s}'")
+
+            return false
+          end
+        end
+
+        return true
       end
     end
 

data/lib/fastlane/plugin/waldo/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
   module Waldo
-    VERSION = "1.2.0"
+    VERSION = "1.2.1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-waldo
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - J. G. Pusey
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-30 00:00:00.000000000 Z
+date: 2019-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler