mesa_test 0.2.15 → 1.0.0

data/lib/mesa_test.rb

@@ -11,9 +11,11 @@ require 'json'
 MesaDirError = Class.new(StandardError)
 TestCaseDirError = Class.new(StandardError)
 InvalidDataType = Class.new(StandardError)
+GitHubError = Class.new(StandardError)
 
-Commit = Struct.new(:revision, :author, :datetime, :message)
 DEFAULT_REVISION = 10_000
+GITHUB_HTTPS = 'https://github.com/MESAHub/mesa.git'.freeze
+GITHUB_SSH = 'git@github.com:MESAHub/mesa.git'.freeze
 
 class MesaTestSubmitter
   DEFAULT_URI = 'https://mesa-test-hub.herokuapp.com'.freeze
@@ -28,7 +30,8 @@ shown in parentheses at the end of a prompt. Pressing enter will accept the
 default values.
 
 To submit to MESATestHub, a valid computer name, email address, and password
-are all required. All other data are useful, but optional. Any data
+are all required. To actually run a test, you need to specify a location for
+your base MESA git repository. All other data are useful, but optional. Any data
 transferred to MESATestHub will be encrypted via HTTPS, but be warned that your
 e-mail and password will be stored in plain text.'
       # Get computer name
@@ -36,11 +39,6 @@ e-mail and password will be stored in plain text.'
         "(#{s.computer_name}):", :blue)
       s.computer_name = response unless response.empty?
 
-      # Get user name
-      response = shell.ask 'What is the name of the operator of this ' \
-        "computer? (#{s.user_name}):", :blue
-      s.user_name = response unless response.empty?
-
       # Get user e-mail
       response = shell.ask 'What is the email you can be reached ' \
         "at (required)? (#{s.email}):", :blue
@@ -51,40 +49,33 @@ e-mail and password will be stored in plain text.'
         "#{s.email} (required)? (#{s.password})", :blue
       s.password = response unless response.empty?
 
+      # Determine if we'll use ssh or https to access github
+      response = shell.ask 'When accessing GitHub, which protocol do you '\
+        'want to use? ', :blue, limited_to: %w[ssh https]
+      s.github_protocol = response.strip.downcase.to_sym
+
+      # Get location of source MESA repo (the mirror)
+      response = shell.ask "Where is/should your mirrored MESA repository " \
+      "located? This is where a mirror will be stored from which test " \
+      "repos will be generated. You won't touch this in regular operation. " \
+      "(#{s.mesa_mirror}):", :blue
+      s.mesa_mirror = response unless response.empty?
+
+      # Get location of source MESA work (where testing happens)
+      response = shell.ask "Where is/should your working directory for "\
+      "testing be located? This is where testing actually occurs, but all "\
+      "files it uses are cached in the mirror repo to save time later. " \
+      "(#{s.mesa_work}):", :blue
+      s.mesa_work = response unless response.empty?
+
       # Get platform information
       response = shell.ask 'What is the platform of this computer (eg. ' \
         "macOS, Ubuntu)? (#{s.platform}):", :blue
       s.platform = response unless response.empty?
-      response = shell.ask 'What is the version of the platform (eg. 10.13, ' \
-        "16.04)? (#{s.platform_version}):", :blue
+      response = shell.ask 'What is the version of the platform (eg. 10.15.5, ' \
+        "Ubuntu 16.04)? (#{s.platform_version}):", :blue
       s.platform_version = response unless response.empty?
 
-      # Get processor information
-      response = shell.ask 'What type of processor does this computer have ' \
-        "(eg. 3.1 GHz Intel i7)? (#{s.processor}):", :blue
-      s.processor = response unless response.empty?
-
-      # Get ram information
-      response = shell.ask 'How much RAM (in integer GB) does this computer ' \
-        "have (eg. 8)? (#{s.ram_gb}) ", :blue
-      s.ram_gb = response.to_i unless response.empty?
-
-      # Get compiler information
-      response = shell.ask "Which compiler are you using? (#{s.compiler}):",
-                           :blue, limited_to: ['', 'SDK', 'gfortran', 'ifort']
-      s.compiler = response unless response.empty?
-
-      # Get compiler version
-      response = shell.ask 'What version of the compiler (eg. 20170921 or ' \
-        "7.2.0)? (#{s.compiler_version}): ", :blue
-      s.compiler_version = response unless response.empty?
-
-      # Get earliest revision to check
-      response = shell.ask "What's the earliest revision to search back to " \
-        'when finding the latest testable revision (eg. 10000)? ' \
-        "(#{s.last_tested}): ", :blue
-      s.last_tested = response.to_i unless response.empty?
-
       # Confirm save location
       response = shell.ask "This will be saved in #{s.config_file}. Press " \
         'enter to accept or enter a new location:', :blue, path: true
@@ -95,15 +86,15 @@ e-mail and password will be stored in plain text.'
     if confirm_computer_data
       save_computer_data
     else
-      puts "Restarting wizard.\n"
+      shell.say "Restarting wizard.\n"
       setup
     end
   end
 
   def self.new_from_config(
-    config_file: File.join(ENV['HOME'], '.mesa_test.yml'), force_setup: false,
+    config_file: File.join(ENV['HOME'], '.mesa_test', 'config.yml'),
+    force_setup: false,
     base_uri: DEFAULT_URI
-    # base_uri: 'http://localhost:3000'
   )
     new_submitter = new(config_file: config_file, base_uri: base_uri)
     if force_setup
@@ -117,22 +108,27 @@ e-mail and password will be stored in plain text.'
   end
 
   attr_accessor :computer_name, :user_name, :email, :password, :platform,
-                :platform_version, :processor, :ram_gb, :compiler,
-                :compiler_version, :config_file, :base_uri, :last_tested
+                :mesa_mirror, :mesa_work, :platform_version, :processor,
+                :config_file, :base_uri, :last_tested, :github_protocol
 
   attr_reader :shell
 
   # many defaults are set in body
   def initialize(
-      computer_name: nil, user_name: nil, email: nil, platform: nil,
-      platform_version: nil, processor: nil, ram_gb: nil, compiler: nil,
-      compiler_version: nil, config_file: nil, base_uri: nil, last_tested: nil
+      computer_name: nil, user_name: nil, email: nil, github_protocol: nil,
+      mesa_mirror: nil, platform: nil, platform_version: nil, processor: nil,
+      config_file: nil, base_uri: nil, last_tested: nil
   )
     @computer_name = computer_name || Socket.gethostname.scan(/^[^\.]+\.?/)[0]
     @computer_name.chomp!('.') if @computer_name
     @user_name = user_name || (ENV['USER'] || ENV['USERNAME'])
     @email = email || ''
     @password = password || ''
+    @github_protocol = github_protocol || :ssh
+    @mesa_mirror = mesa_mirror ||
+      File.join(ENV['HOME'], '.mesa_test', 'mirror')
+    @mesa_work = mesa_work ||
+      File.join(ENV['HOME'], '.mesa_test', 'work')
     @platform = platform
     if @platform.nil?
       @platform =
@@ -146,10 +142,8 @@ e-mail and password will be stored in plain text.'
     end
     @platform_version = platform_version || ''
     @processor = processor || ''
-    @ram_gb = ram_gb || 0
-    @compiler = compiler || 'SDK'
-    @compiler_version = compiler_version || ''
-    @config_file = config_file || File.join(ENV['HOME'], '.mesa_test.yml')
+    @config_file = config_file || File.join(ENV['HOME'], '.mesa_test',
+                                            'config.yml')
     @base_uri = base_uri
     @last_tested = last_tested || DEFAULT_REVISION
 
@@ -157,6 +151,7 @@ e-mail and password will be stored in plain text.'
     # gets command, so we have to use its built-in "ask" method, which is
     # actually more useful
     @shell = Thor::Shell::Color.new
+
     yield self if block_given?
   end
 
@@ -169,14 +164,12 @@ e-mail and password will be stored in plain text.'
     puts 'Ready to submit the following data:'
     puts '-------------------------------------------------------'
     puts "Computer Name           #{computer_name}"
-    puts "User Name               #{user_name}"
     puts "User email              #{email}"
     puts 'Password                ***********'
+    puts "GitHub Protocol         #{github_protocol}"
+    puts "MESA Mirror Location    #{mesa_mirror}"
+    puts "MESA Work Location      #{mesa_work}"
     puts "Platform                #{platform} #{platform_version}"
-    puts "Processor               #{processor}"
-    puts "RAM                     #{ram_gb} GB"
-    puts "Compiler                #{compiler} #{compiler_version}"
-    puts "Last tested revision    #{last_tested}"
     puts "Config location         #{config_file}"
     puts '-------------------------------------------------------'
     puts ''
@@ -189,151 +182,107 @@ e-mail and password will be stored in plain text.'
   # change platforms (i.e. switch from mac to linux, or change between linux
   # flavors), you should create a new computer account. Similarly, create new
   # computer accounts if you change your RAM or processor. You do not need
-  # to change computers if you upgrade your platform (macOS 10.12 -> 10.13) or
-  # if you try different compilers
-  #
-  # Note this is NOT checked! The server really only uses the test-by-test
-  # quantities (platform version, compiler, compiler version) and the
-  # computer name. Once the computer is found (by the name) all the other
-  # data is assumed to be fixed. The others... probably shouldn't be here,
-  # but remain so you can confirm that the computer on the web server is the
-  # same one you think you are working with locally.
+  # to change computers if you upgrade your platform (macOS 10.12 -> 10.13
   def save_computer_data
     data_hash = {
       'computer_name' => computer_name,
-      'user_name' => user_name,
       'email' => email,
       'password' => password,
+      'github_protocol' => github_protocol,
+      'mesa_mirror' => mesa_mirror,
+      'mesa_work' => mesa_work,
       'platform' => platform,
-      'processor' => processor,
-      'ram_gb' => ram_gb,
       'platform_version' => platform_version,
-      'compiler' => compiler,
-      'compiler_version' => compiler_version,
-      'last_tested' => last_tested
     }
+    # make sure there's a directory to write to
+    unless dir_or_symlink_exists? File.dirname(config_file)
+      FileUtils.mkdir_p File.dirname(config_file)
+    end
     File.open(config_file, 'w') { |f| f.write(YAML.dump(data_hash)) }
   end
 
   def load_computer_data
     data_hash = YAML.safe_load(File.read(config_file), [Symbol])
     @computer_name = data_hash['computer_name']
-    @user_name = data_hash['user_name']
     @email = data_hash['email']
     @password = data_hash['password']
+    @github_protocol = data_hash['github_protocol'].to_sym
+    @mesa_mirror = data_hash['mesa_mirror']
+    @mesa_work = data_hash['mesa_work']
     @platform = data_hash['platform']
-    @processor = data_hash['processor']
-    @ram_gb = data_hash['ram_gb']
     @platform_version = data_hash['platform_version']
-    @compiler = data_hash['compiler']
-    @compiler_version = data_hash['compiler_version']
-    @last_tested = data_hash['last_tested'] || @last_tested
   end
 
-  # create and return hash of parameters for a TestInstance submission
-  # Note: prefer test case's self-reported compiler and compiler version over
-  # user reported
-  def submit_params(test_case)
-    res = {
-      test_case: test_case.test_name,
-      mod: test_case.mod,
-      computer: computer_name,
+  # Parameters to be submitted in JSON format for reporting information about
+  # the submitting user and computer
+  def submitter_params
+    {
       email: email,
       password: password,
-      runtime_seconds: test_case.runtime_seconds,
-      re_time: test_case.re_time,
-      total_runtime_seconds: test_case.total_runtime_seconds,
-      mesa_version: test_case.mesa_version,
-      passed: test_case.passed? ? 1 : 0,
-      compiler: test_case.compiler || compiler,
-      compiler_version: test_case.compiler_version || compiler_version,
-      platform_version: platform_version,
-      omp_num_threads: test_case.test_omp_num_threads,
-      success_type: test_case.success_type,
-      failure_type: test_case.failure_type,
-      steps: test_case.steps,
-      retries: test_case.retries,
-      backups: test_case.backups,
-      diff: test_case.diff,
-      checksum: test_case.checksum,
-      rn_mem: test_case.rn_mem,
-      re_mem: test_case.re_mem,
-      summary_text: test_case.summary_text
+      computer: computer_name,
+      platform_version: platform_version
     }
-
-    # enter in test-specific data, DISABLED FOR NOW
-    # test_case.data_names.each do |data_name|
-    #   unless test_case.data[data_name].nil?
-    #     res[data_name] = test_case.data[data_name]
-    #   end
-    # end
-    res
   end
 
-  def revision_submit_params(mesa)
-    # only query svn if we didn't do it in the first place. Probably
-    # unnecessary
-    mesa.load_svn_data if mesa.use_svn? && mesa.svn_version.nil?     
-    # version gives data about version
-    # user gives data about the user and computer submitting information
-    # instances is array of hashes that identify test instances (more below)
-    res = {
-            version: {number: mesa.version_number, compiled: mesa.installed?},
-            user: {email: email, password: password, computer: computer_name},
-            instances: []
-          }
-    if mesa.use_svn?
-      res[:version][:author] = mesa.svn_author
-      res[:version][:log] = mesa.svn_log
-    end
-
-    # bail out if installation failed (and we care)
-    return [res, []] unless res[:version][:compiled]
-
-    # Successfully compiled, now gather test instance data.
-
-    # hold on to test case names that fail in synthesizing params
+  # Parameters to be submitted in JSON format for reporting information about
+  # the overall commit being tested; used even if only submitting an entire
+  # test. This also determines if the submission is for an entire commit 
+  # (compilation information and every test), an empty commit (just
+  # compilation information), or a non-empty, but also non-entire submission
+  # (results for a single test without compilation information)
+  def commit_params(mesa, entire: true, empty: false)
+    # the compiler data should be able to be used as-is, but right now the
+    # names don't match with what the database expects, so we do some renaming
+    # shenanigans.
+    # 
+    ####################################
+    # THIS SHOULD GO BEFORE PRODUCTION #
+    {
+      sha: mesa.sha,
+      compiled: mesa.installed?,
+      entire: entire,
+      empty: empty,
+    }.merge(mesa.compiler_hash)
+  end
+
+  # Given a valid +Mesa+ object, create an array of hashes that describe the
+  # test cases and the test results. These will be encoded as an array of
+  # JSON objects.
+  def instance_params(mesa)
     has_errors = []
-
-    # each instance has basic information in :test_instance and extra
-    # information that requires the web app to work, stored in :extra
-    mesa.test_names.each do |mod, names|
+    res = []
+    mesa.test_case_names.each do |mod, names|
       names.each do |test_name|
         begin
           test_case = mesa.test_cases[mod][test_name]
-          res[:instances] << {
-            test_instance: {
-              runtime_seconds: test_case.runtime_seconds,
-              re_time: test_case.re_time,
-              total_runtime_seconds: test_case.total_runtime_seconds,
-              passed: test_case.passed?,
-              compiler: test_case.compiler || compiler,
-              compiler_version: test_case.compiler_version || compiler_version,
-              platform_version: platform_version,
-              omp_num_threads: test_case.test_omp_num_threads,
-              success_type: test_case.success_type,
-              failure_type: test_case.failure_type,
-              steps: test_case.steps,
-              retries: test_case.retries,
-              backups: test_case.backups,
-              diff: test_case.diff,
-              checksum: test_case.checksum,
-              rn_mem: test_case.rn_mem,
-              re_mem: test_case.re_mem,
-              summary_text: test_case.summary_text
-            },
-            extra: { test_case: test_name, mod: mod }
-          }
+          res << test_case.results_hash
         rescue TestCaseDirError
-          shell.say "Passage status for #{test_case.test_name} not yet "\
-                    'known. Run test first and then submit.', :red
+          # shell.say "It appears that #{test_case.test_name} has not been "\
+          #           'run yet. Unable to submit data for this test.', :red
           has_errors << test_case
         end
       end
     end
-    [res, has_errors]
+    unless has_errors.empty?
+      shell.say "The following test cases could NOT be read for submission:",
+                :red
+      has_errors.each do |test_case|
+        shell.say "- #{test_case.test_name}", :red
+      end
+    end
+    res
+  end
+
+  # Parameters for a single test case. +mesa+ is an instance of +Mesa+, and
+  # +test_case+ is an instance of MesaTestCase representing the test case to
+  # be submitted
+  def single_instance_params(test_case)
+    [test_case.results_hash]
   end
 
+  # Phone home to testhub and confirm that computer and user are valid. Useful
+  # for confirming that submissions will be accepted before wasting time on a
+  # test later.
   def confirm_computer
     uri = URI.parse(base_uri + '/check_computer.json')
     https = Net::HTTP.new(uri.hostname, uri.port)
@@ -350,12 +299,10 @@ e-mail and password will be stored in plain text.'
     JSON.parse(https.request(request).body).to_hash
   end
 
-  # attempt to post to MesaTestHub with test_case parameters
-  # returns true if the id is in the returned JSON (indicating success)
-  # otherwise returns false (maybe failed in authorization or in finding
-  # computer or test case) No error thrown for failure, though.
-  def submit(test_case)
-    uri = URI.parse(base_uri + '/test_instances/submit.json')
+  # submit entire commit's worth of test cases, OR submit compilation status
+  # and NO test cases
+  def submit_commit(mesa, empty: false)
+    uri = URI.parse(base_uri + '/submissions/create.json')
     https = Net::HTTP.new(uri.hostname, uri.port)
     https.use_ssl = true if base_uri.include? 'https'
 
@@ -363,74 +310,38 @@ e-mail and password will be stored in plain text.'
       uri,
       initheader = { 'Content-Type' => 'application/json' }
     )
-    begin
-      request.body = submit_params(test_case).to_json
-    rescue TestCaseDirError
-      shell.say "\nPassage status for #{test_case.test_name} not yet known. " \
-                'Run test first and then submit.', :red
-      return false
-    end
 
-    # verbose = true
-    # puts "\n" if verbose
-    # puts JSON.parse(request.body).to_hash if verbose
+    # create the request body for submission to the submissions API
+    # 
+    # if we have an empty submission, then it is necessarily not entire.
+    # Similarly, a non-empty submission is necessarily entire (otherwise one
+    # would use +submit_instance+)
+    request_data = {submitter: submitter_params,
+                    commit: commit_params(mesa, empty: empty, entire: !empty)}
+    # don't need test instances if it's an empty submission or if compilation
+    # failed
+    if !empty && request_data[:commit][:compiled]
+      request_data[:instances] = instance_params(mesa)
+    end
+    request.body = request_data.to_json
 
+    # actually do the submission
     response = https.request request
-    # puts JSON.parse(response.body).to_hash if verbose
-    response.is_a? Net::HTTPCreated
-  end
 
-  def submit_all(mesa, mod = :all)
-    submitted_cases = []
-    unsubmitted_cases = []
-    if mod == :all
-      success = true
-      mesa.test_names.each_key do |this_mod|
-        success &&= submit_all(mesa, mod = this_mod)
-      end
+    if !response.is_a? Net::HTTPCreated
+      shell.say "\nFailed to submit some or all test case instances and/or "\
+                'commit data.', :red
+      false
     else
-      mesa.test_names[mod].each do |test_name|
-        # get at test case
-        test_case = mesa.test_cases[mod][test_name]
-        # try to submit and note if it does or doesn't successfully submit
-        submitted = false
-        submitted = submit(test_case) unless test_case.outcome == :not_tested
-        if submitted
-          submitted_cases << test_name
-        else
-          unsubmitted_cases << test_name
-        end
-      end
-      puts "\nSubmission results for #{mod} module:"
-      puts '#####################################'
-      if !submitted_cases.empty?
-        shell.say 'Submitted the following cases:', :green
-        puts submitted_cases.join("\n")
-      else
-        shell.say 'Did not successfully submit any cases.', :red
-      end
-      unless unsubmitted_cases.empty?
-        puts "\n\n\n"
-        shell.say 'Failed to submit the following cases:', :red
-        puts unsubmitted_cases.join("\n")
-      end
-      # return true and update last tested if all cases were submitted
-      success = submitted_cases.length == mesa.test_names[mod].length
-      if success
-        @last_tested = mesa.version_number
-        shell.say "\n\nUpdating last tested revision to #{last_tested}."
-        save_computer_data
-      end
+      shell.say "\nSuccessfully submitted commit #{mesa.sha}.", :green
+      true
     end
-    # return boolean indicating whether or not all cases successfully
-    # SUBMITTED (irrespective of passing status)
-    success
   end
 
-  # similar to submit_all, but does EVERYTHING in one post, including
-  # version information. No support for individual modules now.
-  def submit_revision(mesa)
-    uri = URI.parse(base_uri + '/versions/submit_revision.json')
+  # submit results for a single test case instance. Does *not* report overall
+  # compilation status to testhub. Use an empty commit submission for that
+  def submit_instance(mesa, test_case)
+    uri = URI.parse(base_uri + '/submissions/create.json')
     https = Net::HTTP.new(uri.hostname, uri.port)
     https.use_ssl = true if base_uri.include? 'https'
 
@@ -438,207 +349,182 @@ e-mail and password will be stored in plain text.'
       uri,
       initheader = { 'Content-Type' => 'application/json' }
     )
-    request_data, error_cases = revision_submit_params(mesa)
-    if request_data[:instances].empty? && mesa.installed?
-      shell.say "No completed test data found in #{mesa.mesa_dir}. Aborting.",
-                :red
-      return false
-    end
-    request.body = request_data.to_json
 
-    # verbose = true
-    # puts "\n" if verbose
-    # puts JSON.parse(request.body).to_hash if verbose
+    # create the request body for submission to the submissions API
+    # 
+    # submission is not empty (there is one test case), and it is also not
+    # entire (... there is only test case)
+    request_data = {submitter: submitter_params,
+                    commit: commit_params(mesa, empty: false, entire: false),
+                    instances: single_instance_params(test_case)}
+    request.body = request_data.to_json
 
+    # actually do the submission
     response = https.request request
-    # puts JSON.parse(response.body).to_hash if verbose
+
     if !response.is_a? Net::HTTPCreated
-      shell.say "\nFailed to submit some or all cases and/or version data.",
-                :red
-      false
-    elsif !error_cases.empty?
-      shell.say "\nFailed to gather data for the following cases:", :red
-      error_cases.each { |tc| shell.say "  #{tc.test_name}", :red }
+      shell.say "\nFailed to submit #{test_case.test_name} for commit "\
+                "#{mesa.sha}", :red
       false
     else
-      shell.say "\nSuccessfully submitted revision #{mesa.version_number}.", :green
-      @last_tested = mesa.version_number
-      shell.say "\n\nUpdating last tested revision to #{last_tested}."
-      save_computer_data
-      true      
+      shell.say "\nSuccessfully submitted instance of #{test_case.test_name} "\
+                "for commit #{mesa.sha}.", :green
+      true
     end
   end
 end
 
 class Mesa
-  SVN_URI = 'https://subversion.assembla.com/svn/mesa\^mesa/trunk'.freeze    
-
-  attr_reader :mesa_dir, :test_data, :test_names, :test_cases, :shell,
-              :svn_version, :svn_author, :svn_log, :using_sdk
-  attr_accessor :update_checksums
-
-  def self.download(version_number: nil, new_mesa_dir: nil, use_svn: true,
-    using_sdk: true)
-    new_mesa_dir ||= File.join(ENV['HOME'], 'mesa-test-r' + version_number.to_s)
-    svn_command = "svn co -r #{version_number} #{SVN_URI} #{new_mesa_dir}"
-    success = bash_execute(svn_command)
-    unless success
-      raise MesaDirError, 'Encountered a problem in downloading mesa ' \
-                          "revision #{version_number}. Perhaps svn isn't " \
-                          'working properly?' + "\n\n"\
-                          'Tried the following command: ' + svn_command
-
-    end
-    Mesa.new(mesa_dir: new_mesa_dir, use_svn: use_svn, using_sdk: using_sdk)
-  end
-
-  def self.log_since(last_tested = DEFAULT_REVISION)
-    # svn commit log back to, but excluding, the last revision tested
-    `svn log #{SVN_URI} -r #{last_tested + 1}:HEAD`
-  end
-
-  def self.log_lines_since(last_tested = DEFAULT_REVISION)
-    log_since(last_tested).split("\n").reject(&:empty?)
-  end
-
-  def self.add_commit(commits, revision, author)
-    commits << Commit.new
-    commits.last.revision = revision.to_i
-    commits.last.author = author
-    commits.last.message = []
-  end
-
-  def self.process_line(commits, line)
-    last = commits.last
-    if line =~ /^-+$/
-      # dashed lines separate commits
-      # Done with last commit (if it exists), so clean up message
-      last.message = last.message.join("\n") unless last.nil?
-    elsif line =~ /^r(\d+) \| (\w+) \| .* \| \d+ lines?$/
-      # first line of a commit, scrape data and make new commit
-      add_commit(commits, $1, $2)
-    else
-      # add lines to the message (will concatenate later to single String)
-      last.message << line.strip
-    end
-  end
-
-  # all commits since the given version number
-  def self.commits_since(last_tested = DEFAULT_REVISION)
-    commits = []
-    log_lines_since(last_tested).each { |line| process_line(commits, line) }
-    commits.sort_by(&:revision).reverse
-  end
+  attr_reader :mesa_dir, :mirror_dir, :names_to_numbers, :shell,
+              :test_case_names, :test_cases, :github_protocol
 
-  def self.last_non_paxton_revision(last_tested = DEFAULT_REVISION)
-    commits_since(last_tested).each do |commit|
-      return commit.revision unless commit.author == 'bill_paxton'
-    end
-    # give out garbage if no valid commit is found
-    nil
+  def self.checkout(sha: nil, work_dir: nil, mirror_dir: nil,
+                    github_protocol: :ssh)
+    m = Mesa.new(mesa_dir: work_dir, mirror_dir: mirror_dir,
+                 github_protocol: github_protocol)   
+    m.checkout(new_sha: sha)
+    m
   end
 
-  def initialize(mesa_dir: ENV['MESA_DIR'], use_svn: true, using_sdk: true)
+  def initialize(mesa_dir: ENV['MESA_DIR'], mirror_dir: nil,
+                 github_protocol: :ssh)
     # absolute_path ensures that it doesn't matter where commands are executed
     # from
     @mesa_dir = File.absolute_path(mesa_dir)
-    @use_svn = use_svn
-    @using_sdk = using_sdk
-    @update_checksums = false
+    @mirror_dir = File.absolute_path(mirror_dir)
+
+    # don't worry about validity of github protocol until it is needed in a
+    # checkout. This way you can have garbage in there if you never really need
+    # it.
+    @github_protocol = if github_protocol.respond_to? :to_sym
+                         github_protocol.to_sym
+                       else
+                         github_protocol
+                       end
 
     # these get populated by calling #load_test_data
-    @test_data = {}
-    @test_names = {}
     @test_cases = {}
+    @test_case_names = {}
+    @names_to_numbers = {}
 
     # way to output colored text
     @shell = Thor::Shell::Color.new
-
-    # these can be populated by calling load_svn_data
-    @svn_version = nil
-    @svn_author = nil
-    @svn_log = nil
-    load_svn_data if use_svn?
-  end
-
-  def use_svn?
-    @use_svn
   end
 
-  def determine_diff
-    # automatically determine if update_checksums should be true (don't do
-    # diffs or true (DO do diffs). Only works if svn data has ALREADY been
-    # loaded
-
-    # don't do anything to @update_checksums if we haven't loaded svn data
-    return unless @svn_log
-
-    # by default, DON'T do diffs
-    @update_checksums = true
-
-    # list of phrases, which, if present in the log entry, will trigger diffs
-    [
-      /updated? checksums?/i,
-      /checksums? updated?/i,
-      /ready for diffs?/i,
-    ].each { |trigger| @update_checksums = false if trigger =~ @svn_log }
-    if @update_checksums
-      shell.say "\nFrom svn log, didn't decide to tak diffs."
+  def checkout(new_sha: 'HEAD')
+    # before anything confirm that git-lfs has been installed
+    shell.say "\nEnsuring that git-lfs is installed... ", :blue
+    command = 'git lfs help >> /dev/null 2>&1'
+    if bash_execute(command)
+      shell.say "yes", :green
     else
-      shell.say "From svn log, automatically decided to take diffs." 
+      shell.say "no", :red
+      raise(GitHubError, "The command #{command} returned with an error "\
+                         'status, indicating that git-lfs is not installed. '\
+                         'Make sure it is installed and try again.')
+    end
+
+    # set up mirror if it doesn't exist
+    unless dir_or_symlink_exists?(mirror_dir)
+      shell.say "\nCreating initial mirror at #{mirror_dir}. "\
+                'This might take awhile...', :blue
+      FileUtils.mkdir_p mirror_dir
+      case github_protocol
+      when :ssh
+        command = "git clone --mirror #{GITHUB_SSH} #{mirror_dir}"
+        shell.say command
+        # fail loudly if this doesn't work
+        unless bash_execute(command)
+          # nuke the mirror directory since it is probably bogus (make this
+          # code fire off the next time checkout is done)
+          shell.say "Failed. Removing the [potentially corrupted] mirror.", :red
+          command = "rm -rf #{mirror_dir}"
+          shell.say command
+          bash_execute(command)
+
+          raise(GitHubError, 'Error while executing the following command:'\
+                             "#{command}. Perhaps you haven't set up ssh "\
+                             'ssh keys with your GitHub account?')
+        end
+      when :https
+        command = "git clone --mirror #{GITHUB_HTTPS} #{mirror_dir}"
+        shell.say command
+        # fail loudly if this doesn't work
+        unless bash_execute(command)
+          # nuke the mirror directory since it is probably bogus (make this
+          # code fire off the next time checkout is done)
+          shell.say "Failed. Removing the [potentially corrupted] mirror.", :red
+          command = "rm -rf #{mirror_dir}"
+          shell.say command
+          bash_execute(command)
+
+          raise(GitHubError, 'Error while executing the following command: '\
+                             "#{command}. Perhaps you need to configure "\
+                             'global GitHub account settings for https '\
+                             'authentication to work properly?')
+        end
+      else
+        raise(GitHubError, "Invalid GitHub protocol: \"#{github_protocol}\"")
+      end
     end
-    shell.say "log entry: #{@svn_log}"
-  end
 
-  def version_number
-    version = @svn_version || 0
-    # fall back to MESA_DIR/data's version number svn didn't work
-    version = data_version_number unless version > 0
-    version
+    update_mirror
+
+    # ensure "work" directory is removed from worktree
+    remove
+
+    # create "work" directory with proper commit
+    shell.say "\nSetting up worktree repo...", :blue
+    FileUtils.mkdir_p mesa_dir
+    command = "git -C #{mirror_dir} worktree add #{mesa_dir} #{new_sha}"
+    shell.say command
+    return if bash_execute(command)
+
+    raise(GitHubError, 'Failed while executing the following command: '\
+                       "\"#{command}\".")
   end
 
-  def log_entry
-    `svn log #{mesa_dir} -r #{version_number}`
+  def update_mirror
+    shell.say "\nFetching MESA history...", :blue
+    command = "git -C #{mirror_dir} fetch origin"
+    shell.say command
+    # fail loudly
+    return if bash_execute(command)
+
+    raise(GitHubError, 'Failed while executing the following command: '\
+                       "\"#{command}\".")
   end
 
-  def load_svn_data
-    # if this number is bad, #version_number will use fallback method
-    @svn_version = svn_version_number
-    lines = log_entry.split("\n").reject { |line| line =~ /^-+$/ or line.empty?}
-    data_line = lines.shift
-    revision, author, date, length = data_line.split('|')
-    @svn_author = author.strip
-    @svn_log = lines.join("\n").strip
+  def remove
+    return unless File.exist? mesa_dir
+    shell.say "\nRemoving work directory from worktree (clearing old data)...",
+              :blue
+    command = "git -C #{mirror_dir} worktree remove --force #{mesa_dir}"
+    shell.say command
+    return if bash_execute(command)
+
+    shell.say "Failed. Simply trying to remove the directory.", :red
+    command = "rm -rf #{mesa_dir}"
+    shell.say command
+    # fail loudly (the "true" tells bash_execute to raise an exception if
+    # the command fails)
+    bash_execute(command, true)
   end
 
-  # get version number from svn (preferred method)
-  def svn_version_number
-    # match output of svn info to a line with the revision, capturing the
-    # number, and defaulting to 0 if none is found.
-    matches = /Revision\:\s+(\d+)/.match(`svn info #{mesa_dir}`)
-    unless matches.nil?
-      return matches[1].to_i
-    end
-    return 0
-  rescue Errno::ENOENT
-    return 0
+  def git_sha
+    bashticks("git -C #{mesa_dir} rev-parse HEAD")
   end
 
-  # read version number from $MESA_DIR/data/version_number
-  def data_version_number
-    contents = ''
-    File.open(File.join(mesa_dir, 'data', 'version_number'), 'r') do |f|
-      contents = f.read
-    end
-    contents.strip.to_i
+  def sha
+    git_sha
   end
 
   def clean
     with_mesa_dir do
       visit_and_check mesa_dir, MesaDirError, 'E\countered a problem in ' \
                                 "running `clean` in #{mesa_dir}." do
-        puts 'MESA_DIR = ' + ENV['MESA_DIR']
-        puts './clean'
+        shell.say('MESA_DIR = ' + ENV['MESA_DIR'])
+        shell.say './clean'
         bash_execute('./clean')
       end
     end
@@ -649,8 +535,8 @@ class Mesa
     with_mesa_dir do
       visit_and_check mesa_dir, MesaDirError, 'Encountered a problem in ' \
                                 "running `install` in #{mesa_dir}." do
-        puts 'MESA_DIR = ' + ENV['MESA_DIR']
-        puts './install'
+        shell.say('MESA_DIR = ' + ENV['MESA_DIR'])
+        shell.say './install'
         bash_execute('./install')
       end
     end
@@ -661,20 +547,31 @@ class Mesa
 
   # throw an error unless it seems like it's properly compiled
   def check_installation
-    unless installed?
-      raise MesaDirError, 'Installation check failed (no .mod files found ' \
-                          'in the last compiled module).'
+    return if installed?
+
+    raise MesaDirError, 'Installation check failed (build.log doesn\'t '\
+                        'show a successful installation).'
+  end
+
+  # sourced from $MESA_DIR/testhub.yml, which should be created after
+  # installation
+  def compiler_hash
+    data_file = File.join(mesa_dir, 'testhub.yml')
+    unless File.exist? data_file
+      raise(MesaDirError, "Could not find file testhub.yml in #{mesa_dir}.")
     end
-  end    
 
-  def destroy
-    FileUtils.rm_rf mesa_dir
+    res = YAML.safe_load(File.read(data_file))
+    # currently version_number is reported, but we don't need that in Git land
+    res.delete('version_number') # returns the value, not the updated hash
+    res
   end
 
   ## TEST SUITE METHODS
 
   def check_mod(mod)
     return if MesaTestCase.modules.include? mod
+
     raise TestCaseDirError, "Invalid module: #{mod}. Must be one of: " +
                             MesaTestCase.modules.join(', ')
   end
@@ -694,53 +591,32 @@ class Mesa
       end
     else
       check_mod mod
-      # load data from the source file
-      source_lines = IO.readlines(
-        File.join(test_suite_dir(mod: mod), 'do1_test_source')
-      )
 
-      # initialize data hash to empty hash and name array to empty array
-      @test_data[mod] = {}
-      @test_names[mod] = []
+      # convert output of +list_tests+ to a dictionary that maps
+      # names to numbers since +each_test_run+ only knows about numbers
+      @names_to_numbers[mod] = {}
+      @test_case_names[mod] = []
       @test_cases[mod] = {}
-
-      # read through each line and find four data, name, success string, final
-      # model name, and photo. Either of model name and photo can be "skip"
-      source_lines.each do |line|
-        no_skip = /^do_one (.+)\s+"([^"]*)"\s+"([^"]+)"\s+(x?\d+|auto)/
-        one_skip = /^do_one (.+)\s+"([^"]*)"\s+"([^"]+)"\s+skip/
-        two_skip = /^do_one (.+)\s+"([^"]*)"\s+skip\s+skip/
-        found_test = false
-        if line =~ no_skip
-          found_test = true
-          @test_data[mod][$1] = { success_string: $2, final_model: $3,
-                                  photo: $4}
-        elsif line =~ one_skip
-          found_test = true
-          @test_data[mod][$1] = { success_string: $2, final_model: $3,
-                                  photo: nil }
-        elsif line =~ two_skip
-          found_test = true
-          @test_data[mod][$1] = { success_string: $2, final_model: nil,
-                                  photo: nil }
-        end
-
-        if found_test
-          @test_names[mod] << $1 unless @test_names[mod].include? $1
+      visit_dir(test_suite_dir(mod: mod), quiet: true) do
+        bashticks('./list_tests').split("\n").each do |line|
+          num, tc_name = line.strip.split
+          @names_to_numbers[mod][tc_name.strip] = num.to_i
+          @test_case_names[mod] << tc_name.strip
+          @test_cases[mod][tc_name.strip] = MesaTestCase.new(
+            test: tc_name.strip,
+            mod: mod,
+            position: num.to_i,
+            mesa: self
+          )
         end
       end
-
-      # make MesaTestCase objects accessible by name
-      @test_names[mod].each do |test_name|
-        data = @test_data[mod][test_name]
-        @test_cases[mod][test_name] = MesaTestCase.new(
-          test: test_name, mesa: self, success_string: data[:success_string],
-          mod: mod, final_model: data[:final_model], photo: data[:photo]
-        )
-      end
     end
   end
 
+  def test_case_count(mod: :all)
+    all_names_ordered(mod: mod).count
+  end
+
   # can accept a number (in string form) as a name for indexed access
   def find_test_case(test_case_name: nil, mod: :all)
     if /\A[0-9]+\z/ =~ test_case_name
@@ -750,44 +626,16 @@ class Mesa
     end
   end
 
-  # based off of `$MESA_DIR/star/test_suite/each_test_run_and_diff` from
-  # revision 10000
-  def each_test_clean(mod: :all)
-    if mod == :all
-      MesaTestCase.modules.each { |this_mod| each_test_clean mod: this_mod }
-    else
-      check_mod mod
-      test_names[mod].each do |test_name|
-        test_cases[mod][test_name].clean
-      end
-    end
-  end
-
-  def each_test_run_and_diff(mod: :all, log_results: false)
+  def each_test_run(mod: :all)
     check_installation
-    each_test_clean(mod: mod)
-
-    if mod == :all
-      MesaTestCase.modules.each do |this_mod|
-        each_test_run_and_diff(mod: this_mod, log_results: log_results)
-      end
-    else
-      test_names[mod].each do |test_name|
-        test_cases[mod][test_name].do_one
-        test_cases[mod][test_name].log_results if log_results
-      end
-      log_summary(mod: mod) if log_results
-    end
-  end
 
-  def each_test_load_results(mod: :all)
     if mod == :all
       MesaTestCase.modules.each do |this_mod|
-        each_test_load_results(mod: this_mod)
+        each_test_run(mod: this_mod)
       end
     else
-      test_names[mod].each do |test_name|
-        test_cases[mod][test_name].load_results
+      visit_dir(test_suite_dir(mod: mod)) do
+        bash_execute('./each_test_run')
       end
     end
   end
@@ -797,34 +645,21 @@ class Mesa
   end
 
   def installed?
-    # look for output files in the last-installed module
-    # this isn't perfect, but it's a pretty good indicator of completing
-    # installation
-    install_file = File.join(mesa_dir, 'install')
-    # match last line of things like "do_one SOME_MODULE" or "do_one_parallel 
-    # SOME_MODULE", after which the "SOME_MODULE" will be stored in $1
-    # that is the last module to be compiled by ./install.
-    IO.readlines(install_file).select do |line|
-      line =~ /^\s*do_one\w*\s+\w+/
-    end.last =~ /^\s*do_one\w*\s+(\w+)/
-    # module is "installed" if there is a nonzero number of files in the
-    # module's make directory of the form SOMETHING.mod
-    !Dir.entries(File.join(mesa_dir, $1, 'make')).select do |file|
-      File.extname(file) == '.mod'
-    end.empty?
+    # assume build log reflects installation status; does not account for
+    # mucking with modules after the fact
+    downloaded? && File.read(File.join(mesa_dir, 'build.log')).include?(
+      'MESA installation was successful'
+    )
   end
 
-
   private
 
-  # verify that mesa_dir is valid by checking for version number and test_suite
-  # directory
+  # verify that mesa_dir is valid by checking for existence of test_suite
+  # directory for each module (somewhat arbitrary)
   def check_mesa_dir
-    res = File.exist?(File.join(mesa_dir, 'data', 'version_number'))
-    MesaTestCase.modules.each do |mod|
-      res &&= dir_or_symlink_exists?(test_suite_dir(mod: mod))
+    MesaTestCase.modules.inject(true) do |res, mod|
+      res && dir_or_symlink_exists?(test_suite_dir(mod: mod))
     end
-    res
   end
 
   # change MESA_DIR for the execution of the block and then revert to the
@@ -845,49 +680,64 @@ class Mesa
     end
   end
 
-  def log_summary(mod: :all)
+  def all_names_ordered(mod: :all)
+    load_test_source_data unless @names_to_numbers
     if mod == :all
-      MesaTestCase.modules.each do |this_mod|
-        log_summary(mod: this_mod)
+      # build up list by first constructing each modules list and then
+      # concatenating them
+      MesaTestCase.modules.inject([]) do |res, this_mod|
+        res += all_names_ordered(mod: this_mod)
       end
     else
       check_mod mod
-      res = []
-      test_names[mod].each do |test_name|
-        test_case = test_cases[mod][test_name]
-        res << {
-          'test_name' => test_case.test_name,
-          'outcome' => test_case.outcome,
-          'failure_type' => test_case.failure_type,
-          'success_type' => test_case.success_type,
-          'runtime_seconds' => test_case.runtime_seconds,
-          'omp_num_threads' => test_case.test_omp_num_threads,
-          'mesa_version' => test_case.mesa_version
-        }
-      end
-      summary_file = File.join(test_suite_dir(mod: mod), 'test_summary.yml')
-      File.open(summary_file, 'w') do |f|
-        f.write(YAML.dump(res))
+      res = Array.new(@names_to_numbers[mod].length, '')
+
+      # values of the hash give their order, keys are the names, so
+      # we assign keys to positions in the array according to their value
+      @names_to_numbers[mod].each_pair do |key, val|
+        res[val - 1] = key # +list_tests+ gives 1-indexed positions
       end
+      res
     end
   end
 
   def find_test_case_by_name(test_case_name: nil, mod: :all)
+    load_test_source_data unless @names_to_numbers
     if mod == :all
-      # look through all loaded modules for desired test case name, return
-      # FIRST found (assuming no name duplication across modules)
-      @test_names.each do |this_mod, mod_names|
-        if mod_names.include? test_case_name
-          return @test_cases[this_mod][test_case_name]
+      # look through all loaded modules for desired test case name, only 
+      # return a test case if a single case is found with that name
+      case all_names_ordered.count(test_case_name)
+      when 1
+        # it exists in exactly one module, but we need to find the module
+        # and then return the +MesaTestCase+ object
+        MesaTestCase.modules.each do |this_mod|
+          if @test_case_names[this_mod].include? test_case_name
+            # found it, return the appropriate object
+            return @test_cases[this_mod][test_case_name]
+          end
         end
+        raise 'Weird problem: found test case in overall names, but '\
+          "not in any particular module. This shouldn't happen."
+      when 0
+        raise(TestCaseDirError, "Could not find test case #{test_case_name} "\
+                                'in any module.')
+      else
+        raise(TestCaseDirError, 'Found multiple test cases named '\
+          "#{test_case_name} in multiple modules. Indicate the module you "\
+          'want to search.')
       end
-      # didn't find any matches, return nil
-      nil
+      # append this array to the end of the exisitng one
     else
       # module specified; check it and return the proper test case (may be nil
       # if the test case doesn't exist)
       check_mod mod
-      @test_cases[mod][test_case_name]
+      if @test_case_names[mod].include? test_case_name
+        # happy path: test case exists in the specified module
+        return @test_cases[mod][test_case_name]
+      else
+        raise TestCaseDirError.new('Could not find test case ' \
+          "#{test_case_name} in the #{mod} module.")
+      end
     end
   end
 
@@ -895,149 +745,69 @@ class Mesa
     # this will be the index in the name array of the proper module of
     # the desired test case
     # input numbers are 1-indexed, but we'll fix that later
-    return nil if test_number < 1
-    i = test_number
+    if test_number < 1 || test_number > test_case_count(mod: mod)
+      raise TestCaseDirError.new('Invalid test case number for searching '\
+        "in module #{mod}. Must be between 1 and #{test_case_count(mod: mod)}.")
+    end
 
     if mod == :all
-      # search through each module in order
-      MesaTestCase.modules.each do |this_mod|
-        # if i is a valid index for names of this module, extract the proper
-        # test case taking into account that the given i is 1-indexed
-        if i <= @test_names[this_mod].length
-          # puts "i = #{i} <= #{@test_names[this_mod].length}"
-          # @test_names[this_mod].each_with_index do |test_name, i|
-          #   puts sprintf("%-4d", i + 1) + test_name
-          # end
-          return find_test_case_by_name(
-            test_case_name: @test_names[this_mod][i - 1],
-            mod: this_mod
+      # can get the name easily, now need to find the module
+      test_case_name = all_names_ordered[test_number - 1]
+      MesaTestCase.modules.each do |mod|
+        if test_number <= test_case_count(mod: mod)
+          # test must live in this module; we have everything
+          return MesaTestCase.new(
+            test: test_case_name,
+            mod: mod,
+            mesa: self,
+            position: @names_to_numbers[mod][test_case_name]
           )
+        else
+          # number was too big, so decrement by this modules case count
+          # and move on to next one
+          test_number -= test_case_count(mod: mod)
         end
-        # index lies outside possible range for this module, move on to
-        # next module and decrement index by the number of test cases in this
-        # module
-        i -= @test_names[this_mod].length
       end
-      # return nil if we never broke out of the loop
-      nil
+      # should return before we get here, but fail hard if we do
+      raise TestCaseDirError.new('Unknown problem in loading test case #' +
+        test_number + '.') 
     else
-      # module was specified, so just hope things work out for the number
-      # should probably add a check that the index is actually in the array,
-      # but if you're using this feature, you probably know what you're doing,
-      # right? Right?
-      return find_test_case_by_name(
-        test_case_name: @test_names[mod][i - 1],
-        mod: mod
+      # module was specified, so we can get at everything right away
+      check_mod mod
+      return MesaTestCase.new(
+        test: all_names_ordered(mod: mod)[test_number - 1],
+        mod: mod,
+        mesa: self,
+        position: test_number
       )
     end
   end
 end
 
 class MesaTestCase
-  attr_reader :test_name, :mesa_dir, :mesa, :success_string, :final_model,
-              :failure_msg, :success_msg, :photo, :runtime_seconds,
-              :test_omp_num_threads, :mesa_version, :shell, :mod, :retries,
-              :backups, :steps, :runtime_minutes, :summary_text, :compiler,
-              :compiler_version, :diff, :checksum, :rn_mem, :re_mem,
-              :re_time, :total_runtime_seconds
-  attr_accessor :data_names, :data_types, :failure_type, :success_type,
-                :outcome
+  attr_reader :test_name, :mesa, :mod, :position, :shell
 
   def self.modules
     %i[star binary astero]
   end
 
-  def initialize(test: nil, mesa: nil, success_string: '',
-                 final_model: 'final.mod', photo: nil, mod: nil)
+  def initialize(test: nil, mesa: nil, mod: nil, position: nil)
     @test_name = test
-    @mesa_dir = mesa.mesa_dir
     @mesa = mesa
-    @mesa_version = mesa.version_number
-    @success_string = success_string
-    @final_model = final_model
-    @photo = photo
-    @failure_type = nil
-    @success_type = nil
-    @outcome = :not_tested
-    @runtime_seconds = 0
-    @test_omp_num_threads = 1
-    @runtime_minutes = 0
-    @total_runtime_seconds = 0
-    @retries = 0
-    @backups = 0
-    @steps = 0
-    # 2 (default) means uknown. Updated by running or loading data.
-    # 1 means did diffs (not update_checksums; like each_test_run_and_diff)
-    # 0 means no diffs (update_checksums; like each_test_run)
-    @diff = 2
-    # start with nil. Should only be updated to a non-nil value if test is
-    # completely successful
-    @checksum = nil
-    @re_time = nil # rn_time is in the form of @runtime_seconds
-
-    # these only get used with modern versions of both the sdk and the test
-    # suite
-    @rn_mem = nil
-    @re_mem = nil
-
-    # note: this gets overridden for new runs, so this is probably irrelevant
-    @summary_text = nil
-
-    # this overrides the submitters choice if it is non-nil
-    @compiler = mesa.using_sdk ? 'SDK' : nil
-    # only relevant if @compiler is SDK. Gets set during do_one
-    @compiler_version = nil
-
     unless MesaTestCase.modules.include? mod
       raise TestCaseDirError, "Invalid module: #{mod}. Must be one of: " +
                               MesaTestCase.modules.join(', ')
     end
     @mod = mod
-    @failure_msg = {
-      run_test_string: "#{test_name} run failed: does not match test string",
-      final_model: "#{test_name} run failed: final model #{final_model} not " \
-        'made.',
-      run_checksum: "#{test_name} run failed: checksum for #{final_model} " \
-        'does not match after ./rn',
-      run_diff: "#{test_name} run failed: diff #{final_model} " \
-        'final_check.mod after ./rn',
-      photo_file: "#{test_name} restart failed: #{photo} does not exist",
-      photo_checksum: "#{test_name} restart failed: checksum for " \
-        "#{final_model} does not match after ./re",
-      photo_diff: "#{test_name} restart failed: diff #{final_model} " \
-        'final_check.mod after ./re',
-      compilation: "#{test_name} compilation failed"
+    @position = position
 
-    }
-    @success_msg = {
-      run_test_string: "#{test_name} run: found test string: " \
-        "'#{success_string}'",
-      run_checksum: "#{test_name} run: checksum for #{final_model} matches " \
-        'after ./rn',
-      photo_checksum: "#{test_name} restart: checksum for #{final_model} " \
-        "matches after ./re #{photo}"
-    }
+    # way to output colored text to shell
+    @shell = Thor::Shell::Color.new
 
     # validate stuff
     check_mesa_dir
     check_test_case
 
-    @data = {}
-    @data_names = []
-
-    # way to output colored text to shell
-    @shell = Thor::Shell::Color.new
-  end
-
-  def passed?
-    if @outcome == :pass
-      true
-    elsif @outcome == :fail
-      false
-    else
-      raise TestCaseDirError, 'Cannot determine pass/fail status of ' \
-      "#{test_name} yet."
-    end
   end
 
   def test_suite_dir
@@ -1048,214 +818,26 @@ class MesaTestCase
     File.join(test_suite_dir, test_name)
   end
 
-  def add_datum(datum_name, datum_type)
-    unless data_types.include? datum_type.to_sym
-      raise InvalidDataType, "Invalid data type: #{datum_type}. Must be one "\
-        'of ' + data_types.join(', ') + '.'
-    end
-    @data[datum_name] = datum_type
-    @data_names << datum_name
-  end
-
-  def omp_num_threads
-    ENV['OMP_NUM_THREADS'].to_i || 1
-  end
-
-  # based on $MESA_DIR/star/test_suite/each_test_clean, revision 10000
-  def clean
-    shell.say("Cleaning #{test_name}", color = :yellow)
-    # puts ''
-    check_mesa_dir
-    check_test_case
-    in_dir do
-      puts './clean'
-      unless bash_execute('./clean')
-        raise TestCaseDirError, 'Encountered an error while running ./clean ' \
-        "in #{Dir.getwd}."
-      end
-      shell.say 'Removing all files from LOGS, LOGS1, LOGS2, photos, ' \
-        'photos1, and photos2 as well as old test results', color = :blue
-      FileUtils.rm_f Dir.glob('LOGS/*')
-      FileUtils.rm_f Dir.glob('LOGS1/*')
-      FileUtils.rm_f Dir.glob('LOGS2/*')
-      FileUtils.rm_f Dir.glob('photos/*')
-      FileUtils.rm_f Dir.glob('photos1/*')
-      FileUtils.rm_f Dir.glob('photos2/*')
-
-      shell.say 'Removing files binary_history.data, out.txt, ' \
-        'test_results.yml, and memory usage files', color = :blue
-      FileUtils.rm_f 'binary_history.data'
-      FileUtils.rm_f 'out.txt'
-      FileUtils.rm_f 'test_results.yml'
-      FileUtils.rm_f Dir.glob('mem-*.txt')
-      if File.directory? File.join('star_history', 'history_out')
-        shell.say 'Removing all files of the form history_out* from ' \
-          'star_history', :blue
-        FileUtils.rm_f Dir.glob(File.join('star_history', 'history_out', '*'))
-      end
-      if File.directory? File.join('star_profile', 'profiles_out')
-        shell.say 'Removing all files of the form profiles_out* from ' \
-          'star_profile', color = :blue
-        FileUtils.rm_f Dir.glob(File.join('star_profile', 'profiles_out', '*'))
-      end
-      shell.say 'Removing .running', color = :blue
-      FileUtils.rm_f '.running'
-    end
-  end
-
-  # based on $MESA_DIR/star/test_suite/each_test_run_and_diff, revision 10000
+  # just punt to +each_test_run+ in the test_suite directory. It's your problem
+  # now, sucker!
   def do_one
     shell.say("Testing #{test_name}", :yellow)
-    # puts ''
-    test_start = Time.now
-    @test_omp_num_threads = omp_num_threads
-    if mesa.using_sdk
-      version_bin = File.join(ENV['MESASDK_ROOT'], 'bin', 'mesasdk_version')
-      # can't use bash_execute because the return value of bash_execute is the
-      # exit status of the commmand (true or false), whereas backticks give the
-      # output (the version string) as the output
-      if File.exist? version_bin
-        # newer SDKs have a simple executable
-        @compiler_version = `#{version_bin}`.strip
-      else
-        # older way, call bash on it (file is mesasdk_version.sh)
-        @compiler_version = `bash -c #{version_bin + '.sh'}`.strip
-      end
-
-      shell.say("Using version #{@compiler_version} of the SDK.", :blue)
-    end
-    in_dir do
-      FileUtils.touch '.running'
-      build_and_run
-      # report memory usage if it is available
-      if File.exist?('mem-rn.txt')
-        @rn_mem = File.read('mem-rn.txt').strip.to_i
-      end
-      if File.exist?('mem-re.txt')
-        @re_mem = File.read('mem-re.txt').strip.to_i
-      end
-      FileUtils.rm '.running'
-      puts ''
-    end
-    test_finish = Time.now
-    @total_runtime_seconds = (test_finish - test_start).to_i
-  end
-
-  def log_results
-    # gets all parameters that would be submitted as well as computer
-    # information and dumps to a yml file in the test case directory
-    save_file = File.join(test_case_dir, 'test_results.yml')
-    shell.say "Logging test results to #{save_file}...", :blue
-    res = {
-      'test_case' => test_name,
-      'module' => mod,
-      'runtime_seconds' => runtime_seconds,
-      're_time' => re_time,
-      'total_runtime_seconds' => total_runtime_seconds,
-      'mesa_version' => mesa_version,
-      'outcome' => outcome,
-      'omp_num_threads' => test_omp_num_threads,
-      'success_type' => success_type,
-      'failure_type' => failure_type,
-      'runtime_minutes' => runtime_minutes,
-      'retries' => retries,
-      'backups' => backups,
-      'steps' => steps,
-      'diff' => diff,
-      'checksum' => checksum,
-      'rn_mem' => rn_mem,
-      're_mem' => re_mem,
-      'summary_text' => summary_text
-    }
-    if compiler == 'SDK'
-      res['compiler'] = 'SDK'
-      res['compiler_version'] = compiler_version
-    end
-    File.open(save_file, 'w') { |f| f.write(YAML.dump(res)) }
-    shell.say "Successfully saved results to file #{save_file}.\n", :green
-  end
-
-  def load_results
-    # loads all parameters from a previous test run, likely for submission
-    # purposes
-    load_file = File.join(test_case_dir, 'test_results.yml')
-    shell.say "Loading data from #{load_file}...", :blue
-    unless File.exist? load_file
-      shell.say "No such file: #{load_file}. No data loaded.", :red
-      return
-    end
-    data = YAML.safe_load(File.read(load_file), [Symbol])
-    @runtime_seconds = data['runtime_seconds'] || @runtime_seconds
-    @re_time = data['re_time'] || @re_time
-    @total_runtime_seconds = data['total_runtime_seconds'] || @total_runtime_seconds
-    @mod = data['module'] || @mod
-    @mesa_version = data['mesa_version'] || @mesa_version
-    @outcome = data['outcome'] || @outcome
-    @test_omp_num_threads = data['omp_num_threads'] || @test_omp_num_threads
-    @success_type = data['success_type'] || @success_type
-    @failure_type = data['failure_type'] || @failure_type
-    @runtime_minutes = data['runtime_minutes'] || @runtime_minutes
-    @retries = data['retries'] || @retries
-    @backups = data['backups'] || @backups
-    @steps = data['steps'] || @steps
-    @diff = data['diff'] || @diff
-    @checksum = data['checksum'] || @checksum
-    @rn_mem = data['rn_mem'] || @rn_mem
-    @re_mem = data['re_mem'] || @re_mem
-    @summary_text = data['summary_text'] || @summary_text
-    @compiler = data['compiler'] || @compiler
-
-    @compiler_version = data['compiler_version'] || @compiler_version
-
-    # convert select data to symbols since that is how they are used
-    @outcome = @outcome.to_sym if @outcome
-    @success_type = @success_type.to_sym if @success_type
-    @failure_type = @failure_type.to_sym if @failure_type
-
-    shell.say "Done loading data from #{load_file}.\n", :green
-  end
-
-  def load_summary_data
-    begin
-      out_data = parse_out
-      @summary_text = get_summary_text
-    rescue Errno::ENOENT
-      shell.say "\nError loading data from #{out_file}. No summary data "\
-                'loaded. Proceeding anyway.', :red
-    else
-      @runtime_minutes = out_data[:runtime_minutes]
-      @retries = out_data[:retries]
-      @backups = out_data[:backups]
-      @steps = out_data[:steps]
+    visit_dir(test_suite_dir) do
+      bash_execute("./each_test_run #{position}")
     end
   end
 
-  def parse_out
-    runtime_minutes = 0
-    retries = 0
-    backups = 0
-    steps = 0
-    run_summaries.each do |summary|
-      summary =~ /^\s*runtime\s*\(minutes\),\s+retries,\s+backups,\ssteps\s+(\d+\.?\d*)\s+(\d+)\s+(\d+)\s+(\d+)\s*$/
-      runtime_minutes += $1.to_f
-      retries += $2.to_i
-      backups += $3.to_i
-      steps += $4.to_i
+  def results_hash
+    testhub_file = File.join(test_case_dir, 'testhub.yml')
+    unless File.exist?(testhub_file)
+      raise TestCaseDirError.new('No results found for test case '\
+                                 "#{test_name}.")
     end
-    {runtime_minutes: runtime_minutes, retries: retries, backups: backups,
-     steps: steps}
+    YAML.safe_load(File.read(testhub_file), [Symbol])
   end
 
   private
 
-  def data_types
-    %i[float integer string boolean]
-  end
-
-  def rn_time
-    runtime_seconds
-  end
-
   # cd into the test case directory, do something in a block, then cd back
   # to original directory
   def in_dir(&block)
@@ -1269,328 +851,10 @@ class MesaTestCase
     raise TestCaseDirError, "No such test case: #{test_case_dir}."
   end
 
-  # verify that mesa_dir is valid by checking for version number and test_suite
-  # directory
+  # "verify" that mesa_dir is valid by checking for test_suite directory
   def check_mesa_dir
-    is_valid = File.exist?(File.join(mesa_dir, 'data', 'version_number')) &&
-               dir_or_symlink_exists?(test_suite_dir)
-    raise MesaDirError, "Invalid MESA dir: #{mesa_dir}" unless is_valid
-  end
-
-  # append message to log file
-  def log_message(msg, color = nil, log_file = 'out.txt')
-    if color.nil?
-      shell.say(msg)
-    else
-      shell.say(msg, color)
-    end
-    File.open(log_file, 'a') { |f| f.puts(msg) }
-  end
-
-  # write failure message to log file
-  def write_failure_message
-    msg = "******************** #{failure_msg[@failure_type]} " \
-      '********************'
-    log_message(msg, :red)
-  end
-
-  # write success message to log file
-  def write_success_msg(success_type)
-    msg = 'PASS ' + success_msg[success_type]
-    log_message(msg, :green)
-  end
-
-  # used as return value for run or photo test. Logs failure to text file, and
-  # sets internal status to failing
-  def fail_test(failure_type)
-    @failure_type = failure_type
-    @outcome = :fail
-    write_failure_message
-    false
-  end
-
-  # used as return value for run or photo test. Logs data to text file, and
-  # sets internal status to passing
-  def succeed(success_type)
-    @success_type = success_type
-    @outcome = :pass
-    # this should ONLY be read after we are certain we've passed AND that we
-    # even have a newly-made checksum
-    if File.exist?('checks.md5') && @mesa.update_checksums
-      # sometimes we want to ignore the final checksum value
-      # we still want to check that restarts on individual machines are bit-for-bit
-      # but we don't require bit-for-bit globally, so we report a bogus checksum
-      if File.exist?('.ignore_checksum') then
-        @checksum ='00000000000000000000000000000000'
-      else
-        @checksum = File.read('checks.md5').split.first
-      end
-    end
-    write_success_msg(success_type)
-    true
-  end
-
-  def check_run
-    # assumes we are in the directory already, called from something else
-    run_start = Time.now
-
-    # do the run
-    rn_command = if ENV['MESASDK_ROOT'] && File.exist?(File.join(ENV['MESASDK_ROOT'], 'bin', 'time'))
-                   %q(command time -f '%M' -o mem-rn.txt ./rn > out.txt 2> ) +
-                     'err.txt'
-                 else
-                   './rn >> out.txt 2> err.txt'
-                 end
-    puts rn_command
-    bash_execute(rn_command)
-
-    # report runtime and clean up
-    run_finish = Time.now
-    @runtime_seconds = (run_finish - run_start).to_i
-    @rn_time = (run_finish - run_start).to_i
-    shell.say("Finished with ./rn; runtime = #{@runtime_seconds} seconds.",
-              :blue)
-    append_and_rm_err
-
-    # look for success text
-    success = true
-    File.open('out.txt', 'r') do |f|
-      success = !f.read.downcase.scan(success_string.downcase).empty?
-    end
-    # bail if there was no test string found
-    return fail_test(:run_test_string) unless success
-
-    # no final model to check, and we already found the test string, so pass
-    return succeed(:run_test_string) unless final_model
-
-    # display runtime message
-    puts IO.readlines('out.txt').select { |line| line.scan(/runtime/i) }[-1]
-
-    # there's supposed to be a final model; check that it exists first
-    return fail_test(:final_model) unless File.exist?(final_model)
-
-    # update checksums
-    #
-    # if this is true, behave like each_test_run.  update the checksum
-    # after rn and then check it matches after re
-    #
-    # if this is false, behave like each_test_run_and_diff.  assume
-    # the checksum is up-to-date and check it matches after rn and re.
-    if @mesa.update_checksums
-      @diff = 0  # this means no diffs run
-      puts "md5sum \"#{final_model}\" > checks.md5"
-      bash_execute("md5sum \"#{final_model}\" > checks.md5")
-      FileUtils.cp final_model, 'final_check.mod'
-
-      # if there's no photo, we won't check the checksum, so we've succeeded
-      return succeed(:run_test_string) unless photo
-      # if there is a photo, we'll have to wait and see
-      return true
-    end
-
-    # check that final model matches
-    @diff = 1  # this means diffs were run
-    puts './ck >& final_check_diff.txt'
-    return fail_test(:run_checksum) unless
-      bash_execute('./ck >& final_check_diff.txt')
-    return fail_test(:run_diff) if File.exist?('final_check_diff.txt') &&
-                                   !File.read('final_check_diff.txt').empty?
-    return succeed(:run_checksum) if File.exist? final_model
-  end
-
-  # prepare for and do restart, check results, and return pass/fail status
-  def check_restart
-    # abort if there is not photo specified
-    return unless photo
-
-    # get antepenultimate photo
-    if photo == "auto" then
-      # get all photos [single-star (x100) or binary (b_x100); exclude binary stars (1_x100, 2_x100)]
-      photo_files = Dir["photos/*"].select{|p| p =~ /^photos\/(b_)?x?\d+$/}
-      # sort by filesystem modification time
-      sorted_photo_files = photo_files.sort_by { |file_name| File.stat(file_name).mtime }
-      # if you can, pull out 3rd most recent one; otherwise take the oldest
-      if sorted_photo_files.length >= 3 then
-        re_photo = File.basename(sorted_photo_files[-3])
-      else
-        re_photo = File.basename(sorted_photo_files[0])
-      end
-      # if binary, trim off prefix
-      re_photo = re_photo.sub("b_", "")
-    else
-      re_photo = photo
-    end
-
-    # check that photo file actually exists
-    unless File.exist?(File.join('photos', re_photo)) ||
-           File.exist?(File.join('photos1', re_photo)) ||
-           File.exist?(File.join('photos', "b_#{re_photo}"))
-      return fail_test(:photo_file)
-    end
-
-    # remove final model since it will be remade by restart
-    FileUtils.rm_f final_model
-
-    # do restart and consolidate output. Command depends on if we have access
-    # to SDK version of gnu time.
-    re_command = if ENV['MESASDK_ROOT'] && File.exist?(File.join(ENV['MESASDK_ROOT'], 'bin', 'time'))
-                   %q(command time -f '%M' -o mem-re.txt ./re ) + "#{re_photo}" \
-                     ' >> out.txt 2> err.txt'
-                 else
-                   "./re #{re_photo} >> out.txt 2> err.txt"
-                 end
-
-    puts re_command
-    # puts "./re #{re_photo} >> out.txt 2> err.txt"
-    re_start = Time.now
-    # bash_execute("./re #{re_photo} >> out.txt 2> err.txt")
-    # bash_execute(%Q{command time -f '%M' -o mem-re.txt ./re #{re_photo} >> out.txt 2> err.txt})
-    bash_execute(re_command)
-    re_finish = Time.now
-    @re_time = (re_finish - re_start).to_i
-    append_and_rm_err
-
-    # check that final model matches
-    puts './ck >& final_check_diff.txt'
-    return fail_test(:photo_checksum) unless
-      bash_execute('./ck >& final_check_diff.txt')
-    return fail_test(:photo_diff) if
-      File.exist?('final_check_diff.txt') &&
-      !File.read('final_check_diff.txt').empty?
-    succeed(:photo_checksum)
-  end
-
-  def build_and_run
-    # assumes we are in the test case directory. Should only be called
-    # in the context of an `in_dir` block.
-
-    # first clean and make... Should be compatible with any shell since
-    # redirection is always wrapped in 'bash -c "{STUFF}"'
-    simple_clean
-    begin
-      mk
-    rescue TestCaseDirError
-      return fail_test(:compilation)
-    end
-
-    # remove old final model if it exists
-    remove_final_model
-
-    # only check restart/photo if we get through run successfully
-    check_restart if check_run
-
-    # get reported runtime, retries, backups, and steps
-    load_summary_data if File.exist?(out_file)
-  end
-
-  # append contents of err.txt to end of out.txt, then delete err.txt
-  def append_and_rm_err(outfile = 'out.txt', errfile = 'err.txt')
-    err_contents = File.read(errfile)
-    display_errors(err_contents)
-    log_errors(err_contents, outfile)
-    FileUtils.rm errfile
-  end
-
-  def display_errors(err_contents)
-    return if err_contents.strip.empty?
-    shell.say("\nERRORS", :red)
-    puts err_contents
-    shell.say('END OF ERRORS', :red)
-  end
-
-  def log_errors(err_contents, outfile)
-    return if err_contents.strip.empty?
-    File.open(outfile, 'a') { |f_out| f_out.write(err_contents) }
-    shell.say("appended to #{outfile}\n", :red)
-  end
-
-  def simple_clean
-    puts './clean'
-    return if bash_execute('./clean')
-    raise TestCaseDirError, 'Encountered an error when running `clean` in ' \
-      "#{Dir.getwd} for test case #{test_name}."
-  end
-
-  def mk
-    puts './mk > mk.txt'
-    unless bash_execute('./mk > mk.txt')
-      raise TestCaseDirError, 'Encountered an error when running `mk` in ' \
-        "#{Dir.getwd} for test case #{test_name}."
-    end
-    FileUtils.rm 'mk.txt'
-  end
-
-  def remove_final_model
-    # remove final model if it already exists
-    return unless final_model
-    return unless File.exist?(final_model)
-    FileUtils.rm(final_model)
-  end
-
-  def out_file
-    File.join(test_case_dir, 'out.txt')
-  end
-
-  # helpers for getting run summaries
-  def run_summaries
-    # look at all lines in out.txt
-    lines = IO.readlines(out_file)
-
-    # find lines with summary information
-    summary_line_numbers = []
-    lines.each_with_index do |line, i|
-      if line =~ /^\s*runtime \(minutes\),\s+retries,\s+backups,\ssteps/
-        summary_line_numbers << i
-      end
-    end
-
-    # find lines indicating passage or failure of runs and restarts
-    run_finish_line_numbers = []
-    restart_finish_line_numbers = []
-    lines.each_with_index do |line, i|
-      if line =~ /^\s*((?:PASS)|(?:FAIL))\s+#{test_name}\s+restart/
-        restart_finish_line_numbers << i
-      elsif line =~ /^\s*((?:PASS)|(?:FAIL))\s+#{test_name}\s+run/
-        run_finish_line_numbers << i
-      end
-    end
-
-    # only keep summaries that correspond to runs rather than restart
-    summary_line_numbers.select do |i|
-      run_summary?(i, run_finish_line_numbers, restart_finish_line_numbers)
-    end.map { |line_number| lines[line_number] }
-  end
-
-  def get_summary_text
-    # original plan was to include diff data in summary text... now it's just
-    # part of the test_instance object and is submitted as an integer
-    # res = case diff
-    #       when 0
-    #         "No Diff\n"
-    #       when 1
-    #         "Diff\n"
-    #       else
-    #         "Ambiguous Diff\n"
-    #       end
-    # res +
-    IO.readlines(out_file).select do |line|
-      line =~ /^\s*runtime/ 
-    end.join
-  end
-
-  def run_summary?(i, run_finish_line_numbers, restart_finish_line_numbers)
-    # iterate from starting line (a summary line) up to largest PASS/FAIL
-    # line, bail out if summary line is beyond any PASS/FAIL line
-    max_line = run_finish_line_numbers.max || 0
-    max_line = [max_line, (restart_finish_line_numbers.max || 0)].max
-    return false if i > max_line
-    # return true if next PASS/FAIL line is for a run and fail if it is for a
-    # restart
-    i.upto(max_line) do |j|
-      return true if run_finish_line_numbers.include?(j)
-      return false if restart_finish_line_numbers.include?(j)
-    end
-    false
+    is_valid =  dir_or_symlink_exists? test_suite_dir
+    raise MesaDirError, "Invalid MESA dir: #{mesa.mesa_dir}" unless is_valid
   end
 
 end
@@ -1605,13 +869,11 @@ end
 def visit_and_check(new_dir, exception, message)
   cwd = Dir.getwd
   shell.say "Leaving  #{cwd}", :blue
-  puts ''
-  shell.say "Entering #{new_dir}.", :blue
+  shell.say "\nEntering #{new_dir}.", :blue
   Dir.chdir(new_dir)
   success = yield if block_given?
   shell.say "Leaving  #{new_dir}", :blue
-  puts ''
-  shell.say "Entering #{cwd}.", :blue
+  shell.say "\nEntering #{cwd}.", :blue
   Dir.chdir(cwd)
   return if success
   raise exception, message
@@ -1619,18 +881,18 @@ end
 
 # cd into a new directory, execute a block, then cd back into original
 # directory
-def visit_dir(new_dir)
+def visit_dir(new_dir, quiet: false)
   cwd = Dir.getwd
-  shell.say "Leaving  #{cwd}\n", :blue
-  shell.say "Entering #{new_dir}.", :blue
+  shell.say "Leaving  #{cwd}\n", :blue unless quiet
+  shell.say "\nEntering #{new_dir}.", :blue unless quiet
   Dir.chdir(new_dir)
   yield if block_given?
-  shell.say "Leaving  #{new_dir}\n", :blue
-  shell.say "Re-entering #{cwd}.", :blue
-  puts ""
+  shell.say "Leaving  #{new_dir}\n", :blue unless quiet
+  shell.say "\nRe-entering #{cwd}.", :blue unless quiet
   Dir.chdir(cwd)
 end
 
+# the next function probalby doesn't belong here, but keep it anyway, please
 # create seed data for test cases for MesaTestHub of a given mesa version
 def generate_seeds_rb(mesa_dir, outfile)
   m = Mesa.new(mesa_dir: mesa_dir)
@@ -1641,7 +903,6 @@ def generate_seeds_rb(mesa_dir, outfile)
     m.test_names.each do |test_case_name|
       f.puts '    {'
       f.puts "      name: '#{test_case_name}',"
-      f.puts "      version_added: #{m.version_number},"
       # no comma on last one
       if test_case_name == m.test_names[-1]
         f.puts('    }')
@@ -1654,12 +915,22 @@ def generate_seeds_rb(mesa_dir, outfile)
   end
 end
 
-# Check if path is directory or symlink
 def dir_or_symlink_exists?(path)
-  File.directory?(path) || File.symlink?(path)
+   File.directory?(path) || File.symlink?(path)
 end
 
 # force the execution to happen with bash
-def bash_execute(command)
-  system('bash -c "' + command + '"')
+def bash_execute(command, throw_exception=false)
+  res = system('bash -c "' + command + '"')
+  if !res && throw_exception
+    raise BashError('Encountered an error when executing the following '\
+      "command in bash: #{command}.")
+  end
+  res
+end
+
+# force execution to happen with bash, but return result rather than exit
+# status (like backticks)
+def bashticks(command)
+  `bash -c "#{command}"`.chomp
 end