fastlane 1.111.0 → 2.0.1

data/scan/lib/scan/report_collector.rb

@@ -0,0 +1,70 @@
+module Scan
+  class ReportCollector
+    SUPPORTED = %w(html junit json-compilation-database)
+
+    # Intialize with values from Scan.config matching these param names
+    def initialize(open_report, output_types, output_directory, use_clang_report_name, custom_report_file_name = nil)
+      @open_report = open_report
+      @output_types = output_types
+      @output_directory = output_directory
+      @use_clang_report_name = use_clang_report_name
+      @custom_report_file_name = custom_report_file_name
+    end
+
+    def parse_raw_file(path)
+      UI.user_error!("Couldn't find file at path '#{path}'") unless File.exist?(path)
+
+      commands = generate_commands(path)
+      commands.each do |output_path, command|
+        if system(command)
+          UI.success("Successfully generated report at '#{output_path}'")
+        else
+          UI.user_error!("Failed to generate report at '#{output_path}'")
+        end
+
+        if @open_report and output_path.end_with?(".html")
+          # Open the HTML file
+          `open --hide '#{output_path}'`
+        end
+      end
+    end
+
+    # Returns a hash containing the resulting path as key and the command as value
+    def generate_commands(path, types: nil, output_file_name: nil)
+      types ||= @output_types
+      types = types.split(",") if types.kind_of?(String) # might already be an array when passed via fastlane
+      commands = {}
+
+      types.each do |raw|
+        type = raw.strip
+
+        unless SUPPORTED.include?(type)
+          UI.error("Couldn't find reporter '#{type}', available #{SUPPORTED.join(', ')}")
+          next
+        end
+
+        output_path = output_file_name || File.join(File.expand_path(@output_directory), determine_output_file_name(type))
+
+        parts = ["cat '#{path}' | "]
+        parts << "xcpretty"
+        parts << "--report #{type}"
+        parts << "--output '#{output_path}'"
+        parts << "&> /dev/null "
+
+        commands[output_path] = parts.join(" ")
+      end
+
+      return commands
+    end
+
+    def determine_output_file_name(type)
+      if @use_clang_report_name && type == "json-compilation-database"
+        "compile_commands.json"
+      elsif !@custom_report_file_name.nil?
+        @custom_report_file_name
+      else
+        "report.#{type}"
+      end
+    end
+  end
+end

data/scan/lib/scan/runner.rb

@@ -0,0 +1,103 @@
+require 'pty'
+require 'open3'
+require 'fileutils'
+require 'terminal-table'
+
+module Scan
+  class Runner
+    def run
+      handle_results(test_app)
+    end
+
+    def test_app
+      # We call this method, to be sure that all other simulators are killed
+      # And a correct one is freshly launched. Switching between multiple simulator
+      # in case the user specified multiple targets works with no issues
+      # This way it's okay to just call it for the first simulator we're using for
+      # the first test run
+      open_simulator_for_device(Scan.devices.first) if Scan.devices
+
+      command = TestCommandGenerator.generate
+      prefix_hash = [
+        {
+          prefix: "Running Tests: ",
+          block: proc do |value|
+            value.include?("Touching")
+          end
+        }
+      ]
+      exit_status = 0
+      FastlaneCore::CommandExecutor.execute(command: command,
+                                          print_all: true,
+                                      print_command: true,
+                                             prefix: prefix_hash,
+                                            loading: "Loading...",
+                                              error: proc do |error_output|
+                                                begin
+                                                  exit_status = $?.exitstatus
+                                                  ErrorHandler.handle_build_error(error_output)
+                                                rescue => ex
+                                                  SlackPoster.new.run({
+                                                    build_errors: 1
+                                                  })
+                                                  raise ex
+                                                end
+                                              end)
+      exit_status
+    end
+
+    def handle_results(tests_exit_status)
+      # First, generate a JUnit report to get the number of tests
+      require 'tempfile'
+      output_file = Tempfile.new("junit_report")
+
+      report_collector = ReportCollector.new(Scan.config[:open_report],
+                                             Scan.config[:output_types],
+                                             Scan.config[:output_directory],
+                                             Scan.config[:use_clang_report_name],
+                                             Scan.config[:custom_report_file_name])
+
+      cmd = report_collector.generate_commands(TestCommandGenerator.xcodebuild_log_path,
+                                               types: 'junit',
+                                               output_file_name: output_file.path).values.last
+      system(cmd)
+
+      result = TestResultParser.new.parse_result(output_file.read)
+      SlackPoster.new.run(result)
+
+      if result[:failures] > 0
+        failures_str = result[:failures].to_s.red
+      else
+        failures_str = result[:failures].to_s.green
+      end
+
+      puts Terminal::Table.new({
+        title: "Test Results",
+        rows: [
+          ["Number of tests", result[:tests]],
+          ["Number of failures", failures_str]
+        ]
+      })
+      puts ""
+
+      report_collector.parse_raw_file(TestCommandGenerator.xcodebuild_log_path)
+
+      unless tests_exit_status == 0
+        UI.user_error!("Test execution failed. Exit status: #{tests_exit_status}")
+      end
+
+      unless result[:failures] == 0
+        UI.user_error!("Tests failed")
+      end
+    end
+
+    def open_simulator_for_device(device)
+      return unless ENV['FASTLANE_EXPLICIT_OPEN_SIMULATOR']
+
+      UI.message("Killing all running simulators")
+      `killall Simulator &> /dev/null`
+
+      FastlaneCore::Simulator.launch(device)
+    end
+  end
+end

data/scan/lib/scan/slack_poster.rb

@@ -0,0 +1,59 @@
+module Scan
+  class SlackPoster
+    def run(results)
+      return if Scan.config[:skip_slack]
+      return if Scan.config[:slack_only_on_failure] && results[:failures] == 0
+      return if Scan.config[:slack_url].nil?
+
+      require 'slack-notifier'
+      notifier = Slack::Notifier.new(Scan.config[:slack_url])
+      notifier.username = 'fastlane'
+
+      if Scan.config[:slack_channel].to_s.length > 0
+        notifier.channel = Scan.config[:slack_channel]
+        notifier.channel = ('#' + notifier.channel) unless ['#', '@'].include?(notifier.channel[0]) # send message to channel by default
+      end
+
+      attachments = []
+
+      if Scan.config[:slack_message]
+        attachments << {
+          text: Scan.config[:slack_message].to_s,
+          color: "good"
+        }
+      end
+
+      attachments << {
+        text: "Build Errors: #{results[:build_errors] || 0}",
+        color: results[:build_errors].to_i > 0 ? "danger" : "good",
+        short: true
+      }
+
+      if results[:failures]
+        attachments << {
+          text: "Test Failures: #{results[:failures]}",
+          color: results[:failures].to_i > 0 ? "danger" : "good",
+          short: true
+        }
+      end
+
+      if results[:tests] and results[:failures]
+        attachments << {
+          text: "Successful Tests: #{results[:tests] - results[:failures]}",
+          color: "good",
+          short: true
+        }
+      end
+
+      result = notifier.ping "#{Scan.project.app_name} Tests:",
+                             icon_url: 'https://s3-eu-west-1.amazonaws.com/fastlane.tools/fastlane.png',
+                             attachments: attachments
+
+      if result.code.to_i == 200
+        UI.success('Successfully sent Slack notification')
+      else
+        UI.error(result.to_s)
+      end
+    end
+  end
+end

data/scan/lib/scan/test_command_generator.rb

@@ -0,0 +1,130 @@
+module Scan
+  # Responsible for building the fully working xcodebuild command
+  class TestCommandGenerator
+    class << self
+      def generate
+        parts = prefix
+        parts << "env NSUnbufferedIO=YES xcodebuild"
+        parts += options
+        parts += actions
+        parts += suffix
+        parts += pipe
+
+        parts
+      end
+
+      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 = Scan.project.xcodebuild_parameters
+        return proj if proj.count > 0
+        UI.user_error!("No project/workspace found")
+      end
+
+      def options
+        config = Scan.config
+
+        options = []
+        options += project_path_array
+        options << "-sdk '#{config[:sdk]}'" if config[:sdk]
+        options << destination # generated in `detect_values`
+        options << "-derivedDataPath '#{config[:derived_data_path]}'" if config[:derived_data_path]
+        options << "-resultBundlePath '#{result_bundle_path}'" if config[:result_bundle]
+        options << "-enableCodeCoverage YES" if config[:code_coverage]
+        options << "-enableAddressSanitizer YES" if config[:address_sanitizer]
+        options << "-xcconfig '#{config[:xcconfig]}'" if config[:xcconfig]
+        options << config[:xcargs] if config[:xcargs]
+
+        options
+      end
+
+      def actions
+        config = Scan.config
+
+        actions = []
+        actions << :clean if config[:clean]
+        actions << :build unless config[:skip_build]
+        actions << :test
+
+        actions
+      end
+
+      def suffix
+        suffix = []
+        suffix
+      end
+
+      def pipe
+        # During building we just show the output in the terminal
+        # Check out the ReportCollector class for more xcpretty things
+        pipe = ["| tee '#{xcodebuild_log_path}'"]
+
+        if Scan.config[:output_style] == 'raw'
+          return pipe
+        end
+
+        formatter = []
+        if Scan.config[:formatter]
+          formatter << "-f `#{Scan.config[:formatter]}`"
+        elsif ENV.key?("TRAVIS")
+          formatter << "-f `xcpretty-travis-formatter`"
+          UI.success("Automatically switched to Travis formatter")
+        end
+
+        if Helper.colors_disabled?
+          formatter << "--no-color"
+        end
+
+        if Scan.config[:output_style] == 'basic'
+          formatter << "--no-utf"
+        end
+
+        if Scan.config[:output_style] == 'rspec'
+          formatter << "--test"
+        end
+
+        return pipe << ["| xcpretty #{formatter.join(' ')}"]
+      end
+
+      # Store the raw file
+      def xcodebuild_log_path
+        file_name = "#{Scan.project.app_name}-#{Scan.config[:scheme]}.log"
+        containing = File.expand_path(Scan.config[:buildlog_path])
+        FileUtils.mkdir_p(containing)
+
+        return File.join(containing, file_name)
+      end
+
+      # Generate destination parameters
+      def destination
+        unless Scan.cache[:destination]
+          Scan.cache[:destination] = [*Scan.config[:destination]].map { |dst| "-destination '#{dst}'" }.join(' ')
+        end
+        Scan.cache[:destination]
+      end
+
+      # The path to set the Derived Data to
+      def build_path
+        unless Scan.cache[:build_path]
+          day = Time.now.strftime("%F") # e.g. 2015-08-07
+
+          Scan.cache[:build_path] = File.expand_path("~/Library/Developer/Xcode/Archives/#{day}/")
+          FileUtils.mkdir_p Scan.cache[:build_path]
+        end
+        Scan.cache[:build_path]
+      end
+
+      def result_bundle_path
+        unless Scan.cache[:result_bundle_path]
+          Scan.cache[:result_bundle_path] = File.join(Scan.config[:output_directory], Scan.config[:scheme]) + ".test_result"
+        end
+        return Scan.cache[:result_bundle_path]
+      end
+    end
+  end
+end

data/scan/lib/scan/test_result_parser.rb

@@ -0,0 +1,21 @@
+module Scan
+  class TestResultParser
+    def parse_result(output)
+      # e.g. ...<testsuites tests='2' failures='1'>...
+      matched = output.scan(/<testsuites\b(?=[^<>]*\s+tests='(\d+)')(?=[^<>]*\s+failures='(\d+)')[^<>]+>/)
+
+      if matched and matched.length == 1 and matched[0].length == 2
+        tests = matched[0][0].to_i
+        failures = matched[0][1].to_i
+
+        return {
+          tests: tests,
+          failures: failures
+        }
+      else
+        UI.error("Couldn't parse the number of tests from the output")
+        return {}
+      end
+    end
+  end
+end

data/screengrab/README.md

@@ -0,0 +1,190 @@
+<h3 align="center">
+  <a href="https://github.com/fastlane/fastlane/tree/master/fastlane">
+    <img src="../fastlane/assets/fastlane.png" width="150" />
+    <br />
+    fastlane
+  </a>
+</h3>
+<p align="center">
+  <a href="https://github.com/fastlane/fastlane/tree/master/deliver">deliver</a> &bull;
+  <b>screengrab</b> &bull;
+  <a href="https://github.com/fastlane/fastlane/tree/master/frameit">frameit</a> &bull;
+  <a href="https://github.com/fastlane/fastlane/tree/master/pem">pem</a> &bull;
+  <a href="https://github.com/fastlane/fastlane/tree/master/sigh">sigh</a> &bull;
+  <a href="https://github.com/fastlane/fastlane/tree/master/produce">produce</a> &bull;
+  <a href="https://github.com/fastlane/fastlane/tree/master/cert">cert</a> &bull;
+  <a href="https://github.com/fastlane/fastlane/tree/master/spaceship">spaceship</a> &bull;
+  <a href="https://github.com/fastlane/fastlane/tree/master/pilot">pilot</a> &bull;
+  <a href="https://github.com/fastlane/boarding">boarding</a> &bull;
+  <a href="https://github.com/fastlane/fastlane/tree/master/gym">gym</a> &bull;
+  <a href="https://github.com/fastlane/fastlane/tree/master/scan">scan</a> &bull;
+  <a href="https://github.com/fastlane/fastlane/tree/master/match">match</a>
+</p>
+-------
+
+<p align="center">
+  <img src="assets/screengrab.png" height="110">
+</p>
+
+screengrab
+============
+
+[![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/screengrab/LICENSE)
+[![Gem](https://img.shields.io/gem/v/screengrab.svg?style=flat)](http://rubygems.org/gems/screengrab)
+
+###### Automated localized screenshots of your Android app on every device
+
+`screengrab` generates localized screenshots of your Android app for different device types and languages for Google Play and can be uploaded using [`supply`](https://github.com/fastlane/fastlane/tree/master/supply).
+
+<img src="assets/running-screengrab.gif" width="640">
+
+### Why should I automate this process?
+- Create hundreds of screenshots in multiple languages on emulators or real devices, saving you hours
+- Easily verify that localizations fit into labels on all screen dimensions to find UI mistakes before you ship
+- You only need to configure it once for anyone on your team to run it
+- Keep your screenshots perfectly up-to-date with every app update. Your customers deserve it!
+- Fully integrates with [`fastlane`](https://fastlane.tools) and [`supply`](https://github.com/fastlane/fastlane/tree/master/supply)
+
+# Installation
+Install the gem
+
+```
+sudo gem install fastlane
+```
+
+##### Gradle dependency
+```java
+androidTestCompile 'tools.fastlane:screengrab:x.x.x'
+```
+
+The latest version can be determined by visiting the [screengrab RubyGems page](https://rubygems.org/gems/screengrab)
+
+##### Configuring your Manifest Permissions
+Ensure that the following permissions exist in your **src/debug/AndroidManifest.xml**
+
+```xml
+<!-- Allows unlocking your device and activating its screen so UI tests can succeed -->
+<uses-permission android:name="android.permission.DISABLE_KEYGUARD"/>
+<uses-permission android:name="android.permission.WAKE_LOCK"/>
+
+<!-- Allows for storing and retrieving screenshots -->
+<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+
+<!-- Allows changing locales -->
+<uses-permission android:name="android.permission.CHANGE_CONFIGURATION" />
+```
+
+##### Configuring your <a href="#ui-tests">UI Tests</a> for Screenshots
+
+1.  Add `@ClassRule public static final LocaleTestRule localeTestRule = new LocaleTestRule();` to your tests class to handle automatic switching of locales
+2.  To capture screenshots, add the following to your tests `Screengrab.screenshot("name_of_screenshot_here");` on the appropriate screens
+
+# Generating Screenshots with Screengrab
+- Then, before running `screengrab` you'll need a debug and test apk
+  - You can create your APKs with `./gradlew assembleDebug assembleAndroidTest`
+- Once complete run `screengrab` in your app project directory to generate screenshots
+    - You will be prompted to provide any required parameters which are not in your **Screengrabfile** or provided as command line arguments
+- Your screenshots will be saved to `fastlane/metadata/android` in the directory where you ran `screengrab`
+
+## Improved screenshot capture with UI Automator
+
+As of `screengrab` 0.5.0, you can specify different strategies to control the way `screengrab` captures screenshots. The newer strategy delegates to [UI Automator](https://developer.android.com/topic/libraries/testing-support-library/index.html#UIAutomator) which fixes a number of problems compared to the original strategy:
+
+* Shadows/elevation are correctly captured for Material UI
+* Multi-window situations are correctly captured (dialogs, etc.)
+* Works on Android N
+
+However, UI Automator requires a device with **API level >= 18**, so it is not yet the default strategy. To enable it for all screenshots by default, make the following call before your tests run:
+
+```java
+Screengrab.setDefaultScreenshotStrategy(new UiAutomatorScreenshotStrategy());
+```
+
+## Advanced Screengrabfile Configuration
+
+Running `fastlane screengrab init` generated a Screengrabfile which can store all of your configuration options. Since most values will not change often for your project, it is recommended to store them there.
+
+The `Screengrabfile` is written in Ruby, so you may find it helpful to use an editor that highlights Ruby syntax to modify this file.
+
+```ruby
+# remove the leading '#' to uncomment lines
+
+# app_package_name 'your.app.package'
+# use_tests_in_packages ['your.screenshot.tests.package']
+
+# app_apk_path 'path/to/your/app.apk'
+# tests_apk_path 'path/to/your/tests.apk'
+
+locales ['en-US', 'fr-FR', 'it-IT']
+
+# clear all previously generated screenshots in your local output directory before creating new ones
+clear_previous_screenshots true
+```
+
+For more information about all available options run
+
+```
+fastlane screengrab --help
+```
+
+# Tips
+
+# UI Tests
+
+Check out [Testing UI for a Single App](http://developer.android.com/training/testing/ui-testing/espresso-testing.html) for an introduction to using Espresso for UI testing.
+
+##### Example UI Test Class (Using JUnit4)
+```java
+@RunWith(JUnit4.class)
+public class JUnit4StyleTests {
+    @ClassRule
+    public static final LocaleTestRule localeTestRule = new LocaleTestRule();
+
+    @Rule
+    public ActivityTestRule<MainActivity> activityRule = new ActivityTestRule<>(MainActivity.class);
+
+    @Test
+    public void testTakeScreenshot() {
+        Screengrab.screenshot("before_button_click");
+
+        onView(withId(R.id.fab)).perform(click());
+
+        Screengrab.screenshot("after_button_click");
+    }
+}
+
+```
+There is an [example project](https://github.com/fastlane/fastlane/tree/master/screengrab/example/src/androidTest/java/tools/fastlane/localetester) showing how to use use JUnit 3 or 4 and Espresso with the screengrab Java library to capture screenshots during a UI test run.
+
+Using JUnit 4 is preferable because of its ability to perform actions before and after the entire test class is run. This means you will change the device's locale far fewer times when compared with JUnit 3 running those commands before and after each test method.
+
+When using JUnit 3 you'll need to add a bit more code:
+
+- Use `LocaleUtil.changeDeviceLocaleTo(LocaleUtil.getTestLocale());` in `setUp()`
+- Use `LocaleUtil.changeDeviceLocaleTo(LocaleUtil.getEndingLocale());` in `tearDown()`
+- Use `Screengrab.screenshot("name_of_screenshot_here");` to capture screenshots at the appropriate points in your tests
+
+If you're having trouble getting your device unlocked and the screen activated to run tests, try using `ScreenUtil.activateScreenForTesting(activity);` in your test setup.
+
+## [`fastlane`](https://fastlane.tools) Toolchain
+
+- [`fastlane`](https://fastlane.tools): The easiest way to automate beta deployments and releases for your iOS and Android apps
+- [`supply`](https://github.com/fastlane/fastlane/tree/master/supply): Upload screenshots, metadata and your app to the Play Store
+
+You can find all the tools on [fastlane.tools](https://fastlane.tools).
+
+##### [Like this tool? Be the first to know about updates and new fastlane tools](https://tinyletter.com/krausefx)
+
+# Need help?
+Please submit an issue on GitHub and provide information about your setup.
+
+## Code of Conduct
+
+Help us keep `screengrab` 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 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.