snapshot 0.10.2 → 1.0.1

data/lib/snapshot/options.rb

@@ -0,0 +1,98 @@
+require 'fastlane_core'
+
+module Snapshot
+  class Options
+    def self.available_options
+      output_directory = (File.directory?("fastlane") ? "fastlane/screenshots" : "screenshots")
+
+      @@options ||= [
+        FastlaneCore::ConfigItem.new(key: :workspace,
+                                     short_option: "-w",
+                                     env_name: "SNAPSHOT_WORKSPACE",
+                                     optional: true,
+                                     description: "Path the workspace file",
+                                     verify_block: proc do |value|
+                                       v = File.expand_path(value.to_s)
+                                       raise "Workspace file not found at path '#{v}'".red unless File.exist?(v)
+                                       raise "Workspace file invalid".red unless File.directory?(v)
+                                       raise "Workspace file is not a workspace, must end with .xcworkspace".red unless v.include?(".xcworkspace")
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :project,
+                                     short_option: "-p",
+                                     optional: true,
+                                     env_name: "SNAPSHOT_PROJECT",
+                                     description: "Path the project file",
+                                     verify_block: proc do |value|
+                                       v = File.expand_path(value.to_s)
+                                       raise "Project file not found at path '#{v}'".red unless File.exist?(v)
+                                       raise "Project file invalid".red unless File.directory?(v)
+                                       raise "Project file is not a project file, must end with .xcodeproj".red unless v.include?(".xcodeproj")
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :devices,
+                                     description: "A list of devices you want to take the screenshots from",
+                                     is_string: false,
+                                     optional: true,
+                                     verify_block: proc do |value|
+                                       raise "Devices must be an array" unless value.kind_of?(Array)
+                                       available = FastlaneCore::Simulator.all
+                                       value.each do |current|
+                                         unless available.any? { |d| d.name.strip == current.strip }
+                                           raise "Device '#{current}' not in list of available simulators '#{available.join(', ')}'".red
+                                         end
+                                       end
+                                     end),
+        FastlaneCore::ConfigItem.new(key: :languages,
+                                     description: "A list of languages which should be used",
+                                     is_string: false,
+                                     default_value: [
+                                       'en-US'
+                                     ]),
+        FastlaneCore::ConfigItem.new(key: :output_directory,
+                                     short_option: "-o",
+                                     env_name: "SNAPSHOT_OUTPUT_DIRECTORY",
+                                     description: "The directory where to store the screenshots",
+                                     default_value: output_directory),
+        FastlaneCore::ConfigItem.new(key: :ios_version,
+                                     description: "By default, the latest version should be used automatically. If you want to change it, do it here",
+                                     default_value: Snapshot::LatestIosVersion.version),
+        FastlaneCore::ConfigItem.new(key: :stop_after_first_error,
+                                     env_name: 'SNAPSHOT_BREAK_ON_FIRST_ERROR',
+                                     description: "Should snapshot stop immediately after one of the tests failed on one device?",
+                                     default_value: false,
+                                     is_string: false),
+        FastlaneCore::ConfigItem.new(key: :skip_open_summary,
+                                     env_name: 'SNAPSHOT_SKIP_OPEN_SUMMARY',
+                                     description: "Don't open the HTML summary after running `snapshot`",
+                                     default_value: false,
+                                     is_string: false),
+        FastlaneCore::ConfigItem.new(key: :clear_previous_screenshots,
+                                     env_name: 'SNAPSHOT_CLEAR_PREVIOUS_SCREENSHOTS',
+                                     description: "Enabling this option will automatically clear previously generated screenshots before running snapshot",
+                                     default_value: false,
+                                     is_string: false),
+
+        # Everything around building
+        FastlaneCore::ConfigItem.new(key: :buildlog_path,
+                                     short_option: "-l",
+                                     env_name: "SNAPSHOT_BUILDLOG_PATH",
+                                     description: "The directory where to store the build log",
+                                     default_value: "~/Library/Logs/snapshot"),
+        FastlaneCore::ConfigItem.new(key: :configuration,
+                                     short_option: "-q",
+                                     env_name: "SNAPSHOT_CONFIGURATION",
+                                     description: "The configuration to use when building the app. Defaults to 'Release'",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :sdk,
+                                     short_option: "-k",
+                                     env_name: "SNAPSHOT_SDK",
+                                     description: "The SDK that should be used for building the application",
+                                     optional: true),
+        FastlaneCore::ConfigItem.new(key: :scheme,
+                                     short_option: "-s",
+                                     env_name: 'SNAPSHOT_SCHEME',
+                                     description: "The scheme you want to use, this must be the scheme for the UI Tests",
+                                     optional: true) # optional true because we offer a picker to the user
+      ]
+    end
+  end
+end

data/lib/snapshot/page.html.erb

@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html>
   <head>
-    <title><%= @title %></title>
+    <title>KrauseFx/snapshot</title>
     <meta charset="UTF-8">
     <style type="text/css">
       * {

data/lib/snapshot/reports_generator.rb

@@ -4,30 +4,25 @@ require 'fastimage'
 module Snapshot
   class ReportsGenerator
     def generate
+      Helper.log.info "Generating HTML Report"
 
-      config = SnapshotConfig.shared_instance
-      screens_path = config.screenshots_path
+      screens_path = Snapshot.config[:output_directory]
 
-      @title = config.html_title    
       @data = {}
 
-      Dir["#{screens_path}/*"].sort.each do |language_path|
-        language = File.basename(language_path)
-        Dir[File.join(language_path, '*')].sort.each do |screenshot|
+      Dir[File.join(screens_path, "*")].sort.each do |language_folder|
+        language = File.basename(language_folder)
+        Dir[File.join(language_folder, '*.png')].sort.each do |screenshot|
+          available_devices.each do |key_name, output_name|
+            next unless File.basename(screenshot).include?(key_name)
 
-          ["portrait", "landscape"].each do |orientation|
-            available_devices.each do |key_name, output_name|
-              if File.basename(screenshot).include?key_name and File.basename(screenshot).include?orientation
-                output_name += " (#{orientation.capitalize})"
-                # This screenshot it from this device
-                @data[language] ||= {}
-                @data[language][output_name] ||= []
+            # This screenshot is from this device
+            @data[language] ||= {}
+            @data[language][output_name] ||= []
 
-                resulting_path = File.join('.', language, File.basename(screenshot))
-                @data[language][output_name] << resulting_path
-                break # to not include iPhone 6 and 6 Plus (name is contained in the other name)
-              end
-            end
+            resulting_path = File.join('.', language, File.basename(screenshot))
+            @data[language][output_name] << resulting_path
+            break # to not include iPhone 6 and 6 Plus (name is contained in the other name)
           end
         end
       end
@@ -44,25 +39,26 @@ module Snapshot
     end
 
     private
-      def lib_path
-        if not Helper.is_test? and Gem::Specification::find_all_by_name('snapshot').any?
-          return [Gem::Specification.find_by_name('snapshot').gem_dir, 'lib'].join('/')
-        else
-          return './lib'
-        end
-      end
 
-      def available_devices
-        # The order IS important, since those names are used to check for include?
-        # and the iPhone 6 is inlucded in the iPhone 6 Plus
-        {
-          'iPhone6Plus' => "iPhone 6 Plus",
-          'iPhone6' => "iPhone 6",
-          'iPhone5' => "iPhone 5",
-          'iPhone4' => "iPhone 4",
-          'iPad' => "iPad",
-          'Mac' => "Mac"
-        }
+    def lib_path
+      if !Helper.is_test? and Gem::Specification.find_all_by_name('snapshot').any?
+        return [Gem::Specification.find_by_name('snapshot').gem_dir, 'lib'].join('/')
+      else
+        return './lib'
       end
+    end
+
+    def available_devices
+      # The order IS important, since those names are used to check for include?
+      # and the iPhone 6 is inlucded in the iPhone 6 Plus
+      {
+        'iPhone6Plus' => "iPhone 6 Plus",
+        'iPhone6' => "iPhone 6",
+        'iPhone5' => "iPhone 5",
+        'iPhone4' => "iPhone 4",
+        'iPad' => "iPad",
+        'Mac' => "Mac"
+      }
+    end
   end
-end
+end

data/lib/snapshot/reset_simulators.rb

@@ -21,11 +21,11 @@ module Snapshot
       all_devices.split("\n").each do |line|
         parsed = line.match(/\s+([\w\s]+)\s\(([\w\-]+)\)/) || []
         next unless parsed.length == 3 # we don't care about those headers
-        parsed, name, id = parsed.to_a
+        _, name, id = parsed.to_a
         puts "Removing device #{name} (#{id})"
         `xcrun simctl delete #{id}`
       end
-       
+
       all_device_types = `xcrun simctl list devicetypes`.scan(/(.*)\s\((.*)\)/)
       # == Device Types ==
       # iPhone 4s (com.apple.CoreSimulator.SimDeviceType.iPhone-4s)
@@ -33,7 +33,7 @@ module Snapshot
       # iPhone 5s (com.apple.CoreSimulator.SimDeviceType.iPhone-5s)
       # iPhone 6 (com.apple.CoreSimulator.SimDeviceType.iPhone-6)
       all_device_types.each do |device_type|
-        next if device_type.join(' ').include?"Watch" # we don't want to deal with the Watch right now
+        next if device_type.join(' ').include? "Watch" # we don't want to deal with the Watch right now
 
         ios_versions.each do |ios_version|
           puts "Creating #{device_type} for iOS version #{ios_version}"
@@ -42,4 +42,4 @@ module Snapshot
       end
     end
   end
-end
+end

data/lib/snapshot/runner.rb

@@ -1,275 +1,88 @@
-require 'pty'
 require 'shellwords'
+require 'plist'
 
 module Snapshot
   class Runner
-    TRACE_DIR = '/tmp/snapshot_traces'
+    attr_accessor :number_of_retries
 
-    def work(clean: true, build: true, take_snapshots: true)
-      SnapshotConfig.shared_instance.js_file # to verify the file can be found earlier
+    def work
+      FastlaneCore::PrintTable.print_values(config: Snapshot.config, hide_keys: [], title: "Summary")
 
-      Builder.new.build_app(clean: clean) if build
-      @app_path = determine_app_path
+      clear_previous_screenshots if Snapshot.config[:clear_previous_screenshots]
 
-      counter = 0
-      errors = []
-
-      if (SnapshotConfig.shared_instance.clear_previous_screenshots and take_snapshots)
-        path_to_clear = (SnapshotConfig.shared_instance.screenshots_path + "/*-*/*.png") # languages always contain a `-`
-        Dir[path_to_clear].each { |a| File.delete(a) } # no idea why rm_rf doesn't work
-      end
+      Helper.log.info "Building and running project - this might take some time...".green
 
-      SnapshotConfig.shared_instance.devices.each do |device|
-        SnapshotConfig.shared_instance.languages.each do |language_item|
-
-          if language_item.instance_of?String
-            language = language_item
-            locale = language_item
-          else
-            (language, locale) = language_item            
-          end
-
-
-          prepare_simulator(device, language)
-
-          reinstall_app(device, language, locale) unless ENV["SNAPSHOT_SKIP_UNINSTALL"]
-          
+      self.number_of_retries = 0
+      errors = []
+      Snapshot.config[:devices].each do |device|
+        Snapshot.config[:languages].each do |language|
           begin
-            errors.concat(run_tests(device, language, locale))
+            launch(language, device)
           rescue => ex
-            Helper.log.error(ex)
-          end
-
-          # we also want to see the screenshots when something went wrong
-          counter += copy_screenshots(language) if take_snapshots 
-
-          teardown_simulator(device, language)
-
-          break if errors.any? && ENV["SNAPSHOT_BREAK_ON_FIRST_ERROR"]
-        end
-
-        break if errors.any? && ENV["SNAPSHOT_BREAK_ON_FIRST_ERROR"]
-      end
-
-      kill_simulator # close the simulator after the script is finished
-
-      return unless take_snapshots
-
-      ReportsGenerator.new.generate
-
-      if errors.count > 0
-        Helper.log.error "-----------------------------------------------------------"
-        Helper.log.error errors.join(' - ').red
-        Helper.log.error "-----------------------------------------------------------"
-        raise "Finished generating #{counter} screenshots with #{errors.count} errors.".red
-      else
-        Helper.log.info "Successfully finished generating #{counter} screenshots.".green
-      end
-      
-      Helper.log.info "Check it out here: #{SnapshotConfig.shared_instance.screenshots_path}".green
-    end
-
-    def clean_old_traces
-      FileUtils.rm_rf(TRACE_DIR)
-      FileUtils.mkdir_p(TRACE_DIR)
-    end
-
-    def prepare_simulator(device, language)
-      SnapshotConfig.shared_instance.blocks[:setup_for_device_change].call(device, udid_for_simulator(device), language)  # Callback
-      SnapshotConfig.shared_instance.blocks[:setup_for_language_change].call(language, device) # deprecated
-    end
-
-    def teardown_simulator(device, language)
-      SnapshotConfig.shared_instance.blocks[:teardown_language].call(language, device) # Callback
-      SnapshotConfig.shared_instance.blocks[:teardown_device].call(device, language) # deprecated
-    end
-
-    def udid_for_simulator(name) # fetches the UDID of the simulator type
-      all = Simulators.raw_simulators.split("\n")
-      all.each do |current|
-        return current.match(/\[(.*)\]/)[1] if current.include?name
-      end
-      raise "Could not find simulator '#{name}' to install the app on."
-    end
-
-    def reinstall_app(device, language, locale)
-      Helper.log.info "Reinstalling app...".yellow unless $verbose
+            Helper.log.error ex # we should to show right here as well
+            errors << ex
 
-      app_identifier = ENV["SNAPSHOT_APP_IDENTIFIER"]
-      app_identifier ||= @app_identifier
-
-      def com(cmd)
-        puts cmd.magenta if $verbose
-
-        IO.popen("#{cmd} 2>&1", err: [:child, :out]) do |io|
-          io.each do |line|
-            puts line if (line.to_s.length > 0 and $verbose)
+            raise ex if Snapshot.config[:stop_after_first_error]
           end
-          io.close
         end
       end
 
-      udid = udid_for_simulator(device)
-
-      kill_simulator
-
-      if Snapshot.min_xcode7?
-        clean_old_traces
-        com("xcrun instruments -w '#{udid}' -t 'Blank' -l 1 -D '#{TRACE_DIR}/trace'")
-      else
-        com("xcrun simctl boot '#{udid}'")
-      end
+      raise errors.join('; ') if errors.count > 0
 
-      com("xcrun simctl uninstall booted '#{app_identifier}'")
-      com("xcrun simctl install booted #{@app_path.shellescape}")
-      com("xcrun simctl shutdown booted") unless Snapshot.min_xcode7?
+      # Generate HTML report
+      ReportsGenerator.new.generate
     end
 
-    def run_tests(device, language, locale)
-      Helper.log.info "Running tests on #{device} in language #{language} (locale #{locale})".green
-      
-      clean_old_traces
+    def launch(language, device_type)
+      screenshots_path = TestCommandGenerator.derived_data_path
+      FileUtils.rm_rf(screenshots_path)
+      FileUtils.mkdir_p(screenshots_path)
 
-      ENV['SNAPSHOT_LANGUAGE'] = language
-      command = generate_test_command(device, language, locale)
-      Helper.log.debug command.yellow
-      
-      retry_run = false
+      File.write("/tmp/language.txt", language)
 
-      lines = []
-      errors = []
-      PTY.spawn(command) do |stdout, stdin, pid|
+      command = TestCommandGenerator.generate(device_type: device_type)
 
-        # Waits for process so that we can see if anything has failed
-        begin
-          stdout.sync
+      Helper.log_alert("#{device_type} - #{language}")
 
-          stdout.each do |line|
-            lines << line
-            begin
-              puts line.strip if $verbose
-              result = parse_test_line(line)
-              case result
-                when :retry
-                  retry_run = true
-                when :screenshot
-                  Helper.log.info "Successfully took screenshot 📱"
-                when :pass
-                  Helper.log.info line.strip.gsub("Pass:", "✓").green
-                when :fail
-                  Helper.log.info line.strip.gsub("Fail:", "✗").red
-                when :need_permission
-                  raise "Looks like you may need to grant permission for Instruments to analyze other processes.\nPlease Ctrc + C and run this command: \"#{command}\""
-                end
-            rescue Exception => ex
-              Helper.log.error lines.join('')
-              Helper.log.error ex.to_s.red
-              errors << ex.to_s
-            end
+      prefix_hash = [
+        {
+          prefix: "Running Tests: ",
+          block: proc do |value|
+            value.include?("Touching")
           end
-
-        rescue Errno::EIO => e
-          # We could maybe do something like this
-        ensure
-          ::Process.wait pid
-        end
-
-      end
-
-      if retry_run
-        Helper.log.error "Instruments tool failed again. Re-trying..." if $verbose
-        sleep 2 # We need enough sleep... that's an instruments bug
-        errors = run_tests(device, language, locale)
-      end
-
-      return errors
+        }
+      ]
+
+      FastlaneCore::CommandExecutor.execute(command: command,
+                                          print_all: true,
+                                      print_command: true,
+                                             prefix: prefix_hash,
+                                            loading: "Loading...",
+                                              error: proc do |output, return_code|
+                                                ErrorHandler.handle_test_error(output, return_code)
+
+                                                # no exception raised... that means we need to retry
+                                                Helper.log.info "Cought error... #{return_code}".red
+
+                                                self.number_of_retries += 1
+                                                if self.number_of_retries < 20
+                                                  launch(language, device_type)
+                                                else
+                                                  # It's important to raise an error, as we don't want to collect the screenshots
+                                                  raise "Too many errors... no more retries...".red
+                                                end
+                                              end)
+
+      raw_output = File.read(TestCommandGenerator.xcodebuild_log_path)
+      Collector.fetch_screenshots(raw_output, language, device_type)
     end
 
-    def determine_app_path
-      # Determine the path to the actual app and not the WatchKit app
-      build_dir = SnapshotConfig.shared_instance.build_dir || '/tmp/snapshot'
-      Dir.glob("#{build_dir}/**/*.app/*.plist").each do |path|
-        # `2>&1` to hide the error if it's not there: http://stackoverflow.com/a/4783536/445598
-        watchkit_enabled = `/usr/libexec/PlistBuddy -c 'Print WKWatchKitApp' '#{path}' 2>&1`.strip
-        next if watchkit_enabled == 'true' # we don't care about WatchKit Apps
-
-        app_identifier = `/usr/libexec/PlistBuddy -c 'Print CFBundleIdentifier' '#{path}' 2>&1`.strip
-        if app_identifier and app_identifier.length > 0
-          # This seems to be the valid Info.plist
-          @app_identifier = app_identifier
-          return File.expand_path("..", path) # the app
-        end
+    def clear_previous_screenshots
+      Helper.log.info "Clearing previously generated screenshots".yellow
+      path = File.join(".", Snapshot.config[:output_directory], "*", "*.png")
+      Dir[path].each do |current|
+        File.delete(current)
       end
-
-      raise "Could not find app in '#{build_dir}'. Make sure you're following the README and set the build directory to the correct path.".red
-    end
-
-    def parse_test_line(line)
-      if line =~ /.*Target failed to run.*/
-        return :retry
-      elsif line.include?"segmentation fault" # a new bug introduced with Xcode 7
-        return :retry
-      elsif line.include?"Timed out waiting" # a new bug introduced with Xcode 7
-        `killall "iOS Simulator"`
-        `killall "Simulator"`
-        return :retry
-      elsif line.include?"Screenshot captured"
-        return :screenshot
-      elsif line.include? "Instruments wants permission to analyze other processes"
-        return :need_permission
-      elsif line.include? "Pass: "
-        return :pass
-      elsif line.include? "Fail: "
-        return :fail
-      elsif line =~ /.*Error: (.*)/
-        raise "UIAutomation Error: #{$1}"
-      elsif line =~ /Instruments Usage Error :(.*)/
-        raise "Instruments Usage Error: #{$1}"
-      elsif line.include?"__NSPlaceholderDictionary initWithObjects:forKeys:count:]: attempt to insert nil object"
-        raise "Looks like something is wrong with the used app. Make sure the build was successful."
-      end
-    end
-
-    def kill_simulator
-      `xcrun simctl shutdown booted`
-      `killall "iOS Simulator"`
-      `killall "Simulator"`
-    end
-
-    def copy_screenshots(language)
-      resulting_path = File.join(SnapshotConfig.shared_instance.screenshots_path, language)
-
-      FileUtils.mkdir_p resulting_path
-
-      unless SnapshotConfig.shared_instance.skip_alpha_removal
-        ScreenshotFlatten.new.run(TRACE_DIR)
-      end
-
-      ScreenshotRotate.new.run(TRACE_DIR)
-
-      Dir.glob("#{TRACE_DIR}/**/*.png") do |file|
-        FileUtils.cp_r(file, resulting_path + '/')
-      end
-      return Dir.glob("#{TRACE_DIR}/**/*.png").count
-    end
-
-    def generate_test_command(device, language, locale)
-      is_ipad = (device.downcase.include?'ipad')
-      script_path = SnapshotConfig.shared_instance.js_file(is_ipad)
-      custom_run_args = SnapshotConfig.shared_instance.custom_run_args || ENV["SNAPSHOT_CUSTOM_RUN_ARGS"] || ''
-
-      [
-        "instruments",
-        "-w '#{device}'",
-        "-D '#{TRACE_DIR}/trace'",
-        "-t 'Automation'",
-        "#{@app_path.shellescape}",
-        "-e UIARESULTSPATH '#{TRACE_DIR}'",
-        "-e UIASCRIPT '#{script_path}'",
-        "-AppleLanguages '(#{language})'",
-        "-AppleLocale '#{locale}'",
-        custom_run_args,
-      ].join(' ')
     end
   end
 end