xcknife 0.11.1 → 0.12.0

data/bin/xcknife-test-dumper

@@ -1,4 +1,6 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
+
 require 'xcknife'
 
 XCKnife::TestDumper.invoke

data/example/run_example.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 require_relative '../lib/xcknife'
 require 'pp'
 
 # Gem usage of xcknife. Functionaly equivalent to
 # $ xcknife -p CommonTestTarget -p CommonTestTarget,iPadTestTarget 6 example/xcknife-exemplar-historical-data.json-stream example/xcknife-exemplar.json-stream
-include XCKnife::XCToolCmdHelper
+
 TARGET_PARTITIONS = {
-  "AllTests" => ["CommonTestTarget", "iPadTestTarget"],
-  "OnlyCommon" => ["CommonTestTarget"]
-}
+  'AllTests' => %w[CommonTestTarget iPadTestTarget],
+  'OnlyCommon' => ['CommonTestTarget']
+}.freeze
 
 def run(historical_file, current_file)
   test_target_names = TARGET_PARTITIONS.keys
@@ -20,16 +22,16 @@ def run(historical_file, current_file)
   puts "imbalances = #{result.test_time_imbalances.to_h.inspect}"
   shard_number = 0
   puts "size = #{partition_sets.size}"
-  puts "sizes = #{partition_sets.map(&:size).join(", ")}"
+  puts "sizes = #{partition_sets.map(&:size).join(', ')}"
   partition_sets.each_with_index do |partition_set, i|
     target_name = test_target_names[i]
     partition_set.each do |partition|
       puts "target name for worker #{shard_number} = #{target_name}"
-      puts "only is: #{xctool_only_arguments(partition).inspect}"
-      puts "skip-only is: #{xcodebuild_skip_arguments(partition, result.test_time_for_partitions).inspect}"
+      puts "only is: #{XCKnife::XCToolCmdHelper.xctool_only_arguments(partition).inspect}"
+      puts "skip-only is: #{XCKnife::XCToolCmdHelper.xcodebuild_skip_arguments(partition, result.test_time_for_partitions).inspect}"
       shard_number += 1
     end
   end
 end
 
-run("xcknife-exemplar-historical-data.json-stream", "xcknife-exemplar.json-stream")
+run('xcknife-exemplar-historical-data.json-stream', 'xcknife-exemplar.json-stream')

data/example/xcknife-exemplar-historical-data.json-stream

@@ -1,12 +1,12 @@
-{"bundleName":"CommonTestTarget.xctest","deviceName":"iPad Air","event":"begin-ocunit","targetName":"CommonTestTarget","testType":"logic-test","sdkName":"iphonesimulator9.2"}
+{"bundleName":"CommonTestTarget.xctest","deviceName":"iPad Air","event":"begin-ocunit","targetName":"CommonTestTarget","testType":"logic-test","sdkName":"iphonesimulator13.6"}
 {"test":"1","className":"CommonTestClass","event":"end-test","totalDuration":0.1075069904327393}
 {"test":"1","className":"CommonTestClass","event":"end-test","totalDuration":0.303464949131012}
 {"test":"1","className":"CommonTestClass","event":"end-test","totalDuration":0.2003870010375977}
-{"bundleName":"iPadTestTarget.xctest","deviceName":"iPad Air","event":"begin-ocunit","targetName":"iPadTestTarget","testType":"application-test","sdkName":"iphonesimulator9.2"}
+{"bundleName":"iPadTestTarget.xctest","deviceName":"iPad Air","event":"begin-ocunit","targetName":"iPadTestTarget","testType":"application-test","sdkName":"iphonesimulator13.6"}
 {"test":"1","className":"iPadTestClassOne","event":"end-test","totalDuration":1.001249969005585}
 {"test":"1","className":"iPadTestClassThree","event":"end-test","totalDuration":0.5002140402793884}
 {"test":"1","className":"iPadTestClassTwo","event":"end-test","totalDuration":5.001157999038696}
-{"bundleName":"iPhoneTestTarget.xctest","deviceName":"iPad Air","event":"begin-ocunit","targetName":"iPhoneTestTarget","testType":"application-test","sdkName":"iphonesimulator9.2"}
+{"bundleName":"iPhoneTestTarget.xctest","deviceName":"iPad Air","event":"begin-ocunit","targetName":"iPhoneTestTarget","testType":"application-test","sdkName":"iphonesimulator13.6"}
 {"test":"1","className":"iPhoneTestClassAlpha","event":"end-test","totalDuration":0.2037490010261536}
 {"test":"1","className":"iPhoneTestClassBeta","event":"end-test","totalDuration":0.2012439966201782}
 {"test":"1","className":"iPhoneTestClassDelta","event":"end-test","totalDuration":0.1004489660263062}

data/example/xcknife-exemplar.json-stream

@@ -1,15 +1,15 @@
-{"bundleName":"iPadTestTarget.xctest","deviceName":"iPad Air","event":"begin-ocunit","targetName":"iPadTestTarget","testType":"application-test","sdkName":"iphonesimulator9.2"}
+{"bundleName":"iPadTestTarget.xctest","deviceName":"iPad Air","event":"begin-ocunit","targetName":"iPadTestTarget","testType":"application-test","sdkName":"iphonesimulator13.6"}
 {"test":"1","className":"iPadTestClassFour","event":"end-test","totalDuration":"0"}
 {"test":"1","className":"iPadTestClassOne","event":"end-test","totalDuration":"0"}
 {"test":"1","className":"iPadTestClassThree","event":"end-test","totalDuration":"0"}
 {"test":"1","className":"iPadTestClassTwo","event":"end-test","totalDuration":"0"}
-{"bundleName":"iPhoneTestTarget.xctest","deviceName":"iPad Air","event":"begin-ocunit","targetName":"iPhoneTestTarget","testType":"application-test","sdkName":"iphonesimulator9.2"}
+{"bundleName":"iPhoneTestTarget.xctest","deviceName":"iPad Air","event":"begin-ocunit","targetName":"iPhoneTestTarget","testType":"application-test","sdkName":"iphonesimulator13.6"}
 {"test":"1","className":"iPhoneTestClassAlpha","event":"end-test","totalDuration":"0"}
 {"test":"1","className":"iPhoneTestClassBeta","event":"end-test","totalDuration":"0"}
 {"test":"1","className":"iPhoneTestClassDelta","event":"end-test","totalDuration":"0"}
 {"test":"1","className":"iPhoneTestClassGama","event":"end-test","totalDuration":"0"}
 {"test":"1","className":"iPhoneTestClassOmega","event":"end-test","totalDuration":"0"}
-{"bundleName":"CommonTestTarget.xctest","deviceName":"iPad Air","event":"begin-ocunit","targetName":"CommonTestTarget","testType":"logic-test","sdkName":"iphonesimulator9.2"}
+{"bundleName":"CommonTestTarget.xctest","deviceName":"iPad Air","event":"begin-ocunit","targetName":"CommonTestTarget","testType":"logic-test","sdkName":"iphonesimulator13.6"}
 {"test":"1","className":"CommonTestClass","event":"end-test","totalDuration":"0"}
 {"test":"1","className":"CommonTestClass","event":"end-test","totalDuration":"0"}
 {"test":"1","className":"CommonTestClass","event":"end-test","totalDuration":"0"}

data/lib/xcknife.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'xcknife/events_analyzer'
 require 'xcknife/stream_parser'
 require 'xcknife/xctool_cmd_helper'
@@ -7,5 +9,5 @@ require 'xcknife/exceptions'
 require 'xcknife/xcscheme_analyzer'
 
 module XCKnife
-  VERSION = '0.11.1'
+  VERSION = '0.12.0'
 end

data/lib/xcknife/events_analyzer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'xcknife/json_stream_parser_helper'
 require 'set'
 
@@ -8,6 +10,7 @@ module XCKnife
 
     def self.for(events, relevant_partitions)
       return NullEventsAnalyzer.new if events.nil?
+
       new(events, relevant_partitions)
     end
 
@@ -17,19 +20,21 @@ module XCKnife
       @target_class_map = analyze_events(events)
     end
 
-    def has_test_target?(target)
-      target_class_map.has_key?(target)
+    def test_target?(target)
+      target_class_map.key?(target)
     end
 
-    def has_test_class?(target, clazz)
-      has_test_target?(target) and target_class_map[target].include?(clazz)
+    def test_class?(target, clazz)
+      test_target?(target) and target_class_map[target].include?(clazz)
     end
 
     private
+
     def analyze_events(events)
       ret = Hash.new { |h, key| h[key] = Set.new }
       each_test_event(events) do |target_name, result|
         next unless @relevant_partitions.include?(target_name)
+
         @total_tests += 1
         ret[target_name] << result.className
       end
@@ -40,11 +45,11 @@ module XCKnife
   # Null object for EventsAnalyzer
   # @ref https://en.wikipedia.org/wiki/Null_Object_pattern
   class NullEventsAnalyzer
-    def has_test_target?(target)
+    def test_target?(_target)
       true
     end
 
-    def has_test_class?(target, clazz)
+    def test_class?(_target, _clazz)
       true
     end
 

data/lib/xcknife/exceptions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module XCKnife
   # Base error class for xcknife
   XCKnifeError = Class.new(RuntimeError)

data/lib/xcknife/json_stream_parser_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module XCKnife
   module JsonStreamParserHelper
     extend self
@@ -6,18 +8,16 @@ module XCKnife
     def each_test_event(events, &block)
       current_target = nil
       events.each do |result|
-        current_target = result.targetName if result.event == "begin-ocunit"
-        if result.test and result.event == "end-test"
-          raise XCKnife::StreamParsingError, "No test target defined" if current_target.nil?
-          block.call(current_target, normalize_result(result))
-        end
+        current_target = result.targetName if result.event == 'begin-ocunit'
+        next unless result.test && (result.event == 'end-test')
+        raise XCKnife::StreamParsingError, 'No test target defined' if current_target.nil?
+
+        block.call(current_target, normalize_result(result))
       end
     end
 
     def normalize_result(result)
-      if result.totalDuration.is_a?(String)
-        result.totalDuration = result.totalDuration.to_f
-      end
+      result.totalDuration = result.totalDuration.to_f if result.totalDuration.is_a?(String)
       result
     end
   end

data/lib/xcknife/runner.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'optparse'
 
 module XCKnife
@@ -33,11 +35,11 @@ module XCKnife
     end
 
     private
+
     def gen_abbreviated_output(result)
       result.test_maps.map { |partition_set| only_arguments_for_a_partition_set(partition_set, output_type) }
     end
 
-
     def output_type
       @xcodebuild_output ? :xcodebuild : :xctool
     end
@@ -47,7 +49,7 @@ module XCKnife
         metadata: {
           worker_count: @worker_count,
           partition_set_count: result.test_maps.size,
-          total_time_in_ms: result.total_test_time,
+          total_time_in_ms: result.total_test_time
         }.merge(result.stats.to_h),
         partition_set_data: partition_sets_data(result)
       }
@@ -81,18 +83,15 @@ module XCKnife
     def write_output(data)
       json = JSON.pretty_generate(data)
       return puts json if @output_file_name.nil?
-      File.open(@output_file_name, "w") { |f| f.puts(json) }
+
+      File.open(@output_file_name, 'w') { |f| f.puts(json) }
       puts "Wrote file to: #{@output_file_name}"
     end
 
     def parse_arguments(args)
       positional_arguments = parse_options(args)
-      if positional_arguments.size < required_arguments.size
-        warn_and_exit("You must specify *all* required arguments: #{required_arguments.join(", ")}")
-      end
-      if @partitions.empty?
-        warn_and_exit("At least one target partition set must be provided with -p flag")
-      end
+      warn_and_exit("You must specify *all* required arguments: #{required_arguments.join(', ')}") if positional_arguments.size < required_arguments.size
+      warn_and_exit('At least one target partition set must be provided with -p flag') if @partitions.empty?
       worker_count, @historical_timings_file, @current_tests_file = positional_arguments
       @worker_count = Integer(worker_count)
     end
@@ -101,24 +100,24 @@ module XCKnife
       build_parser
       begin
         parser.parse(args)
-      rescue OptionParser::ParseError => error
-        warn_and_exit(error)
+      rescue OptionParser::ParseError => e
+        warn_and_exit(e)
       end
     end
 
     def build_parser
       @parser = OptionParser.new do |opts|
         opts.banner += " #{arguments_banner}"
-        opts.on("-p", "--partition TARGETS",
-          "Comma separated list of targets. Can be used multiple times.") do |v|
+        opts.on('-p', '--partition TARGETS',
+                'Comma separated list of targets. Can be used multiple times.') do |v|
           @partition_names << v
-          @partitions << v.split(",")
+          @partitions << v.split(',')
         end
-        opts.on("-o", "--output FILENAME", "Output file. Defaults to STDOUT") { |v| @output_file_name = v }
-        opts.on("-a", "--abbrev", "Results are abbreviated") { |v| @abbreviated_output = v }
-        opts.on("-x", "--xcodebuild-output", "Output is formatted for xcodebuild") { |v| @xcodebuild_output = v }
+        opts.on('-o', '--output FILENAME', 'Output file. Defaults to STDOUT') { |v| @output_file_name = v }
+        opts.on('-a', '--abbrev', 'Results are abbreviated') { |v| @abbreviated_output = v }
+        opts.on('-x', '--xcodebuild-output', 'Output is formatted for xcodebuild') { |v| @xcodebuild_output = v }
 
-        opts.on_tail("-h", "--help", "Show this message") do
+        opts.on_tail('-h', '--help', 'Show this message') do
           puts opts
           exit
         end
@@ -135,7 +134,7 @@ module XCKnife
 
     def arguments_banner
       optional_args = optional_arguments.map { |a| "[#{a}]" }
-      (required_arguments + optional_args).join(" ")
+      (required_arguments + optional_args).join(' ')
     end
 
     def warn_and_exit(msg)

data/lib/xcknife/stream_parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'xcknife/json_stream_parser_helper'
 require 'json'
 require 'set'
@@ -33,6 +35,7 @@ module XCKnife
     class PartitionResult
       TimeImbalances = Struct.new :partition_set, :partitions
       attr_reader :stats, :test_maps, :test_times, :total_test_time, :test_time_imbalances, :test_time_for_partitions
+
       extend Forwardable
       delegate ResultStats.members => :@stats
 
@@ -47,10 +50,11 @@ module XCKnife
       end
 
       private
+
       # Yields the imbalances ratios of the partition sets, and the internal imbalance ratio of the respective partitions
       def compute_test_time_imbalances
         times = test_times
-        average_partition_size = times.map { |l| l.inject(:+).to_f / l.size}
+        average_partition_size = times.map { |l| l.inject(:+).to_f / l.size }
         ideal_partition_set_avg = average_partition_size.inject(:+) / @partition_sets.size
         partition_set_imbalance = average_partition_size.map { |avg| avg / ideal_partition_set_avg }
 
@@ -88,13 +92,15 @@ module XCKnife
     end
 
     def test_time_for_partitions(historical_events, current_events = nil)
-      analyzer =  EventsAnalyzer.for(current_events, relevant_partitions)
+      analyzer = EventsAnalyzer.for(current_events, relevant_partitions)
       @stats[:current_total_tests] = analyzer.total_tests
       times_for_target_class = Hash.new { |h, current_target| h[current_target] = Hash.new(0) }
       each_test_event(historical_events) do |target_name, result|
         next unless relevant_partitions.include?(target_name)
+
         inc_stat :historical_total_tests
-        next unless analyzer.has_test_class?(target_name, result.className)
+        next unless analyzer.test_class?(target_name, result.className)
+
         times_for_target_class[target_name][result.className] += (result.totalDuration * 1000).ceil
       end
 
@@ -102,10 +108,11 @@ module XCKnife
       hash_partitions(times_for_target_class)
     end
 
+    # rubocop:disable Metrics/CyclomaticComplexity
     def split_machines_proportionally(partitions)
       total = 0
       partitions.each do |test_time_map|
-        each_duration(test_time_map) { |duration_in_milliseconds| total += duration_in_milliseconds}
+        each_duration(test_time_map) { |duration_in_milliseconds| total += duration_in_milliseconds }
       end
 
       used_shards = 0
@@ -121,18 +128,17 @@ module XCKnife
         PartitionWithMachines.new(test_time_map, n, partition_time, max_shard_count, options)
       end
 
-      fifo_with_machines_who_can_use_more_shards = partition_with_machines_list.select { |x| x.number_of_shards < x.max_shard_count}.sort_by(&:partition_time)
+      fifo_with_machines_who_can_use_more_shards = partition_with_machines_list.select { |x| x.number_of_shards < x.max_shard_count }.sort_by(&:partition_time)
       while number_of_shards > used_shards
         if fifo_with_machines_who_can_use_more_shards.empty?
           break if @allow_fewer_shards
+
           raise XCKnife::XCKnifeError, "There are #{number_of_shards - used_shards} extra machines"
         end
         machine = fifo_with_machines_who_can_use_more_shards.pop
         machine.number_of_shards += 1
         used_shards += 1
-        if machine.number_of_shards < machine.max_shard_count
-          fifo_with_machines_who_can_use_more_shards.unshift(machine)
-        end
+        fifo_with_machines_who_can_use_more_shards.unshift(machine) if machine.number_of_shards < machine.max_shard_count
       end
       partition_with_machines_list
     end
@@ -140,8 +146,9 @@ module XCKnife
     # Computes a 2-aproximation to the optimal partition_time, which is an instance of the Open shop scheduling problem (which is NP-hard)
     # see: https://en.wikipedia.org/wiki/Open-shop_scheduling
     def compute_single_shards(number_of_shards, test_time_map, options: Options::DEFAULT)
-      raise XCKnife::XCKnifeError, "There are not enough workers provided" if number_of_shards <= 0
-      raise XCKnife::XCKnifeError, "Cannot shard an empty partition_time" if test_time_map.empty?
+      raise XCKnife::XCKnifeError, 'There are not enough workers provided' if number_of_shards <= 0
+      raise XCKnife::XCKnifeError, 'Cannot shard an empty partition_time' if test_time_map.empty?
+
       assignements = Array.new(number_of_shards) { MachineAssignment.new(Hash.new { |k, v| k[v] = [] }, 0) }
 
       list_of_test_target_class_times = []
@@ -153,21 +160,19 @@ module XCKnife
 
       # This might seem like an uncessary level of indirection, but it allows us to keep
       # logic consistent regardless of the `split_bundles_across_machines` option
-      list_of_test_target_classes_times = list_of_test_target_class_times.group_by do |test_target, class_name, duration_in_milliseconds|
-        if options.split_bundles_across_machines
-          [test_target, class_name]
-        else
-          test_target
-        end
-      end.map do |(test_target, _), classes|
+      group = list_of_test_target_class_times.group_by do |test_target, class_name, _duration_in_milliseconds|
+        options.split_bundles_across_machines ? [test_target, class_name] : test_target
+      end
+
+      list_of_test_target_classes_times = group.map do |(test_target, _), classes|
         [
           test_target,
-          classes.map { |test_target, class_name, duration_in_milliseconds| class_name },
-          classes.reduce(0) { |total_duration, (test_target, class_name, duration_in_milliseconds)| total_duration + duration_in_milliseconds},
+          classes.map { |_test_target, class_name, _duration_in_milliseconds| class_name },
+          classes.reduce(0) { |total_duration, (_test_target, _class_name, duration_in_milliseconds)| total_duration + duration_in_milliseconds }
         ]
       end
 
-      list_of_test_target_classes_times.sort_by! { |test_target, class_names, duration_in_milliseconds| -duration_in_milliseconds }
+      list_of_test_target_classes_times.sort_by! { |_test_target, _class_names, duration_in_milliseconds| -duration_in_milliseconds }
       list_of_test_target_classes_times.each do |test_target, class_names, duration_in_milliseconds|
         assignemnt = assignements.min_by(&:total_time)
         assignemnt.test_time_map[test_target].concat class_names
@@ -183,27 +188,31 @@ module XCKnife
 
       assignements
     end
+    # rubocop:enable Metrics/CyclomaticComplexity
 
     def parse_json_stream_file(filename)
       return nil if filename.nil?
-      return [] unless File.exists?(filename)
+      return [] unless File.exist?(filename)
+
       lines = IO.readlines(filename)
-      lines.lazy.map { |line| OpenStruct.new(JSON.load(line)) }
+      lines.lazy.map { |line| OpenStruct.new(JSON.parse(line)) }
     end
 
     private
+
     def inc_stat(name)
       @stats[name] += 1
     end
 
-    def each_duration(test_time_map, &block)
-      test_time_map.each do |test_target, class_times|
-        class_times.each do |class_name, duration_in_milliseconds|
+    def each_duration(test_time_map)
+      test_time_map.each do |_test_target, class_times|
+        class_times.each do |_class_name, duration_in_milliseconds|
           yield(duration_in_milliseconds)
         end
       end
     end
 
+    # rubocop:disable Metrics/CyclomaticComplexity
     def extrapolate_times_for_current_events(analyzer, times_for_target_class)
       median_map = {}
       times_for_target_class.each do |test_target, class_times|
@@ -213,9 +222,9 @@ module XCKnife
       all_times_for_all_classes = times_for_target_class.values.flat_map(&:values)
       median_of_targets = median(all_times_for_all_classes)
       analyzer.target_class_map.each do |test_target, class_set|
-        if times_for_target_class.has_key?(test_target)
+        if times_for_target_class.key?(test_target)
           class_set.each do |clazz|
-            unless times_for_target_class[test_target].has_key?(clazz)
+            unless times_for_target_class[test_target].key?(clazz)
               inc_stat :class_extrapolations
               times_for_target_class[test_target][clazz] = median_map[test_target]
             end
@@ -233,6 +242,7 @@ module XCKnife
     DEFAULT_EXTRAPOLATED_DURATION = 1000
     def extrapolated_duration(median_of_targets, class_set)
       return DEFAULT_EXTRAPOLATED_DURATION if median_of_targets.nil?
+
       median_of_targets / class_set.size
     end
 
@@ -248,10 +258,9 @@ module XCKnife
         end
       end
       ret.each_with_index do |partition, index|
-        if partition.empty?
-          raise XCKnife::XCKnifeError, "The following partition has no tests: #{test_partitions[index].to_a.inspect}"
-        end
+        raise XCKnife::XCKnifeError, "The following partition has no tests: #{test_partitions[index].to_a.inspect}" if partition.empty?
       end
     end
   end
+  # rubocop:enable Metrics/CyclomaticComplexity
 end