heroku_hatchet 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+test/fixtures/repos/*
+

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Terence Lee
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,178 @@
+# Hatchet
+
+![](http://f.cl.ly/items/2M2O2Q2I2x0e1M1P2936/Screen%20Shot%202013-01-06%20at%209.59.38%20PM.png)
+
+## What
+
+The Hatchet is a an integration testing library for developing Heroku buildpacks.
+
+## Install
+
+First run:
+
+    $ bundle install
+
+This library uses the heroku-api gem, you will need to make your API key
+available to the system.
+
+You can get your token by running:
+
+    $ heroku auth:token
+    alskdfju108f09uvngu172019
+
+
+We need to export this token into our environment open up your `.bashrc`
+
+    export HEROKU_API_KEY="alskdfju108f09uvngu172019"
+
+Then source the file. If you don't want to set your api key system wide,
+it will be pulled automatically via shelling out, but this is slower.
+
+## Run the Tests
+
+    $ bundle exec rake test
+
+
+## Writing Tests
+
+Hatchet is meant for running integration tests, which means we actually have to deploy a real live honest to goodness app on Heroku and see how it behaves.
+
+First you'll need a repo to an app you know works on Heroku, add it to the proper folder in repos. Such as `repos/rails3/`. Once you've done that make a corresponding test file in the `test` dir such as `test/repos/rails3`. I've already got a project called "codetriage" and the test is "triage_test.rb".
+
+Now that you have an app, we'll need to create a heroku instance, and deploy our code to that instance you can do that with this code:
+
+    Hatchet::App.new("repos/rails3/codetriage").deploy do |app|
+      ##
+    end
+
+The first argument to the app is the directory where you can find the code. Once your test is done, the app will automatically be destroyed.
+
+Now that you've deployed your app you'll want to make sure that the deploy worked correctly. Since we're using `test/unit` you can use regular assertions such as `assert` and `refute`. Since we're yielding to an `app` variable we can check the `deployed?` status of the app:
+
+    Hatchet::App.new("repos/rails3/codetriage").deploy do |app|
+      assert app.deployed?
+    end
+
+The primary purpose of the buildpack is configuring and deploying apps, so if it deployed chances are the buildpack is working correctly, but sometimes you may want more information. You can run arbitrary commands such as `heroku bash` and then check for the existence of a file.
+
+    Hatchet::App.new("repos/rails3/codetriage").deploy do |app|
+      app.run("bash") do |cmd|
+        assert cmd.run("ls public/assets").include?("application.css")
+      end
+    end
+
+Anything you put in `cmd.run` at this point will be executed from with in the app that you are in.
+
+    cmd.run("cat")
+    cmd.run("cd")
+    cmd.run("cd .. ; ls | grep foo")
+
+It behaves exactly as if you were in a remote shell. If you really wanted you could even run the tests:
+
+    cmd.run("rake test")
+
+But since cmd.run doesn't return the exit status now, that wouldn't be
+so useful (also there is a default timeout to all commands). If you want
+you can configure the timeout by passing in a second parameter
+
+    cmd.run("rake test", 180.seconds)
+
+
+## Testing A Different Buildpack
+
+You can specify buildpack to deploy with like so:
+
+    Hatchet::App.new("repos/rails3/codetriage", buildpack: "https://github.com/schneems/heroku-buildpack-ruby.git").deploy do |app|
+
+## Hatchet Config
+
+Hatchet is designed to test buildpacks, and requires full repositories
+to deploy to Heroku. Web application repos, especially Rails repos, aren't known for
+being small, if you're testing a custom buildpack and have
+`BUILDPACK_URL` set in your app config, it needs to be cloned each time
+you deploy your app. If you've `git add`-ed a bunch of repos then this
+clone would be pretty slow, we're not going to do this. Do not commit
+your repos to git.
+
+Instead we will keep a structured file called
+inventively `hatchet.json` at the root of your project. This file will
+describe the structure of your repos, have the name of the repo, and a
+git url. We will use it to sync remote git repos with your local
+project. It might look something like this
+
+    {
+      "hatchet": {},
+      "rails3": ["git@github.com:codetriage/codetriage.git"],
+      "rails2": ["git@github.com:heroku/rails2blog.git"]
+    }
+
+the 'hatchet' object accessor is reserved for hatchet settings.
+. To copy each repo in your `hatchet.json`
+run the command:
+
+    $ hatchet install
+
+The above `hatchet.json` will produce a directory structure like this:
+
+    repos/
+      rails3/
+        codetriage/
+          #...
+      rails2/
+        rails2blog/
+          # ...
+
+While you are running your tests if you reference a repo that isn't
+synced locally Hatchet will raise an error. Since you're using a
+standard file for your repos, you can now reference the name of the git
+repo, provided you don't have conflicting names:
+
+    Hatchet::App.new("codetriage").deploy do |app|
+
+If you do have conflicting names, use full paths.
+
+A word of warning on including rails/ruby repos inside of your test
+directory, if you're using a runner that looks for patterns such as
+`*_test.rb` to run your hatchet tests, it may incorrectly think you want
+to run the tests inside of the rails repositories. To get rid of this
+problem move your repos direcory out of `test/` or be more specific
+with your tests such as moving them to a `test/hatchet` directory and
+changing your pattern if you are using `Rake::TestTask` it might look like this:
+
+    t.pattern = 'test/hatchet/**/*_test.rb'
+
+A note on external repos: since you're basing tests on these repos, it
+is in your best interest to not change them or your tests may
+spontaneously fail. In the future we may create a hatchet.lockfile or
+something to declare the commit
+
+## Hatchet CLI
+
+Hatchet has a CLI for installing and maintaining external repos you're
+using to test against. If you have Hatchet installed as a gem run
+
+    $ hatchet --help
+
+For more info on commands. If you're using the source code you can run
+the command by going to the source code directory and running:
+
+    $ ./bin/hatchet --help
+
+
+
+## The Future
+
+### Speed
+
+Efforts may be spent optimizing / parallelizing the process, almost all of the time of the test is spent waiting for IO, so hopefully we should be able to parallelize many tests / deploys at the same time. The hardest part of this (i believe) would be splitting out the different runs into different log streams so that the output wouldn't be completely useless.
+
+Right now running 1 deploy test takes about 3 min on my machine.
+
+## Git Based Deploys
+
+It would be great to allow hatchet to deploy apps off of git url, however if we do that we could open ourselves up to false negatives, if we are pointing at an external repo that gets broken.
+
+
+## Features?
+
+What else do we want to test? Config vars, addons, etc. Let's write some tests.

data/Rakefile

@@ -0,0 +1,5 @@
+# encoding: UTF-8
+require 'bundler/gem_tasks'
+
+require 'hatchet/tasks'
+

data/bin/hatchet

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+unless File.respond_to? :realpath
+  class File #:nodoc:
+    def self.realpath path
+      return realpath(File.readlink(path)) if symlink?(path)
+      path
+    end
+  end
+end
+$: << File.expand_path(File.dirname(File.realpath(__FILE__)) + '/../lib')
+
+require 'hatchet'
+require 'thor'
+
+class HatchetCLI < Thor
+  desc "install", "installs repos defined in 'hatchet.json'"
+  def install
+    warn_dot_ignore!
+    puts "Installing repos for hatchet"
+    dirs.each do |directory, git_repo|
+      if Dir[directory].present?
+        puts "==  Detected #{git_repo} in #{directory}, pulling\n"
+        pull(directory, git_repo)
+      else
+        puts "==  Did not find #{git_repo} in #{directory}, cloning\n"
+        clone(directory, git_repo)
+      end
+    end
+  end
+
+  desc "list", "lists all repos and their destination listed in hatchet.json"
+  def list
+    repos.each do |repo, directory|
+      puts "#{repo}: #{directory}"
+    end
+  end
+
+  private
+
+  def warn_dot_ignore!
+    gitignore = File.open('.gitignore').read
+    return if gitignore.include?(config.repo_directory_path)
+    puts "WARNING: add #{File.join(config.repo_directory_path, '*')} to your .gitignore file \n\n"
+  end
+
+  def config
+    @config ||= Hatchet::Config.new
+  end
+
+  def repos
+    config.repos
+  end
+
+  def dirs
+    config.dirs
+  end
+
+  def pull(path, git_repo)
+    Dir.chdir(path) do
+      `git pull --rebase #{git_repo} master`
+    end
+  end
+
+  def clone(path, git_repo)
+    path = File.join(path, '..') # up one dir to prevent repos/codetriage/codetriage/#...
+    FileUtils.mkdir_p(path)      # create directory
+    Dir.chdir(path) do
+      `git clone #{git_repo}`
+    end
+  end
+end
+
+HatchetCLI.start(ARGV)

data/hatchet.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hatchet/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "heroku_hatchet"
+  gem.version       = Hatchet::VERSION
+  gem.authors       = ["Richard Schneeman"]
+  gem.email         = ["richard.schneeman+rubygems@gmail.com"]
+  gem.description   = %q{Hatchet is a an integration testing library for developing Heroku buildpacks.}
+  gem.summary       = %q{Hatchet is a an integration testing library for developing Heroku buildpacks.}
+  gem.homepage      = "https://github.com/heroku/hatchet"
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files`.split($/)
+  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.add_dependency "heroku-api"
+  gem.add_dependency "activesupport"
+  gem.add_development_dependency "rake"
+  gem.add_dependency "anvil-cli"
+  gem.add_dependency "excon"
+  gem.add_dependency "thor"
+end
+

data/hatchet.json

@@ -0,0 +1,5 @@
+{
+  "hatchet": {"directory": "test/fixtures"},
+  "rails3": ["sharpstone/codetriage"],
+  "rails2": ["sharpstone/rails2blog"]
+}

data/lib/hatchet/anvil_app.rb

@@ -0,0 +1,57 @@
+require 'json'
+require 'stringio'
+
+module Hatchet
+  class AnvilApp < App
+
+    def initialize(directory, options = {})
+      @buildpack   = options[:buildpack]
+      @buildpack ||= File.expand_path('.')
+      super
+    end
+
+    def push!
+      slug_url = nil
+
+      begin
+        stderr_orig = $stderr
+        stdout_orig = $stdout
+        string_io   = StringIO.new
+        $stderr     = string_io
+        slug_url    = Anvil::Engine.build(".", :buildpack => @buildpack, :pipeline => true)
+        puts "Releasing to http://#{@name}.herokuapp.com"
+        response = release(@name, slug_url)
+        while response.status == 202
+          response = Excon.get("#{release_host}#{response.headers["Location"]}")
+        end
+      rescue Anvil::Builder::BuildError => e
+        output = $stderr.dup
+        stdout_orig.puts output.string # print the errors to the test output
+        return [false, output.string]
+      ensure
+        $stderr = stderr_orig
+        $stdout = stdout_orig
+      end
+
+      [true, string_io.string]
+    end
+
+    def teardown!
+      super
+      FileUtils.rm_rf("#{directory}/.anvil")
+    end
+
+    private
+    def release(name, slug_url)
+      headers         = {"Content-Type" => "application/json", accept: :json}
+      release_options = {description: "Anvil Build", slug_url: slug_url }
+      Excon.post("#{release_host}/v1/apps/#{name}/release",
+                 headers: headers,
+                 body:    release_options.to_json)
+    end
+
+    def release_host
+      "https://:#{api_key}@cisaurus.heroku.com"
+    end
+  end
+end

data/lib/hatchet/app.rb

@@ -0,0 +1,85 @@
+module Hatchet
+  class App
+    attr_reader :name, :directory
+
+    def initialize(repo_name, options = {})
+      @directory = config.path_for_name(repo_name)
+      @name      = options[:name]  || "test-app-#{Time.now.to_f}".gsub('.', '-')
+      @debug     = options[:debug] || options[:debugging]
+    end
+
+    # config is read only, should be threadsafe
+    def self.config
+      @config ||= Config.new
+    end
+
+    def config
+      self.class.config
+    end
+
+    # runs a command on heroku similar to `$ heroku run #foo`
+    # but programatically and with more control
+    def run(command, timeout = nil, &block)
+      ProcessSpawn.new(command, self, timeout).run(&block)
+    end
+
+    # set debug: true when creating app if you don't want it to be
+    # automatically destroyed, useful for debugging...bad for app limits.
+    # turn on global debug by setting HATCHET_DEBUG=true in the env
+    def debug?
+      @debug || ENV['HATCHET_DEBUG'] || false
+    end
+    alias :debugging? :debug?
+
+    def not_debugging?
+      !debug?
+    end
+    alias :no_debug? :not_debugging?
+
+    def deployed?
+      !heroku.get_ps(name).body.detect {|ps| ps["process"].include?("web") }.nil?
+    end
+
+    # creates a new heroku app via the API
+    def setup!
+      heroku.post_app(name: name)
+      @app_is_setup = true
+    end
+
+    def push!
+      raise NotImplementedError
+    end
+
+    def teardown!
+      return false unless @app_is_setup
+      if debugging?
+        puts "Debugging App:#{name}"
+        return false
+      end
+      heroku.delete_app(name)
+    end
+
+    # creates a new app on heroku, "pushes" via anvil or git
+    # then yields to self so you can call self.run or
+    # self.deployed?
+    def deploy(&block)
+      Dir.chdir(directory) do
+        self.setup!
+        result, output = self.push!
+        block.call(self, heroku, output)
+      end
+    ensure
+      self.teardown!
+    end
+
+    private
+      def api_key
+        @api_key ||= ENV['HEROKU_API_KEY'] || `heroku auth:token`.chomp
+      end
+
+      def heroku
+        @heroku ||= Heroku::API.new(api_key: api_key)
+      end
+  end
+end
+

data/lib/hatchet/config.rb

@@ -0,0 +1,90 @@
+module Hatchet
+  class MissingConfig < Errno::ENOENT
+    def initialize
+      super("could not find a 'hatchet.json' file in root directory")
+    end
+  end
+  class ParserError   < JSON::ParserError;  end
+  class BadRepoName   < StandardError
+    def initialize(name, paths)
+      msg = "could not find repo: '#{name}', check for spelling or " <<
+            "duplicate repos. Run `$ hatchet list` to see all "   <<
+            "repo options. Checked in #{paths.inspect}. \n\n" <<
+            "  make sure repos are installed by running `$ hatchet install`"
+      super(msg)
+    end
+  end
+
+  # This class is responsible for parsing hatchet.json into something
+  # meaninful.
+  class Config
+    REPOS_DIR_NAME       = "repos" # the top level name of repos folder
+    REPOS_DIRECTORY_ROOT = '.'     # the the root directory where your repos folder will be stored
+
+    attr_accessor :repos, :dirs
+
+    def repo_directory_path
+      File.join(@repo_directory_path, REPOS_DIR_NAME)
+    end
+
+    # creates new config object, pass in directory where `heroku.json`
+    # is located
+    def initialize(directory = '.')
+      self.repos = {}
+      self.dirs  = {}
+      Dir.chdir(directory) do
+        config_file = File.open('hatchet.json').read
+        init_config! JSON.parse(config_file)
+      end
+    rescue Errno::ENOENT
+      raise MissingConfig
+    rescue JSON::ParserError => e
+      raise ParserError, "Improperly formatted json in 'hatchet.json' \n\n" + e.message
+    end
+
+    # use this method to turn "codetriage" into repos/rails3/codetriage
+    def path_for_name(name)
+      possible_paths = [repos[name.to_s], "repos/#{name}", name].compact
+      path = possible_paths.detect do |path|
+        Dir[path].present?
+      end
+      raise BadRepoName.new(name, possible_paths) if path.blank?
+      path
+    end
+
+    # 'git@github.com:codetriage/codetriage.git' => 'codetriage'
+    def name_from_git_repo(repo)
+      repo.split('/').last.chomp('.git')
+    end
+
+  private
+
+    def set_internal_config!(config)
+      @internal_config     = config.delete('hatchet') || {}
+      @repo_directory_path = @internal_config['directory'] || REPOS_DIRECTORY_ROOT
+      config
+    end
+
+    # pulls out config and makes easy to use hashes
+    # dirs has the repo paths as keys and the git_repos as values
+    # repos has repo names as keys and the paths as values
+    def init_config!(config)
+      set_internal_config!(config)
+      config.each do |(directory, git_repos)|
+        git_repos.each do |git_repo|
+          git_repo         = git_repo.include?("github.com") ? git_repo : "git@github.com:#{git_repo}.git"
+          repo_name        = name_from_git_repo(git_repo)
+          repo_path        = File.join(repo_directory_path, directory, repo_name)
+          if repos.key? repo_name
+            puts "  warning duplicate repo found: #{repo_name.inspect}"
+            repos[repo_name] = false
+          else
+            repos[repo_name] = repo_path
+          end
+          dirs[repo_path]  = git_repo
+        end
+      end
+    end
+  end
+end
+

data/lib/hatchet/git_app.rb

@@ -0,0 +1,25 @@
+module Hatchet
+  # used for deploying a test app to heroku via git
+  class GitApp < App
+    BUILDPACK_URL = "https://github.com/heroku/heroku-buildpack-ruby.git"
+
+    def initialize(directory, options = {})
+      @buildpack = options[:buildpack] || options[:buildpack_url] || BUILDPACK_URL
+      super
+    end
+
+    def setup!
+      super
+      heroku.put_config_vars(name, 'BUILDPACK_URL' => @buildpack)
+    end
+
+    def git_repo
+      "git@heroku.com:#{name}.git"
+    end
+
+    def push!
+      output = `git push #{git_repo} master`
+      [$?.success?, output]
+    end
+  end
+end

data/lib/hatchet/process_spawn.rb

@@ -0,0 +1,49 @@
+require 'pty'
+module Hatchet
+  # spawns a process on Heroku, and keeps it open for writing
+  # like `heroku run bash`
+  class ProcessSpawn
+    attr_reader :command, :app, :timeout
+
+    TIMEOUT = 20 # seconds to bring up a heroku command like `heroku run bash`
+
+    def initialize(command, app, timeout = nil)
+      @command = command
+      @app     = app
+      @timeout = timeout || TIMEOUT
+    end
+
+    def ready?
+      `heroku ps -a #{app.name}`.match(/^run.*up.*`#{command}`/).present?
+    end
+
+    def not_ready?
+      !ready?
+    end
+
+    def wait_for_spawn!
+      while not_ready?
+        sleep 1
+      end
+      return true
+    end
+
+    # Open up PTY (pseudo terminal) to command like `heroku run bash`
+    # Wait for the dyno to deploy, then allow user to run arbitrary commands
+    #
+    def run(&block)
+      raise "need app"     unless app.present?
+      raise "need command" unless command.present?
+      output, input, pid = PTY.spawn("heroku run #{command} -a #{app.name}")
+      stream = StreamExec.new(input, output)
+      stream.timeout("waiting for spawn", timeout) do
+        wait_for_spawn!
+      end
+      raise "Could not run: #{command}" unless self.ready?
+      yield stream
+    ensure
+      stream.close                if stream.present?
+      Process.kill('TERM', pid)   if pid.present?
+    end
+  end
+end

data/lib/hatchet/stream_exec.rb

@@ -0,0 +1,58 @@
+require 'timeout'
+module Hatchet
+  # runs arbitrary commands within a Heroku process
+  class StreamExec
+    attr_reader :input, :output
+    TIMEOUT = 1 # seconds to run an arbitrary command on a heroku process like `$ls`
+
+    def initialize(input, output)
+      @input  = input
+      @output = output
+    end
+
+    def run(cmd)
+      raise "command expected" if cmd.blank?
+      input.write("#{cmd}\n")
+      return read(cmd)
+    end
+
+    def close
+      timeout("closing stream") do
+        input.close
+        output.close
+      end
+    end
+
+    # There be dragons - (You're playing with process deadlock)
+    #
+    # We want to read the whole output of the command
+    # First pull all contents from stdout (except we don't know how many there are)
+    # So we have to go until our process deadlocks, then we timeout and return the string
+    #
+    # Example
+    #   result = ""
+    #   input.write("ls\n")
+    #   Timeout::timeout(1) {output.each {|x| result << x}}
+    #      Timeout::Error: execution expired
+    #   puts result
+    #     # => "ls\r\r\napp\tconfig.ru  Gemfile\t LICENSE.txt  public\t script  vendor\r\r\nbin\tdb\t   Gemfile.lock  log\t      Rakefile\t test\r\r\nconfig\tdoc\t   lib\t\t Procfile     README.md  tmp\r\r\n"
+    #
+    # Now we want to remove the original command ("ls\r\r\n") and return the remainder
+    def read(cmd, str = "")
+      timeout do
+        # this is guaranteed to timeout; output.each will not return
+        output.each { |line| str << line }
+      end
+      str.split("#{cmd}\r\r\n").last
+    end
+
+    def timeout(msg = nil, val = TIMEOUT, &block)
+      Timeout::timeout(val) do
+        yield
+      end
+    rescue Timeout::Error
+      puts "timeout #{msg}" if msg
+    end
+  end
+end
+

data/lib/hatchet/tasks.rb

@@ -0,0 +1,10 @@
+require 'rake'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/hatchet/**/*_test.rb'
+  t.verbose = false
+end
+

data/lib/hatchet/version.rb

@@ -0,0 +1,3 @@
+module Hatchet
+  VERSION = "0.0.1"
+end

data/lib/hatchet.rb

@@ -0,0 +1,20 @@
+require 'heroku/api'
+require 'anvil/engine'
+require 'active_support/core_ext/object/blank'
+
+require 'json'
+require 'stringio'
+require 'fileutils'
+
+module Hatchet
+  class App
+  end
+end
+
+require 'hatchet/version'
+require 'hatchet/app'
+require 'hatchet/anvil_app'
+require 'hatchet/git_app'
+require 'hatchet/stream_exec'
+require 'hatchet/process_spawn'
+require 'hatchet/config'

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

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

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

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

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

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

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

@@ -0,0 +1,5 @@
+{
+  "hatchet": {"directory": "../.."},
+  "rails3": ["sharpstone/codetriage"],
+  "rails2": ["sharpstone/rails2blog"]
+}

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

@@ -0,0 +1,41 @@
+# 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/anvil_test.rb

@@ -0,0 +1,21 @@
+require 'test_helper'
+
+class AnvilTest < Test::Unit::TestCase
+  def test_deploy
+    Dir.chdir('test/fixtures/builpacks/null-buildpack') do
+      Hatchet::AnvilApp.new("codetriage",debug: true).deploy do |app|
+        assert true
+        app.run("bash") do |cmd|
+          # cmd.run("cd public/assets")
+
+          assert cmd.run("cat Gemfile").include?("gem 'pg'")
+
+          # deploying with null buildpack, no assets should be compiled
+          refute cmd.run("ls public/assets").include?("application.css")
+        end
+      end
+    end
+  end
+end
+
+

data/test/hatchet/config_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+class ConfigTest < Test::Unit::TestCase
+
+  def setup
+    @config = Hatchet::Config.new
+  end
+
+  def test_config_path_for_name
+    assert_equal 'test/fixtures/repos/rails3/codetriage', @config.path_for_name('codetriage')
+  end
+
+  def test_config_dirs
+    expected_dirs = { "test/fixtures/repos/rails3/codetriage" => "git@github.com:sharpstone/codetriage.git",
+                      "test/fixtures/repos/rails2/rails2blog" => "git@github.com:sharpstone/rails2blog.git" }
+    assert_equal expected_dirs, @config.dirs
+  end
+
+  def test_config_repos
+    expected_repos = { "codetriage" => "test/fixtures/repos/rails3/codetriage",
+                       "rails2blog" => "test/fixtures/repos/rails2/rails2blog" }
+    assert_equal expected_repos, @config.repos
+  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("git@github.com:schneems/sextant.git", @config.dirs["./repos/foo/sextant"])
+  end
+end

data/test/hatchet/git_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+class TriageTest < Test::Unit::TestCase
+  def test_foo
+    Hatchet::GitApp.new("codetriage").deploy do |app|
+      assert true
+      assert app.deployed?
+      app.run("bash") do |cmd|
+        # cmd.run("cd public/assets")
+        assert cmd.run("ls public/assets").include?("application.css")
+      end
+    end
+  end
+end
+

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+Bundler.require
+
+
+require 'hatchet'
+require 'test/unit'
+
+
+def assert_tests_run
+end
+
+

metadata

@@ -0,0 +1,179 @@
+--- !ruby/object:Gem::Specification
+name: heroku_hatchet
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Richard Schneeman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: heroku-api
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: anvil-cli
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: excon
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Hatchet is a an integration testing library for developing Heroku buildpacks.
+email:
+- richard.schneeman+rubygems@gmail.com
+executables:
+- hatchet
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/hatchet
+- hatchet.gemspec
+- hatchet.json
+- lib/hatchet.rb
+- lib/hatchet/anvil_app.rb
+- lib/hatchet/app.rb
+- lib/hatchet/config.rb
+- lib/hatchet/git_app.rb
+- lib/hatchet/process_spawn.rb
+- lib/hatchet/stream_exec.rb
+- lib/hatchet/tasks.rb
+- lib/hatchet/version.rb
+- test/fixtures/builpacks/null-buildpack/bin/compile
+- test/fixtures/builpacks/null-buildpack/bin/detect
+- test/fixtures/builpacks/null-buildpack/bin/release
+- test/fixtures/builpacks/null-buildpack/hatchet.json
+- test/fixtures/builpacks/null-buildpack/readme.md
+- test/hatchet/anvil_test.rb
+- test/hatchet/config_test.rb
+- test/hatchet/git_test.rb
+- test/test_helper.rb
+homepage: https://github.com/heroku/hatchet
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Hatchet is a an integration testing library for developing Heroku buildpacks.
+test_files:
+- test/fixtures/builpacks/null-buildpack/bin/compile
+- test/fixtures/builpacks/null-buildpack/bin/detect
+- test/fixtures/builpacks/null-buildpack/bin/release
+- test/fixtures/builpacks/null-buildpack/hatchet.json
+- test/fixtures/builpacks/null-buildpack/readme.md
+- test/hatchet/anvil_test.rb
+- test/hatchet/config_test.rb
+- test/hatchet/git_test.rb
+- test/test_helper.rb
+has_rdoc: