Merge pull request #3 from hone/testing

implement testing for the buildpack

.gitignore

+vendor/
+.bundle/

.rspec

+--color
+--require spec_helper
+--format d

Dockerfile

+FROM heroku/cedar:14
+
+RUN useradd -d /app -m app
+USER app
+
+WORKDIR /buildpack
+COPY bin/ /buildpack/bin/
+COPY scripts/ /buildpack/scripts/
+RUN /buildpack/bin/compile /app
+
+ENV HOME /app
+ENV PORT 3000
+EXPOSE 3000
+
+WORKDIR /app

Gemfile

+source "https://rubygems.org"
+
+group :development do
+  gem "docker-api"
+  gem "rspec"
+  gem "concurrent-ruby"
+end

Gemfile.lock

+GEM
+  remote: https://rubygems.org/
+  specs:
+    concurrent-ruby (0.8.0)
+      ref (~> 1.0, >= 1.0.5)
+    diff-lcs (1.2.5)
+    docker-api (1.21.4)
+      excon (>= 0.38.0)
+      json
+    excon (0.45.3)
+    json (1.8.2)
+    ref (1.0.5)
+    rspec (3.2.0)
+      rspec-core (~> 3.2.0)
+      rspec-expectations (~> 3.2.0)
+      rspec-mocks (~> 3.2.0)
+    rspec-core (3.2.3)
+      rspec-support (~> 3.2.0)
+    rspec-expectations (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-mocks (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-support (3.2.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  concurrent-ruby
+  docker-api
+  rspec
+
+BUNDLED WITH
+   1.10.2

README.md

@@ -90,3 +90,21 @@ For single page web applications like Ember, it's common to back the application
   }
 }
 ```
+
+## Testing
+For testing we use Docker to replicate Heroku locally. You'll need to have [it setup locally](https://docs.docker.com/installation/). We're also using rspec for testing with Ruby. You'll need to have those setup and install those deps:
+
+```sh
+$ bundle install
+```
+
+To run the test suite just execute:
+
+```sh
+$ bundle exec rspec
+```
+
+### Structure
+To add a new test, add another example inside `spec/simple_spec.rb` or create a new file based off of `spec/simple_spec.rb`. All the example apps live in `spec/fixtures`.
+
+When writing a test, `BuildpackBuilder` creates the docker container we need that represents the heroku cedar-14 stack. `AppRunner.new` takes the name of a fixture and mounts it in the container built by `BuildpackBuilder` to run tests against. The `AppRunner` instance provides convenience methods like `get` that just wrap `net/http` for analyzing the response.

scripts/config/make-config

@@ -18,6 +18,11 @@ class NginxConfig
     json["port"] ||= ENV["PORT"] || 5000
     json["root"] ||= "public_html/"
     json["proxies"] ||= {}
+    json["proxies"].each do |loc, hash|
+      if hash["origin"][-1] != "/"
+        json["proxies"][loc].merge!("origin" => hash["origin"] + "/")
+      end
+    end
     json["clean_urls"] ||= false
     json["routes"] ||= {}
     json["routes"] = Hash[json["routes"].map { |route, target| [to_regex(route), target] }]

spec/fixtures/clean_urls/public_html/foo.html

+foobar

spec/fixtures/clean_urls/static.json

+{
+  "clean_urls": true
+}

spec/fixtures/custom_error_pages/public_html/error.html

+not found

spec/fixtures/custom_error_pages/static.json

+{
+  "error_page": "error.html"
+}

spec/fixtures/different_root/dist/index.html

+Hello from dist/

spec/fixtures/different_root/static.json

+{
+  "root": "dist"
+}

spec/fixtures/hello_world/public_html/index.html

+Hello World

spec/fixtures/hello_world/static.json

+{}

spec/fixtures/proxies/public_html/foo/bar/index.html

+api

spec/fixtures/redirects/public_html/index.html

+hello world

spec/fixtures/redirects/static.json

+{
+  "redirects": {
+    "/old/gone": {
+      "url": "/",
+      "status": 302
+    }
+  }
+}

spec/fixtures/routes/public_html/index.html

+hello world

spec/fixtures/routes/public_html/route.html

+hello from route

spec/fixtures/routes/static.json

+{
+  "routes": {
+    "/*.html": "index.html",
+    "/route/**": "route.html"
+  }
+}

spec/simple_spec.rb

+require "fileutils"
+require_relative "spec_helper"
+require_relative "support/app_runner"
+require_relative "support/buildpack_builder"
+require_relative "support/path_helper"
+
+RSpec.describe "Simple" do
+  before(:all) do
+    @debug = false
+    BuildpackBuilder.new(@debug)
+  end
+
+  after do
+    app.destroy
+  end
+
+  let(:app)  { AppRunner.new(name, @debug) }
+
+  let(:name) { "hello_world" }
+
+  it "should serve out of public_html by default" do
+    response = app.get("/")
+    expect(response.code).to eq("200")
+    expect(response.body.chomp).to eq("Hello World")
+  end
+
+  describe "root" do
+    let(:name) { "different_root" }
+
+    it "should serve assets out of user defined root" do
+      response = app.get("/")
+      expect(response.code).to eq("200")
+      expect(response.body.chomp).to eq("Hello from dist/")
+    end
+  end
+
+  describe "clean_urls" do
+    let(:name) { "clean_urls" }
+
+    it "should drop the .html extension from URLs" do
+      response = app.get("/foo")
+      expect(response.code).to eq("200")
+      expect(response.body.chomp).to eq("foobar")
+    end
+  end
+
+  describe "routes" do
+    let(:name) { "routes" }
+
+    it "should support custom routes" do
+      response = app.get("/foo.html")
+      expect(response.code).to eq("200")
+      expect(response.body.chomp).to eq("hello world")
+
+      response = app.get("/route/foo")
+      expect(response.code).to eq("200")
+      expect(response.body.chomp).to eq("hello from route")
+
+      response = app.get("/route/foo/bar")
+      expect(response.code).to eq("200")
+      expect(response.body.chomp).to eq("hello from route")
+    end
+  end
+
+  describe "redirects" do
+    let(:name) { "redirects" }
+
+    it "should redirect and respect the http code" do
+      response = app.get("/old/gone")
+      expect(response.code).to eq("302")
+      expect(response["location"]).to eq("http://#{AppRunner::HOST_IP}:#{AppRunner::HOST_PORT}/")
+    end
+  end
+
+  describe "custom error pages" do
+    let(:name) { "custom_error_pages" }
+
+    it "should render the error page for a 404" do
+      response = app.get("/ewat")
+      expect(response.code).to eq("404")
+      expect(response.body.chomp).to eq("not found")
+    end
+  end
+
+  describe "proxies" do
+    include PathHelper
+
+    let(:name)              { "proxies" }
+    let(:static_json_path)  { fixtures_path("proxies/static.json") }
+    let(:setup_static_json) do
+      Proc.new do |path|
+      File.open(static_json_path, "w") do |file|
+        file.puts <<STATIC_JSON
+{
+  "proxies": {
+    "/api/": {
+      "origin": "http://#{AppRunner::HOST_IP}:#{AppRunner::HOST_PORT}#{path}"
+    }
+  }
+}
+STATIC_JSON
+
+        end
+      end
+    end
+
+    after do
+      FileUtils.rm(static_json_path)
+    end
+
+    context "trailing slash" do
+      before do
+        setup_static_json.call("/foo/")
+      end
+
+      it "should proxy requests" do
+        response = app.get("/api/bar/")
+        expect(response.code).to eq("200")
+        expect(response.body.chomp).to eq("api")
+      end
+    end
+
+    context "without a trailing slash" do
+      before do
+        setup_static_json.call("/foo")
+      end
+
+      it "should proxy requests" do
+        response = app.get("/api/bar/")
+        expect(response.code).to eq("200")
+        expect(response.body.chomp).to eq("api")
+      end
+    end
+  end
+end

spec/spec_helper.rb

+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+end

spec/support/app_runner.rb

+require "uri"
+require "net/http"
+require "fileutils"
+require "json"
+require "docker"
+require "concurrent/atomic/count_down_latch"
+require_relative "path_helper"
+require_relative "buildpack_builder"
+
+class AppRunner
+  include PathHelper
+
+  HOST_PORT      = "3000"
+  HOST_IP        = "127.0.0.1"
+  CONTAINER_PORT = "3000"
+
+  def initialize(fixture, debug = false)
+    @debug     = debug
+    @container = Docker::Container.create(
+      'Image'      => BuildpackBuilder::TAG,
+      'Cmd'        => ["bash", "-c", "cp -rf /src/* /app/ && /app/bin/boot"],
+      'HostConfig' => {
+        'Binds' => ["#{fixtures_path(fixture)}:/src"],
+        'PortBindings' => {
+          "#{CONTAINER_PORT}/tcp" => [{
+            "HostIp" => HOST_IP,
+            "HostPort": HOST_PORT,
+          }]
+        }
+      }
+    )
+  end
+
+  def run
+    latch = Concurrent::CountDownLatch.new(1)
+    run_thread = Thread.new {
+      latch.wait(0.5)
+      yield(@container)
+    }
+    container_thread = Thread.new {
+      @container.tap(&:start).attach do |stream, chunk|
+        puts "#{stream}: #{chunk}" if @debug
+        latch.count_down if chunk.include?("Starting nginx...")
+      end
+    }
+
+    run_thread.join
+    @container.stop
+    container_thread.join
+  end
+
+  def get(path, max_retries = 5)
+    response = nil
+
+    run do
+      network_retry(max_retries) do
+        uri      = URI("http://#{HOST_IP}:#{HOST_PORT}/#{path}")
+        response = Net::HTTP.get_response(uri)
+      end
+    end
+
+    response
+  end
+
+  def destroy
+    @container.delete(force: true) unless @debug
+  end
+
+  private
+  def network_retry(max_retries, retry_count = 0)
+    yield
+  rescue Errno::ECONNRESET, EOFError
+    if retry_count < max_retries
+      puts "Retry Count: #{retry_count}" if @debug
+      sleep(0.01 * retry_count)
+      retry_count += 1
+      retry
+    end
+  end
+end

spec/support/buildpack_builder.rb

+require "tmpdir"
+require "fileutils"
+require "docker"
+require_relative "path_helper"
+
+class BuildpackBuilder
+  include PathHelper
+
+  TAG = "hone/static:cedar-14"
+
+  def initialize(debug = false)
+    @debug = debug
+    @image = build_image
+  end
+
+  def build_image
+    print_output =
+      if @debug
+        -> (chunk) {
+          json = JSON.parse(chunk)
+          puts json["stream"]
+        }
+      else
+        -> (chunk) { nil }
+      end
+
+    Docker::Image.build_from_dir(buildpack_path.to_s, 't' => TAG, 'rm' => true, &print_output)
+  end
+end

spec/support/path_helper.rb

+module PathHelper
+  def fixtures_path(*path)
+    __build_path("../fixtures", *path)
+  end
+
+  def buildpack_path(*path)
+    __build_path("../../", *path)
+  end
+  
+  private
+  def __build_path(name, *path)
+    Pathname.new(File.join(File.dirname(__FILE__), name, *path))
+  end
+end