heroku_hatchet 5.0.3 → 7.1.2

data/test/fixtures/buildpacks/null-buildpack/bin/compile

@@ -1,4 +0,0 @@
-#!/usr/bin/env bash
-# bin/compile <build-dir> <cache-dir>
-
-echo "-----> Nothing to do."

data/test/fixtures/buildpacks/null-buildpack/bin/detect

@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-# bin/detect <build-dir>
-
-echo "Null"
-exit 0

data/test/fixtures/buildpacks/null-buildpack/bin/release

@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-
-echo "--- {}"

data/test/fixtures/buildpacks/null-buildpack/hatchet.json

@@ -1,4 +0,0 @@
-{
-  "hatchet": {"directory": "../.."},
-  "rails3": ["sharpstone/rails3_mri_193"]
-}

data/test/fixtures/buildpacks/null-buildpack/readme.md

@@ -1,41 +0,0 @@
-# Heroku Buildpack: Ø
-
-Use Ø if you need Heroku to execute a binary.
-
-## Usage
-
-Create a directory for our Heroku app:
-
-```bash
-$ mkdir -p myapp/bin
-$ cd myapp
-```
-
-Here is an example of an executable that will run on 64bit linux machine:
-
-```bash
-$ echo -e "#\!/usr/bin/env bash\n echo hello world" > ./bin/program
-$ echo -e "program: bin/program" > Procfile
-$ chmod +x ./bin/program
-$ ./bin/program
-hello world
-```
-
-Push the app to Heroku and run our executable:
-
-```bash
-$ git init; git add .; git commit -am 'init'
-$ heroku create --buildpack http://github.com/ryandotsmith/null-buildpack.git
-$ git push heroku master
-$ heroku run program
-Running `program` attached to terminal... up, run.8663
-hello world
-```
-
-## Motivation
-
-I wanted to run various executables (e.g. [log-shuttle](https://github.com/ryandotsmith/log-shuttle)) on Heroku without compiling them on Heroku. Thus, I compile programs on my linux 64 machine, or fetch the binary from the project, commit them to a repo and then run them on Heroku with the Ø buildpack.
-
-## Issues
-
-You will need to make sure that a 64bit linux machine can execute the binary.

data/test/hatchet/allow_failure_git_test.rb

@@ -1,16 +0,0 @@
-require 'test_helper'
-
-class AllowFailureGitTest < Minitest::Test
-  def test_allowed_failure
-    Hatchet::GitApp.new("no_lockfile", allow_failure: true).deploy do |app|
-      refute app.deployed?
-      assert_match "Gemfile.lock required", app.output
-    end
-  end
-
-  def test_failure_with_no_flag
-    assert_raise(Hatchet::App::FailedDeploy) do
-      Hatchet::GitApp.new("no_lockfile").deploy
-    end
-  end
-end

data/test/hatchet/app_test.rb

@@ -1,96 +0,0 @@
-require 'test_helper'
-
-class AppTest < Minitest::Test
-  def test_app_with_default
-    app = Hatchet::App.new("default_ruby", buildpacks: [:default])
-    assert_match "https://github.com/heroku/heroku-buildpack-ruby", app.buildpacks.first
-  end
-
-  def test_create_app_with_stack
-    stack = "heroku-16"
-    app = Hatchet::App.new("default_ruby", stack: stack)
-    app.create_app
-    assert_equal stack, app.platform_api.app.info(app.name)["build_stack"]["name"]
-  end
-
-  def test_before_deploy
-    @called = false
-    @dir    = false
-
-    app = Hatchet::App.new("default_ruby")
-    def app.push_with_retry!; end # Don't actually deploy
-
-    app.before_deploy do
-      @called = true
-      @dir    = Dir.pwd
-    end
-
-    app.deploy do
-      assert_equal true,    @called
-      assert_equal Dir.pwd, @dir
-    end
-
-    refute_equal Dir.pwd, @dir
-  end
-
-  def test_auto_commits_code
-    string = "foo#{SecureRandom.hex}"
-
-    app = Hatchet::App.new("default_ruby")
-    def app.push_with_retry!; end # Don't actually deploy
-
-    app.before_deploy do |app|
-      assert_equal false, app.send(:needs_commit?)
-      `echo "#{string}" > Gemfile`
-      assert_equal true, app.send(:needs_commit?)
-    end
-    app.deploy do
-      assert_equal string, File.read("Gemfile").chomp
-      assert_equal false, app.send(:needs_commit?)
-    end
-  end
-
-
-  def test_nested_in_directory
-    string = "foo#{SecureRandom.hex}"
-
-    app = Hatchet::App.new("default_ruby")
-    def app.push_with_retry!; end # Don't actually deploy
-
-    app.in_directory do
-      `echo "#{string}" > Gemfile`
-      dir = Dir.pwd
-
-      app.deploy do
-        assert_equal string, File.read("Gemfile").chomp
-        assert_equal Dir.pwd, dir
-      end
-    end
-  end
-
-  def test_run
-    app = Hatchet::GitApp.new("default_ruby")
-    app.deploy do
-      assert_match(/ls: cannot access 'foo bar #baz': No such file or directory\s+Gemfile/, app.run("ls -a Gemfile 'foo bar #baz'"))
-      assert (0 != $?.exitstatus) # $? is from the app.run use of backticks
-      sleep(4) # Dynos don't exit right away and free dynos can't have more than one running at a time, wait before calling `run` again
-
-      app.run("ls erpderp", { :heroku => { "exit-code" => Hatchet::App::SkipDefaultOption } } )
-      assert (0 == $?.exitstatus) # $? is from the app.run use of backticks, but we asked the CLI not to return the program exit status by skipping the default "exit-code" option
-      sleep(4)
-
-      app.run("ls erpderp", { :heroku => { "no-tty" => nil } } )
-      assert (0 != $?.exitstatus) # $? is from the app.run use of backticks
-      sleep(4)
-
-      assert_match(/ohai world/, app.run('echo \$HELLO \$NAME', { raw: true, :heroku => { "env" => "HELLO=ohai;NAME=world" } } ))
-      sleep(4)
-
-      refute_match(/ohai world/, app.run('echo \$HELLO \$NAME', { raw: true, :heroku => { "env" => "" } } ))
-      sleep(4)
-
-      random_name = SecureRandom.hex
-      assert_match(/#{random_name}/, app.run("mkdir foo; touch foo/#{random_name}; ls foo/"))
-    end
-  end
-end

data/test/hatchet/ci_four_test.rb

@@ -1,19 +0,0 @@
-require 'test_helper'
-
-class CIFourTest < Minitest::Test
-  def test_error_with_bad_app
-    string = SecureRandom.hex
-    Hatchet::GitApp.new("default_ruby").run_ci do |test_run|
-      refute_match(string, test_run.output)
-      assert_match("Installing rake" , test_run.output)
-
-      run!(%Q{echo 'puts "#{string}"' >> Rakefile})
-      test_run.run_again
-
-      assert_match(string, test_run.output)
-      assert_match("Using rake" , test_run.output)
-
-      refute_match("Installing rake" , test_run.output)
-    end
-  end
-end

data/test/hatchet/ci_test.rb

@@ -1,11 +0,0 @@
-require 'test_helper'
-
-class CITest < Minitest::Test
-  def test_error_with_bad_app
-    error = assert_raise(Hatchet::FailedTestError) do
-      Hatchet::GitApp.new("rails5_ci_fails_no_database").run_ci {}
-    end
-
-    assert_match "PG::ConnectionBad: could not connect to server", error.message
-  end
-end

data/test/hatchet/ci_three_test.rb

@@ -1,20 +0,0 @@
-require 'test_helper'
-
-class CIThreeTest < Minitest::Test
-  def test_error_with_bad_app
-    @before_deploy_called = false
-    @before_deploy_dir_pwd = nil
-    before_deploy = -> {
-      @before_deploy_called = true
-      @before_deploy_dir_pwd = Dir.pwd
-    }
-    Hatchet::GitApp.new("rails5_ci_fails_no_database", allow_failure: true, before_deploy: before_deploy).run_ci do |test_run|
-      assert_equal :errored, test_run.status
-      assert_equal Dir.pwd, @before_deploy_dir_pwd
-
-      assert @before_deploy_called
-    end
-
-    refute_equal Dir.pwd, @before_deploy_dir_pwd
-  end
-end

data/test/hatchet/ci_too_test.rb

@@ -1,19 +0,0 @@
-require 'test_helper'
-
-# Split out to be faster
-class CITestToo < Minitest::Test
-  def test_ci_create_app_with_stack
-    app = Hatchet::GitApp.new("rails5_ruby_schema_format")
-    app.run_ci do |test_run|
-      assert_match "Ruby buildpack tests completed successfully", test_run.output
-      assert_equal :succeeded, test_run.status
-      refute_nil app.pipeline_id
-
-      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"])
-      assert_equal app.name, coupled_app["name"]
-    end
-    assert_nil app.pipeline_id
-  end
-end

data/test/hatchet/config_test.rb

@@ -1,51 +0,0 @@
-require 'test_helper'
-
-class ConfigTest < Minitest::Test
-
-  def setup
-    @config = Hatchet::Config.new
-  end
-
-  def test_config_path_for_name
-    assert_equal 'test/fixtures/repos/rails3/rails3_mri_193', @config.path_for_name('rails3_mri_193')
-  end
-
-  def test_config_dirs
-    {
-      "test/fixtures/repos/bundler/no_lockfile"   => "https://github.com/sharpstone/no_lockfile.git",
-      "test/fixtures/repos/default/default_ruby"  => "https://github.com/sharpstone/default_ruby.git",
-      "test/fixtures/repos/rails2/rails2blog"     => "https://github.com/sharpstone/rails2blog.git",
-      "test/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
-
-  def test_config_repos
-    {
-      "default_ruby"   => "test/fixtures/repos/default/default_ruby",
-      "no_lockfile"    => "test/fixtures/repos/bundler/no_lockfile",
-      "rails2blog"     => "test/fixtures/repos/rails2/rails2blog",
-      "rails3_mri_193" => "test/fixtures/repos/rails3/rails3_mri_193"
-     }.each do |key, value|
-       assert_include(key, value, @config.repos)
-     end
-  end
-
-  def test_no_internal_config_raises_no_errors
-    # assert no_raise
-    @config.send :set_internal_config!, {}
-    assert_equal './repos', @config.repo_directory_path
-  end
-
-  def test_github_shortcuts
-    @config.send :init_config!, {"foo" => ["schneems/sextant"]}
-    assert_equal("https://github.com/schneems/sextant.git", @config.dirs["./repos/foo/sextant"])
-  end
-  private
-
-    def assert_include(key, value, actual)
-      assert_equal value, actual[key], "Expected #{actual.inspect} to include #{ {key => value } } but it did not"
-    end
-end
-

data/test/hatchet/edit_repo_test.rb

@@ -1,20 +0,0 @@
-require 'test_helper'
-
-class EditRepoTest < Minitest::Test
-  def test_can_deploy_git_app
-    Hatchet::GitApp.new("default_ruby").in_directory do |app|
-      msg = `touch foo`
-      assert $?.success?, msg
-
-      msg = `git add .; git commit -m foo`
-      assert $?.success?, msg
-
-      assert_match "foo", `ls`
-    end
-
-    Hatchet::GitApp.new("default_ruby").in_directory do |app|
-      refute_match(/foo/, `ls`)
-    end
-  end
-end
-

data/test/hatchet/git_test.rb

@@ -1,16 +0,0 @@
-require 'test_helper'
-
-class GitAppTest < Minitest::Test
-  def test_can_deploy_git_app
-    Hatchet::GitApp.new("rails5_ruby_schema_format").deploy do |app|
-      assert true
-      assert_match '2.4.1', app.run("ruby -v")
-
-      app.run("bash") do |cmd|
-        # cmd.run("cd public/assets")
-        cmd.run("ls public/") {|r| assert_match("assets", r) }
-      end
-    end
-  end
-end
-

data/test/hatchet/heroku_api_test.rb

@@ -1,30 +0,0 @@
-require 'test_helper'
-
-class HerokuApiTest < Minitest::Test
-
-  def test_config_vars
-    runner = Hatchet::Runner.new("no_lockfile").setup!
-    expected = {}
-    actual  = runner.get_config
-    actual.delete("BUILDPACK_URL")
-    assert_equal expected, actual
-
-    runner.set_config("foo" => "bar")
-    expected = {"foo" => "bar"}
-    actual   = runner.get_config
-    actual.delete("BUILDPACK_URL")
-    assert_equal expected, actual
-  ensure
-    runner.teardown! if runner
-  end
-
-
-  def test_config_vars_in_init
-    runner    = Hatchet::Runner.new("no_lockfile", config: { foo: "bar"}).setup!
-    actual    = runner.get_config
-    expected  = {"foo" => "bar"}
-    assert_equal expected, actual
-  ensure
-    runner.teardown! if runner
-  end
-end

data/test/hatchet/labs_test.rb

@@ -1,20 +0,0 @@
-require 'test_helper'
-
-class LabsTest < Minitest::Test
-  def setup
-    @buildpack_path = File.expand_path 'test/fixtures/buildpacks/heroku-buildpack-ruby'
-  end
-
-  def test_can_deploy_git_app
-    # You can't enable preboot on a free app.
-    # BUT you can't make an app hobby until you've deploy once
-    # Catch-22
-    # lab_name = "preboot"
-    # app = Hatchet::App.new("rails3_mri_193", labs: lab_name, buildpack: @buildpack_path)
-    # app.setup!
-    # assert(app.lab_is_installed?(lab_name), "Expected #{app.get_labs.inspect} to include {'name' => '#{lab_name}' } but it did not")
-    assert(true)
-  # ensure
-  #   app.teardown! if app
-  end
-end

data/test/hatchet/local_repo_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-class LocalRepoTest < Minitest::Test
-  def test_in_directory_fork
-    env_name = SecureRandom.hex
-    ENV[env_name] = env_name
-
-    Hatchet::App.new("default_ruby").in_directory_fork do
-      ENV.delete(env_name)
-      assert_nil ENV[env_name]
-    end
-
-    assert_equal env_name, ENV[env_name]
-  end
-
-  def test_repos_checked_into_git
-    app = Hatchet::App.new("test/different-folder-for-checked-in-repos/default_ruby")
-    app.in_directory do
-      assert_equal false, Dir.exist?(".git")
-      app.setup!
-      assert_equal true, Dir.exist?(".git")
-    end
-  ensure
-    app.teardown! if app
-  end
-end

data/test/hatchet/lock_test.rb

@@ -1,18 +0,0 @@
-require 'test_helper'
-
-class LockTest < Minitest::Test
-  def test_app_with_failure_can_be_locked_to_prior_commit
-    Hatchet::GitApp.new("lock_fail").deploy do |app|
-      assert app.deployed?
-    end
-  end
-
-  def test_app_with_failure_can_be_locked_to_master
-    puts `bundle exec hatchet lock`
-
-    lock = YAML.load_file("hatchet.lock")
-    name, branch = lock.select {|k,v| k.end_with?("lock_fail_master") }.first
-    assert_equal "test/fixtures/repos/lock/lock_fail_master", name
-    assert_equal "master", branch
-  end
-end