illuminator 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c94f4888bca611f421fcaf152f94e1e5418bed78
+  data.tar.gz: f967a48a1432cf3419c7e7d62e269a0769159d33
+SHA512:
+  metadata.gz: 6ebf64b498f0f7fee2b399c824a7d307bcb4c1bf58536685bdd1232cbb98c7a425753a5b42ffa4d58729a69b3f242da2e22f40a3961185f798ea0e757701a119
+  data.tar.gz: 1b00dd71f903e20cc000dad3f78effe97879544bf61596b7a0925d9b49e0ca7522de20f882b5926361d545c32c2463dc756f0bf0f5c289198fd82a9fc13d4934

data/gem/README.md

@@ -0,0 +1,37 @@
+# Illuminator gem
+
+This gem contains ruby modules necessary to run tests using the [Illuminator framework](http://github.com/paypal/Illuminator).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'illuminator'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install illuminator
+
+## Usage
+
+See the [main Illuminator documentation](https://github.com/paypal/Illuminator).
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/paypal/illuminator/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/gem/bin/illuminatorTestRunner.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+require 'bundler/setup'
+require 'illuminator'
+require 'pathname'
+
+options = {}
+parser_factory = Illuminator::ParserFactory.new
+
+parser_factory.prepare({},  # no defaults are being set
+                       {},  # no extra parse flags are being defined
+                       {})  # no argument processing overrides are being provided
+
+# Each command line option has a single-character code, so we lay out the order of the options (# for separator) here
+#parser = parser_factory.build_parser(options, 'APDasdq#xtoni#rvmw#bzl#Bfek#')
+parser = parser_factory.build_parser(options, 'AyfEBxrc#aDPWqs#dbzlek#vmp#xtoniw#')
+
+# read the options into an Illuminator::Options structure
+option_struct = parser.parse ARGV
+
+# use the defined options
+success = Illuminator::run_with_options option_struct
+exit 1 unless success

data/gem/lib/illuminator.rb

@@ -0,0 +1,171 @@
+require "illuminator/version"
+
+require "illuminator/automation-builder"
+require "illuminator/automation-runner"
+require "illuminator/argument-parsing"
+require "illuminator/device-installer"
+require "illuminator/build-artifacts"
+require "illuminator/host-utils"
+require "illuminator/xcode-utils"
+require "illuminator/options"
+
+
+module Illuminator
+
+  class Framework
+
+    def self.will_clean options
+      return true if options.illuminator.clean.derived
+      return true if options.illuminator.clean.artifacts
+      return true if options.illuminator.clean.xcode
+      return false
+    end
+
+    def self.clean_countdown
+      countdown = "3....2....1...."
+      print "Cleaning in ".yellow
+      countdown.split("").each do |c|
+        print c.yellow
+        sleep(0.2)
+      end
+      print "\n"
+    end
+
+    def self.validate_options(options)
+      noproblems = true
+
+      # so we can call BS on the user
+      bs = lambda do |message|
+        puts message.red
+        noproblems = false
+      end
+
+      # some things to check
+      things = {
+        "Build artifacts directory" => options.build_artifacts_dir,
+      }
+
+      # now check them
+      things.each { |k, v| bs.call "#{k} was not specified" if v.nil? }
+
+      # fail quickly if simulator device and/or version are wrong
+      if options.illuminator.hardware_id.nil?
+        device = options.simulator.device
+        version = options.simulator.version
+        devices = XcodeUtils.instance.get_simulator_device_types()
+        versions = XcodeUtils.instance.get_simulator_runtimes()
+
+
+        unless devices.include? device
+          bs.call "Specified simulator device '#{device}' does not appear to be installed -  options are #{devices}"
+        end
+
+        unless versions.include? version
+          bs.call "Specified simulator iOS version '#{version}' does not appear to be installed -  options are #{versions}"
+        end
+
+      end
+
+      # check paths
+      if options.illuminator.task.automate
+        bs.call "Implementation was not specified" if options.javascript.implementation.nil?
+
+        if options.javascript.test_path.nil?
+          bs.call "Javascript test definitions file was not specified"
+        else
+          unless File.exists? options.javascript.test_path
+            bs.call "Could not find specified javascript test definitions file at '#{options.javascript.test_path}'"
+          end
+        end
+      end
+
+      return noproblems
+    end
+
+  end
+
+
+
+  def self.run_with_options(originalOptions)
+
+    options = Options.new(originalOptions.to_h) # immediately create a copy of the options, because we may mangle them
+
+    # validate some inputs
+    return false unless Framework.validate_options(options)
+
+    Illuminator::BuildArtifacts.instance.set_root options.build_artifacts_dir
+
+    hardware_id = options.illuminator.hardware_id
+    app_name    = options.xcode.app_name
+
+    # do any initial cleaning
+    clean_dirs = {
+      HostUtils.realpath("~/Library/Developer/Xcode/DerivedData") => options.illuminator.clean.derived,
+      Illuminator::BuildArtifacts.instance.root(true)             => options.illuminator.clean.artifacts,
+    }
+    Framework.clean_countdown if Framework.will_clean(options) and (not options.illuminator.clean.no_delay)
+    clean_dirs.each do |d, do_clean|
+      dir = HostUtils.realpath d
+      if do_clean
+        puts "Illuminator cleanup: removing #{dir}"
+        FileUtils.rmtree dir
+      end
+    end
+
+    # Initialize builder and build
+    if (not options.instruments.app_location.nil?)
+      puts "Skipping build because app_location was provided".yellow if options.illuminator.task.build
+      options.instruments.app_location = HostUtils::realpath(options.instruments.app_location)
+    elsif (not options.illuminator.task.build)
+      options.instruments.app_location = Illuminator::BuildArtifacts.instance.app_location(app_name) # assume app is here
+    else
+      builder = AutomationBuilder.new
+      builder.project_dir = options.xcode.project_dir
+      builder.project    = options.xcode.project
+      builder.scheme     = options.xcode.scheme
+      builder.workspace  = options.xcode.workspace
+      builder.do_clean    = options.illuminator.clean.xcode
+      unless options.xcode.environment_vars.nil?
+        options.xcode.environment_vars.each { |name, value| builder.add_environment_variable(name, value) }
+      end
+
+      # if app name is not specified, make sure that we will only have one to run
+      XcodeUtils.remove_existing_apps(Illuminator::BuildArtifacts.instance.xcode) if app_name.nil?
+      if builder.build_for_automation(options.xcode.sdk, hardware_id)
+        puts 'Build succeded'.green
+        options.instruments.app_location = Illuminator::BuildArtifacts.instance.app_location(app_name)
+      else
+        puts 'Build failed, check logs for results'.red
+        exit builder.exit_code
+      end
+    end
+
+    return true unless options.illuminator.task.automate
+
+    # Install on real device
+    unless hardware_id.nil?
+      DeviceInstaller.instance.install_on_device(options.instruments.app_location, hardware_id)
+    end
+
+    # Initialize automation
+    runner = AutomationRunner.new
+    runner.app_name = app_name
+    runner.cleanup
+    return runner.run_with_options(options)
+
+  end
+
+  # override_options is a lambda function that acts on the options object
+  def self.rerun(config_path, override_options = nil)
+
+    # load config from supplied path
+    json_config = IO.read(config_path)
+
+    # process any overrides
+    options = override_options.(Illuminator::Options.new(JSON.parse(json_config))) unless override_options.nil?
+
+    return run_with_options options
+  end
+
+
+end

data/gem/lib/illuminator/argument-parsing.rb

@@ -0,0 +1,299 @@
+require 'optparse'
+require 'ostruct'
+
+require_relative './options'
+require_relative './host-utils'
+
+module Illuminator
+
+  class Parser < OptionParser
+    attr_reader :positional_args
+
+    def initialize options
+      super
+      @_options = options
+    end
+
+    def check_retest_args
+      known_retests = ["solo"]
+
+      @_options["retest"] = [] if @_options["retest"].nil?
+
+      @_options["retest"].each do |r|
+        if known_retests.include? r
+          # ok
+        elsif /^\d+x$/.match(r)
+          # ok (1x, 2x, 3x...)
+        else
+          puts "Got unknown --retest specifier '#{r}'".yellow
+        end
+      end
+    end
+
+    def get_max_retests
+      ret = 0
+      @_options["retest"].each do |r|
+        matches = /^(\d+)x$/.match(r)
+        unless matches.nil?
+          ret = [ret, matches[1].to_i].max
+        end
+      end
+      ret
+    end
+
+    def check_clean_args
+      known_cleans = ["xcode", "buildArtifacts", "derivedData", "noDelay"]
+
+      @_options["clean"] = [] if @_options["clean"].nil?
+
+      @_options["clean"].each do |c|
+        unless known_cleans.include? c
+          puts "Got unknown --clean specifier '#{c}'".yellow
+        end
+      end
+    end
+
+    # copy internal options storage into a options object
+    def copy_parsed_options_into(illuminatorOptions)
+      check_clean_args
+      check_retest_args
+
+      # load up known illuminatorOptions
+      # we only load non-nil options, just in case there was already something in the illuminatorOptions obj
+      illuminatorOptions.build_artifacts_dir = @_options["buildArtifacts"] unless @_options["buildArtifacts"].nil?
+
+      illuminatorOptions.xcode.app_name       = @_options["app_name"] unless @_options["app_name"].nil?
+      illuminatorOptions.xcode.sdk            = @_options["sdk"] unless @_options["sdk"].nil?
+      illuminatorOptions.xcode.scheme         = @_options["scheme"] unless @_options["scheme"].nil?
+      illuminatorOptions.xcode.workspace      = @_options["xcodeWorkspace"] unless @_options["xcodeWorkspace"].nil?
+
+      illuminatorOptions.illuminator.entry_point      = @_options["entry_point"] unless @_options["entry_point"].nil?
+      illuminatorOptions.illuminator.test.random_seed = @_options["random_seed"].to_i unless @_options["random_seed"].nil?
+      illuminatorOptions.illuminator.test.tags.any    = @_options["tags_any"] unless @_options["tags_any"].nil?
+      illuminatorOptions.illuminator.test.tags.all    = @_options["tags_all"] unless @_options["tags_all"].nil?
+      illuminatorOptions.illuminator.test.tags.none   = @_options["tags_none"] unless @_options["tags_none"].nil?
+
+      illuminatorOptions.illuminator.test.retest.attempts = get_max_retests
+      illuminatorOptions.illuminator.test.retest.solo     = @_options["retest"].include? "solo"
+
+      illuminatorOptions.illuminator.clean.xcode     = @_options["clean"].include? "xcode"
+      illuminatorOptions.illuminator.clean.derived   = @_options["clean"].include? "derivedData"
+      illuminatorOptions.illuminator.clean.artifacts = @_options["clean"].include? "buildArtifacts"
+      illuminatorOptions.illuminator.clean.noDelay   = @_options["clean"].include? "noDelay"
+
+      illuminatorOptions.illuminator.task.build     = (not @_options["skipBuild"]) unless @_options["skipBuild"].nil?
+      illuminatorOptions.illuminator.task.automate  = (not @_options["skipAutomate"]) unless @_options["skipAutomate"].nil?
+      illuminatorOptions.illuminator.task.set_sim   = (not @_options["skipSetSim"]) unless @_options["skipSetSim"].nil?
+      illuminatorOptions.illuminator.task.coverage  = @_options["coverage"] unless @_options["coverage"].nil?
+      illuminatorOptions.illuminator.hardware_id    = @_options["hardware_id"] unless @_options["hardware_id"].nil?
+
+      illuminatorOptions.simulator.device     = @_options["sim_device"] unless @_options["sim_device"].nil?
+      illuminatorOptions.simulator.version    = @_options["sim_version"] unless @_options["sim_version"].nil?
+      illuminatorOptions.simulator.language   = @_options["sim_language"] unless @_options["sim_language"].nil?
+      illuminatorOptions.simulator.kill_after = (not @_options["skipKillAfter"]) unless @_options["skipKillAfter"].nil?
+
+      illuminatorOptions.instruments.app_location = @_options["app_location"] unless @_options["app_location"].nil?
+      illuminatorOptions.instruments.do_verbose   = @_options["verbose"] unless @_options["verbose"].nil?
+      illuminatorOptions.instruments.timeout      = @_options["timeout"].to_i unless @_options["timeout"].nil?
+
+      illuminatorOptions.javascript.test_path       = @_options["test_path"] unless @_options["test_path"].nil?
+      illuminatorOptions.javascript.implementation  = @_options["implementation"] unless @_options["implementation"].nil?
+
+      known_keys = Illuminator::ParserFactory.new.letter_map.values # get option keynames from a plain vanilla factory
+
+      # load up unknown illuminatorOptions
+      illuminatorOptions.app_specific = @_options.select { |keyname, _| not (known_keys.include? keyname) }
+
+      return illuminatorOptions
+    end
+
+    def parse args
+      @positional_args = super(args)
+      return copy_parsed_options_into(Illuminator::Options.new)
+    end
+
+  end
+
+
+
+  class ParserFactory
+
+    attr_reader :letter_map
+
+    # the currency of this parser factory is the "short" single-letter argument switch
+    def initialize()
+      @options = nil
+      @switches = {}
+
+      # build the list of how each parameter will be saved in the output
+      @letter_map = {
+        'A' => 'buildArtifacts',
+        'x' => 'entry_point',
+        'p' => 'test_path',
+        'a' => 'app_name',
+        'D' => 'xcodeProjectDir',
+        'P' => 'xcodeProject',
+        'W' => 'xcodeWorkspace',
+        't' => 'tags_any',
+        'o' => 'tags_all',
+        'n' => 'tags_none',
+        'q' => 'sdk',
+        's' => 'scheme',
+        'd' => 'hardware_id',
+        'i' => 'implementation',
+        'E' => 'app_location',
+        'b' => 'sim_device',
+        'z' => 'sim_version',
+        'l' => 'sim_language',
+        'f' => 'skipBuild',
+        'B' => 'skipAutomate',
+        'e' => 'skipSetSim',
+        'k' => 'skipKillAfter',
+        'c' => 'coverage',
+        'r' => 'retest',
+        'v' => 'verbose',
+        'm' => 'timeout',
+        'w' => 'random_seed',
+        'y' => 'clean',
+      }
+
+      @letter_processing = {
+        'p' => lambda {|p| Illuminator::HostUtils.realpath(p) },     # get real path to tests file
+        'E' => lambda {|p| Illuminator::HostUtils.realpath(p) },     # get real path to app
+        'y' => lambda {|p| p.split(',')},                            # split comma-separated string into array
+        'r' => lambda {|p| p.split(',')},                            # split comma-separated string into array
+        't' => lambda {|p| p.split(',')},                            # split comma-separated string into array
+        'o' => lambda {|p| p.split(',')},                            # split comma-separated string into array
+        'n' => lambda {|p| p.split(',')},                            # split comma-separated string into array
+      }
+
+      @default_values = {
+        # 'D' => Dir.pwd,   # Since this effectively happens in xcode-builder, DON'T do it here too
+        'A' => File.join(Dir.pwd, "buildArtifacts"),
+        'b' => 'iPhone 5',
+        'z' => '8.2',
+        'q' => 'iphonesimulator',
+        'l' => 'en',
+        'x' => 'runTestsByTag',
+        'm' => 30,
+        'f' => false,
+        'B' => false,
+        'e' => false,
+        'k' => false,
+        'c' => false,
+      }
+    end
+
+    # you must custom prepare before you can add custom switches... otherwise things get all stupid
+    def prepare(default_values = nil, letter_map_updates = nil, letter_processing_updates = nil)
+      @letter_map = @letter_map.merge(letter_map_updates) unless letter_map_updates.nil?
+      @letter_processing = @letter_processing.merge(letter_processing_updates) unless letter_processing_updates.nil?
+      @default_values = @default_values.merge default_values unless default_values.nil?
+
+      add_switch('A', ['-A', '--buildArtifacts PATH', 'The directory in which to store build artifacts'])
+      add_switch('x', ['-x', '--entryPoint LABEL', 'The execution entry point {runTestsByTag, runTestsByName, describe}'])
+      add_switch('p', ['-p', '--test_path PATH', 'Path to js file with all tests imported'])
+      add_switch('a', ['-a', '--app_name APPNAME', "Name of the app to build / run"])
+      add_switch('D', ['-D', '--xcodeProjectDirectory PATH', "Directory containing the Xcode project to build"])
+      add_switch('P', ['-P', '--xcodeProject PROJECTNAME', "Project to build -- required if there are 2 in the same directory"])
+      add_switch('W', ['-W', '--xcodeWorkspace WORKSPACENAME', "Workspace to build"])
+      add_switch('t', ['-t', '--tags-any TAGSANY', 'Run tests with any of the given tags'])
+      add_switch('o', ['-o', '--tags-all TAGSALL', 'Run tests with all of the given tags'])
+      add_switch('n', ['-n', '--tags-none TAGSNONE', 'Run tests with none of the given tags'])
+      add_switch('q', ['-q', '--sdk SDK', 'SDK to build against'])
+      add_switch('s', ['-s', '--scheme SCHEME', 'Build and run specific tests on given workspace scheme'])
+      add_switch('d', ['-d', '--hardware_id ID', 'hardware id of device to run on instead of simulator'])
+      add_switch('i', ['-i', '--implementation IMPL', 'Device tests implementation'])
+      add_switch('E', ['-E', '--app_location LOCATION', 'Location of app executable, if pre-built'])
+      add_switch('b', ['-b', '--simDevice DEVICE', 'Run on given simulated device'])
+      add_switch('z', ['-z', '--simVersion VERSION', 'Run on given simulated iOS version'])
+      add_switch('l', ['-l', '--simLanguage LANGUAGE', 'Run on given simulated iOS language'])
+      add_switch('f', ['-f', '--skip-build', 'Just automate; assume already built'])
+      add_switch('B', ['-B', '--skip-automate', "Don't automate; build only"])
+      add_switch('e', ['-e', '--skip-set-sim', 'Assume that simulator has already been chosen and properly reset'])
+      add_switch('k', ['-k', '--skip-kill-after', 'Leave the simulator open after the run'])
+      add_switch('y', ['-y', '--clean PLACES', 'Comma-separated list of places to clean {xcode, buildArtifacts, derivedData}'])
+      add_switch('c', ['-c', '--coverage', 'Generate coverage files'])
+      add_switch('r', ['-r', '--retest OPTIONS', 'Immediately retest failed tests with comma-separated options {1x, solo}'])
+      add_switch('v', ['-v', '--verbose', 'Show verbose output from instruments'])
+      add_switch('m', ['-m', '--timeout TIMEOUT', 'Seconds to wait for instruments tool to start tests'])
+      add_switch('w', ['-w', '--random-seed SEED', 'Randomize test order based on given integer seed'])
+    end
+
+    # add a parse switch for the given letter key, using the given options.
+    #   the parse action is defined by the existence of letter_processing for the letter key,
+    #   which by default is simple assignment
+    def add_switch(letter, opts)
+      dest = get_letter_destination(letter)
+
+      # alter opts to include the default values
+      altered = false
+      if @default_values[letter].nil?
+        opts_with_default = opts
+      else
+        opts_with_default = opts.map do |item|
+          if (!altered and item.chars.first != '-')
+            item += "   ::   Defaults to \"#{@default_values[letter]}\""
+            altered = true
+          end
+          item
+        end
+      end
+
+      @switches[letter] = OpenStruct.new(:opts => opts_with_default,
+                                         :block => lambda do |newval|
+                                           # assign the parsed value to the output, processing it if necessary
+                                           if @letter_processing[letter]
+                                             @options[dest] = @letter_processing[letter].call(newval)
+                                           else
+                                             @options[dest] = newval
+                                           end
+                                         end)
+    end
+
+
+    # letter destination defaults to the letter itself, but can be overwritten by letter_map
+    def get_letter_destination(letter)
+      return @letter_map[letter]? @letter_map[letter] : letter
+    end
+
+
+    # factory function
+    def build_parser(options, letters = nil)
+      @options = options
+
+      if letters.nil?
+        letters = switches.keys.join('')
+      end
+
+      # helpful error message for bad chars
+      bad_chars = letters.chars.to_a.select{|c| c != "#" and @switches[c].nil?}
+      unless bad_chars.empty?
+        raise ArgumentError, "build_parser got letters (#{letters}) containing unknown option characters: #{bad_chars.to_s}"
+      end
+
+      retval = Illuminator::Parser.new options
+
+      # build a parser as specified by the user
+      letters.each_char do |c|
+        options[get_letter_destination(c)] = @default_values[c] unless @default_values[c].nil?
+
+        if c == '#'
+          retval.separator('  ---------------------------------------------------------------------------------')
+        else
+          retval.on(*(@switches[c].send(:opts))) {|foo| @switches[c].send(:block).call(foo)}
+        end
+      end
+
+      # help message is hard coded!
+      retval.on_tail('-h', '--help', 'Show this help message') {|foo| puts retval.help(); exit  }
+
+      retval.banner = "Usage: #{File.basename($PROGRAM_NAME)} [options]"
+
+      #puts retval
+      return retval
+    end
+
+  end
+
+end