heroku_hatchet 7.1.1 → 7.3.1

data/lib/hatchet/config.rb

@@ -46,7 +46,7 @@ module Hatchet
     def path_for_name(name)
       possible_paths = [repos[name.to_s], "repos/#{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,33 +5,37 @@ 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/
+            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} master 2>&1`
+      output = `git push #{git_repo} HEAD:main 2>&1`
 
       if !$?.success?
         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/init_project.rb

@@ -0,0 +1,86 @@
+require 'thor'
+require 'yaml'
+
+module Hatchet
+  # Bootstraps a project with files for running hatchet tests
+  #
+  #   Hatchet::InitProject.new.call
+  #
+  #   puts File.exist?("spec/spec_helper.rb") # => true
+  #   puts File.exist?("") # => true
+  class InitProject
+    def initialize(dir: ".", io: STDOUT)
+
+      @target_dir = Pathname.new(dir)
+      raise "Must run in a directory with a buildpack, #{@target_dir} has no bin/ directory" unless @target_dir.join("bin").directory?
+
+      @template_dir = Pathname.new(__dir__).join("templates")
+      @thor_shell = ::Thor::Shell::Basic.new
+      @io = io
+      @git_ignore = @target_dir.join(".gitignore")
+
+      FileUtils.touch(@git_ignore)
+      FileUtils.touch(@target_dir.join("hatchet.lock"))
+    end
+
+    def call
+      write_target(target: ".circleci/config.yml", template: "circleci_template.erb")
+      write_target(target: "Gemfile", template: "Gemfile.erb")
+      write_target(target: "hatchet.json", template: "hatchet_json.erb")
+      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")
+      write_target(target: ".github/workflows/check_changelog.yml", template: "check_changelog.erb")
+
+      add_gitignore(".rspec_status")
+      add_gitignore("repos/*")
+
+      stream("cd #{@target_dir} && bundle install")
+      stream("cd #{@target_dir} && hatchet install")
+
+      @io.puts
+      @io.puts "Done, run `bundle exec rspec` to execute your tests"
+      @io.puts
+    end
+
+    private def add_gitignore(statement)
+      @git_ignore.open("a") {|f| f.puts statement } unless @git_ignore.read.include?(statement)
+    end
+
+    private def stream(command)
+      output = ""
+      IO.popen(command) do |io|
+        until io.eof?
+          buffer = io.gets
+          output << buffer
+          @io.puts(buffer)
+        end
+      end
+      raise "Error running #{command}. Output:\n#{output}" unless $?.success?
+      output
+    end
+
+    private def write_target(template: nil, target:, contents: nil)
+      if template
+        template = @template_dir.join(template)
+        contents = ERB.new(template.read).result(binding)
+      end
+
+      target = @target_dir.join(target)
+      target.dirname.mkpath # Create directory if it doesn't exist already
+
+      if target.exist?
+        return if contents === target.read # identical
+        target.write(contents) if @thor_shell.file_collision(target) { contents }
+      else
+        target.write(contents)
+      end
+    end
+
+    private def cmd(command)
+      result = `#{command}`.chomp
+      raise "Command #{command} failed:\n#{result}" unless $?.success?
+      result
+    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

data/lib/hatchet/templates/Gemfile.erb

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "parallel_split_test"
+gem "heroku_hatchet"
+gem "rspec-retry"

data/lib/hatchet/templates/buildpack_spec.erb

@@ -0,0 +1,23 @@
+require_relative "../spec_helper.rb"
+
+RSpec.describe "This buildpack" do
+  it "has its own tests" do
+    raise "delete this and replace it with your own logic"
+
+    # Specify where you want your buildpack to go using :default
+    buildpacks = [:default, "heroku/ruby"]
+
+    # To deploy a different app modify the hatchet.json or
+    # commit an app to your source control and use a path
+    # instead of "default_ruby" here
+    Hatchet::Runner.new("default_ruby", buildpacks: buildpacks).tap do |app|
+      app.before_deploy do
+        # Modfiy the app here if you need
+      end
+      app.deploy do
+        # Assert the behavior you desire here
+        expect(app.output).to match("deployed to Heroku")
+      end
+    end
+  end
+end

data/lib/hatchet/templates/check_changelog.erb

@@ -0,0 +1,13 @@
+name: Check Changelog
+
+on:
+ pull_request:
+  types: [opened, reopened, edited, synchronize]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+    - name: Check that CHANGELOG is touched
+      run: |
+        cat $GITHUB_EVENT_PATH | jq .pull_request.title |  grep -i '\[\(\(changelog skip\)\|\(ci skip\)\)\]' ||  git diff remotes/origin/${{ github.base_ref }} --name-only | grep CHANGELOG.md

data/lib/hatchet/templates/circleci_template.erb

@@ -0,0 +1,45 @@
+version: 2
+references:
+  unit: &unit
+    run:
+      name: Run test suite
+      command: PARALLEL_SPLIT_TEST_PROCESSES=25 IS_RUNNING_ON_CI=1 bundle exec parallel_split_test spec/
+  restore: &restore
+    restore_cache:
+      keys:
+        - v1_bundler_deps-{{ .Environment.CIRCLE_JOB }}
+  save: &save
+    save_cache:
+      paths:
+        - ./vendor/bundle
+      key: v1_bundler_deps-{{ .Environment.CIRCLE_JOB }} # CIRCLE_JOB e.g. "ruby-2.5"
+  hatchet_setup: &hatchet_setup
+    run:
+      name: Hatchet setup
+      command: |
+        bundle exec hatchet ci:setup
+  bundle: &bundle
+    run:
+      name: install dependencies
+      command: |
+        bundle install --jobs=4 --retry=3 --path vendor/bundle
+        bundle update
+        bundle clean
+jobs:
+  "ruby-2.7":
+    docker:
+      - image: circleci/ruby:2.7
+    steps:
+      - checkout
+      - <<: *restore
+      - <<: *bundle
+      - <<: *hatchet_setup
+      - <<: *unit
+      - <<: *save
+
+workflows:
+  version: 2
+  build:
+    jobs:
+      - "ruby-2.7"
+

data/lib/hatchet/templates/dependabot.erb

@@ -0,0 +1,9 @@
+version: 1
+updates:
+  - package-ecosystem: "bundler"
+    directory: "/"
+    open-pull-requests-limit: 1 # Limit concurrent CI runs from executing
+    schedule:
+      interval: "weekly"
+    labels:
+      - "dependencies"

data/lib/hatchet/templates/hatchet_json.erb

@@ -0,0 +1,11 @@
+{
+  "ruby_apps": [
+    "sharpstone/default_ruby"
+  ],
+  "node_apps": [
+    "heroku/node-js-getting-started"
+  ],
+  "python_apps": [
+    "heroku/python-getting-started"
+  ]
+}

data/lib/hatchet/templates/spec_helper.erb

@@ -0,0 +1,30 @@
+require "bundler/setup"
+
+require 'rspec/retry'
+
+ENV["HATCHET_BUILDPACK_BASE"] = "<%= cmd("git config --get remote.origin.url")  %>"
+
+require 'hatchet'
+require 'pathname'
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+  config.verbose_retry       = true # show retry status in spec process
+  config.default_retry_count = 2 if ENV['IS_RUNNING_ON_CI'] # retry all tests that fail again
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end
+
+def run!(cmd)
+  out = `#{cmd}`
+  raise "Error running #{cmd}, output: #{out}" unless $?.success?
+  out
+end
+
+def spec_dir
+  Pathname.new(__dir__)
+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.1.1"
+  VERSION = "7.3.1"
 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