xamarin-test-cloud 2.0.0.pre5 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dead16bac1bbcbdb4ed7ff55bc656df5da6f5563
-  data.tar.gz: 8298ea5c4fd1b0dc179a4285a78939ee154e8e0c
+  metadata.gz: d5e647b85d4a43752ebe4960f87b0860f5a3a73e
+  data.tar.gz: 499cba9a6428d4109b771d376d4fa028bd43367e
 SHA512:
-  metadata.gz: 622d1602faa1a5f3e1e54b5dae8a6d8165542d659cffbda2d19f441277f1039a536a461449cd9005bd6e72bb52ab85f8616bc1dee4e89d16a8fed095221fa5ee
-  data.tar.gz: 217a4ba762eebdbb7f69d815ce08df678e14646eab8e167a211dd69e2bf4532bd7fc4f73e370e679e34a951d5cda2cd2602ca823084a65967fa0d25379712b7f
+  metadata.gz: f1340fb676f6a14565b6dce3ebd3fa65f93ef165a29fa90d71a90fe2b749872489b22275dc40896ccb2728392cb951a4b3f2f938af86922ae5a101fb04ce9e77
+  data.tar.gz: a0adae20dd8f71db72eb0ed71d7791b79819cf63b89f66d03aa6e4923d7f698d30f0707ec92e50c6d426b8941c1757d57df4f4ab4409b16a61ca41957f917f02

data/CHANGELOG.md

@@ -1,8 +1,14 @@
 ### 2.0.0
 
+* C: appears in place of ./vendor directory when uploading tests from Windows
+   machines [#237](https://github.com/xamarinhq/test-cloud-frameworks/issues/237)
+* Detecting the calabash android and calabash ios gem versions is broken
+  #51
+* Don't send priority information to XTC #47
 * Set :send\_timeout on HTTPClient to allow uploads from flakey internet
   connections #45
 * Support Calabash 2.0 #43
+* Needs to run in Jenkins CI (Windows/MacOS) and Travis Linux #42
 * Replace RestClient with HTTPClient
 * Set minimum ruby version to 2.0
 * Gem does not work in Windows environment: ffi cannot be found. #34

data/README.md

@@ -11,8 +11,10 @@
 ```
 $ bundle update
 $ bundle exec rake test         # All tests.
-$ bundle exec rake unit         # Unit tests.
-$ bundle exec rake integration  # Integration tests.
-$ bundle exec rake spec         # rspec tests
+$ bundle exec rake spec         # rspec tests (unit and integration)
 ```
 
+### CI
+
+* [Jenkins Windows 10](http://xtc-jenkins.xamdev.com/)
+* [Travis Linux/macOS](https://travis-ci.com/xamarinhq/test-cloud-command-line/)

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

@@ -0,0 +1,175 @@
+
+module XamarinTestCloud
+
+  # A class for determining the Calabash version.
+  #
+  # Finding the calabash version is required because:
+  #
+  # 1. The correct Android test server needs to be identified.
+  # 2. If a Gemfile does exist, a default one needs to be created.
+  #
+  # If a Gemfile and Gemfile.lock exists, use bundler to try to find the version.
+  #
+  # Otherwise, shell out to the gem's version command.
+  #
+  # Callers of `version` should rescue RuntimeError and re-raise.
+  #
+  # ArgumentError should not be caught.  This is an internal class; ArgumentError
+  # represent incorrect usage.
+  class CalabashVersionDetector
+
+    def initialize(workspace, gem_keyword)
+      @workspace = workspace
+
+      if !File.directory?(workspace)
+        raise(ArgumentError, "Workspace must be a directory that exists")
+      end
+
+      case gem_keyword
+        when :android
+          @gem_name = "calabash-android"
+          @version_path = "calabash-android/version"
+          @version_constant = "Calabash::Android::VERSION"
+        when :ios
+          @gem_name = "calabash-cucumber"
+          @version_path = "calabash-cucumber/version"
+          @version_constant = "Calabash::Cucumber::VERSION"
+        when :calabash
+          @gem_name = "calabash"
+          @version_path = "calabash/version"
+          @version_constant = "Calabash::VERSION"
+        else
+          raise(ArgumentError,
+                %Q[Invalid gem_keyword: '#{gem_keyword}'; expected :android, :ios, or :calabash])
+      end
+    end
+
+    def to_s
+      %Q[#<CalabashVersion: #{workspace} #{gem_name} #{version_path} #{version_constant}>]
+    end
+
+    def inspect
+      to_s
+    end
+
+    def version
+      if use_bundler?
+        version = detect_version_with_bundler
+      else
+        version = detect_version_with_ruby
+      end
+      version
+    end
+
+    private
+
+    attr_reader :workspace, :gem_name, :version_path, :version_constant
+
+    def gemfile
+      File.join(workspace, "Gemfile")
+    end
+
+    def gemfile_lock
+      File.join(workspace, "Gemfile.lock")
+    end
+
+    def gemfile?
+      File.exist?(gemfile)
+    end
+
+    def gemfile_lock?
+      File.exist?(gemfile_lock)
+    end
+
+    def use_bundler?
+      gemfile? && gemfile_lock?
+    end
+
+    def detect_version_with_bundler
+      Dir.chdir(workspace) do
+        Bundler.with_clean_env do
+          bundle_install
+          command = %Q[bundle exec #{ruby_version_script}]
+          version = run_version_script(command)
+          if version != ""
+            version
+          else
+            nil
+          end
+        end
+      end
+    end
+
+    def ruby_version_script
+      require_part = %Q[require '#{version_path}']
+      constant_part = %Q[puts #{version_constant}]
+      rescue_part = %Q[rescue LoadError => e]
+
+      command = %Q[begin;#{require_part};#{constant_part};#{rescue_part};puts '';end]
+
+      %Q[ruby -e "#{command}"]
+    end
+
+    def detect_version_with_ruby
+      Dir.chdir(workspace) do
+        Bundler.with_clean_env do
+          command = ruby_version_script
+          version = run_version_script(command)
+          if version != ""
+            version
+          else
+            nil
+          end
+        end
+      end
+    end
+
+    def run_version_script(command)
+      # The version script will always return a String
+      out = shell_out(command)
+
+      # Handle:
+      # Your version of bundler is outdated\n
+      # 0.19.1\n
+      lines = out.split($-0)
+
+      if lines.count == 0
+        nil
+      else
+        lines.last.strip
+      end
+    end
+
+    # Always called in the context of Dir.chdir, so there is no need to use
+    # --gemfile path/to/Gemfile argument.
+    def bundle_install
+      shell_out("bundle install")
+    end
+
+    # TODO Adopt command_runner?
+    # https://github.com/calabash/run_loop/blob/develop/lib/run_loop/shell.rb
+    # The problem with command_runner is that it has timeouts.  We don't really
+    # want to manage time outs for potentially long-running tasks like
+    # $ bundle install
+    #
+    # TODO Handle encoding
+    # https://github.com/calabash/run_loop/blob/develop/lib/run_loop/encoding.rb
+    #
+    # Ruby reads stdout/stderr as US ASCII 8bit.  I am not sure what the behavior
+    # "``" is.
+    def shell_out(command)
+      out = `#{command}`.strip
+      exit_code = $?.exitstatus
+      if exit_code != 0
+        raise RuntimeError, %Q[There was an error executing:
+
+#{command}
+
+exited #{exit_code}
+]
+      end
+
+      out
+    end
+  end
+end

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

@@ -13,9 +13,13 @@ require 'xamarin-test-cloud/version'
 require 'xamarin-test-cloud/retriable_options'
 require 'xamarin-test-cloud/http/request'
 require 'xamarin-test-cloud/http/retriable_client'
+require 'xamarin-test-cloud/environment'
+require "xamarin-test-cloud/dsym"
+require "xamarin-test-cloud/test_file"
+require "xamarin-test-cloud/calabash_version_detector"
 require 'securerandom'
 require 'open3'
-
+require "bundler"
 
 trap "SIGINT" do
   puts "Exiting"
@@ -31,10 +35,9 @@ module XamarinTestCloud
     include Thor::Actions
 
     attr_accessor :app, :api_key, :appname, :test_parameters, :user,
-                  :workspace, :config, :profile, :skip_config_check, :dry_run,
+                  :config, :profile, :skip_config_check, :dry_run,
                   :device_selection, :pretty, :async, :async_json, :priority, :endpoint_path,
-                  :locale, :series,
-                  :dsym, :session_id
+                  :locale, :series, :session_id
 
     def self.exit_on_failure?
       true
@@ -123,7 +126,7 @@ module XamarinTestCloud
                   :default => false
 
     method_option :priority,
-                  :desc => "Run as priority test execution. Please note: This is only available for some tiers, and priority test executions cost double.",
+                  :desc => "REMOVED. You should not pass this option.",
                   :type => :boolean,
                   :default => false
 
@@ -181,6 +184,7 @@ module XamarinTestCloud
         puts "To test your app it needs to be compiled for release."
         puts "You can learn how to compile you app for release here:"
         puts "http://docs.xamarin.com/guides/android/deployment%2C_testing%2C_and_metrics/publishing_an_application/part_1_-_preparing_an_application_for_release"
+        # TODO Change this to: "Shared runtime apps are not supported."
         raise ValidationError, "Aborting"
       end
 
@@ -214,53 +218,32 @@ module XamarinTestCloud
 
       self.skip_config_check = options['skip-config-check']
 
-      self.dsym= options['dsym-file']
-      if dsym
-        dsym_extension = File.extname(self.dsym)
-        unless /dsym/i.match(dsym_extension) && File.directory?(dsym)
-          raise ValidationError, "dsym-file must be a directory and have dSYM extension: #{dsym}"
-        end
-      end
-
-      workspace_path = options[:workspace] || File.expand_path('.')
-
-      unless File.directory?(workspace_path)
-        raise ValidationError, "Provided workspace: #{workspace_path} is not a directory."
-      end
-
-      workspace_basename = File.basename(workspace_path)
-      if workspace_basename.downcase == 'features'
-        self.workspace = File.expand_path(File.join(workspace_path, '..'))
-        puts "Deriving workspace #{self.workspace} from features folder #{workspace_basename}"
-      else
-        self.workspace = File.expand_path(workspace_path)
-      end
-
-      self.workspace = File.join(self.workspace, File::Separator)
-
-
-      unless File.directory?(File.join(self.workspace, 'features'))
-        log_header "Did not find features folder in workspace #{self.workspace}"
-        puts "Either run the test-cloud command from the directory containing your features"
-        puts "or use the --workspace option to refer to this directory"
-        puts "See also test-cloud help submit"
-        raise ValidationError, "Unable to find features folder in #{self.workspace}"
-      end
+      # Resolves the workspace and sets the @derived_workspace variable.
+      expect_features_directory_in_workspace
 
+      # TODO: extract this method and the configuration branch below to a module
       parse_and_set_config_and_profile
       unless self.skip_config_check
-        default_config = File.join(self.workspace, 'config', 'cucumber.yml')
+        default_config = File.join(derived_workspace, 'config', 'cucumber.yml')
+        # TODO .config/cucumber.yml is valid
+        # TODO cucumber.yaml is valid
         if File.exist?(default_config) && self.config.nil?
+          # TODO Reword the header.
           log_header 'Warning: Detected cucumber.yml config file, but no --config specified'
+
+          # TODO Reword the message and pass to raise as message.
           puts "Please specify --config #{default_config}"
           puts 'and specify a profile via --profile'
           puts 'If you know what you are doing you can skip this check with'
           puts '--skip-config-check'
+
+          # TODO This error message is wrong.
+          # It should be cucumber.yml detected by no --config option set.
           raise ValidationError, "#{default_config} detected but no profile selected."
         end
       end
 
-      if debug?
+      if Environment.debug?
         puts "Host = #{self.host}"
         puts "User = #{self.user}"
         puts "App = #{self.app}"
@@ -268,7 +251,7 @@ module XamarinTestCloud
         puts "TestParams = #{self.test_parameters}"
         puts "API Key = #{self.api_key}"
         puts "Device Selection = #{self.device_selection}"
-        puts "Workspace = #{self.workspace}"
+        puts "Workspace = #{derived_workspace}"
         puts "Config = #{self.config}"
         puts "Profile = #{self.profile}"
         puts "dSym = #{self.dsym}"
@@ -282,10 +265,12 @@ module XamarinTestCloud
         return
       end
       json = test_jon_data[:body]
-      if debug?
+      if Environment.debug?
         p json
       end
 
+      warn_about_priority_flag(options)
+
       log_header('Test enqueued')
       puts "User: #{json['user_email']}"
       puts "Team: #{json['team']}" if json['team']
@@ -293,6 +278,7 @@ module XamarinTestCloud
 
       rejected_devices = json['rejected_devices']
       if rejected_devices && rejected_devices.size > 0
+        # TODO Break this into multiple lines and remove the parenthetical
         puts 'Skipping devices (you can update your selections via https://testcloud.xamarin.com)'
         rejected_devices.each { |d| puts d }
       end
@@ -317,7 +303,7 @@ module XamarinTestCloud
         @async_result[:error_messages] << e.message
       else
         raise
-    end
+      end
 
     ensure
       $stdout = STDOUT
@@ -332,8 +318,43 @@ module XamarinTestCloud
 
     no_tasks do
 
-      def debug?
-        ENV['DEBUG'] == '1'
+      def dsym
+        if @dsym.nil?
+          value = options["dsym-file"]
+          if !value
+            @dsym = false
+          else
+            begin
+              @dsym = XamarinTestCloud::Dsym.new(value)
+            rescue RuntimeError => e
+              raise(ValidationError, e.message)
+            end
+          end
+        end
+        @dsym
+      end
+
+      # TODO Capture the log output when --async-json?; warn ==> stderr
+      def warn_about_priority_flag(options)
+        if options["priority"]
+
+          log_warn = lambda do |string|
+            if XamarinTestCloud::Environment.windows_env?
+              message = "WARN: #{string}"
+            else
+              message = "\033[34mWARN: #{string}\033[0m"
+            end
+            warn message
+          end
+
+          log_header("Detected Legacy Option")
+          puts ""
+          log_warn.call("The --priority option has been removed.")
+          log_warn.call("Priority execution is enabled automatically for Enterprise subscriptions.")
+          true
+        else
+          false
+        end
       end
 
       def process_async_log
@@ -353,13 +374,16 @@ module XamarinTestCloud
             JSON.parse(http_post("status_v3", {'id' => id, 'api_key' => api_key, 'user' => user}))
           end
 
-          if debug?
+          if Environment.debug?
             log "Status JSON result:"
             puts status_json
           end
 
           wait_time = (Integer status_json["wait_time"] rescue nil) || 10
-          wait_time = 1 if debug?
+          if Environment.debug?
+            wait_time = 1
+          end
+
           log status_json["message"]
 
           if status_json["exit_code"]
@@ -379,86 +403,84 @@ module XamarinTestCloud
       end
 
       def workspace_gemfile
-        File.join(self.workspace, 'Gemfile')
+        File.join(derived_workspace, 'Gemfile')
       end
 
       def workspace_gemfile_lock
-        File.join(self.workspace, 'Gemfile.lock')
+        File.join(derived_workspace, 'Gemfile.lock')
       end
 
       def submit_test_job(device_selection_data)
         tmpdir = Dir.mktmpdir
-        if debug?
+        if Environment.debug?
           log "Packaging gems in: #{tmpdir}"
         end
 
-        server = verify_app_and_extract_test_server
-
-        log_header('Checking for Gemfile')
+        # TODO Move to common expect_valid_application
+        # TODO Rename: does not need to extract a test server
+        verify_app_and_extract_test_server
 
-        if File.exist?(workspace_gemfile)
-          FileUtils.cp workspace_gemfile, tmpdir
-          FileUtils.cp workspace_gemfile_lock, tmpdir if File.exist?(workspace_gemfile_lock)
-        else
-          copy_default_gemfile(File.join(tmpdir, "Gemfile"), server)
-        end
+        stage_gemfile_and_bundle_package(tmpdir)
 
-        log_header('Packaging')
+        log_header('Verifying dependencies')
 
-        ENV['BUNDLE_GEMFILE'] = File.join(tmpdir, "Gemfile")
-        FileUtils.cd(self.workspace) do
-          if self.async_json
-            bundle_log, status = Open3.capture2e('bundle package --all')
-            puts bundle_log
-          else
-            system('bundle package --all')
-            status = $?
-          end
-          if status != 0
-            log_and_abort 'Bundler failed. Please check command: bundle package'
-          end
+        # TODO Move to common expect_valid_application
+        if is_android?
+          expect_android_test_server
         end
-        log_header('Verifying dependencies')
-        verify_dependencies(tmpdir)
 
+        # TODO this happens too soon, it should collect the files to upload
         if dry_run
           log_header('Dry run only')
           log('Dry run completed OK')
           return
         end
 
-        app_file, dsym_zip, files, paths = gather_files_and_paths_to_upload(all_files(tmpdir), tmpdir)
+        # TestFile instances
+        test_suite_files = collect_test_suite_files(tmpdir)
+
+        negotiated = negotiate_contents_of_upload(test_suite_files)
+        app_digest_or_file = negotiated[:app_digest_or_file]
+        dsym_digest_or_file = negotiated[:dsym_digest_or_file]
+        digests_and_files = negotiated[:digests_and_files]
+        remote_paths = negotiated[:remote_paths]
 
         log_header('Uploading negotiated files')
 
-        upload_data = {'files' => files,
-                       'paths' => paths,
-                       'user' => self.user,
-                       'client_version' => XamarinTestCloud::VERSION,
-                       'app_file' => app_file,
-                       'device_selection' => device_selection_data,
-                       'app' => self.appname,
-                       'test_parameters' => self.test_parameters,
-                       'locale' => self.locale,
-                       'series' => self.series,
-                       'api_key' => api_key,
-                       'dsym_file' => dsym_zip,
-                       'dsym_filename' => dsym_file_name,
-                       'app_filename' => File.basename(app),
-                       'priority' => self.priority}
+        upload_data = {
+          'files' => digests_and_files,
+          'paths' => remote_paths,
+          'user' => self.user,
+          'client_version' => XamarinTestCloud::VERSION,
+          'app_file' => app_digest_or_file,
+          'device_selection' => device_selection_data,
+          'app' => self.appname,
+          'test_parameters' => self.test_parameters,
+          'locale' => self.locale,
+          'series' => self.series,
+          'api_key' => api_key,
+          'app_filename' => File.basename(app)
+        }
+
+        if dsym
+          upload_data["dsym_file"] = dsym_digest_or_file
+          upload_data["dsym_filename"] = dsym.remote_path(app)
+        else
+          upload_data["dsym_file"] = nil
+          upload_data["dsym_filename"] = nil
+        end
 
         if profile #only if config and profile
           upload_data['profile'] = profile
         end
 
-        if debug?
+        if Environment.debug?
           puts JSON.pretty_generate(upload_data)
         end
 
+        contains_file = digests_and_files.find { |f| f.is_a?(File) }
 
-        contains_file = files.find { |f| f.is_a?(File) }
-
-        contains_file = contains_file || app_file.is_a?(File)
+        contains_file = contains_file || app_digest_or_file.is_a?(File)
 
         if contains_file
           self.endpoint_path = FILE_UPLOAD_ENDPOINT #nginx receives upload
@@ -466,12 +488,12 @@ module XamarinTestCloud
           self.endpoint_path = FORM_URL_ENCODED_ENDPOINT #ruby receives upload
         end
 
-        if debug?
+        if Environment.debug?
           puts "Will upload to file path: #{self.endpoint_path}"
         end
 
         response = http_post(endpoint_path, upload_data) do |response, request|
-          if debug?
+          if Environment.debug?
             puts "Request url: #{self.host}/#{request.route}"
             puts "Response code: #{response.code}"
             puts "Response body: #{response.body}"
@@ -498,103 +520,110 @@ module XamarinTestCloud
 
       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.')
-
-        File.open(gemfile_path, "w") do |f|
-          f.puts "source 'http://rubygems.org'"
-          if is_android?
-            f.puts "gem 'calabash-android', '#{calabash_android_version}'"
-          elsif is_ios?
-            f.puts "gem 'calabash-cucumber', '#{calabash_ios_version}'"
-          else
-            raise ValidationError, 'Your app must be an ipa or apk file.'
-          end
+      def app_and_dsym_details
+        dsym_digest = nil
+        dsym_file = nil
+        if dsym
+          dsym_file = dsym.symbol_file
+          dsym_digest = digest(dsym_file)
         end
-        log("Proceeding with Gemfile: #{gemfile_path}")
 
-        puts(File.read(gemfile_path))
+        {
+          :app_digest => digest(app),
+          :dsym_digest => dsym_digest,
+          :dsym_file => dsym_file
+        }
 
-        log('')
       end
 
-      def gather_files_and_paths_to_upload(collected_files, tmpdir)
-
-        log_header('Calculating digests')
+      def http_fetch_remote_digests(file_digests, app_digest, dsym_digest)
+        parameters = {
+          "hashes" => file_digests,
+          "app_hash" => app_digest,
+          "dsym_hash" => dsym_digest
+        }
 
-        file_paths = collected_files[:files]
-        feature_prefix = collected_files[:feature_prefix]
-        workspace_prefix = collected_files[:workspace_prefix]
+        response = http_post("check_hash", parameters)
 
-        hashes = file_paths.collect { |f| digest(f) }
+        JSON.parse(response)
+      end
 
-        if hashes.nil? || hashes.size == 0
-          hashes << '0222222222222222222222222222222222222222222222222222222222222222'
+      # @param [Array<TestFiles>] test_files A list of TestFile instances.
+      # @param [Hash] cache_status <digest> => true/false pairs based on whether
+      #  or not the server (Test Cloud) already has this file.
+      def negotiated_digests_files_and_remote_paths(test_files, cache_status)
+        digests_and_files = []
+        remote_paths = []
+        test_files.each do |test_file|
+          if cache_status[test_file.digest]
+            # Server already knows about this file; don't upload it.
+            digests_and_files << test_file.digest
+          else
+            # Upload file
+            digests_and_files << test_file.file_instance
+          end
+          remote_paths << test_file.remote_path
         end
 
+        {
+          :digests_and_files => digests_and_files,
+          :remote_paths => remote_paths
+        }
+      end
 
-        log_header('Negotiating upload')
+      # test_files is a list of TestFile instance for the assets in:
+      #
+      # 1. <tmpdir>/vendor/cache/*
+      # 2. features/**/*
+      # 3. test_server/<the matching test server>
+      # 4. The cucumber configuration file
+      #
+      # 3 and 4 are only present if they exist.
+      #
+      # @param [Array<TestFile>] test_files a list of TestFile instances
+      def negotiate_contents_of_upload(test_files)
+        log_header('Calculating digests')
 
-        app_digest = digest(app)
+        file_digests = collect_test_suite_file_digests(test_files)
 
-        dsym_digest= nil
-        if dsym
-          FileUtils.cp_r(dsym, tmpdir)
-          files_in_dwarf = Dir.glob(File.join(tmpdir, File.basename(dsym), 'Contents', 'Resources', 'DWARF', '*'))
-          unless files_in_dwarf.count == 1
-            raise ValidationError, "dSym #{dsym} contains more than one file in Contents/Resources/DWARF: #{files_in_dwarf}"
-          end
-
-          dsym_abs_path= files_in_dwarf.first
-          dsym_digest = digest(dsym_abs_path)
-        end
-        out = {'hashes' => hashes, 'app_hash' => app_digest, 'dsym_hash' => dsym_digest}
+        log_header('Negotiating upload')
 
-        response = http_post('check_hash', out)
+        app_and_dsym = app_and_dsym_details
+        app_digest = app_and_dsym[:app_digest]
+        dsym_digest = app_and_dsym[:dsym_digest]
 
-        cache_status = JSON.parse(response)
+        server_digests = http_fetch_remote_digests(file_digests, app_digest, dsym_digest)
 
         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
+        negotiated = negotiated_digests_files_and_remote_paths(test_files,
+                                                               server_digests)
 
-          if file.start_with?(feature_prefix)
-            prefix = feature_prefix
-          else
-            prefix = workspace_prefix
-          end
-          paths << file.sub(prefix, '').sub("#{tmpdir}/", '')
-        end
+        digests_and_files = negotiated[:digests_and_files]
+        remote_paths = negotiated[:remote_paths]
 
-        if config
-          files << File.new(config)
-          paths << 'config/cucumber.yml'
+        if server_digests[app_digest]
+          app_digest_or_file = app_digest
+        else
+          app_digest_or_file = File.new(app)
         end
 
-        app_file = cache_status[app_digest] ? app_digest : File.new(app)
-
-        if dsym_digest
-          dsym_file = cache_status[dsym_digest] ? dsym_digest : File.new(dsym_abs_path)
+        dsym_digest_or_file = nil
+        if dsym
+          if server_digests[dsym_digest]
+            dsym_digest_or_file = dsym_digest
+          else
+            dsym_file = app_and_dsym[:dsym_file]
+            dsym_digest_or_file = File.new(dsym_file)
+          end
         end
 
-        return app_file, dsym_file, files, paths
+        {
+          :app_digest_or_file => app_digest_or_file,
+          :dsym_digest_or_file => dsym_digest_or_file,
+          :digests_and_files => digests_and_files,
+          :remote_paths => remote_paths
+        }
       end
 
       def digest(file)
@@ -620,132 +649,166 @@ module XamarinTestCloud
       end
 
       def is_calabash_2?
-        detect_calabash_2
+        calabash_2_version
       end
 
-      def get_calabash_version_from_bundler
-        cmd = "bundle exec ruby -e \"begin; require 'calabash/version';puts Calabash::VERSION;rescue LoadError => e; puts '';end\""
-
-        `#{cmd}`.strip
+      # Valid gem keywords are: :calabash, :android, :ios
+      # This is potentially very expensive because there is at least one shell
+      # call and possibly a `bundle install`. We only want to call this method
+      # once.
+      def detect_calabash_version(gem_keyword)
+        begin
+          # Raises RuntimeError if there is an error shelling out.
+          # Raises ArgumentError on incorrect (logical) usage.
+          # Returns nil if there is no version information available.
+          CalabashVersionDetector.new(derived_workspace, gem_keyword).version
+        rescue RuntimeError => e
+          raise(ValidationError, e.message)
+        end
       end
 
-      def detect_calabash_2
-        @detected_calabash_2 ||= lambda do
-          log "Auto-detecting if Calabash 2.0 testsuite" if debug?
-
-          # Implicitly detect
-          if File.exist?(workspace_gemfile)
-            FileUtils.cd(self.workspace) do
-              version = get_calabash_version_from_bundler
-
-              if version.split('.').first.to_i >= 2
-                log "It is a Calabash 2.0 testsuite" if debug?
-                return true
-              end
-            end
+      # Memoize: we only want to call detect_calabash_version once.
+      def calabash_2_version
+        if @calabash_2_version.nil?
+          version = detect_calabash_version(:calabash)
+          if version
+            @calabash_2_version = version
+          else
+            @calabash_2_version = false
           end
-
-          false
-        end.call
+        end
+        @calabash_2_version
       end
 
-      def calabash_2_version
-        version = nil
+      # TODO: this should be called as part of a validation step.
+      # Memoize: we only want to call detect_calabash_version once.
+      def calabash_android_version
+        return calabash_2_version if is_calabash_2?
 
-        if File.exist?(workspace_gemfile)
-          FileUtils.cd(self.workspace) do
-            version = get_calabash_version_from_bundler
+        if @calabash_android_version.nil?
+          version = detect_calabash_version(:android)
+          if version
+            @calabash_android_version = version
+          else
+            @calabash_android_version = false
           end
         end
+        @calabash_android_version
+      end
 
-        unless version
-          require 'calabash'
-          version = Calabash::VERSION
+      # TODO: this should be called as part of a validation step.
+      # Memoize: we only want to call detect_calabash_version once.
+      def calabash_ios_version
+        return calabash_2_version if is_calabash_2?
+
+        if @calabash_ios_version.nil?
+          version = detect_calabash_version(:ios)
+          if version
+            @calabash_ios_version = version
+          else
+            @calabash_ios_version = false
+          end
         end
 
-        version.strip
+        @calabash_ios_version
       end
 
-      def calabash_android_version
-        if is_calabash_2?
-          return calabash_2_version
-        end
+      # TODO What to do about logical errors?
+      def android_test_server
+        @android_test_server ||= begin
+          if !is_android?
+            raise RuntimeError, %Q[
+This method cannot be called on a non-android project.
 
-        version = nil
+Please send a bug report to testcloud@xamarin.com that includes:
 
-        if File.exist?(workspace_gemfile)
-          FileUtils.cd(self.workspace) do
-            version = `bundle exec ruby -e "require 'calabash-android/version'; puts Calabash::Android::VERSION"`
-            version = version && version.strip
+1. The exact command you are running.
+2. The following stack trace.
+]
+          else
+            digest = XamarinTestCloud::TestFile.file_digest(app, :MD5)
+            name = "#{digest}_#{calabash_android_version}.apk"
+            basedir = derived_workspace
+            file = File.join(basedir, 'test_servers', name)
+            TestFile.new(file, basedir)
           end
         end
-
-        unless version
-          require 'calabash-android'
-          version = Calabash::Android::VERSION
-        end
-
-        version.strip
       end
 
-      def calabash_ios_version
-        if is_calabash_2?
-          return calabash_2_version
-        end
+      def expect_android_test_server
+        return nil if !is_android?
 
-        version = nil
+        path = android_test_server.path
+        return true if File.exist?(path)
 
-        if File.exist?(workspace_gemfile)
-          FileUtils.cd(self.workspace) do
-           version = `bundle exec ruby -e "require 'calabash-cucumber/version'; puts Calabash::Cucumber::VERSION"`
-           version = version && version.strip
-          end
+        if is_calabash_2?
+          build_command = "calabash build #{app}"
+        else
+          build_command = "calabash-android build #{app}"
         end
 
-        unless version
-          require 'calabash-cucumber'
-          version = Calabash::Cucumber::VERSION
-        end
+        raise ValidationError, %Q[
+No test server '#{path}' found. Please run:
 
-        version.strip
-      end
+  #{build_command}
 
-      def test_server_path
-        require 'digest/md5'
-        digest = Digest::MD5.file(app).hexdigest
-        File.join(self.workspace, 'test_servers', "#{digest}_#{calabash_android_version}.apk")
+and try submitting again.
+]
       end
 
-      def all_files(tmpdir)
-        dir = workspace
-
-        files = Dir.glob(File.join("#{dir}features", '**', '*'))
-
-        if File.directory?("#{dir}playback")
-          files += Dir.glob(File.join("#{dir}playback", '*'))
-        end
+      def collect_test_suite_files(tmpdir)
+        files = collect_files_from_features +
+          collect_files_from_tmpdir(tmpdir) +
+          collect_gemfile_files(tmpdir)
 
         if config
           files << config
         end
 
-        files += Dir.glob(File.join(tmpdir, "vendor", 'cache', '*'))
+        if is_android?
+          files << android_test_server
+        end
+
+        files
+      end
 
-        if workspace and workspace.strip != ''
-          files += Dir.glob("#{workspace}Gemfile")
-          files += Dir.glob("#{workspace}Gemfile.lock")
+      # Returns file paths as Strings
+      def collect_files_with_glob(glob)
+        Dir.glob(glob).select do |path|
+          File.file?(path)
         end
+      end
 
-        if is_android?
-          files << test_server_path
+      # Returns TestFile instances.
+      def collect_files_from_features
+        basedir = derived_workspace
+        glob = File.join(basedir, "features", "**", "*")
+        collect_files_with_glob(glob).map do |file|
+          TestFile.new(file, basedir)
         end
+      end
 
-        {:feature_prefix => dir, :workspace_prefix => workspace, :files => files.find_all { |file_or_dir| File.file? file_or_dir }}
+      # Returns TestFile instances.
+      def collect_files_from_tmpdir(tmpdir)
+        glob = File.join(tmpdir, "vendor", "cache", "*")
+        collect_files_with_glob(glob).map do |file|
+          TestFile.new(file, tmpdir)
+        end
       end
 
-      def dsym_file_name
-        if dsym
-          "#{File.basename(self.app)}_dSym"
+      # Returns TestFile instances.
+      def collect_gemfile_files(tmpdir)
+        glob = File.join(tmpdir, "{Gemfile,Gemfile.lock}")
+        collect_files_with_glob(glob).map do |file|
+          TestFile.new(file, tmpdir)
+        end
+      end
+
+      # Returns a list of digests
+      # @param [Array<TestFile>] test_files A list of TestFile instances.
+      def collect_test_suite_file_digests(test_files)
+        test_files.map do |test_file|
+          test_file.digest
         end
       end
 
@@ -797,14 +860,10 @@ module XamarinTestCloud
         end
       end
 
-      def is_windows?
-        (RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/)
-      end
-
-      def is_macosx?
-        (RbConfig::CONFIG['host_os'] =~ /darwin/)
-      end
-
+      # TODO: move to separate module/class
+      # TODO: fix the detection algorithm - it is broken
+      # TODO: remove the Frank check
+      # https://github.com/xamarinhq/test-cloud-command-line/issues/19
       def validate_ipa(ipa)
         result = false
         dir = Dir.mktmpdir #do |dir|
@@ -846,14 +905,14 @@ module XamarinTestCloud
       end
 
       def log_header(message)
-        if is_windows?
+        if XamarinTestCloud::Environment.windows_env?
           puts "\n### #{message} ###"
         else
           puts "\n\e[#{35}m### #{message} ###\e[0m"
         end
       end
 
-
+      # TODO: rename: does not need to extract or return the server
       def verify_app_and_extract_test_server
         server = nil
 
@@ -863,7 +922,7 @@ module XamarinTestCloud
         unless (/\.(apk|ipa)$/ =~ app)
           raise ValidationError, '<APP> should be either an ipa or apk file.'
         end
-        if is_ios? and is_macosx?
+        if is_ios? && Environment.macos_env?
           log_header('Checking ipa for linking with Calabash')
           server = validate_ipa(app)
           abort_unless(server) do
@@ -874,11 +933,15 @@ module XamarinTestCloud
         server
       end
 
+      # TODO Rename or remove; abort is not the right verb - use exit
+      # +1 for remove
       def abort(&block)
         yield block
         exit 1
       end
 
+      # TODO Rename or remove; abort is not the right verb - use exit
+      # +1 for remove
       def abort_unless(condition, &block)
         unless condition
           yield block
@@ -886,6 +949,8 @@ module XamarinTestCloud
         end
       end
 
+      # TODO Rename or remove; abort is not the right verb - use exit
+      # +1 for remove
       def log_and_abort(message)
         raise XamarinTestCloud::ValidationError.new(message) if self.async_json
         abort do
@@ -894,7 +959,7 @@ module XamarinTestCloud
         end
       end
 
-
+      # TODO Move to a module
       def shared_runtime?(app_path)
         f = files(app_path)
         f.any? do |file|
@@ -905,6 +970,7 @@ module XamarinTestCloud
         end
       end
 
+      # TODO One caller #shared_runtime? move to a module
       def files(app)
         Zip::File.open(app) do |zip_file|
           zip_file.collect do |entry|
@@ -913,44 +979,22 @@ module XamarinTestCloud
         end
       end
 
-      def verify_dependencies(path)
-        if is_android?
-          abort_unless(File.exist?(test_server_path)) do
-            puts "No test server '#{test_server_path}' found. Please run:"
-
-            if is_calabash_2?
-              puts "  calabash build #{app}"
-            else
-              puts "  calabash-android build #{app}"
-            end
-          end
+      # TODO: extract to a module
+      # TODO: replace unless/else branches
+      def parse_and_set_config_and_profile
+        config_path = options[:config]
 
-          if is_calabash_2?
-            calabash_gem = Dir.glob("#{path}/vendor/cache/calabash-*").first
-            abort_unless(calabash_gem) do
-              puts 'calabash was not packaged correct.'
-              puts 'Please tell testcloud@xamarin.com about this bug.'
-            end
-          else
-            calabash_gem = Dir.glob("#{path}/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
+        if !config_path
+          self.config = false
+          return
         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(ERB.new(File.read(config_path)).result)
           rescue Exception => e
@@ -958,7 +1002,7 @@ module XamarinTestCloud
             raise ValidationError, e
           end
 
-          if debug?
+          if Environment.debug?
             puts 'Parsed Cucumber config as:'
             puts config_yml.inspect
           end
@@ -980,13 +1024,147 @@ module XamarinTestCloud
           end
         end
 
-        self.config = config_path
+        self.config = TestFile.cucumber_config(config_path)
       end
 
-    end
+      def expect_features_directory_in_workspace
+        path = derived_workspace
+        features = File.join(path, "features")
 
+        return true if File.directory?(features)
+        log_header("Missing features Directory")
+        raise(ValidationError, %Q[Did not find a features directory in workspace:
 
-  end
-end
+#{path}
+
+You have two options:
+
+1. Run the test-cloud submit command in the directory that contains your
+   features directory or
+2. Use the --workspace option point to the directory that contains your
+   features directory.
+
+See also
+
+$ test-cloud help submit
+])
+      end
+
+      def derived_workspace
+        @derived_workspace ||= begin
+          path = detect_workspace(options)
+          expect_workspace_directory(path)
+
+          workspace_basename = File.basename(path)
+          if workspace_basename.downcase == "features"
+            derived = File.expand_path(File.join(path, ".."))
+            log("Deriving workspace as: #{derived} from features folder")
+            derived
+          else
+            File.expand_path(path)
+          end
+        end
+      end
+
+      def detect_workspace(options)
+        options["workspace"] || File.expand_path(".")
+      end
+
+      def expect_workspace_directory(path)
+        message = nil
+        if !File.exist?(path)
+          message = %Q[The path specified by --workspace:
+
+#{path}
+
+does not exist.
+]
+       elsif !File.directory?(path)
+          message = %Q[The path specified by --workspace:
+
+#{path}
+
+is not a directory.
+]
+        end
+
+        if message
+          raise(ValidationError, message)
+        else
+          true
+        end
+      end
+
+      # TODO We should require a Gemfile
+      # TODO Untested
+      def copy_default_gemfile(gemfile_path)
+        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://bundler.io/')
+        log('')
+        log('Warning proceeding with default Gemfile.')
+        log('It is strongly recommended that you create a custom Gemfile.')
+
+        File.open(gemfile_path, "w") do |f|
+          f.puts "source 'http://rubygems.org'"
+          if is_android?
+            f.puts "gem 'calabash-android', '#{calabash_android_version}'"
+          elsif is_ios?
+            f.puts "gem 'calabash-cucumber', '#{calabash_ios_version}'"
+          else
+            raise ValidationError, 'Your app must be an ipa or apk file.'
+          end
+        end
+        log("Proceeding with Gemfile: #{gemfile_path}")
+
+        puts(File.read(gemfile_path))
+
+        log('')
+      end
 
+      def stage_gemfile_and_bundle_package(tmpdir)
+        log_header('Checking for Gemfile')
 
+        if File.exist?(workspace_gemfile)
+          FileUtils.cp(workspace_gemfile, tmpdir)
+          if File.exist?(workspace_gemfile_lock)
+            FileUtils.cp(workspace_gemfile_lock, tmpdir)
+          end
+        else
+          copy_default_gemfile(File.join(tmpdir, "Gemfile"))
+        end
+        gemfile = File.join(tmpdir, "Gemfile")
+        bundle_package(gemfile)
+      end
+
+      def bundle_package(gemfile)
+        log_header('Packaging')
+
+        Bundler.with_clean_env do
+          args = ["package", "--all", "--gemfile", gemfile]
+          success = shell_out_with_system("bundle", args)
+          if !success
+            cmd = "bundle #{args.join(" ")}"
+            raise(ValidationError, %Q[Could not package gems.  This command failed:
+
+#{cmd}
+
+Check your local Gemfile and and the remote Gemfile at:
+
+#{gemfile})
+])
+          end
+        end
+        true
+      end
+
+      # stderr will not be captured during --async-json
+      def shell_out_with_system(command, arguments)
+        system(command, *arguments)
+        $?.exitstatus == 0
+      end
+    end
+  end
+end