heroku_hatchet 7.2.0 → 7.3.4

data/lib/hatchet/config.rb

@@ -44,9 +44,9 @@ module Hatchet
 
     # use this method to turn "codetriage" into repos/rails3/codetriage
     def path_for_name(name)
-      possible_paths = [repos[name.to_s], "repos/#{name}", name].compact
+      possible_paths = [repos[name.to_s], "#{repo_directory_path}/#{name}", name].compact
       path = possible_paths.detect do |path|
-        !Dir[path]&.empty?
+        !(Dir[path] && Dir[path].empty?)
       end
       raise BadRepoName.new(name, possible_paths) if path.nil? || path.empty?
       path

data/lib/hatchet/git_app.rb

@@ -5,25 +5,30 @@ 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/)
-          throw(:throttle)
-        elsif @allow_failure
-          output = e.output
-        else
-          raise e
+        begin
+          output = git_push_heroku_yall
+        rescue FailedDeploy => e
+          case e.output
+          when /reached the API rate limit/, /429 Too Many Requests/, /HTTP 429/, /HTTP code = 429/
+            throw(:throttle)
+          else
+            raise e unless @allow_failure
+            output = e.output
+          end
         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 +36,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/reaper.rb

@@ -55,7 +55,7 @@ module Hatchet
       # To be safe try to delete an app even if we're not over the limit
       # since the exception may have been caused by going over the maximum account limit
       if app_exception_message
-          io.puts <<~EOM
+          io.puts <<-EOM.strip_heredoc
             WARNING: Running reaper due to exception on app
                      #{stats_string}
                      Exception: #{app_exception_message}
@@ -122,7 +122,7 @@ module Hatchet
 
         # Sleep, try again later
         @reaper_throttle.call(max_sleep: age.sleep_for_ttl) do |sleep_for|
-          io.puts <<~EOM
+          io.puts <<-EOM.strip_heredoc
             WARNING: Attempting to destroy an app without maintenance mode on, but it is not old enough. app: #{app["name"]}, app_age: #{age.in_minutes} minutes
                      This can happen if App#teardown! is not called on an application, which will leave it in an 'unfinished' state
                      This can also happen if you're trying to run more tests concurrently than your currently set value for HATCHET_APP_COUNT
@@ -170,14 +170,14 @@ module Hatchet
       body = e.response.body
       request_id = e.response.headers["Request-Id"]
       if body =~ /Couldn\'t find that app./
-        io.puts "Duplicate destoy attempted #{name.inspect}: #{id}, status: 404, request_id: #{request_id}"
+        io.puts "Duplicate destroy attempted #{name.inspect}: #{id}, status: 404, request_id: #{request_id}"
         raise AlreadyDeletedError.new
       else
         raise e
       end
     rescue Excon::Error::Forbidden => e
       request_id = e.response.headers["Request-Id"]
-      io.puts "Duplicate destoy attempted #{name.inspect}: #{id}, status: 403, request_id: #{request_id}"
+      io.puts "Duplicate destroy attempted #{name.inspect}: #{id}, status: 403, request_id: #{request_id}"
       raise AlreadyDeletedError.new
     end
 

data/lib/hatchet/templates/dependabot.erb

@@ -1,4 +1,4 @@
-version: 1
+version: 2
 updates:
   - package-ecosystem: "bundler"
     directory: "/"

data/lib/hatchet/test_run.rb

@@ -1,7 +1,9 @@
+require "tempfile"
+
 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 +142,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
@@ -176,15 +179,17 @@ module Hatchet
         app_json["stack"]                              ||= @app.stack if @app.stack && !@app.stack.empty?
         File.open("app.json", "w") {|f| f.write(JSON.generate(app_json)) }
 
-        out = `tar c . | gzip -9 > slug.tgz`
-        raise "Tar command failed: #{out}" unless $?.success?
-
-        source_put_url = @app.create_source
-        Hatchet::RETRIES.times.retry do
-          PlatformAPI.rate_throttle.call do
-            Excon.put(source_put_url,
-                      expects: [200],
-                      body:    File.read('slug.tgz'))
+        Tempfile.create("slug.tgz") do |slug|
+          out = `tar c . | gzip -9 > #{slug.path}`
+          raise "Tar command failed: #{out}" unless $?.success?
+
+          source_put_url = @app.create_source
+          Hatchet::RETRIES.times.retry do
+            PlatformAPI.rate_throttle.call do
+              Excon.put(source_put_url,
+                        expects: [200],
+                        body:    slug.read)
+            end
           end
         end
       end

data/lib/hatchet/version.rb

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

data/spec/hatchet/allow_failure_git_spec.rb

@@ -5,7 +5,7 @@ describe "AllowFailureGitTest" do
     let(:release_fail_proc) {
       Proc.new do
         File.open("Procfile", "w+") do |f|
-          f.write <<~EOM
+          f.write <<-EOM.strip_heredoc
             release: echo "failing on release" && exit 1
           EOM
         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
@@ -64,6 +58,10 @@ describe "AppTest" do
     expect(app.buildpacks.first).to match("https://github.com/heroku/heroku-buildpack-ruby")
   end
 
+  it "default_buildpack is only computed once" do
+    expect(Hatchet::App.default_buildpack.object_id).to eq(Hatchet::App.default_buildpack.object_id)
+  end
+
   it "create app with stack" do
     stack = "heroku-16"
     app = Hatchet::App.new("default_ruby", stack: stack)
@@ -71,6 +69,19 @@ describe "AppTest" do
     expect(app.platform_api.app.info(app.name)["build_stack"]["name"]).to eq(stack)
   end
 
+  it "create app with HATCHET_DEFAULT_STACK set" do
+    begin
+      original_default_stack = ENV["HATCHET_DEFAULT_STACK"]
+      default_stack = "heroku-18"
+      ENV["HATCHET_DEFAULT_STACK"] = default_stack
+      app = Hatchet::App.new("default_ruby")
+      app.create_app
+      expect(app.platform_api.app.info(app.name)["build_stack"]["name"]).to eq(default_stack)
+    ensure
+      ENV["HATCHET_DEFAULT_STACK"] = original_default_stack
+    end
+  end
+
   it "marks itself 'finished' when done in block mode" do
     app = Hatchet::Runner.new("default_ruby")
 
@@ -102,22 +113,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/hatchet/ci_spec.rb

@@ -28,7 +28,7 @@ describe "CIFourTest" do
 
   it "error with bad app" do
     expect {
-      Hatchet::GitApp.new("rails5_ci_fails_no_database").run_ci { }
+      Hatchet::GitApp.new("rails5_ci_fails_no_database", stack: "heroku-18").run_ci { }
     }.to raise_error(/PG::ConnectionBad: could not connect to server/)
   end
 
@@ -41,7 +41,7 @@ describe "CIFourTest" do
       @before_deploy_dir_pwd = Dir.pwd
     end
 
-    Hatchet::GitApp.new("rails5_ci_fails_no_database", allow_failure: true, before_deploy: before_deploy).run_ci do |test_run|
+    Hatchet::GitApp.new("rails5_ci_fails_no_database", stack: "heroku-18", allow_failure: true, before_deploy: before_deploy).run_ci do |test_run|
       expect(test_run.status).to eq(:errored)
       expect(@before_deploy_dir_pwd).to eq(Dir.pwd)
       expect(@before_deploy_called).to be_truthy