heroku_hatchet 7.1.2 → 7.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1896d0a09cfae27ff55b130431dcab677ab7ee5a11851c52d23f32abb1d773db
-  data.tar.gz: 50827926cffb6d14894c4fac985bdaf9ac88645a4640e8d3e203cad6ba405e90
+  metadata.gz: 960b3c8f2eee0b1252df5b2e6ce23b718de130d099f913812bd5fbb196c3b006
+  data.tar.gz: 3dec91bb9b7de86d3aef2ef78086f29239f078d1c6c004244b3ead7aaf139a58
 SHA512:
-  metadata.gz: '07895d1b500d6f1d40cd50786440aa4156703ebae3c9eb92af96e1662400f66d493ce413d104e882d338e6b8990136f8a2b967130298c7d154e4b2abd77c6227'
-  data.tar.gz: 82766796bfabe96afed53caec7aa1e78d4a788583a544c2a07130eb66265f598f7c1d15b693bd6b95f79dea15c3c8336bb6bd4d0260c8fd802c067e5fd531331
+  metadata.gz: b19e39c4963c64a5448f5b4ff4961722e1c17b020d3c6a8f3ef102a1bb136ba2feb504afddc8cbb6a286f384806776ebfdfebb76834f3d1a3eb37af36cbe4532
+  data.tar.gz: 3cc4cb2320f711e1d5fbb2024dc7a7ff1d734158b2f89322104a162fc00a2cb21940cf520f64e679b948c1a9be4bedeb3735c447c8287496438d1265bd372104

data/.circleci/config.yml

@@ -29,9 +29,9 @@ references:
         bundle clean
 
 jobs:
-  "ruby-2.5":
+  "ruby-2.2":
     docker:
-      - image: circleci/ruby:2.5
+      - image: circleci/ruby:2.2
     steps:
       - checkout
       - <<: *restore
@@ -39,9 +39,9 @@ jobs:
       - <<: *hatchet_setup
       - <<: *unit
       - <<: *save
-  "ruby-2.6":
+  "ruby-2.5":
     docker:
-      - image: circleci/ruby:2.6
+      - image: circleci/ruby:2.5
     steps:
       - checkout
       - <<: *restore
@@ -64,6 +64,6 @@ workflows:
   version: 2
   build:
     jobs:
+      - "ruby-2.2"
       - "ruby-2.5"
-      - "ruby-2.6"
       - "ruby-2.7"

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,45 @@
 ## HEAD
 
+## 7.3.2
+
+- Fix App#in_directory_fork not receiving debugging output when an error is raised (https://github.com/heroku/hatchet/pull/146)
+- Do not create CI tarball inside cwd to prevent tar "file changed as we read it" warnings.
+
+## 7.3.1
+
+- Fix Ruby incompatibility introduced by using `&.` and `rescue` without
+  `begin`/`end` without a `required_ruby_version` in hatchet.gemspec.
+  (https://github.com/heroku/hatchet/pull/139)
+
+## 7.3.0
+
+- Deprecations
+  - Deprecation: Calling `App#before_deploy` as a way to clear/replace the existing block should now be done with `App#before_deploy(:replace)` (https://github.com/heroku/hatchet/pull/126)
+  - Deprecation: HATCHET_BUILDPACK_BASE default (https://github.com/heroku/hatchet/pull/133)
+  - Deprecation: App#directory (https://github.com/heroku/hatchet/pull/135)
+
+- Flappy test improvements
+  - Increase CI timeout limit to 900 seconds (15 minutes) (https://github.com/heroku/hatchet/pull/137)
+  - Empty string returns from App#run now trigger retries (https://github.com/heroku/hatchet/pull/132)
+  - Rescue 403 on pipeline delete (https://github.com/heroku/hatchet/pull/130)
+  - Additional rate throttle cases handled (https://github.com/heroku/hatchet/pull/128)
+
+- Usability
+  - Annotate rspec expectation failures inside of deploy blocks with hatchet debug information (https://github.com/heroku/hatchet/pull/136)
+  - Hatchet#new raises a helpful error when no source code location is provided (https://github.com/heroku/hatchet/pull/134)
+  - Lazy evaluation of HATCHET_BUILDPACK_BASE env var (https://github.com/heroku/hatchet/pull/133)
+  - Allow multiple `App#before_deploy` blocks to be set and called (https://github.com/heroku/hatchet/pull/126)
+  - Performance improvement when running without an explicit HEROKU_API_KEY set (https://github.com/heroku/hatchet/pull/128)
+
+## 7.2.0
+
+- 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)

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.
 
@@ -484,7 +525,7 @@ end
 
 In this example, the app would use the nodejs buildpack, and then `:default` gets replaced by your Git url and branch name.
 
-- before_deploy (Block): Instead of using the `tap` syntax you can provide a block directly to hatchet app initialization:
+- before_deploy (Block): Instead of using the `tap` syntax you can provide a block directly to hatchet app initialization. Example:
 
 ```ruby
 Hatchet::Runner.new("default_ruby", before_deploy: ->{ FileUtils.touch("foo.txt")}).deploy do
@@ -589,6 +630,23 @@ Hatchet::Runner.new("default_ruby", before_deploy: before_deploy_proc).deploy do
 end
 ```
 
+You can call multiple blocks by specifying (`:prepend` or `:append`):
+
+```ruby
+Hatchet::Runner.new("default_ruby").tap do |app|
+  app.before_deploy do
+    FileUtils.touch("foo.txt")
+  end
+
+  app.before_deploy(:append) do
+    FileUtils.touch("bar.txt")
+  end
+  app.deploy do
+  end
+end
+```
+
+
 - `app.commit!`: Will updates the contents of your local git dir if you've modified files on disk
 
 ```ruby
@@ -619,7 +677,7 @@ end
 > Note: If you want to execute tests in this temp directory, you likely want to use `in_directory_fork` otherwise, you might accidentally contaminate the current environment's variables if you modify them.
 
 - `app.in_directory_fork`: Runs the given block in a temp directory and inside of a forked process, an example given above.
-- `app.directory`: Returns the directory of the example application on disk, this is NOT the temp directory that you're currently executing against. It's probably not what you want.
+- `app.original_source_code_directory`: Returns the directory of the example application on disk, this is NOT the temp directory that you're currently executing against. It's probably not what you want.
 - `app.deploy`: Your main method takes a block to execute after the deploy is successful. If no block is provided, you must manually call `app.teardown!` (see below for an example).
 - `app.output`: The output contents of the deploy
 - `app.platform_api`: Returns an instance of the [platform-api Heroku client](https://github.com/heroku/platform-api). If Hatchet doesn't give you access to a part of Heroku that you need, you can likely do it with the platform-api client.

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?
@@ -46,7 +52,7 @@ class HatchetCLI < Thor
       Threaded.later do
         commit = lock_hash[directory]
         directory = File.expand_path(directory)
-        if !Dir[directory]&.empty?
+        if !(Dir[directory] && Dir[directory].empty?)
           puts "== pulling '#{git_repo}' into '#{directory}'\n"
           pull(directory, git_repo)
         else

data/hatchet.gemspec

@@ -17,17 +17,17 @@ Gem::Specification.new do |gem|
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
+  gem.required_ruby_version = '>= 2.2.0'
 
   gem.add_dependency "platform-api",  "~> 3"
   gem.add_dependency "rrrretry",      "~> 1"
   gem.add_dependency "excon",         "~> 0"
-  gem.add_dependency "thor",          "~> 0"
+  gem.add_dependency "thor",          "~> 1"
   gem.add_dependency "threaded",      "~> 0"
 
   gem.add_development_dependency "rspec"
   gem.add_development_dependency "rake",           ">= 10"
   gem.add_development_dependency "mocha",          ">= 1"
   gem.add_development_dependency "parallel_split_test"
-  gem.add_development_dependency "travis",         ">= 1"
   gem.add_development_dependency "rspec-retry"
 end

data/lib/hatchet.rb

@@ -18,6 +18,8 @@ require 'hatchet/anvil_app'
 require 'hatchet/git_app'
 require 'hatchet/config'
 require 'hatchet/api_rate_limit'
+require 'hatchet/init_project'
+require 'hatchet/heroku_run'
 
 module Hatchet
   RETRIES = Integer(ENV['HATCHET_RETRIES']   || 1)
@@ -30,7 +32,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
@@ -44,3 +46,22 @@ module Hatchet
     end
   end
 end
+
+unless ::String.instance_methods.include?(:strip_heredoc)
+  # We can get rid of this when all rubies can support <<~ syntax
+  class ::String
+    def strip_heredoc
+      gsub(/^#{scan(/^[ \t]*(?=\S)/).min}/, "".freeze)
+    end
+  end
+end
+
+unless ::String.instance_methods.include?(:match?)
+  # We can get rid of this when all rubies can support String#match? method
+  class ::String
+    def match?(value)
+      self =~ value
+    end
+  end
+end
+

data/lib/hatchet/app.rb

@@ -5,11 +5,15 @@ require 'tmpdir'
 
 module Hatchet
   class App
-    HATCHET_BUILDPACK_BASE   = (ENV['HATCHET_BUILDPACK_BASE'] || "https://github.com/heroku/heroku-buildpack-ruby.git")
+    HATCHET_BUILDPACK_BASE = -> {
+      ENV.fetch('HATCHET_BUILDPACK_BASE') {
+        warn "ENV HATCHET_BUILDPACK_BASE is not set. It currently defaults to the ruby buildpack. In the future this env var will be required"
+        "https://github.com/heroku/heroku-buildpack-ruby.git"
+      }
+    }
     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, :max_retries_count
+    attr_reader :name, :stack, :repo_name, :app_config, :buildpacks, :reaper, :max_retries_count
 
     class FailedDeploy < StandardError; end
 
@@ -18,7 +22,7 @@ module Hatchet
 
       def initialize(app, message, output: )
         @output = output
-        msg = "Could not deploy '#{app.name}' (#{app.repo_name}) using '#{app.class}' at path: '#{app.directory}'\n"
+        msg = "Could not deploy '#{app.name}' (#{app.repo_name}) using '#{app.class}' at path: '#{app.original_source_code_directory}'\n"
         msg << "if this was expected add `allow_failure: true` to your deploy hash.\n"
         msg << "#{message}\n"
         msg << "output:\n"
@@ -32,7 +36,7 @@ module Hatchet
 
       def initialize(app, message, output: )
         @output = output
-        msg = "Could not release '#{app.name}' (#{app.repo_name}) using '#{app.class}' at path: '#{app.directory}'\n"
+        msg = "Could not release '#{app.name}' (#{app.repo_name}) using '#{app.class}' at path: '#{app.original_source_code_directory}'\n"
         msg << "if this was expected add `allow_failure: true` to your deploy hash.\n"
         msg << "#{message}\n"
         msg << "output:\n"
@@ -42,8 +46,9 @@ module Hatchet
     end
 
     SkipDefaultOption = Object.new
+    DEFAULT_REPO_NAME = Object.new
 
-    def initialize(repo_name,
+    def initialize(repo_name = DEFAULT_REPO_NAME,
                    stack: "",
                    name: default_name,
                    debug: nil,
@@ -58,6 +63,7 @@ module Hatchet
                    retries: RETRIES,
                    config: {}
                   )
+      raise "You tried creating a Hatchet::App instance without source code, pass in a path to an app to deploy or the name of an app in your hatchet.json" if repo_name == DEFAULT_REPO_NAME
       @repo_name     = repo_name
       @directory     = self.config.path_for_name(@repo_name)
       @name          = name
@@ -78,13 +84,36 @@ module Hatchet
       @already_in_dir = nil
       @app_is_setup = nil
 
-      @before_deploy = before_deploy
+      @before_deploy_array = []
+      @before_deploy_array << before_deploy if before_deploy
       @app_config    = config
       @reaper        = Reaper.new(api_rate_limit: api_rate_limit)
     end
 
+    private def test_failure_classes
+      class_array = []
+      class_array << RSpec::Expectations::ExpectationNotMetError if defined?(RSpec::Expectations::ExpectationNotMetError)
+      class_array
+    end
+
+    def annotate_failures
+      yield
+    rescue *test_failure_classes => e
+      raise e, "App: #{name} (#{@repo_name})\n#{e.message}"
+    end
+
+    def directory
+      warn "Calling App#directory returns the original location of the app's source code that should not be modified, if this is really what you want use `original_source_code_directory` instead."
+      warn caller
+      @directory
+    end
+
+    def original_source_code_directory
+      @directory
+    end
+
     def self.default_buildpack
-      [HATCHET_BUILDPACK_BASE, HATCHET_BUILDPACK_BRANCH.call].join("#")
+      [HATCHET_BUILDPACK_BASE.call, HATCHET_BUILDPACK_BRANCH.call].join("#")
     end
 
     def allow_failure?
@@ -157,32 +186,17 @@ module Hatchet
         command = command.to_s
       end
 
-      heroku_command = build_heroku_command(command, options)
-
       allow_run_multi! if @run_multi
 
-      output = ""
-
-      ShellThrottle.new(platform_api: @platform_api).call do |throttle|
-        output = `#{heroku_command}`
-        throw(:throttle) if output.match?(/reached the API rate limit/)
-      end
-
-      return output
-    end
-
-    private def build_heroku_command(command, options = {})
-      command = command.shellescape unless options.delete(:raw)
+      run_obj = Hatchet::HerokuRun.new(
+        command,
+        app: self,
+        retry_on_empty: options.fetch(:retry_on_empty, !ENV["HATCHET_DISABLE_EMPTY_RUN_RETRY"]),
+        heroku: options[:heroku],
+        raw: options[:raw]
+      ).call
 
-      default_options = { "app" => name, "exit-code" => nil }
-      heroku_options = (default_options.merge(options.delete(:heroku) || {})).map do |k,v|
-        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.join(" ")
-
-      "heroku run #{heroku_options} -- #{command}"
+      return run_obj.output
     end
 
     private def allow_run_multi!
@@ -191,7 +205,6 @@ module Hatchet
       @run_multi_is_setup ||= platform_api.formation.update(name, "web", {"size" => "Standard-1X"})
     end
 
-
     # Allows multiple commands to be run concurrently in the background.
     #
     # WARNING! Using the feature requres that the underlying app is not on the "free" Heroku
@@ -229,23 +242,15 @@ module Hatchet
       allow_run_multi!
 
       run_thread = Thread.new do
-        heroku_command = build_heroku_command(command, options)
-
-        out = nil
-        status = nil
-        ShellThrottle.new(platform_api: @platform_api).call do |throttle|
-          out = `#{heroku_command}`
-          throw(:throttle) if output.match?(/reached the API rate limit/)
-          status = $?
-        end
-
-        yield out, status
-
-        # if block.arity == 1
-        #   block.call(out)
-        # else
-        #   block.call(out, status)
-        # end
+        run_obj = Hatchet::HerokuRun.new(
+          command,
+          app: self,
+          retry_on_empty: options.fetch(:retry_on_empty, !ENV["HATCHET_DISABLE_EMPTY_RUN_RETRY"]),
+          heroku: options[:heroku],
+          raw: options[:raw]
+        ).call
+
+        yield run_obj.output, run_obj.status
       end
       run_thread.abort_on_exception = true
 
@@ -297,22 +302,46 @@ 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!
 
-    def before_deploy(&block)
+    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(behavior = :default, &block)
       raise "block required" unless block
-      @before_deploy = block
+
+      case behavior
+      when :default, :replace
+        if @before_deploy_array.any? && behavior == :default
+          STDERR.puts "Calling App#before_deploy multiple times will overwrite the contents. If you intended this: use `App#before_deploy(:replace)`"
+          STDERR.puts "In the future, calling this method with no arguements will default to `App#before_deploy(:append)` behavior.\n#{caller.join("\n")}"
+        end
+
+        @before_deploy_array.clear
+        @before_deploy_array << block
+      when :prepend
+        @before_deploy_array = [block] + @before_deploy_array
+      when :append
+        @before_deploy_array << block
+      else
+        raise "Unrecognized behavior: #{behavior.inspect}, valid inputs are :append, :prepend, and :replace"
+      end
 
       self
     end
@@ -338,14 +367,14 @@ module Hatchet
       @reaper.cycle if @app_is_setup
     end
 
-    def in_directory(directory = self.directory)
-      yield directory and return if @already_in_dir
+    def in_directory
+      yield and return if @already_in_dir
 
       Dir.mktmpdir do |tmpdir|
-        FileUtils.cp_r("#{directory}/.", "#{tmpdir}/.")
+        FileUtils.cp_r("#{original_source_code_directory}/.", "#{tmpdir}/.")
         Dir.chdir(tmpdir) do
           @already_in_dir = true
-          yield directory
+          yield
           @already_in_dir = false
         end
       end
@@ -358,8 +387,8 @@ module Hatchet
     def in_directory_fork(&block)
       Tempfile.create("stdout") do |tmp_file|
         pid = fork do
-          $stdout.reopen(tmp_file, "w")
-          $stderr.reopen(tmp_file, "w")
+          $stdout.reopen(tmp_file, "a")
+          $stderr.reopen(tmp_file, "a")
           $stdout.sync = true
           $stderr.sync = true
           in_directory do |dir|
@@ -379,9 +408,11 @@ module Hatchet
 
     def deploy(&block)
       in_directory do
-        self.setup!
-        self.push_with_retry!
-        block.call(self, api_rate_limit.call, output) if block_given?
+        annotate_failures do
+          in_dir_setup!
+          self.push_with_retry!
+          block.call(self, api_rate_limit.call, output) if block_given?
+        end
       end
     ensure
       self.teardown! if block_given?
@@ -415,26 +446,26 @@ module Hatchet
     end
 
     def api_key
-      @api_key ||= ENV['HEROKU_API_KEY'] || `heroku auth:token`.chomp
+      @api_key ||= ENV['HEROKU_API_KEY'] ||= `heroku auth:token`.chomp
     end
 
     def heroku
       raise "Not supported, use `platform_api` instead."
     end
 
-    def run_ci(timeout: 300, &block)
+    def run_ci(timeout: 900, &block)
       in_directory do
         max_retries_count.times.retry do
           result       = create_pipeline
           @pipeline_id = result["id"]
         end
 
-        # when the CI run finishes, the associated ephemeral app created for the test run internally gets removed almost immediately
+        # When the CI run finishes, the associated ephemeral app created for the test run internally gets removed almost immediately
         # the system then sees a pipeline with no apps, and deletes it, also almost immediately
         # 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!
+        in_dir_setup!
         max_retries_count.times.retry do
           couple_pipeline(@name, @pipeline_id)
         end
@@ -487,6 +518,9 @@ module Hatchet
 
     def delete_pipeline(pipeline_id)
       api_rate_limit.call.pipeline.delete(pipeline_id)
+    rescue Excon::Error::Forbidden
+      warn "Error deleting pipeline id: #{pipeline_id.inspect}, status: 403"
+      # Means the pipeline likely doesn't exist, not sure why though
     end
 
     def platform_api
@@ -526,14 +560,17 @@ module Hatchet
     end
 
     private def call_before_deploy
-      return unless @before_deploy
-      raise "before_deploy: #{@before_deploy.inspect} must respond to :call"  unless @before_deploy.respond_to?(:call)
-      raise "before_deploy: #{@before_deploy.inspect} must respond to :arity" unless @before_deploy.respond_to?(:arity)
+      return unless @before_deploy_array.any?
 
-      if @before_deploy.arity == 1
-        @before_deploy.call(self)
-      else
-        @before_deploy.call
+      @before_deploy_array.each do |block|
+        raise "before_deploy: #{block.inspect} must respond to :call"  unless block.respond_to?(:call)
+        raise "before_deploy: #{block.inspect} must respond to :arity" unless block.respond_to?(:arity)
+
+        if block.arity == 1
+          block.call(self)
+        else
+          block.call
+        end
       end
 
       commit! if needs_commit?