heroku_hatchet 7.1.3 → 7.3.3

data/lib/hatchet/version.rb

@@ -1,3 +1,3 @@
 module Hatchet
-  VERSION = "7.1.3"
+  VERSION = "7.3.3"
 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,24 +1,40 @@
 require("spec_helper")
 
 describe "AppTest" 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")
+  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
 
-    def app.sleep_called?; @sleep_called; 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)
+      Dir.mktmpdir do |dir_2|
+        Dir.chdir(dir_2) do
+          FileUtils.touch("foo.txt")
+
+          app.setup!
+        end
+
+        entries_array = Dir.entries(dir_2)
+        entries_array -= ["..", ".", "foo.txt"]
+        expect(entries_array).to be_empty
 
-    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)
+        entries_array = Dir.entries(dir_1)
+        entries_array -= ["..", ".", "foo.txt"]
+        expect(entries_array).to be_empty
+      end
+    end
   end
 
   it "calls reaper if cannot create an app" do
@@ -80,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/hatchet/local_repo_spec.rb

@@ -11,16 +11,26 @@ describe "LocalRepoTest" do
     expect(ENV[env_name]).to eq(env_name)
   end
 
+  it "in directory fork captures stdout even when there is an error" do
+    expect {
+      Hatchet::App.new("default_ruby").in_directory_fork do
+        puts "hello_there"
+        raise "error"
+      end
+    }.to raise_error(/hello_there/)
+  end
+
   it "repos checked into git" do
     begin
-      app = Hatchet::App.new("repo_fixtures/different-folder-for-checked-in-repos/default_ruby")
-      app.in_directory do
-        expect(Dir.exist?(".git")).to eq(false)
-        app.setup!
-        expect(Dir.exist?(".git")).to eq(true)
+      fixture_dir = "repo_fixtures/different-folder-for-checked-in-repos/default_ruby"
+      app = Hatchet::App.new(fixture_dir)
+      def app.push_with_retry!; end
+
+      expect(Dir.exist?("#{fixture_dir}/.git")).to be_falsey
+
+      app.deploy do
+        expect(Dir.exist?(".git")).to be_truthy
       end
-    ensure
-      app.teardown! if app
     end
   end
 end

data/spec/hatchet/lock_spec.rb

@@ -57,7 +57,7 @@ describe "isolated lock tests" do
       end
 
       dir.join("hatchet.lock").open("w+") do |f|
-        f.puts <<~EOM
+        f.puts <<-EOM.strip_heredoc
         ---
         - - "./repos/foo/lock_fail_main_default_is_master"
           - main

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/init_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+describe "Hatchet::Init" do
+  def fake_buildpack_dir
+    Dir.mktmpdir do |dir|
+      FileUtils.mkdir_p("#{dir}/bin")
+      yield dir
+    end
+  end
+  it "raises an error when not pointing at the right directory" do
+    Dir.mktmpdir do |dir|
+      expect {
+        Hatchet::InitProject.new(dir: dir)
+      }.to raise_error(/Must run in a directory with a buildpack/)
+    end
+  end
+
+      # write_target(target: ".circleci/config.yml", template: "circleci_template.erb")
+      # write_target(target: "Gemfile", template: "Gemfile.erb")
+      # write_target(target: "hatchet.json", contents: "{}")
+      # write_target(target: "hatchet.lock", contents: YAML.dump({}))
+      # write_target(target: "spec/spec_helper.rb", template: "spec_helper.erb")
+      # write_target(target: "spec/hatchet/buildpack_spec.rb", template: "buildpack_spec.erb")
+      # write_target(target: ".github/dependabot.yml", template: "dependabot.erb")
+
+  it "generates files" do
+    fake_buildpack_dir do |dir|
+      fake_stdout = StringIO.new
+      init = Hatchet::InitProject.new(dir: dir, io: fake_stdout)
+      init.call
+
+      circle_ci_file = Pathname.new(dir).join(".circleci/config.yml")
+      expect(circle_ci_file.read).to match("parallel_split_test")
+
+      %W{
+         .circleci/config.yml
+         Gemfile
+         hatchet.json
+         hatchet.lock
+         spec/spec_helper.rb
+         spec/hatchet/buildpack_spec.rb
+         .github/dependabot.yml
+         .github/workflows/check_changelog.yml
+         .gitignore
+      }.each do |path|
+        expect(Pathname.new(dir).join(path)).to exist
+      end
+
+      expect(fake_stdout.string).to match("Bundle complete")
+    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