heroku_hatchet 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cbe186a27b0018f41b0ab9338925c09acdf9a52b
-  data.tar.gz: b7dcdd7fdf884f4e6773e6ae5c34fc731b615876
+  metadata.gz: b3de8693165cadd85b33f59521ea5c1a7d5bf7a5
+  data.tar.gz: fe8f0f5783ceb61174f907cd19039760789aa248
 SHA512:
-  metadata.gz: 66ae54f148dfde98f77515fedc1401aee42820084de8846d0dae3c1a350f0b3e19393033ecac347e14096b945adc5c7f84d3f0c26d1e72cbde78fbfd0b3b114a
-  data.tar.gz: 8f2fc16b6a0aaa668eed1efd53b1807bbbceb15afc4a298bf8a081086bcb53c7e2afe3bb1539d605d943368ff7926d46dfa4678e36b292366e0f06f3949e41c2
+  metadata.gz: a3075c645dd0ecbfa932e610f0522746945b33c6fd12749a9a6b37dfd51f016b528f0e1f1a97320a7f1550b1e5b19bd6d9eb201479d1d97bcacd314e46e980bd
+  data.tar.gz: 526de86c2aaf5e1e4b8bb0d5ddafa35d35f33f38dcbdbddf2506bbeb47f21344d29e568364510b5cbfd476fee4332882098809221dbf2629085c644da82c809a

data/.travis.yml

@@ -9,6 +9,7 @@ after_script: bundle exec rake hatchet:teardown_travis
 env:
   global:
   - HATCHET_RETRIES=3
+  - HATCHET_BUILDPACK_BRANCH=master
   - secure: |-
       SfUgPagZILPjm4rjkYlEck76PUE47dimpNZgUtUf7wTAbe6EE83QmnRl6uDT
       eSdxuY9uNFoTwNLC0J+mRiDAJtAQxBsst8wFoc3diK2o8Ojnor5yd3cxddBv

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 ## HEAD
 
+## 1.1.0
+
+- Added `Hatchet::Runner` which can dynamically swap the backend (anvil/git) depending on the value of ENV['HATCHET_DEPLOY_STRATEGY'] you can use 'anvil' or 'git'.
+
 ## 1.0.0
 
 - Move remote console running code to https://github.com/schneems/repl_runner

data/README.md

@@ -79,7 +79,7 @@ test/
 Now in your test you can reference one of these applications by using it's git name:
 
 ```ruby
-Hatchet::AnvilApp.new('no_lockfile')
+Hatchet::Runner.new('no_lockfile')
 ```
 
 If you have conflicting names, use full paths.
@@ -99,30 +99,50 @@ 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
 
+
+## Deployments: Anvil vs. Git
+
+Before you start testing a buildpack, understand that there are two different ways to deploy to Heroku. The first you are likely familiar with Git, requires a `git push heroku master`. You can configure the buildpack of an app being deployed in this way through the `BUILDPACK_URL` environment variable of the app. The buildpack url must be publicaly available.
+
+The second method is by [Anvil](https://github.com/ddollar/anvil-cli) . In this method the build is performed as a service. This service takes an app to be built as well as a buildpack. When using Anvil, you do not need to put your buildpack anywhere publicly available.
+
+When developing local features you will likely wish to use Anvil since it does not require a publicly available URL and you can iterate faster. When testing for regression you will almost always want to use Git, since it is the closest approximation to real world deployment. For this reason Hatchet provides a globally configurable way to toggle between the two deployment modes `Hatchet::Runner`
+
+
 ## Deploying apps
 
-Now that you've got your apps locally you can have hatchet deploy them for you. Hatchet can deploy using one of two ways Anvil and Git. A `Hatchet::AnvilApp` will deploy using Anvil against the current directory. This means that the buildpack you have locally will be used when deploying, due to this we recommend using Anvil to run your tests.
+Now that you've got your apps locally you can have hatchet deploy them for you. Hatchet can deploy using one of two ways Anvil and Git. To specify one or the other set your `HATCHET_DEPLOY_STRATEGY` environment variable to `anvil` or `git`. The default is `anvil`. In production, you should always test against `git`
+
 
-A `Hatchet::GitApp` will deploy using the standard `git push heroku master`, if you use this option you need to have a publicly accessible copy of your buildpack. Using Git to test your buildpack may be slow and require you to frequently push your buildpack to a public git repo. For this reason we recommend using Anvil to run your tests:
+A `Hatchet::GitApp` will deploy using the standard `git push heroku master` and is not configurable, if you use this option you need to have a publicly accessible copy of your buildpack. Using Git to test your buildpack may be slow and require you to frequently push your buildpack to a public git repo. For this reason we recommend using Anvil to run your tests locally:
 
 ```ruby
-Hatchet::AnvilApp.new("rails3_mri_193").deploy do |app|
+Hatchet::Runner.new("rails3_mri_193").deploy do |app|
 
 end
 ```
 
+If you are using GIT, you can specify the location of your public buildpack url in an environment variable:
+
+```sh
+HATCHET_BUILDPACK_BASE=https://github.com/heroku/heroku-buildpack-ruby.git
+HATCHET_BUILDPACK_BRANCH=master
+```
+
+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.
+
 Deploys are expected to work, if the `ENV['HATCHET_RETRIES']` is set, then deploys will be automatically retried that number of times. Due to testing using a network and random Anvil failures, setting this value to `3` retries seems to work well. If an app cannot be deployed within its allotted number of retries an error will be raised.
 
 If you are testing an app that is supposed to fail deployment you can set the `allow_failure: true` flag when creating the app:
 
 ```ruby
-Hatchet::AnvilApp.new("no_lockfile", allow_failure: true).deploy do |app|
+Hatchet::Runner.new("no_lockfile", allow_failure: true).deploy do |app|
 ```
 
 After the block finishes your app will be removed from heroku. If you are investigating a deploy, you can add the `debug: true` flag to your app:
 
 ```ruby
-Hatchet::AnvilApp.new("rails3_mri_193", debug: true).deploy do |app|
+Hatchet::Runner.new("rails3_mri_193", debug: true).deploy do |app|
 ```
 
 Now after Hatchet is done deploying your app it will remain on Heroku. It will also output the name of the app into your test logs so that you can `heroku run bash` into it for detailed postmortem.
@@ -130,7 +150,7 @@ Now after Hatchet is done deploying your app it will remain on Heroku. It will a
 If you are wanting to run a test against a specific app without deploying to it, you can set the app name like this:
 
 ```ruby
-app = Hatchet::AnvilApp.new("rails3_mri_193", name: "testapp")
+app = Hatchet::Runner.new("rails3_mri_193", name: "testapp")
 ```
 
 Deploying the app takes a few minutes, so you may want to skip that part to make debugging a problem easier since you're iterating much faster.
@@ -143,7 +163,7 @@ If you need to deploy using a buildpack that is not in the root of your director
 buildpack_path = File.expand_path 'test/fixtures/buildpacks/heroku-buildpack-ruby'
 
 def test_deploy
-  Hatchet::AnvilApp.new("rails3_mri_193", buildpack: buildpack_path).deploy do |app|
+  Hatchet::GitApp.new("rails3_mri_193", buildpack: buildpack_path).deploy do |app|
   # ...
 ```
 
@@ -155,7 +175,7 @@ If you are using a `Hatchet::GitApp` this is where you specify the publicly avai
 After Hatchet deploys your app you can get the output by using `app.output`
 
 ```ruby
-Hatchet::AnvilApp.new("rails3_mri_193").deploy do |app|
+Hatchet::Runner.new("rails3_mri_193").deploy do |app|
   puts app.output
 end
 ```
@@ -163,7 +183,7 @@ end
 If you told Hatchet to `allow_failure: true` then the full output of the failed build will be in `app.output` even though the app was not deployed. It is a good idea to test against the output for text that should be present. Using a testing framework such as `Test::Unit` a failed test output may look like this
 
 ```ruby
-Hatchet::AnvilApp.new("no_lockfile", allow_failure: true).deploy do |app|
+Hatchet::Runner.new("no_lockfile", allow_failure: true).deploy do |app|
   assert_match "Gemfile.lock required", app.output
 end
 ```
@@ -175,14 +195,14 @@ Since an error will be raised on failed deploys you don't need to check for a de
 Often times asserting output of a build can only get you so far, and you will need to actually run a task on the dyno. To run a non-interactive command such as `heroku run ls` you can do this using the `app.run()` command and do not pass it a block
 
 ```ruby
-Hatchet::AnvilApp.new("rails3_mri_193").deploy do |app|
+Hatchet::Runner.new("rails3_mri_193").deploy do |app|
   assert_match "applications.css", app.run("ls public/assets")
 ```
 
 This is useful for checking the existence of generated files such as assets. If you need to run an interactive session such as `heroku run bash` or `heroku run rails console` you can use the run command and pass a block:
 
 ```ruby
-Hatchet::AnvilApp.new("rails3_mri_193").deploy do |app|
+Hatchet::Runner.new("rails3_mri_193").deploy do |app|
   app.run("bash") do |bash|
     bash.run("ls")           {|result| assert_match "Gemfile.lock", result }
     bash.run("cat Procfile") {|result| assert_match "web:", result }
@@ -193,7 +213,7 @@ end
 or
 
 ```ruby
-Hatchet::AnvilApp.new("rails3_mri_193").deploy do |app|
+Hatchet::Runner.new("rails3_mri_193").deploy do |app|
   app.run("rails console") do |console|
     console.run("a = 1 + 2")  {|result| assert_match "3", result }
     console.run("'foo' * a")  {|result| assert_match "foofoofoo", result }
@@ -227,6 +247,8 @@ If you're unfamiliar with the ruby testing eco-system or want some help with boi
 
 Once you've got your tests working locally, you'll likely want to get them running on Travis because a) CI is awesome, and b) you can use pull requests to run your all your tests in parallel without having to kill your network connection.
 
+You will want to set the `HATCHET_DEPLOY_STRATEGY` to `git`.
+
 To run on travis you will need to configure your `.travis.yml` to run the appropriate commands and to set up encrypted data so you can run tests against a valid heroku user.
 
 For reference see the `.travis.yml` from [hatchet](https://github.com/heroku/hatchet/blob/master/.travis.yml) and the [heroku-ruby-buildpack](https://github.com/heroku/heroku-buildpack-ruby/blob/master/.travis.yml). To make running on travis easier there is a rake task in Hatchet that can be run before your tests are executed
@@ -258,5 +280,8 @@ the command by going to the source code directory and running:
     $ ./bin/hatchet --help
 
 
+## License
+
+MIT
 
 

data/lib/hatchet.rb

@@ -11,10 +11,26 @@ require 'stringio'
 
 
 module Hatchet
-  RETRIES = Integer(ENV['HATCHET_RETRIES'] || 1)
+  RETRIES = Integer(ENV['HATCHET_RETRIES']  || 1)
 
   class App
   end
+
+  def self.git_branch
+    `git describe --contains --all HEAD`.strip
+  end
+
+  def self.set_deploy_strategy!
+    deploy_strat = (ENV['HATCHET_DEPLOY_STRATEGY'] || :anvil).to_sym
+    case Hatchet::const_set("DEPLOY_STRATEGY", deploy_strat)
+    when :anvil
+      Hatchet.const_set("Runner", Hatchet::AnvilApp)
+    when :git
+      Hatchet.const_set("Runner", Hatchet::GitApp)
+    else
+      raise "unknown deploy strategy #{Hatchet::DEPLOY_STRATEGY}, expected 'anvil', 'git'"
+    end
+  end
 end
 
 require 'hatchet/version'
@@ -22,3 +38,6 @@ require 'hatchet/app'
 require 'hatchet/anvil_app'
 require 'hatchet/git_app'
 require 'hatchet/config'
+
+
+Hatchet.set_deploy_strategy!

data/lib/hatchet/git_app.rb

@@ -1,10 +1,12 @@
 module Hatchet
   # used for deploying a test app to heroku via git
   class GitApp < App
+    HATCHET_BUILDPACK_BASE   = (ENV['HATCHET_BUILDPACK_BASE'] || "https://github.com/heroku/heroku-buildpack-ruby.git")
+    HATCHET_BUILDPACK_BRANCH = (ENV['HATCHET_BUILDPACK_BRANCH'] || Hatchet.git_branch)
     BUILDPACK_URL = "https://github.com/heroku/heroku-buildpack-ruby.git"
 
     def initialize(directory, options = {})
-      @buildpack = options[:buildpack] || options[:buildpack_url] || BUILDPACK_URL
+      @buildpack = options[:buildpack] || options[:buildpack_url] || [HATCHET_BUILDPACK_BASE, HATCHET_BUILDPACK_BRANCH].join("#")
       super
     end
 
@@ -20,7 +22,7 @@ module Hatchet
     def push!
       output = `git push #{git_repo} master 2>&1`
       if !$?.success?
-        raise FailedDeploy.new(self, output) unless @allow_failure
+        raise FailedDeploy.new(self, "Buildpack: #{@buildpack.inspect}\n#{output}") unless @allow_failure
       end
       return output
     end

data/lib/hatchet/version.rb

@@ -1,3 +1,3 @@
 module Hatchet
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/test/hatchet/runner_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class HatchetRunnerTest < Test::Unit::TestCase
+
+  def setup
+    @default = ENV['HATCHET_DEPLOY_STRATEGY']
+  end
+
+  def teardown
+    ENV['HATCHET_DEPLOY_STRATEGY'] = @default
+    Hatchet.set_deploy_strategy!
+  end
+
+  def test_defaults
+    assert_equal nil, ENV['HATCHET_DEPLOY_STRATEGY']
+    assert_equal :anvil, Hatchet::DEPLOY_STRATEGY
+    assert_equal Hatchet::AnvilApp, Hatchet::Runner
+  end
+
+  def test_change_deploy_strat
+    ENV['HATCHET_DEPLOY_STRATEGY'] = "git"
+    Hatchet.set_deploy_strategy!
+    assert_equal :git, Hatchet::DEPLOY_STRATEGY
+    assert_equal Hatchet::GitApp, Hatchet::Runner
+
+    ENV['HATCHET_DEPLOY_STRATEGY'] = "anvil"
+    Hatchet.set_deploy_strategy!
+    assert_equal :anvil, Hatchet::DEPLOY_STRATEGY
+    assert_equal Hatchet::AnvilApp, Hatchet::Runner
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: heroku_hatchet
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Richard Schneeman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-26 00:00:00.000000000 Z
+date: 2013-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: heroku-api
@@ -217,6 +217,7 @@ files:
 - test/hatchet/config_test.rb
 - test/hatchet/git_test.rb
 - test/hatchet/multi_cmd_runner_test.rb
+- test/hatchet/runner_test.rb
 - test/test_helper.rb
 homepage: https://github.com/heroku/hatchet
 licenses:
@@ -238,7 +239,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.2
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: Hatchet is a an integration testing library for developing Heroku buildpacks.
@@ -285,4 +286,5 @@ test_files:
 - test/hatchet/config_test.rb
 - test/hatchet/git_test.rb
 - test/hatchet/multi_cmd_runner_test.rb
+- test/hatchet/runner_test.rb
 - test/test_helper.rb