heroku_hatchet 5.0.3 → 7.1.2

data/lib/hatchet/test_run.rb

@@ -181,10 +181,11 @@ module Hatchet
 
         source_put_url = @app.create_source
         Hatchet::RETRIES.times.retry do
-          @api_rate_limit.call
-          Excon.put(source_put_url,
-                    expects: [200],
-                    body:    File.read('slug.tgz'))
+          PlatformAPI.rate_throttle.call do
+            Excon.put(source_put_url,
+                      expects: [200],
+                      body:    File.read('slug.tgz'))
+          end
         end
       end
       return @app.source_get_url
@@ -192,8 +193,11 @@ module Hatchet
 
   private
     def get_contents_or_whatever(url)
-      @api_rate_limit.call
-      Excon.get(url, read_timeout: @pause).body
+      response = PlatformAPI.rate_throttle.call do
+        Excon.get(url, read_timeout: @pause)
+      end
+
+      return response.body
     rescue Excon::Error::Timeout
       ""
     end
@@ -214,11 +218,14 @@ 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
-        @api_rate_limit.call
-        connection = Excon.new("https://api.heroku.com")
-        return connection.request(options)
+        PlatformAPI.rate_throttle.call do
+          connection = Excon.new("https://api.heroku.com")
+
+          connection.request(options)
+        end
       end
     end
   end

data/lib/hatchet/version.rb

@@ -1,3 +1,3 @@
 module Hatchet
-  VERSION = "5.0.3"
+  VERSION = "7.1.2"
 end

data/spec/hatchet/allow_failure_git_spec.rb

@@ -0,0 +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|
+      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))
+  end
+end

data/spec/hatchet/app_spec.rb

@@ -0,0 +1,226 @@
+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")
+  end
+
+  it "create app with stack" do
+    stack = "heroku-16"
+    app = Hatchet::App.new("default_ruby", stack: stack)
+    app.create_app
+    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
+    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
+
+  it "auto commits code" do
+    string = "foo#{SecureRandom.hex}"
+    app = Hatchet::App.new("default_ruby")
+    def app.push_with_retry!
+      # do nothing
+    end
+    app.before_deploy do |app|
+      expect(app.send(:needs_commit?)).to eq(false)
+      `echo "#{string}" > Gemfile`
+      expect(app.send(:needs_commit?)).to eq(true)
+    end
+    app.deploy do
+      expect(File.read("Gemfile").chomp).to eq(string)
+      expect(app.send(:needs_commit?)).to eq(false)
+    end
+  end
+
+  it "nested in directory" do
+    string = "foo#{SecureRandom.hex}"
+    app = Hatchet::App.new("default_ruby")
+    def app.push_with_retry!
+      # do nothing
+    end
+    app.in_directory do
+      `echo "#{string}" > Gemfile`
+      dir = Dir.pwd
+      app.deploy do
+        expect(File.read("Gemfile").chomp).to eq(string)
+        expect(dir).to eq(Dir.pwd)
+      end
+    end
+  end
+
+  it "run" do
+    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
+
+      app.run("ls erpderp", heroku: ({ "exit-code" => (Hatchet::App::SkipDefaultOption) }))
+      expect((0 == $?.exitstatus)).to be_truthy
+
+      app.run("ls erpderp", heroku: ({ "no-tty" => nil }))
+      expect((0 != $?.exitstatus)).to be_truthy
+
+      expect(app.run("echo \\$HELLO \\$NAME", raw: true, heroku: ({ "env" => "HELLO=ohai;NAME=world" }))).to match(/ohai world/)
+
+      expect(app.run("echo \\$HELLO \\$NAME", raw: true, heroku: ({ "env" => "" }))).to_not match(/ohai world/)
+
+      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

@@ -0,0 +1,67 @@
+require "spec_helper"
+
+describe "CIFourTest" do
+  it "error with bad app" do
+    string = SecureRandom.hex
+
+    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")
+
+      run!("echo 'puts \"#{string}\"' >> Rakefile")
+      test_run.run_again
+
+      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
+    expect {
+      Hatchet::GitApp.new("rails5_ci_fails_no_database").run_ci { }
+    }.to raise_error(/PG::ConnectionBad: could not connect to server/)
+  end
+
+  it "error with bad app" do
+    @before_deploy_called = false
+    @before_deploy_dir_pwd = nil
+
+    before_deploy = -> do
+      @before_deploy_called = true
+      @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|
+      expect(test_run.status).to eq(:errored)
+      expect(@before_deploy_dir_pwd).to eq(Dir.pwd)
+      expect(@before_deploy_called).to be_truthy
+    end
+
+    expect(@before_deploy_dir_pwd).to_not eq(Dir.pwd)
+  end
+
+  it "ci create app with stack" do
+    app = Hatchet::GitApp.new("rails5_ruby_schema_format")
+    app.run_ci do |test_run|
+      expect(test_run.output).to match("Ruby buildpack tests completed successfully")
+      expect(test_run.status).to eq(:succeeded)
+      expect(app.pipeline_id).to_not be_nil
+
+      api_rate_limit = app.api_rate_limit.call
+      couplings = api_rate_limit.pipeline_coupling.list_by_pipeline(app.pipeline_id)
+      coupled_app = api_rate_limit.app.info(couplings.first["app"]["id"])
+      expect(coupled_app["name"]).to eq(app.name)
+    end
+    expect(app.pipeline_id).to be_nil
+  end
+end

data/spec/hatchet/config_spec.rb

@@ -0,0 +1,34 @@
+require("spec_helper")
+describe "ConfigTest" do
+  before { @config = Hatchet::Config.new }
+
+  it("config path for name") do
+    expect(@config.path_for_name("rails3_mri_193")).to(eq("repo_fixtures/repos/rails3/rails3_mri_193"))
+  end
+
+  it("config dirs") do
+    { "repo_fixtures/repos/bundler/no_lockfile" => "https://github.com/sharpstone/no_lockfile.git", "repo_fixtures/repos/default/default_ruby" => "https://github.com/sharpstone/default_ruby.git", "repo_fixtures/repos/rails2/rails2blog" => "https://github.com/sharpstone/rails2blog.git", "repo_fixtures/repos/rails3/rails3_mri_193" => "https://github.com/sharpstone/rails3_mri_193.git" }.each do |key, value|
+      assert_include(key, value, @config.dirs)
+    end
+  end
+
+  it("config repos") do
+    { "default_ruby" => "repo_fixtures/repos/default/default_ruby", "no_lockfile" => "repo_fixtures/repos/bundler/no_lockfile", "rails2blog" => "repo_fixtures/repos/rails2/rails2blog", "rails3_mri_193" => "repo_fixtures/repos/rails3/rails3_mri_193" }.each do |key, value|
+      assert_include(key, value, @config.repos)
+    end
+  end
+
+  it("no internal config raises no errors") do
+    @config.send(:set_internal_config!, {})
+    expect(@config.repo_directory_path).to(eq("./repos"))
+  end
+
+  it("github shortcuts") do
+    @config.send(:init_config!, "foo" => (["schneems/sextant"]))
+    expect(@config.dirs["./repos/foo/sextant"]).to(eq("https://github.com/schneems/sextant.git"))
+  end
+
+  private def assert_include(key, value, actual)
+    expect(actual[key]).to eq(value), "Expected #{actual.inspect} to include #{{ key => value }} but it did not"
+  end
+end

data/spec/hatchet/edit_repo_spec.rb

@@ -0,0 +1,17 @@
+require("spec_helper")
+describe "EditRepoTest" do
+  it "can deploy git app" do
+    Hatchet::GitApp.new("default_ruby").in_directory do |app|
+      `touch foo`
+      expect($?.success?).to(eq(true))
+
+      `git add .; git commit -m foo`
+      expect($?.success?).to(eq(true))
+      expect(`ls`).to(match("foo"))
+    end
+
+    Hatchet::GitApp.new("default_ruby").in_directory do |app|
+      expect(`ls`).to_not match(/foo/)
+    end
+  end
+end