xamarin-test-cloud 0.9.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: eb0063f60324d962136569cbb02a120355c4a9b3
+  data.tar.gz: c3f3a4eafe87aa4ee3a2e750cdd92144ac50b86c
+SHA512:
+  metadata.gz: 94064d3747ab099c6f042106f6bb93ad69d4bb1bba70cdef9223be64539d48334bf1a66aac47d4457963823d09990e36e6b04df7d38c1ea4c0a4d1652d20fa7f
+  data.tar.gz: f0c598d9d96dc52303cb2b3e52425aa3bc1cf3b794fd7f3abbf5ee9a89c022ee143da830abef93711eb3b85b27bacad34976419a9221de3bda3fa17310712e7a

data/CHANGES.txt

@@ -0,0 +1,2 @@
+0.9.0 Initial beta
+Supports upload of Calabash test suites to https://testcloud.xamarin.com.

data/bin/test-cloud

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+require 'xamarin-test-cloud/cli'
+
+begin
+  ENV['THOR_DEBUG'] = '1'
+  XamarinTestCloud::CLI.start
+  exit(true)
+rescue XamarinTestCloud::ValidationError, Thor::RequiredArgumentMissingError, Thor::UndefinedCommandError => e
+  puts e.message
+  exit 64
+rescue Thor::Error => e
+  puts e.message
+  if ENV['DEBUG'] == '1'
+    puts e.backtrace.join("\n") if e.backtrace
+    p e.class
+  end
+  exit 70
+end

data/lib/GemfileAndroid

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+gem 'calabash-android'
+

data/lib/GemfileIOS

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+gem 'calabash-cucumber'
+

data/lib/xamarin-test-cloud/cli.rb

@@ -0,0 +1,618 @@
+require 'thor'
+require 'yaml'
+require 'rubygems'
+require 'zip/zip'
+require 'digest'
+require 'rest_client'
+require 'json'
+require 'rbconfig'
+require 'tmpdir'
+require 'fileutils'
+
+module XamarinTestCloud
+
+  class ValidationError < Thor::InvocationError
+  end
+
+  class CLI < Thor
+    include Thor::Actions
+
+    attr_accessor :host, :app, :api_key, :appname, :workspace, :config, :profile, :features_zip, :skip_check, :dry_run, :device_selection
+    attr_accessor :pretty
+    attr_accessor :endpoint_path
+
+    FILE_UPLOAD_ENDPOINT = 'upload2'
+    FORM_URL_ENCODED_ENDPOINT = 'upload'
+
+
+    def self.source_root
+      File.join(File.dirname(__FILE__), '..')
+    end
+
+    desc 'version', 'Prints version of the xamarin-test-cloud gem'
+
+    def version
+      puts XamarinTestCloud::VERSION
+    end
+
+    desc 'submit <APP> <API_KEY>', 'Submits your app and test suite to Xamarin Test Cloud'
+
+    method_option :host,
+                  :desc => 'Test Cloud host to submit to',
+                  :aliases => '-h', :type => :string,
+                  :default => (ENV['XTC_ENDPOINT'] || 'https://testcloud.xamarin.com/ci')
+
+    method_option 'app-name',
+                  :desc => 'App name to create or add test to',
+                  :aliases => '-a',
+                  :required => true,
+                  :type => :string
+
+    method_option 'device-selection',
+                  :desc => 'Device selection',
+                  :aliases => '-d',
+                  :required => true,
+                  :type => :string
+
+    method_option :workspace,
+                  :desc => 'Workspace containing Gemfile and features',
+                  :aliases => '-w',
+                  :type => :string,
+                  :default => File.expand_path('.')
+
+    method_option :features,
+                  :desc => 'Zip file with features, step definitions, etc...',
+                  :aliases => '-f',
+                  :type => :string
+
+    method_option :config,
+                  :desc => 'Cucumber configuration file (cucumber.yml)',
+                  :aliases => '-c',
+                  :type => :string
+
+    method_option :profile,
+                  :desc => 'Profile to run (profile from cucumber.yml)',
+                  :aliases => '-p',
+                  :type => :string
+
+    method_option :pretty,
+                  :desc => 'Pretty print output.',
+                  :type => :boolean,
+                  :default => false
+
+    method_option 'skip-check',
+                  :desc => 'Skip checking for ipa linked with Calabash (iOS only)',
+                  :type => :boolean
+
+    method_option 'dry-run',
+                  :desc => "Sanity check only, don't upload",
+                  :aliases => '-d',
+                  :type => :boolean,
+                  :default => false #do upload by default
+
+    def submit(app, api_key)
+
+      self.host = options[:host]
+
+      self.pretty = options[:pretty]
+
+      app_path = File.expand_path(app)
+      unless File.exist?(app_path)
+        raise ValidationError, "App is not a file: #{app_path}"
+      end      
+
+      self.app = app_path
+
+      self.dry_run = options['dry-run']
+
+      self.api_key = api_key
+
+      self.appname = options['app-name']
+
+      self.device_selection = options['device-selection']
+      unless File.exist?(device_selection)
+        raise ValidationError, "Device selection is not a file: #{device_selection}"
+      end
+
+      self.skip_check = options['skip-check']
+
+      parse_and_set_config_and_profile
+
+      workspace_path = options[:workspace] || File.expand_path('.')
+
+      unless File.directory?(workspace_path)
+        raise ValidationError, "Provided workspace: #{workspace_path} is not a directory."
+      end
+      self.workspace = File.join(File.expand_path(workspace_path), File::Separator)
+
+      features_path = options[:features]
+
+      unless features_path.nil?
+        if File.exist?(features_path)
+          self.features_zip = File.expand_path(features_path)
+        else
+          raise ValidationError, "Provided features file does not exist #{features_path}"
+        end
+      end
+
+      if ENV['DEBUG']
+        puts "Host = #{self.host}"
+        puts "App = #{self.app}"
+        puts "App Name = #{self.app}"
+        puts "API Key = #{self.api_key}"
+        puts "Device Selection = #{self.device_selection}"
+        puts "Workspace = #{self.workspace}"
+        puts "Features Zip = #{self.features_zip}"
+        puts "Config = #{self.config}"
+        puts "Profile = #{self.profile}"
+        puts "Skip Check = #{self.skip_check}"
+      end
+
+      #Argument parsing done
+      json = submit_test_job[:body]
+      log_header("Test enqueued")
+      puts "User: #{json["user_email"]}"
+
+      puts "Devices:"
+      json["devices"].each do |device|
+        puts device
+      end
+      puts ""
+
+
+      result = wait_for_job(json["id"])
+
+    end
+
+    default_task :submit
+
+    no_tasks do
+
+      def exit_on_failure?
+        true
+      end
+
+      def wait_for_job(id)
+        while(true)          
+          status_json = JSON.parse(http_post("status", {'id' => id, 'api_key' => api_key}))
+          
+          log  "Status: #{status_json["status_description"]}"
+          if status_json["status"] == "finished"
+            puts "Done!"
+            exit 0
+          end
+
+          if ["cancelled", "invalid"].include?(status_json["status"])
+            puts "Failed!"
+            exit 1
+          end
+          sleep 10
+        end
+      end
+
+
+      def submit_test_job
+        start_at = Time.now
+
+        server = verify_app_and_extract_test_server
+
+
+        log_header('Checking for Gemfile')
+        gemfile_path = File.join(self.workspace, 'Gemfile')
+        unless File.exist?(gemfile_path)
+          copy_default_gemfile(gemfile_path, server)
+        end
+
+        log_header('Packaging')
+        FileUtils.cd(self.workspace) do
+          unless system('bundle package --all')
+            log_and_abort 'Bundler failed. Please check command: bundle package'
+          end
+        end
+
+
+        log_header('Verifying dependencies')
+        verify_dependencies
+
+
+        if dry_run
+          log_header('Dry run only')
+          log('Dry run completed OK')
+          return
+        end
+
+        app_file, files, paths = gather_files_and_paths_to_upload(all_files)
+
+
+        log_header('Uploading negotiated files')
+
+        upload_data = {'files' => files,
+                       'paths' => paths,
+                       'app_file' => app_file,
+                       'device_selection' => IO.read(device_selection),
+                       'app' => self.appname,
+                       'api_key' => api_key,
+                       'app_filename' => File.basename(app)}
+
+        if profile #only if config and profile
+          upload_data['profile'] = profile
+        end
+
+        if ENV['DEBUG']
+          puts JSON.pretty_generate(upload_data)
+        end
+
+
+        contains_file = files.find { |f| f.is_a?(File) }
+
+        contains_file = contains_file || app_file.is_a?(File)
+
+        if contains_file
+          self.endpoint_path = FILE_UPLOAD_ENDPOINT #nginx receives upload
+        else
+          self.endpoint_path = FORM_URL_ENCODED_ENDPOINT #ruby receives upload
+        end
+
+        if ENV['DEBUG']
+          puts "Will upload to file path: #{self.endpoint_path}"
+        end
+
+
+        response = http_post(endpoint_path, upload_data) do |response, request, result, &block|
+          if ENV['DEBUG']
+            puts "Request url: #{request.url}"
+            puts "Response code: #{response.code}"
+          end
+          case response.code
+            when 200..202
+              response
+            when 403
+              abort do
+                puts 'Invalid API key'
+              end
+            when 413
+              abort do
+                puts 'Files too large'
+              end
+            else
+              abort do
+                log 'Unexpected Error. Please contact support at testcloud@xamarin.com.'
+              end
+          end
+        end
+
+        return :status => response.code, :body => JSON.parse(response)
+      end
+
+
+      def copy_default_gemfile(gemfile_path, server)
+        log('')
+        log('Gemfile missing.')
+        log('You must provide a Gemfile in your workspace.')
+        log('A Gemfile must describe your dependencies and their versions')
+        log('See: http://gembundler.com/v1.3/gemfile.html')
+        log('')
+        log('Warning proceeding with default Gemfile.')
+        log('It is strongly recommended that you create a custom Gemfile.')
+        tgt = nil
+        if is_android?
+          log('Creating Gemfile for Android')
+          tgt = File.join(CLI.source_root, 'GemfileAndroid')
+        elsif is_ios?
+          log('Creating Gemfile for iOS')
+          gemfile = 'GemfileIOS'
+          if server == :frank
+            raise ValidationError, 'Frank not supported just yet'
+          end
+          tgt = File.join(CLI.source_root, gemfile)
+        else
+          raise ValidationError, 'Your app must be an ipa or apk file.'
+        end
+        log("Proceeding with Gemfile: #{gemfile_path}")
+
+
+        FileUtils.cp(File.expand_path(tgt), gemfile_path)
+
+        puts(File.read(gemfile_path))
+
+        log('')
+
+      end
+
+      def gather_files_and_paths_to_upload(collected_files)
+
+        log_header('Calculating digests')
+
+        file_paths = collected_files[:files]
+        feature_prefix = collected_files[:feature_prefix]
+        workspace_prefix = collected_files[:workspace_prefix]
+
+        hashes = file_paths.collect { |f| digest(f) }
+        hashes << digest(app)
+
+
+        log_header('Negotiating upload')
+
+        response = http_post('check_hash', {'hashes' => hashes})
+
+        cache_status = JSON.parse(response)
+
+        log_header('Gathering files based on negotiation')
+
+        files = []
+        paths = []
+        file_paths.each do |file|
+          if cache_status[digest(file)]
+            #Server already knows about this file. No need to upload it.
+            files << digest(file)
+          else
+            #Upload file
+            files << File.new(file)
+          end
+
+          if file.start_with?(feature_prefix)
+            prefix = feature_prefix
+          else
+            prefix = workspace_prefix
+          end
+          paths << file.sub(prefix, '')
+        end
+
+        if config
+          files << File.new(config)
+          paths << 'config/cucumber.yml'
+        end
+
+        app_file = cache_status[digest(app)] ? digest(app) : File.new(app)
+
+        return app_file, files, paths
+      end
+
+      def digest(file)
+        Digest::SHA256.file(file).hexdigest
+      end
+
+      def unzip_file (file, destination)
+        Zip::ZipFile.open(file) { |zip_file|
+          zip_file.each { |f|
+            f_path=File.join(destination, f.name)
+            FileUtils.mkdir_p(File.dirname(f_path))
+            zip_file.extract(f, f_path) unless File.exist?(f_path)
+          }
+        }
+      end
+
+
+      def is_android?
+        app.end_with? '.apk'
+      end
+
+      def calabash_android_version
+        `bundle exec calabash-android version`.strip
+      end
+
+      def is_ios?
+        app.end_with? '.ipa'
+      end
+
+      def test_server_path
+        require 'digest/md5'
+        digest = Digest::MD5.file(app).hexdigest
+        File.join('test_servers', "#{digest}_#{calabash_android_version}.apk")
+      end
+
+      def all_files
+        dir = workspace
+        if features_zip
+          dir = Dir.mktmpdir
+          unzip_file(features_zip, dir)
+          dir = File.join(dir, File::Separator)
+        end
+
+
+        files = Dir.glob(File.join("#{dir}features", '**', '*'))
+
+        if File.directory?("#{dir}playback")
+          files += Dir.glob(File.join("#{dir}playback", '*'))
+        end
+
+        if config
+          files << config
+        end
+
+
+        files += Dir.glob(File.join("#{workspace}vendor", 'cache', '*'))
+
+        if workspace and workspace.strip != ''
+          files += Dir.glob("#{workspace}Gemfile")
+          files += Dir.glob("#{workspace}Gemfile.lock")
+        end
+
+        if is_android?
+          files << test_server_path
+        end
+
+        {:feature_prefix => dir, :workspace_prefix => workspace, :files => files.find_all { |file_or_dir| File.file? file_or_dir }}
+      end
+
+      def http_post(address, args, &block)
+        exec_options = {}
+        if ENV['XTC_USERNAME'] && ENV['XTC_PASSWORD']
+          exec_options[:user] = ENV['XTC_USERNAME']
+          exec_options[:password] = ENV['XTC_PASSWORD']
+        end
+
+        if block_given?
+          exec_options = exec_options.merge ({:method => :post, :url => "#{host}/#{address}", :payload => args,
+                          :timeout => 90000000,
+                          :open_timeout => 90000000,
+                          :headers => {:content_type => 'multipart/form-data'}})
+          response = RestClient::Request.execute(exec_options) do |response, request, result, &other_block|
+            block.call(response, request, result, &other_block)
+          end
+        else
+          exec_options = exec_options.merge(:method => :post, :url => "#{host}/#{address}", :payload => args)
+          response = RestClient::Request.execute(exec_options)
+        end
+
+        response.body
+      end
+
+      def is_windows?
+        (RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/)
+      end
+
+      def is_macosx?
+        (RbConfig::CONFIG['host_os'] =~ /darwin/)
+      end
+
+      def validate_ipa(ipa)
+        result = false
+        dir = Dir.mktmpdir #do |dir|
+
+        unzip_file(ipa, dir)
+        unless File.directory?("#{dir}/Payload") #macos only
+          raise ValidationError, "Unzipping #{ipa} to #{dir} failed: Did not find a Payload directory (invalid .ipa)."
+        end
+        app_dir = Dir.foreach("#{dir}/Payload").find { |d| /\.app$/.match(d) }
+        app = app_dir.split('.')[0]
+        res = `otool "#{File.expand_path(dir)}/Payload/#{app_dir}/#{app}" -o 2> /dev/null | grep CalabashServer`
+
+        if /CalabashServer/.match(res)
+          puts "ipa: #{ipa} *contains* calabash.framework"
+          result = :calabash
+        end
+
+        unless result
+          res = `otool "#{File.expand_path(dir)}/Payload/#{app_dir}/#{app}" -o 2> /dev/null | grep FrankServer`
+          if /FrankServer/.match(res)
+            puts "ipa: #{ipa} *contains* FrankServer"
+            result = :frank
+          else
+            puts "ipa: #{ipa} *does not contain* calabash.framework"
+            result = false
+          end
+        end
+
+        result
+      end
+
+
+      def log(message)
+        puts "#{Time.now } #{message}"
+        $stdout.flush
+      end
+
+      def log_header(message)
+        if is_windows?
+          puts "\n### #{message} ###"
+        else
+          puts "\n\e[#{35}m### #{message} ###\e[0m"
+        end
+      end
+
+
+      def verify_app_and_extract_test_server
+        server = nil
+
+        unless File.exist?(app)
+          raise ValidationError, "No such file: #{app}"
+        end
+        unless (/\.(apk|ipa)$/ =~ app)
+          raise ValidationError, '<APP> should be either an ipa or apk file.'
+        end
+        if is_ios? and is_macosx? and not skip_check
+          log_header('Checking ipa for linking with Calabash')
+          server = validate_ipa(app)
+          abort_unless(server) do
+            puts 'The .ipa file does not seem to be linked with Calabash.'
+            puts 'Verify that your app is linked correctly.'
+            puts 'To disable this check run with --skip-check or set Environment Variable CHECK_IPA=0'
+          end
+        end
+        server
+      end
+
+      def abort(&block)
+        yield block
+        exit 1
+      end
+
+      def abort_unless(condition, &block)
+        unless condition
+          yield block
+          exit 1
+        end
+      end
+
+      def log_and_abort(message)
+        abort do
+          puts message
+        end
+      end
+
+
+      def verify_dependencies
+        if is_android?
+          abort_unless(File.exist?(test_server_path)) do
+            puts 'No test server found. Please run:'
+            puts "  calabash-android build #{app}"
+          end
+
+          calabash_gem = Dir.glob('vendor/cache/calabash-android-*').first
+          abort_unless(calabash_gem) do
+            puts 'calabash-android was not packaged correct.'
+            puts 'Please tell testcloud@xamarin.com about this bug.'
+          end
+        end
+      end
+
+
+      def parse_and_set_config_and_profile
+        config_path = options[:config]
+        if config_path
+          config_path = File.expand_path(config_path)
+          unless File.exist?(config_path)
+            raise ValidationError, "Config file does not exist #{config_path}"
+          end
+
+
+          begin
+            config_yml = YAML.load_file(config_path)
+          rescue Exception => e
+            puts "Unable to parse #{config_path} as yml. Is this your Cucumber.yml file?"
+            raise ValidationError, e
+          end
+
+          if ENV['DEBUG']
+            puts 'Parsed Cucumber config as:'
+            puts config_yml.inspect
+          end
+
+          profile = options[:profile]
+          unless profile
+            raise ValidationError, 'Config file provided but no profile selected.'
+          else
+            unless config_yml[profile]
+              raise ValidationError, "Config file provided did not contain profile #{profile}."
+            else
+              puts "Using profile #{profile}..."
+              self.profile = profile
+            end
+          end
+        else
+          if options[:profile]
+            raise ValidationError, 'Profile selected but no config file provided.'
+          end
+        end
+
+        self.config = config_path
+      end
+
+    end
+
+
+  end
+end
+
+

data/lib/xamarin-test-cloud/version.rb

@@ -0,0 +1,3 @@
+module XamarinTestCloud
+  VERSION = '0.9.1'
+end

data/test/ipa/features/step_definitions/calabash_steps.rb

@@ -0,0 +1 @@
+require 'calabash-cucumber/calabash_steps'

data/test/ipa/features/step_definitions/my_first_steps.rb

@@ -0,0 +1,4 @@
+Given /^I am on the Welcome Screen$/ do
+  element_exists("view")
+  sleep(STEP_PAUSE)
+end

data/test/ipa/features/support/env.rb

@@ -0,0 +1 @@
+require 'calabash-cucumber/cucumber'

data/test/ipa/features/support/launch.rb

@@ -0,0 +1,77 @@
+########################################
+#                                      #
+#       Important Note                 #
+#                                      #
+#   When running calabash-ios tests at #
+#   www.xamarin-test-cloud.com                #
+#   this file will be overwritten by   #
+#   a file which automates             #
+#   app launch on devices.             #
+#                                      #
+#   Don't rely on this file being      #
+#   present when running at            #
+#   www.xamarin-test-cloud.com.               #
+#                                      #
+#  Only put stuff here to automate     #
+#  iOS Simulator.                      #
+#                                      #
+#  You can put your app bundle path    #
+#  for automating simulator app start: #
+#  Uncomment APP_BUNDLE_PATH =..       #
+#                                      #
+########################################
+
+require 'calabash-cucumber/launch/simulator_helper'
+require 'sim_launcher'
+
+# Uncomment and replace ?? appropriately
+# This should point to your Simulator build
+# which includes calabash framework
+# this is usually the Calabash build configuration
+# of your production target.
+#APP_BUNDLE_PATH = "~/Library/Developer/Xcode/DerivedData/??/Build/Products/Calabash-iphonesimulator/??.app"
+#
+
+def reset_app_jail(sdk, app_path)
+  app = File.basename(app_path)
+  bundle = `find "#{ENV['HOME']}/Library/Application Support/iPhone Simulator/#{sdk}/Applications/" -type d -depth 2 -name #{app} | head -n 1`
+  return if bundle.empty? # Assuming we're already clean
+
+  sandbox = File.dirname(bundle)
+  ['Library', 'Documents', 'tmp'].each do |dir|
+    FileUtils.rm_rf(File.join(sandbox, dir))
+  end
+end
+
+def relaunch
+  if ENV['NO_LAUNCH']!="1"
+    sdk = ENV['SDK_VERSION'] || SimLauncher::SdkDetector.new().latest_sdk_version
+    path = Calabash::Cucumber::SimulatorHelper.app_bundle_or_raise(app_path)
+    if ENV['RESET_BETWEEN_SCENARIOS']=="1"
+      reset_app_jail(sdk, path)
+    end
+
+    Calabash::Cucumber::SimulatorHelper.relaunch(path,sdk,ENV['DEVICE'] || 'iphone')
+  end
+end
+
+def app_path
+  ENV['APP_BUNDLE_PATH'] || (defined?(APP_BUNDLE_PATH) && APP_BUNDLE_PATH)
+end
+
+def calabash_notify
+  if self.respond_to?(:on_launch)
+    self.on_launch
+  end
+end
+
+Before do |scenario|
+  relaunch
+  calabash_notify
+end
+
+at_exit do
+  if ENV['NO_LAUNCH']!="1" and ENV['NO_STOP']!="1"
+    Calabash::Cucumber::SimulatorHelper.stop
+  end
+end

data/test/test_parser.rb

@@ -0,0 +1,62 @@
+require 'test/unit'
+require 'thor'
+require 'fileutils'
+require 'xamarin-test-cloud/cli'
+
+class TestParser < Test::Unit::TestCase
+  def test_should_raise_if_no_app_or_api_key_is_given
+    script = XamarinTestCloud::CLI.new([])
+    assert_raise Thor::InvocationError do
+      script.invoke(:submit)
+    end
+
+    script = XamarinTestCloud::CLI.new(["test/ipa/2012 Olympics_cal.ipa"])
+    assert_raise Thor::InvocationError do
+      script.invoke(:submit)
+    end
+
+
+  end
+
+  def test_should_raise_if_app_is_not_file_ipa_or_apk
+    script = XamarinTestCloud::CLI.new(["test/ipa/NONE_EXIST_2012 Olympics_cal.ipa","JIFZCTPZJJXJLEKMMYRY","."])
+    assert_raise RuntimeError do
+      script.invoke(:submit)
+    end
+
+    script = XamarinTestCloud::CLI.new(["test/ipa/features.zip","JIFZCTPZJJXJLEKMMYRY","."])
+
+    assert_raise RuntimeError do
+      script.invoke(:submit)
+    end
+  end
+
+  def test_should_parse_all_configuration_options
+    FileUtils.rm_f(File.join("test","vendor"))
+    FileUtils.rm_f(File.join("test","Gemfile"))
+    FileUtils.rm_f(File.join("test","Gemfile.lock"))
+
+    config_options = {
+        :host => "http://localhost:8080",
+        :workspace => "test",
+        :features => "test/ipa/features.zip",
+        :config => "test/config/cucumber.yml",
+        :profile => "a",
+        "skip-check" => false,
+        "reset-between-scenarios" => false,
+        "dry-run" => true
+    }
+    script = XamarinTestCloud::CLI.new(["test/ipa/2012 Olympics_cal.ipa","JIFZCTPZJJXJLEKMMYRY"],config_options)
+
+
+    script.invoke(:submit)
+
+    FileUtils.rm_f(File.join("test","vendor","cache"))
+    FileUtils.rm_f(File.join("test","Gemfile"))
+    FileUtils.rm_f(File.join("test","Gemfile.lock"))
+
+
+
+  end
+
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: xamarin-test-cloud
+version: !ruby/object:Gem::Version
+  version: 0.9.1
+platform: ruby
+authors:
+- Karl Krukow
+- Jonas Maturana Larsen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.18.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.18.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.9
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.7
+description: Xamarin Test Cloud let's you automatically test your app on hundreds
+  of mobile devices
+email:
+- karl@xamarin.com
+- jonas@xamarin.com
+executables:
+- test-cloud
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/test-cloud
+- lib/GemfileAndroid
+- lib/GemfileIOS
+- lib/xamarin-test-cloud/cli.rb
+- lib/xamarin-test-cloud/version.rb
+- README.md
+- CHANGES.txt
+- test/ipa/features/step_definitions/calabash_steps.rb
+- test/ipa/features/step_definitions/my_first_steps.rb
+- test/ipa/features/support/env.rb
+- test/ipa/features/support/hooks.rb
+- test/ipa/features/support/launch.rb
+- test/test_parser.rb
+homepage: http://xamarin.com/test-cloud
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.5
+signing_key: 
+specification_version: 4
+summary: Command-line interface to Xamarin Test Cloud
+test_files:
+- test/ipa/features/step_definitions/calabash_steps.rb
+- test/ipa/features/step_definitions/my_first_steps.rb
+- test/ipa/features/support/env.rb
+- test/ipa/features/support/hooks.rb
+- test/ipa/features/support/launch.rb
+- test/test_parser.rb