fastlane_pricing_fix 2.212.1

data/fastlane/lib/fastlane/actions/appetize.rb

@@ -0,0 +1,193 @@
+module Fastlane
+  module Actions
+    module SharedValues
+      APPETIZE_PUBLIC_KEY = :APPETIZE_PUBLIC_KEY
+      APPETIZE_APP_URL = :APPETIZE_APP_URL
+      APPETIZE_MANAGE_URL = :APPETIZE_MANAGE_URL
+      APPETIZE_API_HOST = :APPETIZE_API_HOST
+    end
+
+    class AppetizeAction < Action
+      def self.is_supported?(platform)
+        [:ios, :android].include?(platform)
+      end
+
+      def self.run(options)
+        require 'net/http'
+        require 'net/http/post/multipart'
+        require 'uri'
+        require 'json'
+
+        params = {
+          platform: options[:platform]
+        }
+
+        if options[:path]
+          params[:file] = UploadIO.new(options[:path], 'application/zip')
+        else
+          UI.user_error!('url parameter is required if no file path is specified') if options[:url].nil?
+          params[:url] = options[:url]
+        end
+
+        params[:note] = options[:note] if options[:note].to_s.length > 0
+
+        if options[:timeout]
+          params[:timeout] = options[:timeout]
+        end
+
+        uri = URI.parse(appetize_url(options))
+        req = create_request(uri, params)
+        req.basic_auth(options[:api_token], nil)
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+
+        if params[:platform] == 'ios'
+          UI.message("Uploading ipa to appetize... this might take a while")
+        else
+          UI.message("Uploading apk to appetize... this might take a while")
+        end
+
+        response = http.request(req)
+
+        parse_response(response) # this will raise an exception if something goes wrong
+
+        UI.message("App URL: #{Actions.lane_context[SharedValues::APPETIZE_APP_URL]}")
+        UI.message("Manage URL: #{Actions.lane_context[SharedValues::APPETIZE_MANAGE_URL]}")
+        UI.message("Public Key: #{Actions.lane_context[SharedValues::APPETIZE_PUBLIC_KEY]}")
+        UI.success("Build successfully uploaded to Appetize.io")
+      end
+
+      def self.appetize_url(options)
+        Actions.lane_context[SharedValues::APPETIZE_API_HOST] = options[:api_host]
+        "https://#{options[:api_host]}/v1/apps/#{options[:public_key]}"
+      end
+      private_class_method :appetize_url
+
+      def self.create_request(uri, params)
+        if params[:url]
+          req = Net::HTTP::Post.new(uri.request_uri, { 'Content-Type' => 'application/json' })
+          req.body = JSON.generate(params)
+        else
+          req = Net::HTTP::Post::Multipart.new(uri.path, params)
+        end
+
+        req
+      end
+      private_class_method :create_request
+
+      def self.parse_response(response)
+        body = JSON.parse(response.body)
+        app_url = body['appURL']
+        manage_url = body['manageURL']
+        public_key = body['publicKey']
+
+        Actions.lane_context[SharedValues::APPETIZE_PUBLIC_KEY] = public_key
+        Actions.lane_context[SharedValues::APPETIZE_APP_URL] = app_url
+        Actions.lane_context[SharedValues::APPETIZE_MANAGE_URL] = manage_url
+        return true
+      rescue => ex
+        UI.error(ex)
+        UI.user_error!("Error uploading to Appetize.io: #{response.body}")
+      end
+      private_class_method :parse_response
+
+      def self.description
+        "Upload your app to [Appetize.io](https://appetize.io/) to stream it in browser"
+      end
+
+      def self.details
+        [
+          "If you provide a `public_key`, this will overwrite an existing application. If you want to have this build as a new app version, you shouldn't provide this value.",
+          "",
+          "To integrate appetize into your GitHub workflow check out the [device_grid guide](https://github.com/fastlane/fastlane/blob/master/fastlane/lib/fastlane/actions/device_grid/README.md)."
+        ].join("\n")
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :api_host,
+                                       env_name: "APPETIZE_API_HOST",
+                                       description: "Appetize API host",
+                                       default_value: 'api.appetize.io',
+                                       verify_block: proc do |value|
+                                         UI.user_error!("API host should not contain the scheme e.g. `https`") if value.start_with?('https')
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :api_token,
+                                       env_name: "APPETIZE_API_TOKEN",
+                                       sensitive: true,
+                                       description: "Appetize.io API Token",
+                                       verify_block: proc do |value|
+                                         UI.user_error!("No API Token for Appetize.io given, pass using `api_token: 'token'`") unless value.to_s.length > 0
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :url,
+                                       env_name: "APPETIZE_URL",
+                                       description: "URL from which the ipa file can be fetched. Alternative to :path",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :platform,
+                                       env_name: "APPETIZE_PLATFORM",
+                                       description: "Platform. Either `ios` or `android`",
+                                       default_value: 'ios'),
+          FastlaneCore::ConfigItem.new(key: :path,
+                                       env_name: "APPETIZE_FILE_PATH",
+                                       description: "Path to zipped build on the local filesystem. Either this or `url` must be specified",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :public_key,
+                                       env_name: "APPETIZE_PUBLICKEY",
+                                       description: "If not provided, a new app will be created. If provided, the existing build will be overwritten",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         if value.start_with?("private_")
+                                           UI.user_error!("You provided a private key to appetize, please provide the public key")
+                                         end
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :note,
+                                       env_name: "APPETIZE_NOTE",
+                                       description: "Notes you wish to add to the uploaded app",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :timeout,
+                                       env_name: "APPETIZE_TIMEOUT",
+                                       description: "The number of seconds to wait until automatically ending the session due to user inactivity. Must be 30, 60, 90, 120, 180, 300, 600, 1800, 3600 or 7200. Default is 120",
+                                       type: Integer,
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("The value provided doesn't match any of the supported options.") unless [30, 60, 90, 120, 180, 300, 600, 1800, 3600, 7200].include?(value)
+                                       end)
+        ]
+      end
+
+      def self.output
+        [
+          ['APPETIZE_API_HOST', 'Appetize API host.'],
+          ['APPETIZE_PUBLIC_KEY', 'a public identifier for your app. Use this to update your app after it has been initially created.'],
+          ['APPETIZE_APP_URL', 'a page to test and share your app.'],
+          ['APPETIZE_MANAGE_URL', 'a page to manage your app.']
+        ]
+      end
+
+      def self.authors
+        ["klundberg", "giginet", "steprescott"]
+      end
+
+      def self.category
+        :beta
+      end
+
+      def self.example_code
+        [
+          'appetize(
+            path: "./MyApp.zip",
+            api_token: "yourapitoken", # get it from https://appetize.io/docs#request-api-token
+            public_key: "your_public_key" # get it from https://appetize.io/dashboard
+          )',
+          'appetize(
+            path: "./MyApp.zip",
+            api_host: "company.appetize.io", # only needed for enterprise hosted solution
+            api_token: "yourapitoken", # get it from https://appetize.io/docs#request-api-token
+            public_key: "your_public_key" # get it from https://appetize.io/dashboard
+          )'
+        ]
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/appetize_viewing_url_generator.rb

@@ -0,0 +1,135 @@
+module Fastlane
+  module Actions
+    module SharedValues
+    end
+
+    class AppetizeViewingUrlGeneratorAction < Action
+      def self.run(params)
+        link = "#{params[:base_url]}/#{params[:public_key]}"
+
+        if params[:scale].nil? # sensible default values for scaling
+          case params[:device].downcase.to_sym
+          when :iphone6splus, :iphone6plus
+            params[:scale] = "50"
+          when :ipadair, :ipadair2
+            params[:scale] = "50"
+          else
+            params[:scale] = "75"
+          end
+        end
+
+        url_params = []
+        url_params << "autoplay=true"
+        url_params << "orientation=#{params[:orientation]}"
+        url_params << "device=#{params[:device]}"
+        url_params << "deviceColor=#{params[:color]}"
+        url_params << "scale=#{params[:scale]}"
+        url_params << "launchUrl=#{params[:launch_url]}" if params[:launch_url]
+        url_params << "language=#{params[:language]}" if params[:language]
+        url_params << "osVersion=#{params[:os_version]}" if params[:os_version]
+        url_params << "params=#{CGI.escape(params[:params])}" if params[:params]
+        url_params << "proxy=#{CGI.escape(params[:proxy])}" if params[:proxy]
+
+        return link + "?" + url_params.join("&")
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Generate an URL for appetize simulator"
+      end
+
+      def self.details
+        "Check out the [device_grid guide](https://github.com/fastlane/fastlane/blob/master/fastlane/lib/fastlane/actions/device_grid/README.md) for more information"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :public_key,
+                                       env_name: "APPETIZE_PUBLICKEY",
+                                       description: "Public key of the app you wish to update",
+                                       sensitive: true,
+                                       default_value: Actions.lane_context[SharedValues::APPETIZE_PUBLIC_KEY],
+                                       default_value_dynamic: true,
+                                       optional: false,
+                                       verify_block: proc do |value|
+                                         if value.start_with?("private_")
+                                           UI.user_error!("You provided a private key to appetize, please provide the public key")
+                                         end
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :base_url,
+                                       env_name: "APPETIZE_VIEWING_URL_GENERATOR_BASE",
+                                       description: "Base URL of Appetize service",
+                                       default_value: "https://appetize.io/embed",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :device,
+                                       env_name: "APPETIZE_VIEWING_URL_GENERATOR_DEVICE",
+                                       description: "Device type: iphone4s, iphone5s, iphone6, iphone6plus, ipadair, iphone6s, iphone6splus, ipadair2, nexus5, nexus7 or nexus9",
+                                       default_value: "iphone5s"),
+          FastlaneCore::ConfigItem.new(key: :scale,
+                                       env_name: "APPETIZE_VIEWING_URL_GENERATOR_SCALE",
+                                       description: "Scale of the simulator",
+                                       optional: true,
+                                       verify_block: proc do |value|
+                                         available = ["25", "50", "75", "100"]
+                                         UI.user_error!("Invalid scale, available: #{available.join(', ')}") unless available.include?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :orientation,
+                                       env_name: "APPETIZE_VIEWING_URL_GENERATOR_ORIENTATION",
+                                       description: "Device orientation",
+                                       default_value: "portrait",
+                                       verify_block: proc do |value|
+                                         available = ["portrait", "landscape"]
+                                         UI.user_error!("Invalid device, available: #{available.join(', ')}") unless available.include?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :language,
+                                       env_name: "APPETIZE_VIEWING_URL_GENERATOR_LANGUAGE",
+                                       description: "Device language in ISO 639-1 language code, e.g. 'de'",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :color,
+                                       env_name: "APPETIZE_VIEWING_URL_GENERATOR_COLOR",
+                                       description: "Color of the device",
+                                       default_value: "black",
+                                       verify_block: proc do |value|
+                                         available = ["black", "white", "silver", "gray"]
+                                         UI.user_error!("Invalid device color, available: #{available.join(', ')}") unless available.include?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :launch_url,
+                                       env_name: "APPETIZE_VIEWING_URL_GENERATOR_LAUNCH_URL",
+                                       description: "Specify a deep link to open when your app is launched",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :os_version,
+                                       env_name: "APPETIZE_VIEWING_URL_GENERATOR_OS_VERSION",
+                                       description: "The operating system version on which to run your app, e.g. 10.3, 8.0",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :params,
+                                       env_name: "APPETIZE_VIEWING_URL_GENERATOR_PARAMS",
+                                       description: "Specify params value to be passed to Appetize",
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :proxy,
+                                       env_name: "APPETIZE_VIEWING_URL_GENERATOR_PROXY",
+                                       description: "Specify a HTTP proxy to be passed to Appetize",
+                                       optional: true)
+        ]
+      end
+
+      def self.category
+        :misc
+      end
+
+      def self.return_value
+        "The URL to preview the iPhone app"
+      end
+
+      def self.authors
+        ["KrauseFx"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios].include?(platform)
+      end
+    end
+  end
+end

data/fastlane/lib/fastlane/actions/appium.rb

@@ -0,0 +1,181 @@
+module Fastlane
+  module Actions
+    class AppiumAction < Action
+      INVOKE_TIMEOUT = 30
+      APPIUM_PATH_HOMEBREW = '/usr/local/bin/appium'
+      APPIUM_APP_PATH = '/Applications/Appium.app'
+      APPIUM_APP_BUNDLE_PATH = 'Contents/Resources/node_modules/.bin/appium'
+
+      def self.run(params)
+        Actions.verify_gem!('rspec')
+        Actions.verify_gem!('appium_lib')
+
+        require 'rspec'
+        require 'appium_lib' unless Helper.test?
+
+        FastlaneCore::PrintTable.print_values(
+          config: params,
+          title: "Summary for Appium Action"
+        )
+
+        if params[:invoke_appium_server]
+          appium_pid = invoke_appium_server(params)
+          wait_for_appium_server(params)
+        end
+
+        configure_rspec(params)
+
+        rspec_args = []
+        rspec_args << params[:spec_path]
+        status = RSpec::Core::Runner.run(rspec_args).to_i
+        if status != 0
+          UI.user_error!("Failed to run Appium spec. status code: #{status}")
+        end
+      ensure
+        Actions.sh("kill #{appium_pid}") if appium_pid
+      end
+
+      def self.invoke_appium_server(params)
+        appium = detect_appium(params)
+        Process.spawn("#{appium} -a #{params[:host]} -p #{params[:port]}")
+      end
+
+      def self.detect_appium(params)
+        appium_path = params[:appium_path] || `which appium`.to_s.strip
+
+        if appium_path.empty?
+          if File.exist?(APPIUM_PATH_HOMEBREW)
+            appium_path = APPIUM_PATH_HOMEBREW
+          elsif File.exist?(APPIUM_APP_PATH)
+            appium_path = APPIUM_APP_PATH
+          end
+        end
+
+        unless File.exist?(appium_path)
+          UI.user_error!("You have to install Appium using `npm install -g appium`")
+        end
+
+        if appium_path.end_with?('.app')
+          appium_path = "#{appium_path}/#{APPIUM_APP_BUNDLE_PATH}"
+        end
+
+        UI.message("Appium executable detected: #{appium_path}")
+        appium_path
+      end
+
+      def self.wait_for_appium_server(params)
+        loop.with_index do |_, count|
+          break if `lsof -i:#{params[:port]}`.to_s.length != 0
+
+          if count * 5 > INVOKE_TIMEOUT
+            UI.user_error!("Invoke Appium server timed out")
+          end
+          sleep(5)
+        end
+      end
+
+      def self.configure_rspec(params)
+        RSpec.configure do |c|
+          c.before(:each) do
+            caps = params[:caps] || {}
+            caps[:platformName] ||= params[:platform]
+            caps[:autoAcceptAlerts] ||= true
+            caps[:app] = params[:app_path]
+
+            appium_lib = params[:appium_lib] || {}
+
+            @driver = Appium::Driver.new(
+              caps: caps,
+              server_url: params[:host],
+              port: params[:port],
+              appium_lib: appium_lib
+            ).start_driver
+            Appium.promote_appium_methods(RSpec::Core::ExampleGroup)
+          end
+
+          c.after(:each) do
+            @driver.quit unless @driver.nil?
+          end
+        end
+      end
+
+      def self.description
+        'Run UI test by Appium with RSpec'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :platform,
+                                       env_name: 'FL_APPIUM_PLATFORM',
+                                       description: 'Appium platform name'),
+          FastlaneCore::ConfigItem.new(key: :spec_path,
+                                       env_name: 'FL_APPIUM_SPEC_PATH',
+                                       description: 'Path to Appium spec directory'),
+          FastlaneCore::ConfigItem.new(key: :app_path,
+                                       env_name: 'FL_APPIUM_APP_FILE_PATH',
+                                       description: 'Path to Appium target app file'),
+          FastlaneCore::ConfigItem.new(key: :invoke_appium_server,
+                                       env_name: 'FL_APPIUM_INVOKE_APPIUM_SERVER',
+                                       description: 'Use local Appium server with invoke automatically',
+                                       type: Boolean,
+                                       default_value: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :host,
+                                       env_name: 'FL_APPIUM_HOST',
+                                       description: 'Hostname of Appium server',
+                                       default_value: '0.0.0.0',
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :port,
+                                       env_name: 'FL_APPIUM_PORT',
+                                       description: 'HTTP port of Appium server',
+                                       type: Integer,
+                                       default_value: 4723,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :appium_path,
+                                       env_name: 'FL_APPIUM_EXECUTABLE_PATH',
+                                       description: 'Path to Appium executable',
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :caps,
+                                       env_name: 'FL_APPIUM_CAPS',
+                                       description: 'Hash of caps for Appium::Driver',
+                                       type: Hash,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :appium_lib,
+                                       env_name: 'FL_APPIUM_LIB',
+                                       description: 'Hash of appium_lib for Appium::Driver',
+                                       type: Hash,
+                                       optional: true)
+        ]
+      end
+
+      def self.author
+        'yonekawa'
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :android].include?(platform)
+      end
+
+      def self.category
+        :testing
+      end
+
+      def self.example_code
+        [
+          'appium(
+            app_path:  "appium/apps/TargetApp.app",
+            spec_path: "appium/spec",
+            platform:  "iOS",
+            caps: {
+              versionNumber: "9.1",
+              deviceName:    "iPhone 6"
+            },
+            appium_lib: {
+              wait: 10
+            }
+          )'
+        ]
+      end
+    end
+  end
+end