heroku_hatchet 7.0.0 → 7.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89dec86ebf0199547ebf527242257a88b26c2741b272aa73945b4c907b72f51a
-  data.tar.gz: fe0bd8c520fc7102e13ad6f91da96b837158f0ba8eaa324c846e3acc92cb233f
+  metadata.gz: 2dd4a304828fca43576fed5a71b7be305142c3220c7dd020bff44b17a4a070a0
+  data.tar.gz: c0dee0a8ffb794f10a3dbb96beeafa26dd5f95b489eb9638a40bf408dce44c11
 SHA512:
-  metadata.gz: bad4717807a5cddb7b0cdd2750bdd1811b8b012e767d92173f364795eb1da3a8af41fddb28269d14c67ad8d2cfe7e7d4c7f9cefbbafd575172408787cca41142
-  data.tar.gz: b2f7905e07091c4b66ad7b6ba4ac00b8e304e32f10c01a259723cb5e12e592160f9ca30cb66f5485c3bc59dffa26d99bbba070f73be161022d85e63c6afd4409
+  metadata.gz: f6fa0cef6167e9b4985b08f01e42f33410632d4dfb083551d2641e7009745a079044f606cc4456ed8b8f0dfb0ec087b9b3197d1dabb9a0c41cd7f96ee978e22c
+  data.tar.gz: 50689c87372d4df2fc7d354ccc0f6f870285283869a190f3272f76d0d238e2d3cd13ca485ca6436916a6976c847fbd2be057fbe4e99ed1aa8ac97abdfef9eeb9

data/.github/workflows/check_changelog.yml

@@ -1,7 +1,8 @@
 name: Check Changelog
 
-on: [pull_request]
-
+on:
+ pull_request:
+  types: [opened, reopened, edited, synchronize]
 jobs:
   build:
     runs-on: ubuntu-latest

data/CHANGELOG.md

@@ -1,5 +1,30 @@
 ## HEAD
 
+## 7.1.4
+
+- App#setup! no longer modifies files on disk. (https://github.com/heroku/hatchet/pull/125)
+- Add `$ hatchet init` command for bootstrapping new projects (https://github.com/heroku/hatchet/pull/123)
+
+## 7.1.3
+
+- Important!! Fix branch name detection on CircleCI (https://github.com/heroku/hatchet/pull/124)
+
+## 7.1.2
+
+- Fix support for Hatchet deploying the 'main' branch (https://github.com/heroku/hatchet/pull/122)
+
+## 7.1.1
+
+- Fix destroy_all functionality (https://github.com/heroku/hatchet/pull/121)
+
+## 7.1.0
+
+- Initializing an `App` can now take a `retries` key to overload the global hatchet env var (https://github.com/heroku/hatchet/pull/119)
+- Calling `App#commit!` now adds an empty commit if there is no changes on disk (https://github.com/heroku/hatchet/pull/119)
+- Bugfix: Failed release phase in deploys can now be re-run (https://github.com/heroku/hatchet/pull/119)
+- Bugfix: Allow `hatchet lock` to be run against new projects (https://github.com/heroku/hatchet/pull/118)
+- Bugfix: Allow `hatchet.lock` file to lock a repo to a different branch than what is specified as default for GitHub (https://github.com/heroku/hatchet/pull/118)
+
 ## 7.0.0
 
 - ActiveSupport's Object#blank? and Object#present? are no longer provided by default (https://github.com/heroku/hatchet/pull/107)

data/README.md

@@ -57,6 +57,8 @@ In addition to speed, Hatchet provides isolation. Suppose you're executing `bin/
 
 ## Quicklinks
 
+- Getting started
+  - [Add hatchet tests to a existing buildpack](#hatchet-init)
 - Concepts
   - [Tell Hatchet how to find your buildpack](#specify-buildpack)
   - [Give Hatchet some example apps to deploy](#example-apps)
@@ -78,6 +80,45 @@ In addition to speed, Hatchet provides isolation. Suppose you're executing `bin/
   - [Introduction to the Rspec testing framework for non-rubyists](#basic-rspec)
   - [Introduction to Ruby for non-rubyists](#basic-ruby)
 
+## Getting Started
+
+### Hatchet Init
+
+If you're working in a project that does not already have hatchet tests you can run this command to get started quickly:
+
+Make sure you're in directory that contains your buildpack and run:
+
+```
+$ gem install heroku_hatchet
+$ hatchet init
+```
+
+This will bootstrap your project with the necessarry files to test your buildpack. Including but not limited to:
+
+- Gemfile
+- hatchet.json
+- spec/spec_helper.rb
+- spec/hatchet/buildpack_spec.rb
+- .circleci/config.yml
+- .github/dependabot.yml
+- .gitignore
+
+Once this executes successfully then you can run your tests with:
+
+```
+$ bundle exec rspec
+```
+
+> Note: You'll need to update the `buildpack_spec.rb` file to remove the exception
+
+You can also focus a specific file or test by providing a path and line number:
+
+```
+$ bundle exec rspec spec/hatchet/buildpack_spec:5
+```
+
+Keep reading to find out more about how hatchet works.
+
 ## Concepts
 
 ### Specify buildpack
@@ -89,7 +130,7 @@ ENV["HATCHET_BUILDPACK_BASE"] = "https://github.com/path-to-your/buildpack"
 require 'hatchet'`
 ```
 
-If you do not specify `HATCHET_BUILDPACK_URL` the default Ruby buildpack will be used. If you do not specify a `HATCHET_BUILDPACK_BRANCH` the current branch you are on will be used. This is how the Ruby buildpack runs tests on branches on CI (by leaving `HATCHET_BUILDPACK_BRANCH` blank).
+If you do not specify `HATCHET_BUILDPACK_BASE` the default Ruby buildpack will be used. If you do not specify a `HATCHET_BUILDPACK_BRANCH` the current branch you are on will be used. This is how the Ruby buildpack runs tests on branches on CI (by leaving `HATCHET_BUILDPACK_BRANCH` blank).
 
 The workflow generally looks like this:
 
@@ -156,7 +197,7 @@ You can reference one of these applications in your test by using it's git name:
 Hatchet::Runner.new('no_lockfile')
 ```
 
-If you have conflicting names, use full paths like `Hatchet::RUnner.new("sharpstone/no_lockfile")`.
+If you have conflicting names, use full paths like `Hatchet::Runner.new("sharpstone/no_lockfile")`.
 
 When you run `hatchet install` it will lock all the Repos to a specific commit. This is done so that if a repo changes upstream that introduces an error the test suite won't automatically pick it up. For example in https://github.com/sharpstone/lock_fail/commit/e61ba47043fbae131abb74fd74added7e6e504df an error is added, but this will only cause a failure if your project intentionally locks to commit `e61ba47043fbae131abb74fd74added7e6e504df` or later.
 
@@ -531,6 +572,8 @@ WARNING: Enabling `run_multi` setting on an app will charge your Heroku account
 WARNING: Do not use `run_multi` if you're not using the `deploy` block syntax or manually call `teardown!` inside the text context [more info about how behavior does not work with the `after` block syntax in rspec](https://github.com/heroku/hatchet/issues/110).
 WARNING: To work, `run_multi` requires your application to have a `web` process associated with it.
 
+- `retries` (Integer): When passed in, this value will be used insead of the global `HATCHET_RETRIES` set via environment variable. When `allow_failures: true` is set as well as a retries value, then the application will not retry pushing to Heroku.
+
 ### App methods:
 
 - `app.set_config()`: Updates the configuration on your app taking in a hash

data/bin/hatchet

@@ -15,8 +15,14 @@ require 'thor'
 require 'threaded'
 require 'date'
 require 'yaml'
+require 'pathname'
 
 class HatchetCLI < Thor
+  desc "init", "bootstraps a project with minimal files required to add hatchet tests"
+  define_method("init") do
+    Hatchet::InitProject.new.call
+  end
+
   desc "ci:install_heroku", "installs the `heroku` cli"
   define_method("ci:install_heroku") do
     if `which heroku` && $?.success?
@@ -67,7 +73,7 @@ class HatchetCLI < Thor
   desc "locks to specific git commits", "updates hatchet.lock"
   def lock
     lock_hash = {}
-    lockfile_hash = load_lockfile
+    lockfile_hash = load_lockfile(create_if_does_not_exist: true)
     dirs.map do |directory, git_repo|
       Threaded.later do
         puts "== locking #{directory}"
@@ -118,10 +124,15 @@ class HatchetCLI < Thor
   end
 
   private
-  def load_lockfile
+  def load_lockfile(create_if_does_not_exist: false)
     return YAML.safe_load(File.read('hatchet.lock')).to_h
   rescue Errno::ENOENT
-    raise "No such file found `hatchet.lock` please run `$ bundle exec hatchet lock`"
+    if create_if_does_not_exist
+      FileUtils.touch('hatchet.lock')
+      {}
+    else
+      raise "No such file found `hatchet.lock` please run `$ bundle exec hatchet lock`"
+    end
   end
 
   def bad_repo?(url)
@@ -151,7 +162,7 @@ class HatchetCLI < Thor
   end
 
   def checkout_commit(directory, commit)
-    cmd("cd #{directory} && git reset --hard #{commit}")
+    cmd("cd #{directory} && git fetch origin #{commit} && git checkout #{commit} && git checkout - && git reset --hard #{commit}")
   end
 
   def commit_at_directory(directory)

data/lib/hatchet.rb

@@ -18,6 +18,7 @@ require 'hatchet/anvil_app'
 require 'hatchet/git_app'
 require 'hatchet/config'
 require 'hatchet/api_rate_limit'
+require 'hatchet/init_project'
 
 module Hatchet
   RETRIES = Integer(ENV['HATCHET_RETRIES']   || 1)
@@ -30,7 +31,7 @@ module Hatchet
     return ENV['TRAVIS_PULL_REQUEST_BRANCH'] if ENV['TRAVIS_PULL_REQUEST_BRANCH'] && !ENV['TRAVIS_PULL_REQUEST_BRANCH'].empty?
     return ENV['TRAVIS_BRANCH'] if ENV['TRAVIS_BRANCH']
 
-    out = `git describe --contains --all HEAD`.strip
+    out = `git rev-parse --abbrev-ref HEAD`.strip
     raise "Attempting to find current branch name. Error: Cannot describe git: #{out}" unless $?.success?
     out
   end

data/lib/hatchet/app.rb

@@ -9,7 +9,7 @@ module Hatchet
     HATCHET_BUILDPACK_BRANCH = -> { ENV['HATCHET_BUILDPACK_BRANCH'] || ENV['HEROKU_TEST_RUN_BRANCH'] || Hatchet.git_branch }
     BUILDPACK_URL = "https://github.com/heroku/heroku-buildpack-ruby.git"
 
-    attr_reader :name, :stack, :directory, :repo_name, :app_config, :buildpacks, :reaper
+    attr_reader :name, :stack, :directory, :repo_name, :app_config, :buildpacks, :reaper, :max_retries_count
 
     class FailedDeploy < StandardError; end
 
@@ -55,6 +55,7 @@ module Hatchet
                    buildpack_url: nil,
                    before_deploy: nil,
                    run_multi: ENV["HATCHET_RUN_MULTI"],
+                   retries: RETRIES,
                    config: {}
                   )
       @repo_name     = repo_name
@@ -68,6 +69,7 @@ module Hatchet
       @buildpacks    = Array(@buildpacks)
       @buildpacks.map! {|b| b == :default ? self.class.default_buildpack : b}
       @run_multi = run_multi
+      @max_retries_count = retries
 
       if run_multi && !ENV["HATCHET_EXPENSIVE_MODE"]
         raise "You're attempting to enable `run_multi: true` mode, but have not enabled `HATCHET_EXPENSIVE_MODE=1` env var to verify you understand the risks"
@@ -129,7 +131,7 @@ module Hatchet
     end
 
     def add_database(plan_name = 'heroku-postgresql:dev', match_val = "HEROKU_POSTGRESQL_[A-Z]+_URL")
-      Hatchet::RETRIES.times.retry do
+      max_retries_count.times.retry do
         # heroku.post_addon(name, plan_name)
         api_rate_limit.call.addon.create(name, plan: plan_name )
         _, value = get_config.detect {|k, v| k.match(/#{match_val}/) }
@@ -295,19 +297,27 @@ module Hatchet
     def setup!
       return self if @app_is_setup
       puts "Hatchet setup: #{name.inspect} for #{repo_name.inspect}"
-      create_git_repo! unless is_git_repo?
       create_app
       set_labs!
       buildpack_list = @buildpacks.map { |pack| { buildpack: pack } }
       api_rate_limit.call.buildpack_installation.update(name, updates: buildpack_list)
       set_config @app_config
 
-      call_before_deploy
       @app_is_setup = true
       self
     end
     alias :setup :setup!
 
+    private def in_dir_setup!
+      setup!
+      raise "Error you're in #{Dir.pwd} and might accidentally modify your disk contents" unless @already_in_dir
+      @in_dir_setup ||= begin
+        create_git_repo! unless is_git_repo?
+        call_before_deploy
+        true
+      end
+    end
+
     def before_deploy(&block)
       raise "block required" unless block
       @before_deploy = block
@@ -316,7 +326,7 @@ module Hatchet
     end
 
     def commit!
-      local_cmd_exec!('git add .; git commit -m next')
+      local_cmd_exec!('git add .; git commit --allow-empty -m next')
     end
 
     def push_without_retry!
@@ -377,7 +387,7 @@ module Hatchet
 
     def deploy(&block)
       in_directory do
-        self.setup!
+        in_dir_setup!
         self.push_with_retry!
         block.call(self, api_rate_limit.call, output) if block_given?
       end
@@ -386,12 +396,12 @@ module Hatchet
     end
 
     def push
-      max_retries = @allow_failure ? 1 : RETRIES
-      max_retries.times.retry do |attempt|
+      retry_count = allow_failure? ? 1 : max_retries_count
+      retry_count.times.retry do |attempt|
         begin
           @output = self.push_without_retry!
         rescue StandardError => error
-          puts retry_error_message(error, attempt, max_retries)
+          puts retry_error_message(error, attempt) unless retry_count == 1
           raise error
         end
       end
@@ -400,10 +410,10 @@ module Hatchet
     alias :push_with_retry  :push
     alias :push_with_retry! :push_with_retry
 
-    def retry_error_message(error, attempt, max_retries)
+    def retry_error_message(error, attempt)
       attempt += 1
-      return "" if attempt == max_retries
-      msg = "\nRetrying failed Attempt ##{attempt}/#{max_retries} to push for '#{name}' due to error: \n"<<
+      return "" if attempt == max_retries_count
+      msg = "\nRetrying failed Attempt ##{attempt}/#{max_retries_count} to push for '#{name}' due to error: \n"<<
             "#{error.class} #{error.message}\n  #{error.backtrace.join("\n  ")}"
       return msg
     end
@@ -422,7 +432,7 @@ module Hatchet
 
     def run_ci(timeout: 300, &block)
       in_directory do
-        Hatchet::RETRIES.times.retry do
+        max_retries_count.times.retry do
           result       = create_pipeline
           @pipeline_id = result["id"]
         end
@@ -432,8 +442,8 @@ module Hatchet
         # that would, with bad timing, mean our test run info poll in wait! would 403, and/or the delete_pipeline at the end
         # that's why we create an app explictly (or maybe it already exists), and then associate it with with the pipeline
         # the app will be auto cleaned up later
-        self.setup!
-        Hatchet::RETRIES.times.retry do
+        in_dir_setup!
+        max_retries_count.times.retry do
           couple_pipeline(@name, @pipeline_id)
         end
 
@@ -446,7 +456,7 @@ module Hatchet
           api_rate_limit: api_rate_limit
         )
 
-        Hatchet::RETRIES.times.retry do
+        max_retries_count.times.retry do
           test_run.create_test_run
         end
         test_run.wait!(&block)

data/lib/hatchet/git_app.rb

@@ -25,7 +25,7 @@ module Hatchet
     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)
@@ -33,6 +33,7 @@ module Hatchet
 
       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)
       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

@@ -80,7 +80,7 @@ module Hatchet
 
     # No guardrails, will delete all apps that match the hatchet namespace
     def destroy_all
-      get_apps
+      refresh_app_list
 
       (@finished_hatchet_apps + @unfinished_hatchet_apps).each do |app|
         begin

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

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

data/spec/hatchet/allow_failure_git_spec.rb

@@ -13,14 +13,29 @@ describe "AllowFailureGitTest" do
     }
 
     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 {
-        Hatchet::GitApp.new("default_ruby", before_deploy: release_fail_proc).deploy {}
-      }.to(raise_error(Hatchet::App::FailedReleaseError))
+        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).deploy do |app|
-        expect(app.output).to match("failing on release")
+      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

data/spec/hatchet/app_spec.rb

@@ -1,6 +1,28 @@
 require("spec_helper")
 
 describe "AppTest" do
+  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
+
+
+        entries_array = Dir.entries(dir_1)
+        entries_array -= ["..", ".", "foo.txt"]
+        expect(entries_array).to be_empty
+      end
+    end
+  end
+
   it "rate throttles `git push` " do
     app = Hatchet::GitApp.new("default_ruby")
     def app.git_push_heroku_yall

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

@@ -13,14 +13,15 @@ describe "LocalRepoTest" do
 
   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

@@ -28,3 +28,54 @@ describe "LockTest" do
     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/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/reaper_spec.rb

@@ -1,6 +1,22 @@
 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)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: heroku_hatchet
 version: !ruby/object:Gem::Version
-  version: 7.0.0
+  version: 7.2.0
 platform: ruby
 authors:
 - Richard Schneeman
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-08-11 00:00:00.000000000 Z
+date: 2020-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: platform-api
@@ -192,11 +192,19 @@ files:
 - lib/hatchet/app.rb
 - lib/hatchet/config.rb
 - lib/hatchet/git_app.rb
+- lib/hatchet/init_project.rb
 - lib/hatchet/reaper.rb
 - lib/hatchet/reaper/app_age.rb
 - lib/hatchet/reaper/reaper_throttle.rb
 - lib/hatchet/shell_throttle.rb
 - lib/hatchet/tasks.rb
+- lib/hatchet/templates/Gemfile.erb
+- lib/hatchet/templates/buildpack_spec.erb
+- lib/hatchet/templates/check_changelog.erb
+- lib/hatchet/templates/circleci_template.erb
+- lib/hatchet/templates/dependabot.erb
+- lib/hatchet/templates/hatchet_json.erb
+- lib/hatchet/templates/spec_helper.erb
 - lib/hatchet/test_run.rb
 - lib/hatchet/version.rb
 - repo_fixtures/different-folder-for-checked-in-repos/default_ruby/Gemfile
@@ -211,6 +219,7 @@ files:
 - spec/hatchet/local_repo_spec.rb
 - spec/hatchet/lock_spec.rb
 - spec/spec_helper.rb
+- spec/unit/init_spec.rb
 - spec/unit/reaper_spec.rb
 - spec/unit/shell_throttle.rb
 - tmp/parallel_runtime_test.log
@@ -248,5 +257,6 @@ test_files:
 - spec/hatchet/local_repo_spec.rb
 - spec/hatchet/lock_spec.rb
 - spec/spec_helper.rb
+- spec/unit/init_spec.rb
 - spec/unit/reaper_spec.rb
 - spec/unit/shell_throttle.rb