heroku_hatchet 7.2.0 → 7.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2dd4a304828fca43576fed5a71b7be305142c3220c7dd020bff44b17a4a070a0
-  data.tar.gz: c0dee0a8ffb794f10a3dbb96beeafa26dd5f95b489eb9638a40bf408dce44c11
+  metadata.gz: f133f985be889073e9f62caf69e73e05373eecaed11cb13a209fe6bd80874f1c
+  data.tar.gz: 910dd76398351f6ecf19e6a882b7652fe531e6a19843fa64d3f5e57ef5e68696
 SHA512:
-  metadata.gz: f6fa0cef6167e9b4985b08f01e42f33410632d4dfb083551d2641e7009745a079044f606cc4456ed8b8f0dfb0ec087b9b3197d1dabb9a0c41cd7f96ee978e22c
-  data.tar.gz: 50689c87372d4df2fc7d354ccc0f6f870285283869a190f3272f76d0d238e2d3cd13ca485ca6436916a6976c847fbd2be057fbe4e99ed1aa8ac97abdfef9eeb9
+  metadata.gz: 952b664cbb78a6b7250f98a3532a5754bf3fe16526ef915594504d6c9ee77ddf97ac204ab9438d3223da33f431c27e335c9495c86c74baeb69db45fd22682f63
+  data.tar.gz: e282d36a9196b74f9999c7c7b57ae55cd1da508f09187058baf92fa711800e882c806299f472ac06cceda88cfe2eba63b3e7eb67c0ac0e657436fc1c207f0e02

data/CHANGELOG.md

@@ -1,6 +1,26 @@
 ## HEAD
 
-## 7.1.4
+## 7.3.0
+
+- Deprecations
+  - Deprecation: Calling `App#before_deploy` as a way to clear/replace the existing block should now be done with `App#before_deploy(:replace)` (https://github.com/heroku/hatchet/pull/126)
+  - Deprecation: HATCHET_BUILDPACK_BASE default (https://github.com/heroku/hatchet/pull/133)
+  - Deprecation: App#directory (https://github.com/heroku/hatchet/pull/135)
+
+- Flappy test improvements
+  - Increase CI timeout limit to 900 seconds (15 minutes) (https://github.com/heroku/hatchet/pull/137)
+  - Empty string returns from App#run now trigger retries (https://github.com/heroku/hatchet/pull/132)
+  - Rescue 403 on pipeline delete (https://github.com/heroku/hatchet/pull/130)
+  - Additional rate throttle cases handled (https://github.com/heroku/hatchet/pull/128)
+
+- Usability
+  - Annotate rspec expectation failures inside of deploy blocks with hatchet debug information (https://github.com/heroku/hatchet/pull/136)
+  - Hatchet#new raises a helpful error when no source code location is provided (https://github.com/heroku/hatchet/pull/134)
+  - Lazy evaluation of HATCHET_BUILDPACK_BASE env var (https://github.com/heroku/hatchet/pull/133)
+  - Allow multiple `App#before_deploy` blocks to be set and called (https://github.com/heroku/hatchet/pull/126)
+  - Performance improvement when running without an explicit HEROKU_API_KEY set (https://github.com/heroku/hatchet/pull/128)
+
+## 7.2.0
 
 - App#setup! no longer modifies files on disk. (https://github.com/heroku/hatchet/pull/125)
 - Add `$ hatchet init` command for bootstrapping new projects (https://github.com/heroku/hatchet/pull/123)

data/README.md

@@ -525,7 +525,7 @@ end
 
 In this example, the app would use the nodejs buildpack, and then `:default` gets replaced by your Git url and branch name.
 
-- before_deploy (Block): Instead of using the `tap` syntax you can provide a block directly to hatchet app initialization:
+- before_deploy (Block): Instead of using the `tap` syntax you can provide a block directly to hatchet app initialization. Example:
 
 ```ruby
 Hatchet::Runner.new("default_ruby", before_deploy: ->{ FileUtils.touch("foo.txt")}).deploy do
@@ -630,6 +630,23 @@ Hatchet::Runner.new("default_ruby", before_deploy: before_deploy_proc).deploy do
 end
 ```
 
+You can call multiple blocks by specifying (`:prepend` or `:append`):
+
+```ruby
+Hatchet::Runner.new("default_ruby").tap do |app|
+  app.before_deploy do
+    FileUtils.touch("foo.txt")
+  end
+
+  app.before_deploy(:append) do
+    FileUtils.touch("bar.txt")
+  end
+  app.deploy do
+  end
+end
+```
+
+
 - `app.commit!`: Will updates the contents of your local git dir if you've modified files on disk
 
 ```ruby
@@ -660,7 +677,7 @@ end
 > Note: If you want to execute tests in this temp directory, you likely want to use `in_directory_fork` otherwise, you might accidentally contaminate the current environment's variables if you modify them.
 
 - `app.in_directory_fork`: Runs the given block in a temp directory and inside of a forked process, an example given above.
-- `app.directory`: Returns the directory of the example application on disk, this is NOT the temp directory that you're currently executing against. It's probably not what you want.
+- `app.original_source_code_directory`: Returns the directory of the example application on disk, this is NOT the temp directory that you're currently executing against. It's probably not what you want.
 - `app.deploy`: Your main method takes a block to execute after the deploy is successful. If no block is provided, you must manually call `app.teardown!` (see below for an example).
 - `app.output`: The output contents of the deploy
 - `app.platform_api`: Returns an instance of the [platform-api Heroku client](https://github.com/heroku/platform-api). If Hatchet doesn't give you access to a part of Heroku that you need, you can likely do it with the platform-api client.

data/lib/hatchet.rb

@@ -19,6 +19,7 @@ require 'hatchet/git_app'
 require 'hatchet/config'
 require 'hatchet/api_rate_limit'
 require 'hatchet/init_project'
+require 'hatchet/heroku_run'
 
 module Hatchet
   RETRIES = Integer(ENV['HATCHET_RETRIES']   || 1)

data/lib/hatchet/app.rb

@@ -5,11 +5,15 @@ require 'tmpdir'
 
 module Hatchet
   class App
-    HATCHET_BUILDPACK_BASE   = (ENV['HATCHET_BUILDPACK_BASE'] || "https://github.com/heroku/heroku-buildpack-ruby.git")
+    HATCHET_BUILDPACK_BASE = -> {
+      ENV.fetch('HATCHET_BUILDPACK_BASE') {
+        warn "ENV HATCHET_BUILDPACK_BASE is not set. It currently defaults to the ruby buildpack. In the future this env var will be required"
+        "https://github.com/heroku/heroku-buildpack-ruby.git"
+      }
+    }
     HATCHET_BUILDPACK_BRANCH = -> { ENV['HATCHET_BUILDPACK_BRANCH'] || ENV['HEROKU_TEST_RUN_BRANCH'] || Hatchet.git_branch }
-    BUILDPACK_URL = "https://github.com/heroku/heroku-buildpack-ruby.git"
 
-    attr_reader :name, :stack, :directory, :repo_name, :app_config, :buildpacks, :reaper, :max_retries_count
+    attr_reader :name, :stack, :repo_name, :app_config, :buildpacks, :reaper, :max_retries_count
 
     class FailedDeploy < StandardError; end
 
@@ -18,7 +22,7 @@ module Hatchet
 
       def initialize(app, message, output: )
         @output = output
-        msg = "Could not deploy '#{app.name}' (#{app.repo_name}) using '#{app.class}' at path: '#{app.directory}'\n"
+        msg = "Could not deploy '#{app.name}' (#{app.repo_name}) using '#{app.class}' at path: '#{app.original_source_code_directory}'\n"
         msg << "if this was expected add `allow_failure: true` to your deploy hash.\n"
         msg << "#{message}\n"
         msg << "output:\n"
@@ -32,7 +36,7 @@ module Hatchet
 
       def initialize(app, message, output: )
         @output = output
-        msg = "Could not release '#{app.name}' (#{app.repo_name}) using '#{app.class}' at path: '#{app.directory}'\n"
+        msg = "Could not release '#{app.name}' (#{app.repo_name}) using '#{app.class}' at path: '#{app.original_source_code_directory}'\n"
         msg << "if this was expected add `allow_failure: true` to your deploy hash.\n"
         msg << "#{message}\n"
         msg << "output:\n"
@@ -42,8 +46,9 @@ module Hatchet
     end
 
     SkipDefaultOption = Object.new
+    DEFAULT_REPO_NAME = Object.new
 
-    def initialize(repo_name,
+    def initialize(repo_name = DEFAULT_REPO_NAME,
                    stack: "",
                    name: default_name,
                    debug: nil,
@@ -58,6 +63,7 @@ module Hatchet
                    retries: RETRIES,
                    config: {}
                   )
+      raise "You tried creating a Hatchet::App instance without source code, pass in a path to an app to deploy or the name of an app in your hatchet.json" if repo_name == DEFAULT_REPO_NAME
       @repo_name     = repo_name
       @directory     = self.config.path_for_name(@repo_name)
       @name          = name
@@ -78,13 +84,36 @@ module Hatchet
       @already_in_dir = nil
       @app_is_setup = nil
 
-      @before_deploy = before_deploy
+      @before_deploy_array = []
+      @before_deploy_array << before_deploy if before_deploy
       @app_config    = config
       @reaper        = Reaper.new(api_rate_limit: api_rate_limit)
     end
 
+    private def test_failure_classes
+      class_array = []
+      class_array << RSpec::Expectations::ExpectationNotMetError if defined?(RSpec::Expectations::ExpectationNotMetError)
+      class_array
+    end
+
+    def annotate_failures
+      yield
+    rescue *test_failure_classes => e
+      raise e, "App: #{name} (#{@repo_name})\n#{e.message}"
+    end
+
+    def directory
+      warn "Calling App#directory returns the original location of the app's source code that should not be modified, if this is really what you want use `original_source_code_directory` instead."
+      warn caller
+      @directory
+    end
+
+    def original_source_code_directory
+      @directory
+    end
+
     def self.default_buildpack
-      [HATCHET_BUILDPACK_BASE, HATCHET_BUILDPACK_BRANCH.call].join("#")
+      [HATCHET_BUILDPACK_BASE.call, HATCHET_BUILDPACK_BRANCH.call].join("#")
     end
 
     def allow_failure?
@@ -157,32 +186,17 @@ module Hatchet
         command = command.to_s
       end
 
-      heroku_command = build_heroku_command(command, options)
-
       allow_run_multi! if @run_multi
 
-      output = ""
-
-      ShellThrottle.new(platform_api: @platform_api).call do |throttle|
-        output = `#{heroku_command}`
-        throw(:throttle) if output.match?(/reached the API rate limit/)
-      end
-
-      return output
-    end
-
-    private def build_heroku_command(command, options = {})
-      command = command.shellescape unless options.delete(:raw)
-
-      default_options = { "app" => name, "exit-code" => nil }
-      heroku_options = (default_options.merge(options.delete(:heroku) || {})).map do |k,v|
-        next if v == Hatchet::App::SkipDefaultOption # for forcefully removing e.g. --exit-code, a user can pass this
-        arg = "--#{k.to_s.shellescape}"
-        arg << "=#{v.to_s.shellescape}" unless v.nil? # nil means we include the option without an argument
-        arg
-      end.join(" ")
+      run_obj = Hatchet::HerokuRun.new(
+        command,
+        app: self,
+        retry_on_empty: options.fetch(:retry_on_empty, !ENV["HATCHET_DISABLE_EMPTY_RUN_RETRY"]),
+        heroku: options[:heroku],
+        raw: options[:raw]
+      ).call
 
-      "heroku run #{heroku_options} -- #{command}"
+      return run_obj.output
     end
 
     private def allow_run_multi!
@@ -191,7 +205,6 @@ module Hatchet
       @run_multi_is_setup ||= platform_api.formation.update(name, "web", {"size" => "Standard-1X"})
     end
 
-
     # Allows multiple commands to be run concurrently in the background.
     #
     # WARNING! Using the feature requres that the underlying app is not on the "free" Heroku
@@ -229,23 +242,15 @@ module Hatchet
       allow_run_multi!
 
       run_thread = Thread.new do
-        heroku_command = build_heroku_command(command, options)
-
-        out = nil
-        status = nil
-        ShellThrottle.new(platform_api: @platform_api).call do |throttle|
-          out = `#{heroku_command}`
-          throw(:throttle) if output.match?(/reached the API rate limit/)
-          status = $?
-        end
-
-        yield out, status
-
-        # if block.arity == 1
-        #   block.call(out)
-        # else
-        #   block.call(out, status)
-        # end
+        run_obj = Hatchet::HerokuRun.new(
+          command,
+          app: self,
+          retry_on_empty: options.fetch(:retry_on_empty, !ENV["HATCHET_DISABLE_EMPTY_RUN_RETRY"]),
+          heroku: options[:heroku],
+          raw: options[:raw]
+        ).call
+
+        yield run_obj.output, run_obj.status
       end
       run_thread.abort_on_exception = true
 
@@ -318,9 +323,25 @@ module Hatchet
       end
     end
 
-    def before_deploy(&block)
+    def before_deploy(behavior = :default, &block)
       raise "block required" unless block
-      @before_deploy = block
+
+      case behavior
+      when :default, :replace
+        if @before_deploy_array.any? && behavior == :default
+          STDERR.puts "Calling App#before_deploy multiple times will overwrite the contents. If you intended this: use `App#before_deploy(:replace)`"
+          STDERR.puts "In the future, calling this method with no arguements will default to `App#before_deploy(:append)` behavior.\n#{caller.join("\n")}"
+        end
+
+        @before_deploy_array.clear
+        @before_deploy_array << block
+      when :prepend
+        @before_deploy_array = [block] + @before_deploy_array
+      when :append
+        @before_deploy_array << block
+      else
+        raise "Unrecognized behavior: #{behavior.inspect}, valid inputs are :append, :prepend, and :replace"
+      end
 
       self
     end
@@ -346,14 +367,14 @@ module Hatchet
       @reaper.cycle if @app_is_setup
     end
 
-    def in_directory(directory = self.directory)
-      yield directory and return if @already_in_dir
+    def in_directory
+      yield and return if @already_in_dir
 
       Dir.mktmpdir do |tmpdir|
-        FileUtils.cp_r("#{directory}/.", "#{tmpdir}/.")
+        FileUtils.cp_r("#{original_source_code_directory}/.", "#{tmpdir}/.")
         Dir.chdir(tmpdir) do
           @already_in_dir = true
-          yield directory
+          yield
           @already_in_dir = false
         end
       end
@@ -387,9 +408,11 @@ module Hatchet
 
     def deploy(&block)
       in_directory do
-        in_dir_setup!
-        self.push_with_retry!
-        block.call(self, api_rate_limit.call, output) if block_given?
+        annotate_failures do
+          in_dir_setup!
+          self.push_with_retry!
+          block.call(self, api_rate_limit.call, output) if block_given?
+        end
       end
     ensure
       self.teardown! if block_given?
@@ -423,21 +446,21 @@ module Hatchet
     end
 
     def api_key
-      @api_key ||= ENV['HEROKU_API_KEY'] || `heroku auth:token`.chomp
+      @api_key ||= ENV['HEROKU_API_KEY'] ||= `heroku auth:token`.chomp
     end
 
     def heroku
       raise "Not supported, use `platform_api` instead."
     end
 
-    def run_ci(timeout: 300, &block)
+    def run_ci(timeout: 900, &block)
       in_directory do
         max_retries_count.times.retry do
           result       = create_pipeline
           @pipeline_id = result["id"]
         end
 
-        # when the CI run finishes, the associated ephemeral app created for the test run internally gets removed almost immediately
+        # When the CI run finishes, the associated ephemeral app created for the test run internally gets removed almost immediately
         # the system then sees a pipeline with no apps, and deletes it, also almost immediately
         # that would, with bad timing, mean our test run info poll in wait! would 403, and/or the delete_pipeline at the end
         # that's why we create an app explictly (or maybe it already exists), and then associate it with with the pipeline
@@ -495,6 +518,9 @@ module Hatchet
 
     def delete_pipeline(pipeline_id)
       api_rate_limit.call.pipeline.delete(pipeline_id)
+    rescue Excon::Error::Forbidden
+      warn "Error deleting pipeline id: #{pipeline_id.inspect}, status: 403"
+      # Means the pipeline likely doesn't exist, not sure why though
     end
 
     def platform_api
@@ -534,14 +560,17 @@ module Hatchet
     end
 
     private def call_before_deploy
-      return unless @before_deploy
-      raise "before_deploy: #{@before_deploy.inspect} must respond to :call"  unless @before_deploy.respond_to?(:call)
-      raise "before_deploy: #{@before_deploy.inspect} must respond to :arity" unless @before_deploy.respond_to?(:arity)
+      return unless @before_deploy_array.any?
 
-      if @before_deploy.arity == 1
-        @before_deploy.call(self)
-      else
-        @before_deploy.call
+      @before_deploy_array.each do |block|
+        raise "before_deploy: #{block.inspect} must respond to :call"  unless block.respond_to?(:call)
+        raise "before_deploy: #{block.inspect} must respond to :arity" unless block.respond_to?(:arity)
+
+        if block.arity == 1
+          block.call(self)
+        else
+          block.call
+        end
       end
 
       commit! if needs_commit?

data/lib/hatchet/git_app.rb

@@ -5,25 +5,28 @@ module Hatchet
       "https://git.heroku.com/#{name}.git"
     end
 
-
     def push_without_retry!
       output = ""
 
       ShellThrottle.new(platform_api: @platform_api).call do
         output = git_push_heroku_yall
       rescue FailedDeploy => e
-        if e.output.match?(/reached the API rate limit/)
+        case e.output
+        when /reached the API rate limit/, /429 Too Many Requests/
           throw(:throttle)
-        elsif @allow_failure
-          output = e.output
         else
-          raise e
+          raise e unless @allow_failure
+          output = e.output
         end
       end
 
       return output
     end
 
+    def releases
+      platform_api.release.list(name)
+    end
+
     private def git_push_heroku_yall
       output = `git push #{git_repo} HEAD:main 2>&1`
 
@@ -31,7 +34,6 @@ module Hatchet
         raise FailedDeployError.new(self, "Buildpack: #{@buildpack.inspect}\nRepo: #{git_repo}", output: output)
       end
 
-      releases = platform_api.release.list(name)
       if releases.last["status"] == "failed"
         commit! # An empty commit allows us to deploy again
         raise FailedReleaseError.new(self, "Buildpack: #{@buildpack.inspect}\nRepo: #{git_repo}", output: output)

data/lib/hatchet/heroku_run.rb

@@ -0,0 +1,96 @@
+module Hatchet
+  # Used for running Heroku commands
+  #
+  # Example:
+  #
+  #   run_obj = HerokuRun.new("ruby -v", app: app).call
+  #   puts run_obj.output #=> "ruby 2.7.1p83 (2020-03-31 revision a0c7c23c9c) [x86_64-linux]"
+  #   puts run_obj.status.success? #=> true
+  #
+  # There's a bug in specs sometimes where App#run will return an empty
+  # value. When that's detected then the command will be re-run. This can be
+  # optionally disabled by setting `retry_on_empty: false` if you're expecting
+  # the command to be empty.
+  #
+  class HerokuRun
+    attr_reader :command
+
+    def initialize(
+      command,
+      app: ,
+      heroku: {},
+      retry_on_empty: !ENV["HATCHET_DISABLE_EMPTY_RUN_RETRY"],
+      raw: false,
+      stderr: $stderr)
+
+      @raw = raw
+      @app = app
+      @command = build_heroku_command(command, heroku || {})
+      @retry_on_empty = retry_on_empty
+      @stderr = stderr
+      @output = ""
+      @status = nil
+      @empty_fail_count = 0
+    end
+
+    def output
+      raise "You must run `call` on this object first" unless @status
+      @output
+    end
+
+    def status
+      raise "You must run `call` on this object first" unless @status
+      @status
+    end
+
+    def call
+      loop do
+        execute!
+
+        break unless output.empty?
+        break unless @retry_on_empty
+
+        @empty_fail_count += 1
+
+        break if @empty_fail_count >= 3
+
+        message = String.new("Empty output from command #{@command}, retrying the command.")
+        message << "\nTo disable pass in `retry_on_empty: false` or set HATCHET_DISABLE_EMPTY_RUN_RETRY=1 globally"
+        message << "\nfailed_count: #{@empty_fail_count}"
+        message << "\nreleases: #{@app.releases}"
+        message << "\n#{caller.join("\n")}"
+        @stderr.puts message
+      end
+
+      self
+    end
+
+    private def execute!
+      ShellThrottle.new(platform_api: @app.platform_api).call do |throttle|
+        run_shell!
+        throw(:throttle) if output.match?(/reached the API rate limit/)
+      end
+    end
+
+    private def run_shell!
+      @output = `#{@command}`
+      @status = $?
+    end
+
+    private def build_heroku_command(command, options = {})
+      command = command.shellescape unless @raw
+
+      default_options = { "app" => @app.name, "exit-code" => nil }
+      heroku_options_array = (default_options.merge(options)).map do |k,v|
+        # This was a bad interface decision
+        next if v == Hatchet::App::SkipDefaultOption # for forcefully removing e.g. --exit-code, a user can pass this
+
+        arg = "--#{k.to_s.shellescape}"
+        arg << "=#{v.to_s.shellescape}" unless v.nil? # nil means we include the option without an argument
+        arg
+      end
+
+      "heroku run #{heroku_options_array.compact.join(' ')} -- #{command}"
+    end
+  end
+end

data/lib/hatchet/test_run.rb

@@ -1,7 +1,7 @@
 module Hatchet
   class FailedTestError < StandardError
     def initialize(app, output)
-      msg = "Could not run tests on pipeline id: '#{app.pipeline_id}' (#{app.repo_name}) at path: '#{app.directory}'\n" <<
+      msg = "Could not run tests on pipeline id: '#{app.pipeline_id}' (#{app.repo_name}) at path: '#{app.original_source_code_directory}'\n" <<
             " if this was expected add `allow_failure: true` to your hatchet initialization hash.\n" <<
             "output:\n" <<
             "#{output}"
@@ -140,8 +140,9 @@ module Hatchet
         end
       end
     rescue Timeout::Error
-      puts "Timed out status: #{@status}, timeout: #{@timeout}"
-      raise FailedTestError.new(self.app, self.output) unless app.allow_failure?
+      message = "Timed out status: #{@status}, timeout: #{@timeout}, app: #{app.name}"
+      puts message
+      raise FailedTestError.new(self.app, "#{message}, output:\n#{self.output}") unless app.allow_failure?
       yield self
       return self
     end

data/lib/hatchet/version.rb

@@ -1,3 +1,3 @@
 module Hatchet
-  VERSION = "7.2.0"
+  VERSION = "7.3.0"
 end

data/spec/hatchet/app_spec.rb

@@ -1,6 +1,20 @@
 require("spec_helper")
 
 describe "AppTest" do
+  it "annotates rspec expectation failures" do
+    app = Hatchet::Runner.new("default_ruby")
+    error = nil
+    begin
+      app.annotate_failures do
+        expect(true).to eq(false)
+      end
+    rescue RSpec::Expectations::ExpectationNotMetError => e
+      error = e
+    end
+
+    expect(error.message).to include(app.name)
+  end
+
   it "does not modify local files by mistake" do
     Dir.mktmpdir do |dir_1|
       app = Hatchet::Runner.new(dir_1)
@@ -23,26 +37,6 @@ describe "AppTest" do
     end
   end
 
-  it "rate throttles `git push` " do
-    app = Hatchet::GitApp.new("default_ruby")
-    def app.git_push_heroku_yall
-      @_git_push_heroku_yall_call_count ||= 0
-      @_git_push_heroku_yall_call_count += 1
-      if @_git_push_heroku_yall_call_count >= 2
-        "Success"
-      else
-        raise Hatchet::App::FailedDeployError.new(self, "message", output: "Your account reached the API rate limit Please wait a few minutes before making new requests")
-      end
-    end
-
-    def app.sleep_called?; @sleep_called; end
-
-    def app.what_is_git_push_heroku_yall_call_count; @_git_push_heroku_yall_call_count; end
-    app.push_without_retry!
-
-    expect(app.what_is_git_push_heroku_yall_call_count).to be(2)
-  end
-
   it "calls reaper if cannot create an app" do
     app = Hatchet::App.new("default_ruby", buildpacks: [:default])
     def app.heroku_api_create_app(*args); raise StandardError.new("made you look"); end
@@ -102,22 +96,75 @@ describe "AppTest" do
     expect(app_update_info["maintenance"]).to be_truthy
   end
 
-  it "before deploy" do
-    @called = false
-    @dir = false
-    app = Hatchet::App.new("default_ruby")
-    def app.push_with_retry!
-      # do nothing
+  describe "before deploy" do
+    it "dir" do
+      @called = false
+      @dir = false
+      app = Hatchet::App.new("default_ruby")
+      def app.push_with_retry!
+        # do nothing
+      end
+      app.before_deploy do
+        @called = true
+        @dir = Dir.pwd
+      end
+      app.deploy do
+        expect(@called).to eq(true)
+        expect(@dir).to eq(Dir.pwd)
+      end
+      expect(@dir).to_not eq(Dir.pwd)
     end
-    app.before_deploy do
-      @called = true
-      @dir = Dir.pwd
+
+    it "prepend" do
+      @value = ""
+      app = Hatchet::App.new("default_ruby")
+      def app.push_with_retry!; end
+      app.before_deploy do
+        @value << "there"
+      end
+
+      app.before_deploy(:prepend) do
+        @value << "hello "
+      end
+      app.deploy do
+      end
+
+      expect(@value).to eq("hello there")
     end
-    app.deploy do
-      expect(@called).to eq(true)
-      expect(@dir).to eq(Dir.pwd)
+
+    it "append" do
+      @value = ""
+      app = Hatchet::App.new("default_ruby")
+      def app.push_with_retry!; end
+      app.before_deploy do
+        @value << "there"
+      end
+
+      app.before_deploy(:append) do
+        @value << " hello"
+      end
+      app.deploy do
+      end
+
+      expect(@value).to eq("there hello")
+    end
+
+    it "replace" do
+      @value = ""
+      app = Hatchet::App.new("default_ruby")
+      def app.push_with_retry!; end
+      app.before_deploy do
+        @value << "there"
+      end
+
+      app.before_deploy(:replace) do
+        @value << "hello"
+      end
+      app.deploy do
+      end
+
+      expect(@value).to eq("hello")
     end
-    expect(@dir).to_not eq(Dir.pwd)
   end
 
   it "auto commits code" do

data/spec/spec_helper.rb

@@ -14,7 +14,8 @@ RSpec.configure do |config|
   end
 end
 
-ENV['HATCHET_BUILDPACK_BRANCH'] = "master"
+ENV['HATCHET_BUILDPACK_BASE'] = "https://github.com/heroku/heroku-buildpack-ruby.git"
+ENV['HATCHET_BUILDPACK_BRANCH'] = "main"
 
 require 'parallel_tests/test/runtime_logger' if ENV['RECORD_RUNTIME']
 

data/spec/unit/heroku_run_spec.rb

@@ -0,0 +1,115 @@
+require "spec_helper"
+
+describe "HerokuRun" do
+  def fake_app
+    app = Object.new
+    def app.name; "fake_app"; end
+    app
+  end
+
+  describe "options" do
+    it "escapes by default" do
+      run_obj = Hatchet::HerokuRun.new("ruby -v", app: fake_app)
+      expect(run_obj.command).to eq("heroku run --app=fake_app --exit-code -- ruby\\ -v")
+    end
+
+    it "escapes by default" do
+      run_obj = Hatchet::HerokuRun.new("ruby -v", app: fake_app, heroku: { "exit-code" => Hatchet::App::SkipDefaultOption })
+      expect(run_obj.command).to eq("heroku run --app=fake_app -- ruby\\ -v")
+    end
+
+    it "allows setting switch values by default" do
+      run_obj = Hatchet::HerokuRun.new("ruby -v", app: fake_app, heroku: { "no-tty" => nil })
+      expect(run_obj.command).to eq("heroku run --app=fake_app --exit-code --no-tty -- ruby\\ -v")
+    end
+
+    it "can be used to pass env vars" do
+      run_obj = Hatchet::HerokuRun.new("ruby -v", app: fake_app, heroku: { "env" => "HELLO=ohai;NAME=world" })
+      expect(run_obj.command).to eq("heroku run --app=fake_app --exit-code --env=HELLO\\=ohai\\;NAME\\=world -- ruby\\ -v")
+    end
+
+
+    it "lets me use raw values" do
+      run_obj = Hatchet::HerokuRun.new("ruby -v", app: fake_app, raw: true )
+      expect(run_obj.command).to eq("heroku run --app=fake_app --exit-code -- ruby -v")
+    end
+  end
+
+  describe "retry on empty" do
+    before(:all) do
+      @app = Hatchet::Runner.new("default_ruby")
+      @app.setup!
+    end
+
+    after(:all) do
+      @app.teardown!
+    end
+
+    it "retries 3 times on empty result" do
+      stderr = StringIO.new
+      run_obj = Hatchet::HerokuRun.new("ruby -v", app: @app, stderr: stderr)
+
+      def run_obj.run_shell!
+        @output = ""
+        @status = Object.new
+      end
+
+      run_obj.call
+
+      expect(run_obj.instance_variable_get(:@empty_fail_count)).to eq(3)
+      expect(stderr.string).to include("retrying the command.")
+    end
+
+    it "retries 0 times on NON empty result" do
+      stderr = StringIO.new
+      run_obj = Hatchet::HerokuRun.new("ruby -v", app: @app, stderr: stderr)
+
+      def run_obj.run_shell!
+        @output = "not empty"
+        @status = Object.new
+      end
+
+      run_obj.call
+
+      expect(run_obj.instance_variable_get(:@empty_fail_count)).to eq(0)
+      expect(run_obj.output).to eq("not empty")
+    end
+
+    it "retries 0 times on empty result when disabled" do
+      stderr = StringIO.new
+      run_obj = Hatchet::HerokuRun.new("ruby -v", app: @app, stderr: stderr, retry_on_empty: false)
+
+      def run_obj.run_shell!
+        @output = ""
+        @status = Object.new
+      end
+
+      run_obj.call
+
+      expect(run_obj.instance_variable_get(:@empty_fail_count)).to eq(0)
+      expect(stderr.string).to_not include("retrying the command.")
+    end
+
+    it "retries 0 times on empty result when disabled via ENV var" do
+      begin
+        original_env = ENV["HATCHET_DISABLE_EMPTY_RUN_RETRY"]
+        ENV["HATCHET_DISABLE_EMPTY_RUN_RETRY"] = "1"
+        stderr = StringIO.new
+        run_obj = Hatchet::HerokuRun.new("ruby -v", app: @app, stderr: stderr)
+
+        def run_obj.run_shell!
+          @output = ""
+          @status = Object.new
+        end
+
+        run_obj.call
+
+        expect(run_obj.instance_variable_get(:@empty_fail_count)).to eq(0)
+        expect(stderr.string).to_not include("retrying the command.")
+      ensure
+        ENV["HATCHET_DISABLE_EMPTY_RUN_RETRY"] = original_env
+      end
+    end
+  end
+end
+

data/spec/unit/shell_throttle_spec.rb

@@ -0,0 +1,94 @@
+require "spec_helper"
+
+describe "ShellThrottle" do
+  before(:each) do
+    throttle = PlatformAPI.rate_throttle
+    def throttle.sleep(value)
+      # No sleep, faster tests
+    end
+  end
+
+  after(:each) do
+    throttle = PlatformAPI.rate_throttle
+    def throttle.sleep(value)
+      super # Unstub
+    end
+  end
+
+  describe "class unit test" do
+    before(:all) do
+      @platform_api = Hatchet::Runner.new("default_ruby").platform_api
+    end
+
+    it "throttles when throw is called" do
+      @count = 0
+      Hatchet::ShellThrottle.new(platform_api: @platform_api).call do
+        @count += 1
+        if @count >= 2
+          # No throttle
+        else
+          throw(:throttle)
+        end
+      end
+      expect(@count).to eq(2)
+    end
+
+    it "does not throttle when throw is NOT called" do
+      @count = 0
+      Hatchet::ShellThrottle.new(platform_api: @platform_api).call do
+        @count += 1
+      end
+      expect(@count).to eq(1)
+    end
+  end
+
+  describe "git push throttle" do
+    it "rate throttles `git push` " do
+      app = Hatchet::GitApp.new("default_ruby")
+      def app.git_push_heroku_yall
+        @_git_push_heroku_yall_call_count ||= 0
+        @_git_push_heroku_yall_call_count += 1
+        if @_git_push_heroku_yall_call_count >= 2
+          "Success"
+        else
+          raise Hatchet::App::FailedDeployError.new(
+            self,
+            "message",
+            output: "Your account reached the API rate limit Please wait a few minutes before making new requests"
+          )
+        end
+      end
+
+      def app.sleep_called?; @sleep_called; end
+      def app.what_is_git_push_heroku_yall_call_count; @_git_push_heroku_yall_call_count; end
+
+      app.push_without_retry!
+
+      expect(app.what_is_git_push_heroku_yall_call_count).to be(2)
+    end
+
+    it "rate throttles `git push` with different output" do
+      app = Hatchet::GitApp.new("default_ruby")
+      def app.git_push_heroku_yall
+        @_git_push_heroku_yall_call_count ||= 0
+        @_git_push_heroku_yall_call_count += 1
+        if @_git_push_heroku_yall_call_count >= 2
+          "Success"
+        else
+          raise Hatchet::App::FailedDeployError.new(
+            self,
+            "message",
+            output: "RPC failed; HTTP 429 curl 22 The requested URL returned error: 429 Too Many Requests"
+          )
+        end
+      end
+
+      def app.sleep_called?; @sleep_called; end
+      def app.what_is_git_push_heroku_yall_call_count; @_git_push_heroku_yall_call_count; end
+
+      app.push_without_retry!
+
+      expect(app.what_is_git_push_heroku_yall_call_count).to be(2)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: heroku_hatchet
 version: !ruby/object:Gem::Version
-  version: 7.2.0
+  version: 7.3.0
 platform: ruby
 authors:
 - Richard Schneeman
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-09-16 00:00:00.000000000 Z
+date: 2020-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: platform-api
@@ -192,6 +192,7 @@ files:
 - lib/hatchet/app.rb
 - lib/hatchet/config.rb
 - lib/hatchet/git_app.rb
+- lib/hatchet/heroku_run.rb
 - lib/hatchet/init_project.rb
 - lib/hatchet/reaper.rb
 - lib/hatchet/reaper/app_age.rb
@@ -219,9 +220,10 @@ files:
 - spec/hatchet/local_repo_spec.rb
 - spec/hatchet/lock_spec.rb
 - spec/spec_helper.rb
+- spec/unit/heroku_run_spec.rb
 - spec/unit/init_spec.rb
 - spec/unit/reaper_spec.rb
-- spec/unit/shell_throttle.rb
+- spec/unit/shell_throttle_spec.rb
 - tmp/parallel_runtime_test.log
 homepage: https://github.com/heroku/hatchet
 licenses:
@@ -257,6 +259,7 @@ test_files:
 - spec/hatchet/local_repo_spec.rb
 - spec/hatchet/lock_spec.rb
 - spec/spec_helper.rb
+- spec/unit/heroku_run_spec.rb
 - spec/unit/init_spec.rb
 - spec/unit/reaper_spec.rb
-- spec/unit/shell_throttle.rb
+- spec/unit/shell_throttle_spec.rb

data/spec/unit/shell_throttle.rb

@@ -1,28 +0,0 @@
-require "spec_helper"
-
-describe "ShellThrottle" do
-  it "throttles when throw is called" do
-    platform_api = Hatchet::Runner.new("default_ruby").platform_api
-
-    @count = 0
-    Hatchet::ShellThrottle.new(platform_api: platform_api).call do
-      @count += 1
-      if @count >= 2
-        # No throttle
-      else
-        throw(:throttle)
-      end
-    end
-    expect(@count).to eq(2)
-  end
-
-  it "does not throttle when throw is NOT called" do
-    platform_api = Hatchet::Runner.new("default_ruby").platform_api
-
-    @count = 0
-    Hatchet::ShellThrottle.new(platform_api: platform_api).call do
-      @count += 1
-    end
-    expect(@count).to eq(1)
-  end
-end