fastlane_pricing_fix 2.212.1

data/snapshot/lib/snapshot/test_command_generator.rb

@@ -0,0 +1,157 @@
+require_relative 'test_command_generator_base'
+require_relative 'latest_os_version'
+
+module Snapshot
+  # Responsible for building the fully working xcodebuild command
+  # Xcode 9 introduced the ability to run tests in parallel on multiple simulators
+  # This TestCommandGenerator constructs the appropriate `xcodebuild` command
+  # to be used for executing simultaneous tests
+  class TestCommandGenerator < TestCommandGeneratorBase
+    class << self
+      def generate(devices: nil, language: nil, locale: nil, log_path: nil)
+        parts = prefix
+        parts << "xcodebuild"
+        parts += options(language, locale)
+        parts += destination(devices)
+        parts += build_settings(language, locale)
+        parts += actions
+        parts += suffix
+        parts += pipe(log_path: log_path)
+
+        return parts
+      end
+
+      def pipe(log_path: nil)
+        tee_command = ['tee']
+        tee_command << '-a' if log_path && File.exist?(log_path)
+        tee_command << log_path.shellescape if log_path
+
+        pipe = ["| #{tee_command.join(' ')}"]
+
+        formatter = Snapshot.config[:xcodebuild_formatter].chomp
+        options = legacy_xcpretty_options
+
+        if Snapshot.config[:disable_xcpretty] || formatter == ''
+          UI.verbose("Not using an xcodebuild formatter")
+        elsif !options.empty?
+          UI.important("Detected legacy xcpretty being used so formatting wth xcpretty")
+          UI.important("Option(s) used: #{options.join(', ')}")
+          pipe += pipe_xcpretty
+        elsif formatter == 'xcpretty'
+          pipe += pipe_xcpretty
+        elsif formatter == 'xcbeautify'
+          pipe += pipe_xcbeautify
+        else
+          pipe << "| #{formatter}"
+        end
+
+        pipe
+      end
+
+      def pipe_xcbeautify
+        pipe = ['| xcbeautify']
+
+        if FastlaneCore::Helper.colors_disabled?
+          pipe << '--disable-colored-output'
+        end
+
+        return pipe
+      end
+
+      def legacy_xcpretty_options
+        options = []
+        options << "xcpretty_args" if Snapshot.config[:xcpretty_args]
+        return options
+      end
+
+      def pipe_xcpretty
+        pipe = []
+        xcpretty = "xcpretty #{Snapshot.config[:xcpretty_args]}"
+        xcpretty << "--no-color" if Helper.colors_disabled?
+        pipe << "| #{xcpretty}"
+        pipe << "> /dev/null" if Snapshot.config[:suppress_xcode_output]
+        return pipe
+      end
+
+      def destination(devices)
+        unless verify_devices_share_os(devices)
+          UI.user_error!('All devices provided to snapshot should run the same operating system')
+        end
+        # on Mac we will always run on host machine, so should specify only platform
+        return ["-destination 'platform=macOS'"] if devices.first.to_s =~ /^Mac/
+
+        case devices.first.to_s
+        when /^Apple TV/
+          os = 'tvOS'
+        when /^Apple Watch/
+          os = 'watchOS'
+        else
+          os = 'iOS'
+        end
+
+        os_version = Snapshot.config[:ios_version] || Snapshot::LatestOsVersion.version(os)
+
+        destinations = devices.map do |d|
+          device = find_device(d, os_version)
+          if device.nil?
+            UI.user_error!("No device found named '#{d}' for version '#{os_version}'") if device.nil?
+          elsif device.os_version != os_version
+            UI.important("Using device named '#{device.name}' with version '#{device.os_version}' because no match was found for version '#{os_version}'")
+          end
+          "-destination 'platform=#{os} Simulator,name=#{device.name},OS=#{device.os_version}'"
+        end
+
+        return [destinations.join(' ')]
+      end
+
+      def verify_devices_share_os(device_names)
+        # Get device types based off of device name
+        devices = get_device_type_with_simctl(device_names)
+
+        # Check each device to see if it is an iOS device
+        all_ios = devices.map do |device|
+          device = device.downcase
+          device.include?('iphone') || device.include?('ipad') || device.include?('ipod')
+        end
+        # Return true if all devices are iOS devices
+        return true unless all_ios.include?(false)
+
+        all_tvos = devices.map do |device|
+          device = device.downcase
+          device.include?('apple tv')
+        end
+        # Return true if all devices are tvOS devices
+        return true unless all_tvos.include?(false)
+
+        all_watchos = devices.map do |device|
+          device = device.downcase
+          device.include?('apple watch')
+        end
+        # Return true if all devices are watchOS devices
+        return true unless all_watchos.include?(false)
+
+        # There should only be more than 1 device type if
+        # it is iOS or tvOS, therefore, if there is more than 1
+        # device in the array, and they are not all iOS or tvOS
+        # as checked above, that would imply that this is a mixed bag
+        return devices.count == 1
+      end
+
+      private
+
+      def get_device_type_with_simctl(device_names)
+        return device_names if Helper.test?
+
+        require("simctl")
+
+        # Gets actual simctl device type from device name
+        return device_names.map do |device_name|
+          device = SimCtl.device(name: device_name)
+          if device
+            device.devicetype.name
+          end
+        end.compact
+      end
+    end
+  end
+end

data/snapshot/lib/snapshot/test_command_generator_base.rb

@@ -0,0 +1,130 @@
+require 'fastlane_core/device_manager'
+require_relative 'module'
+
+module Snapshot
+  class TestCommandGeneratorBase
+    class << self
+      def prefix
+        ["set -o pipefail &&"]
+      end
+
+      # Path to the project or workspace as parameter
+      # This will also include the scheme (if given)
+      # @return [Array] The array with all the components to join
+      def project_path_array
+        proj = Snapshot.project.xcodebuild_parameters
+        return proj if proj.count > 0
+        UI.user_error!("No project/workspace found")
+      end
+
+      def options(language, locale)
+        config = Snapshot.config
+        result_bundle_path = resolve_result_bundle_path(language, locale) if config[:result_bundle]
+
+        options = []
+        options += project_path_array
+        options << "-sdk '#{config[:sdk]}'" if config[:sdk]
+        if derived_data_path && !options.include?("-derivedDataPath #{derived_data_path.shellescape}")
+          options << "-derivedDataPath #{derived_data_path.shellescape}"
+        end
+        options << "-resultBundlePath '#{result_bundle_path}'" if result_bundle_path
+        if FastlaneCore::Helper.xcode_at_least?(11)
+          options << "-testPlan '#{config[:testplan]}'" if config[:testplan]
+        end
+        options << config[:xcargs] if config[:xcargs]
+
+        # detect_values will ensure that these values are present as Arrays if
+        # they are present at all
+        options += config[:only_testing].map { |test_id| "-only-testing:#{test_id.shellescape}" } if config[:only_testing]
+        options += config[:skip_testing].map { |test_id| "-skip-testing:#{test_id.shellescape}" } if config[:skip_testing]
+        return options
+      end
+
+      def build_settings(language, locale)
+        config = Snapshot.config
+
+        build_settings = []
+        build_settings << "FASTLANE_SNAPSHOT=YES"
+        build_settings << "FASTLANE_LANGUAGE=#{language}" if language
+        build_settings << "FASTLANE_LOCALE=#{locale}" if locale
+        build_settings << "TEST_TARGET_NAME=#{config[:test_target_name].shellescape}" if config[:test_target_name]
+
+        return build_settings
+      end
+
+      def actions
+        actions = []
+        if Snapshot.config[:test_without_building]
+          actions << "test-without-building"
+        else
+          actions << :clean if Snapshot.config[:clean]
+          actions << :build # https://github.com/fastlane/fastlane/issues/2581
+          actions << :test
+        end
+        return actions
+      end
+
+      def suffix
+        return []
+      end
+
+      def find_device(device_name, os_version = Snapshot.config[:ios_version])
+        # We might get this error message
+        # > The requested device could not be found because multiple devices matched the request.
+        #
+        # This happens when you have multiple simulators for a given device type / iOS combination
+        #   { platform:iOS Simulator, id:1685B071-AFB2-4DC1-BE29-8370BA4A6EBD, OS:9.0, name:iPhone 5 }
+        #   { platform:iOS Simulator, id:A141F23B-96B3-491A-8949-813B376C28A7, OS:9.0, name:iPhone 5 }
+        #
+        simulators = FastlaneCore::DeviceManager.simulators
+        # Sort devices with matching names by OS version, largest first, so that we can
+        # pick the device with the newest OS in case an exact OS match is not available
+        name_matches = simulators.find_all { |sim| sim.name.strip == device_name.strip }
+                                 .sort_by { |sim| Gem::Version.new(sim.os_version) }
+                                 .reverse
+        return name_matches.find { |sim| sim.os_version == os_version } || name_matches.first
+      end
+
+      def device_udid(device_name, os_version = Snapshot.config[:ios_version])
+        device = find_device(device_name, os_version)
+
+        return device ? device.udid : nil
+      end
+
+      def derived_data_path
+        Snapshot.cache[:derived_data_path] ||= (Snapshot.config[:derived_data_path] || Dir.mktmpdir("snapshot_derived"))
+      end
+
+      def resolve_result_bundle_path(language, locale)
+        Snapshot.cache[:result_bundle_path] = {}
+        language_key = locale || language
+
+        unless Snapshot.cache[:result_bundle_path][language_key]
+          ext = FastlaneCore::Helper.xcode_at_least?(11) ? '.xcresult' : '.test_result'
+          path = File.join(Snapshot.config[:output_directory], "test_output", language_key, Snapshot.config[:scheme]) + ext
+          if File.directory?(path)
+            FileUtils.remove_dir(path)
+          end
+          Snapshot.cache[:result_bundle_path][language_key] = path
+        end
+        return Snapshot.cache[:result_bundle_path][language_key]
+      end
+
+      def initialize
+        not_implemented(__method__)
+      end
+
+      def pipe(device_type, language, locale)
+        not_implemented(__method__)
+      end
+
+      def destination(device_name)
+        not_implemented(__method__)
+      end
+
+      def xcodebuild_log_path(device_type: nil, language: nil, locale: nil)
+        not_implemented(__method__)
+      end
+    end
+  end
+end

data/snapshot/lib/snapshot/test_command_generator_xcode_8.rb

@@ -0,0 +1,70 @@
+require_relative 'test_command_generator_base'
+require_relative 'module'
+require_relative 'latest_os_version'
+
+module Snapshot
+  # Responsible for building the fully working xcodebuild command
+  # This TestCommandGenerator supports Xcode 8's `xcodebuild` requirements
+  # It is its own object, as the logic differs for how we want to handle
+  # creating `xcodebuild` commands for Xcode 9 (see test_command_generator.rb)
+  class TestCommandGeneratorXcode8 < TestCommandGeneratorBase
+    class << self
+      def generate(device_type: nil, language: nil, locale: nil)
+        parts = prefix
+        parts << "xcodebuild"
+        parts += options(language, locale)
+        parts += destination(device_type)
+        parts += build_settings(language, locale)
+        parts += actions
+        parts += suffix
+        parts += pipe(device_type, language, locale)
+
+        return parts
+      end
+
+      def pipe(device_type, language, locale)
+        log_path = xcodebuild_log_path(device_type: device_type, language: language, locale: locale)
+        pipe = ["| tee #{log_path.shellescape}"]
+        pipe << "| xcpretty #{Snapshot.config[:xcpretty_args]}"
+        pipe << "> /dev/null" if Snapshot.config[:suppress_xcode_output]
+        return pipe
+      end
+
+      def destination(device_name)
+        # on Mac we will always run on host machine, so should specify only platform
+        return ["-destination 'platform=macOS'"] if device_name =~ /^Mac/
+
+        # if device_name is nil, use the config and get all devices
+        os = device_name =~ /^Apple TV/ ? "tvOS" : "iOS"
+        os_version = Snapshot.config[:ios_version] || Snapshot::LatestOsVersion.version(os)
+
+        device = find_device(device_name, os_version)
+        if device.nil?
+          UI.user_error!("No device found named '#{device_name}' for version '#{os_version}'")
+        elsif device.os_version != os_version
+          UI.important("Using device named '#{device_name}' with version '#{device.os_version}' because no match was found for version '#{os_version}'")
+        end
+        value = "platform=#{os} Simulator,id=#{device.udid},OS=#{device.os_version}"
+
+        return ["-destination '#{value}'"]
+      end
+
+      def xcodebuild_log_path(device_type: nil, language: nil, locale: nil)
+        name_components = [Snapshot.project.app_name, Snapshot.config[:scheme]]
+
+        if Snapshot.config[:namespace_log_files]
+          name_components << device_type if device_type
+          name_components << language if language
+          name_components << locale if locale
+        end
+
+        file_name = "#{name_components.join('-')}.log"
+
+        containing = File.expand_path(Snapshot.config[:buildlog_path])
+        FileUtils.mkdir_p(containing)
+
+        return File.join(containing, file_name)
+      end
+    end
+  end
+end

data/snapshot/lib/snapshot/update.rb

@@ -0,0 +1,38 @@
+require_relative 'module'
+require_relative 'runner'
+
+module Snapshot
+  # Migrate helper files
+  class Update
+    # @return [Array] A list of helper files (usually just one)
+    def self.find_helper
+      paths = Dir["./**/SnapshotHelper.swift"] + Dir["./**/SnapshotHelperXcode8.swift"]
+      # exclude assets in gym
+      paths.reject { |p| p.include?("snapshot/lib/assets/") || p.include?("DerivedData") }
+    end
+
+    def update(force: false)
+      paths = self.class.find_helper
+      UI.user_error!("Couldn't find any SnapshotHelper files in current directory") if paths.count == 0
+
+      UI.message("Found the following SnapshotHelper:")
+      paths.each { |p| UI.message("\t#{p}") }
+      UI.important("Are you sure you want to automatically update the helpers listed above?")
+      UI.message("This will overwrite all its content with the latest code.")
+      UI.message("The underlying API will not change. You can always migrate manually by looking at")
+      UI.message("https://github.com/fastlane/fastlane/blob/master/snapshot/lib/assets/SnapshotHelper.swift")
+
+      if !force && !UI.confirm("Overwrite configuration files?")
+        return 1
+      end
+
+      paths.each do |path|
+        UI.message("Updating '#{path}'...")
+        input_path = Snapshot::Runner.path_to_helper_file_from_gem
+        File.write(path, File.read(input_path))
+      end
+
+      UI.success("Successfully updated helper files")
+    end
+  end
+end

data/snapshot/lib/snapshot.rb

@@ -0,0 +1,19 @@
+require_relative 'snapshot/runner'
+require_relative 'snapshot/reports_generator'
+require_relative 'snapshot/detect_values'
+require_relative 'snapshot/screenshot_flatten'
+require_relative 'snapshot/screenshot_rotate'
+require_relative 'snapshot/dependency_checker'
+require_relative 'snapshot/latest_os_version'
+require_relative 'snapshot/test_command_generator'
+require_relative 'snapshot/test_command_generator_xcode_8'
+require_relative 'snapshot/error_handler'
+require_relative 'snapshot/collector'
+require_relative 'snapshot/options'
+require_relative 'snapshot/update'
+require_relative 'snapshot/fixes/simulator_zoom_fix'
+require_relative 'snapshot/fixes/hardware_keyboard_fix'
+require_relative 'snapshot/simulator_launchers/launcher_configuration'
+require_relative 'snapshot/simulator_launchers/simulator_launcher'
+require_relative 'snapshot/simulator_launchers/simulator_launcher_xcode_8'
+require_relative 'snapshot/module'

data/spaceship/README.md

@@ -0,0 +1,173 @@
+<h3 align="center">
+  <a href="https://docs.fastlane.tools">
+    <img src="../fastlane/assets/fastlane.png" width="100" />
+    <br />
+    fastlane
+  </a>
+</h3>
+
+-------
+
+<p align="center">
+  <img src="assets/spaceship.png" width="470">
+</p>
+
+-------
+
+[![Twitter: @FastlaneTools](https://img.shields.io/badge/contact-@FastlaneTools-blue.svg?style=flat)](https://twitter.com/FastlaneTools)
+[![License](https://img.shields.io/badge/license-MIT-green.svg?style=flat)](https://github.com/fastlane/fastlane/blob/master/LICENSE)
+
+_spaceship_ exposes both the Apple Developer Center and the App Store Connect API. It’s super fast, well tested and supports all of the operations you can do via the browser. It powers parts of _fastlane_, and can be leveraged for more advanced _fastlane_ features. Scripting your Developer Center workflow has never been easier!
+
+Get in contact with the creators on Twitter: [@FastlaneTools](https://twitter.com/fastlanetools)
+
+-------
+
+<p align="center">
+    <a href="#whats-spaceship">Why?</a> &bull;
+    <a href="#usage">Usage</a> &bull;
+    <a href="#installation">Installation</a> &bull;
+    <a href="#technical-details">Technical Details</a> &bull;
+    <a href="#need-help">Need help?</a>
+</p>
+
+-------
+
+<h5 align="center"><em>spaceship</em> is part of <a href="https://fastlane.tools">fastlane</a>: The easiest way to automate beta deployments and releases for your iOS and Android apps.</h5>
+
+# What's spaceship?
+
+_spaceship_ uses a combination of [5 different API endpoints](#api-endpoints), used by the Apple Developer Portal and Xcode. As no API offers everything we need, spaceship combines all APIs for you. [More details about the APIs](#technical-details).
+
+- Blazing fast communication using only a HTTP client
+- Object oriented access to all resources
+- Resistant against front-end design changes of the of the Apple Developer Portal
+- One central tool for the communication
+- Automatic re-trying of requests in case a timeout occurs
+- No web scraping
+- 90%+ test coverage by stubbing server responses
+
+More details about why spaceship is useful on [spaceship.airforce](https://spaceship.airforce).
+
+> No matter how many apps or certificates you have, spaceship **can** handle your scale.
+
+## Example spaceship code
+
+```ruby
+Spaceship.login
+
+# Create a new app
+app = Spaceship.app.create!(bundle_id: "com.krausefx.app", name: "Spaceship App")
+
+# Use an existing certificate
+cert = Spaceship.certificate.production.all.first
+
+# Create a new provisioning profile
+profile = Spaceship.provisioning_profile.app_store.create!(bundle_id: app.bundle_id,
+                                                         certificate: cert)
+
+# Print the name and download the new profile
+puts("Created Profile " + profile.name)
+profile.download
+```
+
+## Speed
+
+Before _spaceship_, the [fastlane tools](https://fastlane.tools) used web scraping to interact with Apple's web services. With spaceship it is possible to directly access the underlying APIs using a simple HTTP client only.
+
+Using spaceship, the execution time of [_sigh_](https://docs.fastlane.tools/actions/sigh/) was reduced from over 1 minute to less than 5 seconds.
+
+![assets/SpaceshipRecording.gif](assets/SpaceshipRecording.gif)
+
+# Installation
+
+_spaceship_ is part of _fastlane_:
+
+    gem install fastlane
+
+# Usage
+
+## Playground
+
+To try _spaceship_, just run `fastlane spaceship`. It will automatically start the `spaceship playground`. It makes it super easy to try _spaceship_ :rocket:
+
+![assets/docs/Playground.png](assets/docs/Playground.png)
+
+This requires you to install `pry` using `gem install pry`. `pry` is not installed by default, as most [_fastlane_](https://fastlane.tools) users won't need the `spaceship playground`. You can add the `pry` dependency to your `Gemfile`.
+
+## Apple Developer Portal API
+
+Open [DeveloperPortal.md](docs/DeveloperPortal.md) for code samples
+
+## App Store Connect API
+
+Open [AppStoreConnect.md](docs/AppStoreConnect.md) for code samples
+
+## 2 Step Verification
+
+When your Apple account has 2 factor verification enabled, you'll automatically be asked to verify your identity. If you have a trusted device configured for your account, then a code will appear on the device. If you don't have any devices configured, but have trusted a phone number, then a code will be sent to your phone. The resulting session will be stored in `~/.fastlane/spaceship/[email]/cookie`. The session should be valid for about one month, however there is no way to test this without actually waiting for over a month.
+
+### Support for CI machines
+
+#### Web sessions
+
+See [Best Practices > Continuous Integration > Authenticating with Apple services > Method 2: Two-step or two-factor authentication > Storing a manually verified session using spaceauth](https://docs.fastlane.tools/best-practices/continuous-integration/#storing-a-manually-verified-session-using-spaceauth)
+
+#### Transporter
+
+See [Best Practices > Continuous Integration > Authenticating with Apple services > Method 3: Application-specific passwords](https://docs.fastlane.tools/best-practices/continuous-integration/#method-3-application-specific-passwords)
+
+## _spaceship_ in use
+
+All [fastlane tools](https://fastlane.tools) that communicate with Apple's web services in some way, use _spaceship_ to do so.
+
+# Technical Details
+
+## API Endpoints
+
+Overview of the used API endpoints
+
+- `https://idmsa.apple.com`:
+  - Used to authenticate to get a valid session
+- `https://developerservices2.apple.com`:
+  - Get a list of all available provisioning profiles
+  - Register new devices
+- `https://developer.apple.com`:
+  - List all devices, certificates, apps and app groups
+  - Create new certificates, provisioning profiles and apps
+  - Disable/enable services on apps and assign them to app groups
+  - Delete certificates and apps
+  - Repair provisioning profiles
+  - Download provisioning profiles
+  - Team selection
+- `https://appstoreconnect.apple.com`:
+  - Managing apps
+  - Managing beta testers
+  - Submitting updates to review
+  - Managing app metadata
+- `https://du-itc.appstoreconnect.apple.com`:
+  - Upload icons, screenshots, trailers ...
+- `https://is[1-9]-ssl.mzstatic.com`:
+  - Download app screenshots from App Store Connect
+
+_spaceship_ uses all those API points to offer this seamless experience.
+
+## Magic involved
+
+_spaceship_ does a lot of magic to get everything working so neatly:
+
+- **Sensible Defaults**: You only have to provide the mandatory information (e.g. new provisioning profiles contain all devices by default)
+- **Local Validation**: When pushing changes back to the Apple Developer Portal _spaceship_ will make sure only valid data is sent to Apple (e.g. automatic repairing of provisioning profiles)
+- **Various request/response types**: When working with the different API endpoints, _spaceship_ has to deal with `JSON`, `XML`, `txt`, `plist` and sometimes even `HTML` responses and requests.
+- **Automatic Pagination**: Even if you have thousands of apps, profiles or certificates, _spaceship_ **can** handle your scale. It was heavily tested by first using _spaceship_ to create hundreds of profiles and then accessing them using _spaceship_.
+- **Session, Cookie and CSRF token**: All the security aspects are handled by _spaceship_.
+- **Profile Magic**: Create and upload code signing requests, all managed by _spaceship_
+- **Multiple Spaceship**: You can launch multiple _spaceships_ with different Apple accounts to do things like syncing the registered devices.
+
+# Code of Conduct
+Help us keep _fastlane_ open and inclusive. Please read and follow our [Code of Conduct](https://github.com/fastlane/fastlane/blob/master/CODE_OF_CONDUCT.md).
+
+# License
+This project is licensed under the terms of the MIT license. See the LICENSE file.
+
+> This project and all fastlane tools are in no way affiliated with Apple Inc. This project is open source under the MIT license, which means you have full access to the source code and can modify it to fit your own needs. All fastlane tools run on your own computer or server, so your credentials or other sensitive information will never leave your own computer. You are responsible for how you use fastlane tools.