heroku_hatchet 6.0.0 → 7.1.3

data/lib/hatchet/test_run.rb

@@ -218,12 +218,13 @@ module Hatchet
         "Content-Type"  => "application/json"
       }.merge(options[:headers] || {})
       options[:body] = JSON.generate(options[:body]) if options[:body]
+      options[:expects] << 429 if options[:expects]
 
       Hatchet::RETRIES.times.retry do
         PlatformAPI.rate_throttle.call do
           connection = Excon.new("https://api.heroku.com")
 
-          return connection.request(options)
+          connection.request(options)
         end
       end
     end

data/lib/hatchet/version.rb

@@ -1,3 +1,3 @@
 module Hatchet
-  VERSION = "6.0.0"
+  VERSION = "7.1.3"
 end

data/spec/hatchet/allow_failure_git_spec.rb

@@ -1,15 +1,55 @@
 require("spec_helper")
 
 describe "AllowFailureGitTest" do
+  describe "release failures" do
+    let(:release_fail_proc) {
+      Proc.new do
+        File.open("Procfile", "w+") do |f|
+          f.write <<~EOM
+            release: echo "failing on release" && exit 1
+          EOM
+        end
+      end
+    }
+
+    it "is marked as a failure if the release fails" do
+      app = Hatchet::GitApp.new("default_ruby", before_deploy: release_fail_proc, retries: 2)
+      def app.retry_error_message(*args); @test_attempts_count ||= 0; @test_attempts_count += 1; "" end
+      def app.test_attempts_count; @test_attempts_count ; end
+
+      expect {
+        app.deploy {}
+      }.to raise_error { |error|
+        expect(error).to be_a(Hatchet::App::FailedReleaseError)
+        expect(error.message).to_not match("Everything up-to-date")
+      }
+
+      expect(app.test_attempts_count).to eq(2)
+    end
+
+    it "works when failure is allowed" do
+      Hatchet::GitApp.new("default_ruby", before_deploy: release_fail_proc, allow_failure: true, retries: 3).tap do |app|
+        def app.retry_error_message(*args); @test_attempts_count ||= 0; @test_attempts_count += 1; "" end
+        def app.test_attempts_count; @test_attempts_count ; end
+
+        app.deploy do
+          expect(app.output).to match("failing on release")
+          expect(app.test_attempts_count).to eq(nil)
+        end
+      end
+    end
+  end
+
   it "allowed failure" do
     Hatchet::GitApp.new("no_lockfile", allow_failure: true).deploy do |app|
-      puts app.output
       expect(app.deployed?).to be_falsey
       expect(app.output).to match("Gemfile.lock required")
     end
   end
 
   it "failure with no flag" do
-    expect { Hatchet::GitApp.new("no_lockfile").deploy }.to(raise_error(Hatchet::App::FailedDeploy))
+    expect {
+      Hatchet::GitApp.new("no_lockfile").deploy {}
+    }.to(raise_error(Hatchet::App::FailedDeploy))
   end
 end

data/spec/hatchet/app_spec.rb

@@ -1,6 +1,42 @@
 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")
+      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
+
+    reaper = app.reaper
+
+    def reaper.cycle(app_exception_message: ); @app_exception_message = app_exception_message; end
+    def reaper.recorded_app_exception_message; @app_exception_message; end
+
+    expect {
+      app.create_app
+    }.to raise_error("made you look")
+
+    expect(reaper.recorded_app_exception_message).to match("made you look")
+  end
+
   it "app with default" do
     app = Hatchet::App.new("default_ruby", buildpacks: [:default])
     expect(app.buildpacks.first).to match("https://github.com/heroku/heroku-buildpack-ruby")
@@ -13,6 +49,37 @@ describe "AppTest" do
     expect(app.platform_api.app.info(app.name)["build_stack"]["name"]).to eq(stack)
   end
 
+  it "marks itself 'finished' when done in block mode" do
+    app = Hatchet::Runner.new("default_ruby")
+
+    def app.push_with_retry!; nil; end
+    app.deploy do |app|
+      expect(app.platform_api.app.info(app.name)["maintenance"]).to be_falsey
+    end
+
+    # After the app is updated, there's no guarantee it will still exist
+    # so we cannot rely on an api call to determine maintenance mode
+    app_update_info = app.instance_variable_get(:"@app_update_info")
+    expect(app_update_info["name"]).to eq(app.name)
+    expect(app_update_info["maintenance"]).to be_truthy
+  end
+
+  it "marks itself 'finished' when done in non-block mode" do
+    app = Hatchet::Runner.new("default_ruby")
+
+    def app.push_with_retry!; nil; end
+    app.deploy
+    expect(app.platform_api.app.info(app.name)["maintenance"]).to be_falsey
+
+    app.teardown!
+
+    # After the app is updated, there's no guarantee it will still exist
+    # so we cannot rely on an api call to determine maintenance mode
+    app_update_info = app.instance_variable_get(:"@app_update_info")
+    expect(app_update_info["name"]).to eq(app.name)
+    expect(app_update_info["maintenance"]).to be_truthy
+  end
+
   it "before deploy" do
     @called = false
     @dir = false
@@ -65,23 +132,95 @@ describe "AppTest" do
   end
 
   it "run" do
-    app = Hatchet::GitApp.new("default_ruby")
+    skip("Must set HATCHET_EXPENSIVE_MODE") unless ENV["HATCHET_EXPENSIVE_MODE"]
+
+    app = Hatchet::GitApp.new("default_ruby", run_multi: true)
     app.deploy do
       expect(app.run("ls -a Gemfile 'foo bar #baz'")).to match(/ls: cannot access 'foo bar #baz': No such file or directory\s+Gemfile/)
       expect((0 != $?.exitstatus)).to be_truthy
-      sleep(4)
+
       app.run("ls erpderp", heroku: ({ "exit-code" => (Hatchet::App::SkipDefaultOption) }))
       expect((0 == $?.exitstatus)).to be_truthy
-      sleep(4)
+
       app.run("ls erpderp", heroku: ({ "no-tty" => nil }))
       expect((0 != $?.exitstatus)).to be_truthy
-      sleep(4)
+
       expect(app.run("echo \\$HELLO \\$NAME", raw: true, heroku: ({ "env" => "HELLO=ohai;NAME=world" }))).to match(/ohai world/)
-      sleep(4)
+
       expect(app.run("echo \\$HELLO \\$NAME", raw: true, heroku: ({ "env" => "" }))).to_not match(/ohai world/)
-      sleep(4)
+
       random_name = SecureRandom.hex
       expect(app.run("mkdir foo; touch foo/#{random_name}; ls foo/")).to match(/#{random_name}/)
     end
   end
+
+  class AtomicCount
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+      @mutex = Mutex.new
+    end
+
+    # In MRI the `+=` is not atomic, it is two seperate virtual machine
+    # instructions. To protect against race conditions, we can lock with a mutex
+    def add(val)
+      @mutex.synchronize do
+        @value += val
+      end
+    end
+  end
+
+  it "run multi" do
+    skip("Must set HATCHET_EXPENSIVE_MODE") unless ENV["HATCHET_EXPENSIVE_MODE"]
+
+    @run_count = AtomicCount.new(0)
+    app = Hatchet::GitApp.new("default_ruby", run_multi: true)
+    app.deploy do
+      app.run_multi("ls") { |out| expect(out).to include("Gemfile"); @run_count.add(1) }
+      app.run_multi("blerg -v") { |_, status| expect(status.success?).to be_falsey; @run_count.add(1) }
+      app.run_multi("ruby -v") do |out, status|
+        expect(out).to include("ruby")
+        expect(status.success?).to be_truthy
+
+        @run_count.add(1)
+      end
+
+      expect(app.platform_api.formation.list(app.name).detect {|ps| ps["type"] == "web"}["size"].downcase).to_not eq("free")
+    end
+
+    # After the deploy block exits `teardown!` is called
+    # this ensures all `run_multi` commands have exited and the dyno should be scaled down
+    expect(@run_count.value).to eq(3)
+  end
+
+  describe "running concurrent tests in different examples works" do
+    # This is not a great pattern if we're running tests via a parallel runner
+    #
+    # For example this will be guaranteed to be called, not just once, but at least once for every process
+    # that needs to run a test. In the best case it will only fire once, in the worst case it will fire N times
+    # if there are N tests. It is effectively the same as a `before(:each)`
+    #
+    # Documented here: https://github.com/grosser/parallel_split_test/pull/22/files
+    before(:all) do
+      skip("Must set HATCHET_EXPENSIVE_MODE") unless ENV["HATCHET_EXPENSIVE_MODE"]
+
+      @app = Hatchet::GitApp.new("default_ruby", run_multi: true)
+      @app.deploy
+    end
+
+    after(:all) do
+      @app.teardown! if @app
+    end
+
+    it "test one" do
+      expect(@app.run("ls")).to include("Gemfile")
+      expect(@app.platform_api.formation.list(@app.name).detect {|ps| ps["type"] == "web"}["size"].downcase).to_not eq("free")
+    end
+
+    it "test two" do
+      expect(@app.run("ruby -v")).to include("ruby")
+      expect(@app.platform_api.formation.list(@app.name).detect {|ps| ps["type"] == "web"}["size"].downcase).to_not eq("free")
+    end
+  end
 end

data/spec/hatchet/ci_spec.rb

@@ -4,7 +4,8 @@ describe "CIFourTest" do
   it "error with bad app" do
     string = SecureRandom.hex
 
-    Hatchet::GitApp.new("default_ruby").run_ci do |test_run|
+    app = Hatchet::GitApp.new("default_ruby")
+    app.run_ci do |test_run|
       expect(test_run.output).to_not match(string)
       expect(test_run.output).to match("Installing rake")
 
@@ -14,7 +15,15 @@ describe "CIFourTest" do
       expect(test_run.output).to match(string)
       expect(test_run.output).to match("Using rake")
       expect(test_run.output).to_not match("Installing rake")
+
+      expect(app.platform_api.app.info(app.name)["maintenance"]).to be_falsey
     end
+
+    # After the app is updated, there's no guarantee it will still exist
+    # so we cannot rely on an api call to determine maintenance mode
+    app_update_info = app.instance_variable_get(:"@app_update_info")
+    expect(app_update_info["name"]).to eq(app.name)
+    expect(app_update_info["maintenance"]).to be_truthy
   end
 
   it "error with bad app" do

data/spec/hatchet/git_spec.rb

@@ -1,9 +1,15 @@
 require "spec_helper"
 
 describe "GitAppTest" do
-  it "can deploy git app" do
-    Hatchet::GitApp.new("rails5_ruby_schema_format").deploy do |app|
-      expect(app.run("ruby -v")).to match("2.6.6")
+  it "can deploy git app to the main branch" do
+    Hatchet::GitApp.new("lock_fail_main", allow_failure: true).deploy do |app|
+      expect(app.output).to match("INTENTIONAL ERROR")
     end
   end
+
+  it "returns the correct branch name on circle CI" do
+    skip("only runs on circle") unless ENV["CIRCLE_BRANCH"]
+
+    expect(Hatchet.git_branch).to eq(ENV["CIRCLE_BRANCH"])
+  end
 end

data/spec/hatchet/lock_spec.rb

@@ -2,6 +2,10 @@ require "spec_helper"
 require 'yaml'
 
 describe "LockTest" do
+  before(:all) do
+    puts(`bundle exec hatchet lock`)
+  end
+
   it "app with failure can be locked to prior commit" do
     Hatchet::GitApp.new("lock_fail").deploy do |app|
       expect(app.deployed?).to be_truthy
@@ -9,11 +13,69 @@ describe "LockTest" do
   end
 
   it "app with failure can be locked to master" do
-    puts(`bundle exec hatchet lock`)
     lock = YAML.load_file("hatchet.lock")
     name, branch = lock.select { |k, v| k.end_with?("lock_fail_master") }.first
 
     expect(name).to eq("repo_fixtures/repos/lock/lock_fail_master")
     expect(branch).to eq("master")
   end
+
+  it "app with failure can be locked to main" do
+    lock = YAML.load_file("hatchet.lock")
+    name, branch = lock.select { |k, v| k.end_with?("lock_fail_main") }.first
+
+    expect(name).to eq("repo_fixtures/repos/lock/lock_fail_main")
+    expect(branch).to eq("main")
+  end
+end
+
+describe "isolated lock tests" do
+  it "works when there's no hatchet.lock" do
+    Dir.mktmpdir do |dir|
+      dir = Pathname.new(dir)
+
+      dir.join("hatchet.json").open("w+") do |f|
+        f.puts %Q{{ "foo": ["sharpstone/lock_fail_main_default_is_master"] }}
+      end
+
+      output = `cd #{dir} && hatchet lock 2>&1`
+
+      raise "Expected cmd `hatchet lock` to succeed, but it did not: #{output}" unless $?.success?
+      expect(output).to include("locking")
+
+      lockfile_contents = dir.join('hatchet.lock').read
+      expect(lockfile_contents).to include("repos/foo/lock_fail_main_default_is_master")
+    end
+  end
+
+  it "works when a project is locked to main but the default branch is master" do
+    Dir.mktmpdir do |dir|
+      dir = Pathname.new(dir)
+
+      dir.join("hatchet.json").open("w+") do |f|
+        f.puts %Q{{ "foo": ["sharpstone/lock_fail_main_default_is_master"] }}
+      end
+
+      dir.join("hatchet.lock").open("w+") do |f|
+        f.puts <<~EOM
+        ---
+        - - "./repos/foo/lock_fail_main_default_is_master"
+          - main
+        EOM
+      end
+
+      output = `cd #{dir} && hatchet install 2>&1`
+
+      raise "Expected cmd `hatchet install` to succeed, but it did not:\n#{output}" unless $?.success?
+      expect(output).to include("Installing")
+
+      lockfile_contents = dir.join('hatchet.lock').read
+      contents = YAML.safe_load(lockfile_contents).to_h
+      expect(contents).to eq({"./repos/foo/lock_fail_main_default_is_master" => "main"})
+
+      contents.each do |repo_dir, commit_or_branch|
+        expect(`cd #{dir.join(repo_dir)} && git describe --contains --all HEAD`).to match("main")
+      end
+    end
+  end
 end

data/spec/unit/reaper_spec.rb

@@ -0,0 +1,169 @@
+require "spec_helper"
+
+describe "Reaper" do
+  it "destroy all" do
+    reaper = Hatchet::Reaper.new(api_rate_limit: Object.new, hatchet_app_limit: 1, io: StringIO.new)
+
+    def reaper.get_heroku_apps
+      @mock_apps ||= [
+        {"name" => "hatchet-t-unfinished", "id" => 2, "maintenance" => false, "created_at" => Time.now.to_s},
+        {"name" => "hatchet-t-foo", "id" => 1, "maintenance" => true, "created_at" => Time.now.to_s}
+      ]
+    end
+    def reaper.destroy_with_log(*args); @destroy_with_log_count ||= 0; @destroy_with_log_count += 1; end
+
+    reaper.destroy_all
+
+    expect(reaper.instance_variable_get("@destroy_with_log_count")).to eq(1)
+  end
+
+  describe "cycle" do
+    it "does not delete anything if under the limit" do
+      reaper = Hatchet::Reaper.new(api_rate_limit: Object.new, hatchet_app_limit: 1, io: StringIO.new)
+
+      def reaper.get_heroku_apps
+        @called_get_heroku_apps = true
+
+        @mock_apps ||= [{"name" => "hatchet-t-foo", "id" => 1, "maintenance" => true, "created_at" => Time.now.to_s}]
+      end
+      def reaper.check_get_heroku_apps_called; @called_get_heroku_apps ; end
+      def reaper.reap_once; raise "should not be called"; end
+
+      reaper.cycle
+
+      expect(reaper.check_get_heroku_apps_called).to be_truthy
+    end
+
+    it "deletes a maintenance mode app on error" do
+      reaper = Hatchet::Reaper.new(api_rate_limit: Object.new, hatchet_app_limit: 1, io: StringIO.new)
+
+      def reaper.get_heroku_apps
+        @mock_apps ||= [
+          {"name" => "hatchet-t-unfinished", "id" => 2, "maintenance" => false, "created_at" => Time.now.to_s},
+          {"name" => "hatchet-t-foo", "id" => 1, "maintenance" => true, "created_at" => Time.now.to_s}
+        ]
+      end
+      def reaper.destroy_with_log(name: , id: )
+        @reaper_destroy_called_with = {"name" => name, "id" => id}
+      end
+      def reaper.destroy_called_with; @reaper_destroy_called_with; end
+
+      reaper.cycle(app_exception_message: true)
+
+      expect(reaper.destroy_called_with).to eq({"name" => "hatchet-t-foo", "id" => 1})
+    end
+
+    it "deletes maintenance mode app when over limit" do
+      reaper = Hatchet::Reaper.new(api_rate_limit: Object.new, hatchet_app_limit: 0, io: StringIO.new)
+
+      def reaper.get_heroku_apps
+        @mock_apps ||= [{"name" => "hatchet-t-foo", "id" => 1, "maintenance" => true, "created_at" => Time.now.to_s}]
+      end
+      def reaper.destroy_with_log(name: , id: )
+        @reaper_destroy_called_with = {"name" => name, "id" => id}
+      end
+      def reaper.destroy_called_with; @reaper_destroy_called_with; end
+
+      reaper.cycle
+
+      expect(reaper.destroy_called_with).to eq({"name" => "hatchet-t-foo", "id" => 1})
+    end
+
+    it "deletes an old app that is past TLL" do
+      reaper = Hatchet::Reaper.new(api_rate_limit: Object.new, hatchet_app_limit: 0, io: StringIO.new)
+
+      def reaper.get_heroku_apps
+        two_days_ago = DateTime.now.new_offset(0) - 2
+        @mock_apps ||= [{"name" => "hatchet-t-foo", "id" => 1, "maintenance" => false, "created_at" => two_days_ago.to_s }]
+      end
+      def reaper.destroy_with_log(name: , id: )
+        @reaper_destroy_called_with = {"name" => name, "id" => id}
+      end
+      def reaper.destroy_called_with; @reaper_destroy_called_with; end
+
+      reaper.cycle
+
+      expect(reaper.destroy_called_with).to eq({"name" => "hatchet-t-foo", "id" => 1})
+    end
+
+    it "sleeps, refreshes app list, and tries again when an old app is not past TTL" do
+      warning = StringIO.new
+      reaper = Hatchet::Reaper.new(api_rate_limit: Object.new, hatchet_app_limit: 1, initial_sleep: 0, io: warning)
+
+      def reaper.get_heroku_apps
+        now = DateTime.now.new_offset(0)
+        @mock_apps ||= [{"name" => "hatchet-t-foo", "id" => 1, "maintenance" => false, "created_at" => now.to_s }]
+      end
+      def reaper.destroy_with_log(name: , id: )
+        @reaper_destroy_called_with = {"name" => name, "id" => id}
+      end
+      def reaper.destroy_called_with; @reaper_destroy_called_with; end
+      def reaper.sleep(val)
+        @_slept_for = val
+      end
+
+      def reaper.get_slept_for_val; @_slept_for; end
+
+      reaper.cycle(app_exception_message: true)
+
+      expect(reaper.get_slept_for_val).to eq(0)
+      expect(reaper.destroy_called_with).to eq(nil)
+
+      expect(warning.string).to match("WARNING")
+      expect(warning.string).to match("total_app_count: 1, hatchet_app_count: 1/#{Hatchet::Reaper::HATCHET_APP_LIMIT}, finished: 0, unfinished: 1")
+    end
+  end
+
+  describe "app age" do
+    it "calculates young apps" do
+      time_now = DateTime.parse("2020-07-28T14:40:00Z")
+      age = Hatchet::Reaper::AppAge.new(created_at: time_now, time_now: time_now, ttl_minutes: 1)
+      expect(age.in_minutes).to eq(0.0)
+      expect(age.too_young_to_die?).to be_truthy
+      expect(age.can_delete?).to be_falsey
+      expect(age.sleep_for_ttl).to eq(60)
+    end
+
+    it "calculates old apps" do
+      time_now = DateTime.parse("2020-07-28T14:40:00Z")
+      created_at = time_now - 2
+      age = Hatchet::Reaper::AppAge.new(created_at: created_at, time_now: time_now, ttl_minutes: 1)
+      expect(age.in_minutes).to eq(2880.0)
+      expect(age.too_young_to_die?).to be_falsey
+      expect(age.can_delete?).to be_truthy
+      expect(age.sleep_for_ttl).to eq(0)
+    end
+  end
+
+  describe "reaper throttle" do
+    it "increments and decrements based on min_sleep" do
+      reaper_throttle = Hatchet::Reaper::ReaperThrottle.new(initial_sleep: 2)
+      reaper_throttle.call(max_sleep: 5) do |sleep_for|
+        expect(sleep_for).to eq(2)
+      end
+      reaper_throttle.call(max_sleep: 5) do |sleep_for|
+        expect(sleep_for).to eq(4)
+      end
+      reaper_throttle.call(max_sleep: 5) do |sleep_for|
+        expect(sleep_for).to eq(5)
+      end
+      # The throttle is now reset since it hit the min_sleep value
+
+      reaper_throttle.call(max_sleep: 5) do |sleep_for|
+        expect(sleep_for).to eq(2)
+      end
+    end
+  end
+
+  it "over limit" do
+    reaper = Hatchet::Reaper.new(api_rate_limit: -> (){}, io: StringIO.new)
+    def reaper.hatchet_app_count; Hatchet::Reaper::HATCHET_APP_LIMIT + 1; end
+
+    expect(reaper.over_limit?).to be_truthy
+
+    reaper = Hatchet::Reaper.new(api_rate_limit: -> (){}, io: StringIO.new)
+    def reaper.hatchet_app_count; Hatchet::Reaper::HATCHET_APP_LIMIT - 1; end
+
+    expect(reaper.over_limit?).to be_falsey
+  end
+end