dpl 1.8.37.travis.2118.5 → 1.8.37.travis.2137.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e70689f1c5f495770fa775f5e1a181727124da1d
-  data.tar.gz: 8a2f7c9b872867fe8d276ac920a9bd72b20b8044
+  metadata.gz: bcd6ea4fb05d81e5fab3dcce86798099d57c1b8d
+  data.tar.gz: 41ed97cf489fd15bf0265677054f4abad4e4bf0d
 SHA512:
-  metadata.gz: 30c8e4017a804f1f9d2a1c57a30fd254437140fc52cb77e659525cedbc66773398592b8f4080124d3bd607dcfb9bbb3b9a404277633195f11634790b600d7ca8
-  data.tar.gz: 455bcd5016831bd76487ee13d0ae0de0c9b930efee7c82add44b80e4cad6f58a19509543efdb2cd6844362e07aa52c296f1a0a72756474b8ae9c7592fd9e50b0
+  metadata.gz: 69235b6920209a34bd4d908cfdf14f34b0be63f6f134607ddafcbf7a55fd0980a6cc7873df67c9353fe1afb68b72bf0961a4e88ce2d57b89e2860eee716bc4a7
+  data.tar.gz: 9afb31a2f32c25f22ad1b6d54c8171081e67190f35b5f0895f69862cde9d8a18a939f93bf595305dec0b914902ebf554f6e9a6916da1453e9627005f16f0fde2

data/lib/dpl/provider/heroku.rb

@@ -1,7 +1,6 @@
 module DPL
   class Provider
     module Heroku
-      autoload :Anvil,        'dpl/provider/heroku/anvil'
       autoload :API,          'dpl/provider/heroku/api'
       autoload :Generic,      'dpl/provider/heroku/generic'
       autoload :Git,          'dpl/provider/heroku/git'

data/lib/dpl/provider/heroku/api.rb

@@ -10,59 +10,6 @@ module DPL
         requires 'faraday'
         requires 'rendezvous'
 
-        def check_auth
-          response = faraday.get('/account')
-
-          if response.success?
-            email = JSON.parse(response.body)["email"]
-            log "authenticated as #{email}"
-          else
-            handle_error_response(response)
-          end
-        end
-
-        def faraday
-          return @conn if @conn
-          headers = { "Accept" => "application/vnd.heroku+json; version=3" }
-
-          if options[:user] and options[:password]
-            # no-op
-          else
-            headers.merge!({ "Authorization" => "Bearer #{option(:api_key)}" })
-          end
-
-          @conn = Faraday.new( url: 'https://api.heroku.com', headers: headers ) do |faraday|
-            if options[:user] and options[:password]
-              faraday.basic_auth(options[:user], options[:password])
-            end
-            if log_level = options[:log_level]
-              logger = Logger.new($stderr)
-              logger.level = Logger.const_get(log_level.upcase)
-
-              faraday.response :logger, logger do | logger |
-                logger.filter(/(.*Authorization: ).*/,'\1[REDACTED]')
-              end
-            end
-            faraday.adapter Faraday.default_adapter
-          end
-        end
-
-        def check_app
-          log "checking for app #{option(:app)}"
-          response = faraday.get("/apps/#{option(:app)}")
-          if response.success?
-            name = JSON.parse(response.body)["name"]
-            log "found app #{name}"
-          else
-            handle_error_response(response)
-          end
-        end
-
-        def handle_error_response(response)
-          error_response = JSON.parse(response.body)
-          error "API request failed.\nMessage: #{error_response["message"]}\nReference: #{error_response["url"]}"
-        end
-
         def push_app
           pack_archive
           upload_archive
@@ -145,27 +92,6 @@ module DPL
           @version ||= options[:version] || context.env['TRAVIS_COMMIT'] || `git rev-parse HEAD`.strip
         end
 
-        def restart
-          response = faraday.delete "/apps/#{option(:app)}/dynos" do |req|
-            req.headers['Content-Type'] = 'application/json'
-          end
-          unless response.success?
-            handle_error_response(response)
-          end
-        end
-
-        def run(command)
-          response = faraday.post "/apps/#{option(:app)}/dynos" do |req|
-            req.headers['Content-Type'] = 'application/json'
-            req.body = {"command" => command, "attach" => true}.to_json
-          end
-          if response.success?
-            rendezvous_url = JSON.parse(response.body)["attach_url"]
-            Rendezvous.start(url: rendezvous_url)
-          else
-            handle_error_response(response)
-          end
-        end
       end
     end
   end

data/lib/dpl/provider/heroku/generic.rb

@@ -1,64 +1,92 @@
+require 'json'
+
 module DPL
   class Provider
     module Heroku
       class Generic < Provider
-        requires 'heroku-api'
         requires 'rendezvous'
+        requires 'faraday'
+
+        attr_reader :app, :user
 
         def needs_key?
           false
         end
 
-        def api
-          @api ||= ::Heroku::API.new(api_options)
-        end
+        def faraday
+          return @conn if @conn
+          headers = { "Accept" => "application/vnd.heroku+json; version=3" }
 
-        def api_options
-          api_options = { headers: { 'User-Agent' => user_agent(::Heroku::API::HEADERS.fetch('User-Agent')) } }
           if options[:user] and options[:password]
-            api_options[:user]     = options[:user]
-            api_options[:password] = options[:password]
+            # no-op
           else
-            api_options[:api_key]  = option(:api_key)
+            headers.merge!({ "Authorization" => "Bearer #{option(:api_key)}" })
           end
-          api_options
-        end
 
-        def user
-          @user ||= api.get_user.body["email"]
+          @conn = Faraday.new( url: 'https://api.heroku.com', headers: headers ) do |faraday|
+            if options[:user] and options[:password]
+              faraday.basic_auth(options[:user], options[:password])
+            end
+            if log_level = options[:log_level]
+              logger = Logger.new($stderr)
+              logger.level = Logger.const_get(log_level.upcase)
+
+              faraday.response :logger, logger do | logger |
+                logger.filter(/(.*Authorization: ).*/,'\1[REDACTED]')
+              end
+            end
+            faraday.adapter Faraday.default_adapter
+          end
         end
 
         def check_auth
-          log "authenticated as %s" % user
-        end
+          response = faraday.get('/account')
 
-        def info
-          @info ||= api.get_app(option(:app)).body
+          if response.success?
+            email = JSON.parse(response.body)["email"]
+            @user = email
+            log "authenticated as #{email}"
+          else
+            handle_error_response(response)
+          end
         end
 
-        def check_app
-          log "checking for app '#{option(:app)}'"
-          log "found app '#{info['name']}'"
-        rescue ::Heroku::API::Errors::Forbidden => error
-          raise Error, "#{error.message} (does the app '#{option(:app)}' exist and does your account have access to it?)", error.backtrace
+        def handle_error_response(response)
+          error_response = JSON.parse(response.body)
+          error "API request failed.\nMessage: #{error_response["message"]}\nReference: #{error_response["url"]}"
         end
 
-        def run(command)
-          data           = api.post_ps(option(:app), command, :attach => true).body
-          rendezvous_url = data['rendezvous_url']
-          Rendezvous.start(:url => rendezvous_url) unless rendezvous_url.nil?
+        def check_app
+          log "checking for app #{option(:app)}"
+          response = faraday.get("/apps/#{option(:app)}")
+          if response.success?
+            @app = JSON.parse(response.body)
+            log "found app #{@app["name"]}"
+          else
+            handle_error_response(response)
+          end
         end
 
         def restart
-          api.post_ps_restart option(:app)
+          response = faraday.delete "/apps/#{option(:app)}/dynos" do |req|
+            req.headers['Content-Type'] = 'application/json'
+          end
+          unless response.success?
+            handle_error_response(response)
+          end
         end
 
-        def deploy
-          super
-        rescue ::Heroku::API::Errors::NotFound => error
-          raise Error, "#{error.message} (wrong app #{options[:app].inspect}?)", error.backtrace
-        rescue ::Heroku::API::Errors::Unauthorized => error
-          raise Error, "#{error.message} (wrong API key?)", error.backtrace
+        def run(command)
+          response = faraday.post "/apps/#{option(:app)}/dynos" do |req|
+            req.headers['Content-Type'] = 'application/json'
+            req.body = {"command" => command, "attach" => true}.to_json
+          end
+          if response.success?
+            rendezvous_url = JSON.parse(response.body)["attach_url"]
+            Rendezvous.start(url: rendezvous_url)
+          else
+            handle_error_response(response)
+          end
         end
       end
     end

data/lib/dpl/provider/heroku/git_deploy_key.rb

@@ -2,6 +2,11 @@ module DPL
   class Provider
     module Heroku
       class GitDeployKey < GitSSH
+        deprecated(
+          "git-deploy-key strategy is deprecated, and will be shut down on June 26, 2017.",
+          "Please consider moving to the \`api\` or \`git\` strategy."
+        )
+
         def needs_key?
           false
         end

data/lib/dpl/provider/heroku/git_ssh.rb

@@ -1,12 +1,87 @@
 module DPL
   class Provider
     module Heroku
-      class GitSSH < Git
+      class GitSSH < Provider
         deprecated(
           "git-ssh strategy is deprecated, and will be shut down on June 26, 2017.",
           "Please consider moving to the \`api\` or \`git\` strategy."
         )
 
+        requires 'heroku-api'
+        requires 'rendezvous'
+        requires 'netrc'
+
+        def needs_key?
+          false
+        end
+
+        def api
+          @api ||= ::Heroku::API.new(api_options)
+        end
+
+        def api_options
+          api_options = { headers: { 'User-Agent' => user_agent(::Heroku::API::HEADERS.fetch('User-Agent')) } }
+          if options[:user] and options[:password]
+            api_options[:user]     = options[:user]
+            api_options[:password] = options[:password]
+          else
+            api_options[:api_key]  = option(:api_key)
+          end
+          api_options
+        end
+
+        def user
+          @user ||= api.get_user.body["email"]
+        end
+
+        def check_auth
+          log "authenticated as %s" % user
+        end
+
+        def info
+          @info ||= api.get_app(option(:app)).body
+        end
+
+        def check_app
+          log "checking for app '#{option(:app)}'"
+          log "found app '#{info['name']}'"
+        rescue ::Heroku::API::Errors::Forbidden => error
+          raise Error, "#{error.message} (does the app '#{option(:app)}' exist and does your account have access to it?)", error.backtrace
+        end
+
+        def run(command)
+          data           = api.post_ps(option(:app), command, :attach => true).body
+          rendezvous_url = data['rendezvous_url']
+          Rendezvous.start(:url => rendezvous_url) unless rendezvous_url.nil?
+        end
+
+        def restart
+          api.post_ps_restart option(:app)
+        end
+
+        def deploy
+          super
+        rescue ::Heroku::API::Errors::NotFound => error
+          raise Error, "#{error.message} (wrong app #{options[:app].inspect}?)", error.backtrace
+        rescue ::Heroku::API::Errors::Unauthorized => error
+          raise Error, "#{error.message} (wrong API key?)", error.backtrace
+        end
+
+        def push_app
+          git_remote = options[:git] || git_url
+          write_netrc if git_remote.start_with?("https://")
+          log "$ git fetch origin $TRAVIS_BRANCH --unshallow"
+          context.shell "git fetch origin $TRAVIS_BRANCH --unshallow"
+          log "$ git push #{git_remote} HEAD:refs/heads/master -f"
+          context.shell "git push #{git_remote} HEAD:refs/heads/master -f"
+        end
+
+        def write_netrc
+          n = Netrc.read
+          n['git.heroku.com'] = [user, option(:api_key)]
+          n.save
+        end
+
         def git_url
           info['git_url']
         end

data/spec/provider/heroku_spec.rb

@@ -0,0 +1,357 @@
+require 'spec_helper'
+require 'dpl/provider/heroku'
+require 'faraday'
+
+RSpec.shared_context 'with faraday' do
+  let(:api_key) { 'foo' }
+  let(:stubs) { Faraday::Adapter::Test::Stubs.new }
+  let(:faraday) {
+    Faraday.new do |builder|
+      builder.adapter :test, stubs do |stub|
+        stub.get("/account") {|env| [200, response_headers, account_response_body]}
+        stub.get("/apps/example") {|env| [200, response_headers, app_response_body]}
+        stub.post("/apps/example/builds") {|env| [201, response_headers, builds_response_body]}
+        stub.get("/apps/example/builds/01234567-89ab-cdef-0123-456789abcdef/result") {|env| [200, response_headers, build_result_response_body]}
+        stub.post("/sources") {|env| [201, response_headers, source_response_body] }
+        stub.post("/apps/example/dynos") {|env| [201, response_headers, dynos_create_response_body]}
+        stub.delete("/apps/example/dynos") {|env| [202, response_headers, '{}'] }
+      end
+    end
+  }
+
+  let(:response_headers) {
+    {'Content-Type' => 'application/json'}
+  }
+
+  let(:app_response_body) {
+    '{
+      "acm": false,
+      "archived_at": "2012-01-01T12:00:00Z",
+      "buildpack_provided_description": "Ruby/Rack",
+      "build_stack": {
+        "id": "01234567-89ab-cdef-0123-456789abcdef",
+        "name": "cedar-14"
+      },
+      "created_at": "2012-01-01T12:00:00Z",
+      "git_url": "https://git.heroku.com/example.git",
+      "id": "01234567-89ab-cdef-0123-456789abcdef",
+      "maintenance": false,
+      "name": "example",
+      "owner": {
+        "email": "username@example.com",
+        "id": "01234567-89ab-cdef-0123-456789abcdef"
+      },
+      "organization": {
+        "id": "01234567-89ab-cdef-0123-456789abcdef",
+        "name": "example"
+      },
+      "team": {
+        "id": "01234567-89ab-cdef-0123-456789abcdef",
+        "name": "example"
+      },
+      "region": {
+        "id": "01234567-89ab-cdef-0123-456789abcdef",
+        "name": "us"
+      },
+      "released_at": "2012-01-01T12:00:00Z",
+      "repo_size": 0,
+      "slug_size": 0,
+      "space": {
+        "id": "01234567-89ab-cdef-0123-456789abcdef",
+        "name": "nasa",
+        "shield": true
+      },
+      "stack": {
+        "id": "01234567-89ab-cdef-0123-456789abcdef",
+        "name": "cedar-14"
+      },
+      "updated_at": "2012-01-01T12:00:00Z",
+      "web_url": "https://example.herokuapp.com/"
+    }'
+  }
+
+  let(:account_response_body) {
+    '{
+      "allow_tracking": true,
+      "beta": false,
+      "created_at": "2012-01-01T12:00:00Z",
+      "email": "username@example.com",
+      "federated": false,
+      "id": "01234567-89ab-cdef-0123-456789abcdef",
+      "identity_provider": {
+        "id": "01234567-89ab-cdef-0123-456789abcdef",
+        "organization": {
+          "name": "example"
+        }
+      },
+      "last_login": "2012-01-01T12:00:00Z",
+      "name": "Tina Edmonds",
+      "sms_number": "+1 ***-***-1234",
+      "suspended_at": "2012-01-01T12:00:00Z",
+      "delinquent_at": "2012-01-01T12:00:00Z",
+      "two_factor_authentication": false,
+      "updated_at": "2012-01-01T12:00:00Z",
+      "verified": false,
+      "default_organization": {
+        "id": "01234567-89ab-cdef-0123-456789abcdef",
+        "name": "example"
+      }
+    }'
+  }
+
+  let(:builds_response_body) {
+    '{
+      "app": {
+        "id": "01234567-89ab-cdef-0123-456789abcdef"
+      },
+      "buildpacks": [
+        {
+          "url": "https://github.com/heroku/heroku-buildpack-ruby"
+        }
+      ],
+      "created_at": "2012-01-01T12:00:00Z",
+      "id": "01234567-89ab-cdef-0123-456789abcdef",
+      "output_stream_url": "https://build-output.heroku.com/streams/01234567-89ab-cdef-0123-456789abcdef",
+      "source_blob": {
+        "checksum": "SHA256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "url": "https://example.com/source.tgz?token=xyz",
+        "version": "v1.3.0"
+      },
+      "release": {
+        "id": "01234567-89ab-cdef-0123-456789abcdef"
+      },
+      "slug": {
+        "id": "01234567-89ab-cdef-0123-456789abcdef"
+      },
+      "status": "succeeded",
+      "updated_at": "2012-01-01T12:00:00Z",
+      "user": {
+        "id": "01234567-89ab-cdef-0123-456789abcdef",
+        "email": "username@example.com"
+      }
+    }'
+  }
+
+  let(:source_response_body) {
+    '{
+      "source_blob": {
+        "get_url": "https://api.heroku.com/sources/1234.tgz",
+        "put_url": "https://api.heroku.com/sources/1234.tgz"
+      }
+    }'
+  }
+
+  let(:dynos_create_response_body) {
+    '{
+      "attach_url": "rendezvous://rendezvous.runtime.heroku.com:5000/rendezvous",
+      "command": "bash",
+      "created_at": "2012-01-01T12:00:00Z",
+      "id": "01234567-89ab-cdef-0123-456789abcdef",
+      "name": "run.1",
+      "release": {
+        "id": "01234567-89ab-cdef-0123-456789abcdef",
+        "version": 11
+      },
+      "app": {
+        "name": "example",
+        "id": "01234567-89ab-cdef-0123-456789abcdef"
+      },
+      "size": "standard-1X",
+      "state": "up",
+      "type": "run",
+      "updated_at": "2012-01-01T12:00:00Z"
+    }'
+  }
+
+  let(:build_result_response_body) {
+  '{
+      "build": {
+      "id": "01234567-89ab-cdef-0123-456789abcdef",
+      "status": "succeeded",
+      "output_stream_url": "https://build-output.heroku.com/streams/01234567-89ab-cdef-0123-456789abcdef"
+    },
+    "exit_code": 0,
+    "lines": [
+      {
+        "line": "-----> Ruby app detected\n",
+        "stream": "STDOUT"
+      }
+    ]
+  }'
+  }
+
+  let(:build_result_response_body_failure) {
+    '{
+        "build": {
+        "id": "01234567-89ab-cdef-0123-456789abcdef",
+        "status": "failed",
+        "output_stream_url": "https://build-output.heroku.com/streams/01234567-89ab-cdef-0123-456789abcdef"
+      },
+      "exit_code": 1,
+      "lines": [
+        {
+          "line": "-----> Ruby app detected\n",
+          "stream": "STDOUT"
+        }
+      ]
+    }'
+  }
+
+  let(:build_result_response_body_in_progress) {
+    '{
+        "build": {
+        "id": "01234567-89ab-cdef-0123-456789abcdef",
+        "status": "failed",
+        "output_stream_url": "https://build-output.heroku.com/streams/01234567-89ab-cdef-0123-456789abcdef"
+      },
+      "lines": [
+        {
+          "line": "-----> Ruby app detected\n",
+          "stream": "STDOUT"
+        }
+      ]
+    }'
+  }
+end
+
+describe DPL::Provider::Heroku, :api do
+  include_context 'with faraday'
+
+  subject(:provider) do
+    described_class.new(DummyContext.new, provider_options.merge({ :api_key => api_key}))
+  end
+
+  let(:provider_options) {
+    {:app => 'example', :key_name => 'key', :strategy => "api"}
+  }
+
+  describe "#ssh" do
+    it "doesn't require an ssh key" do
+      expect(provider.needs_key?).to eq(false)
+    end
+  end
+
+  describe "#api" do
+    it 'accepts an api key' do
+      expect(provider).to receive(:faraday).at_least(:once).and_return(faraday)
+      provider.check_auth
+    end
+
+    context "when api_key is not given" do
+      let(:provider) { described_class.new(DummyContext.new, provider_options) }
+      it 'raises DPL::Error' do
+        provider.options.update(:user => "foo", :password => "bar")
+        expect { provider.check_auth }.to raise_error(DPL::Error)
+      end
+    end
+  end
+
+  describe "#trigger_build" do
+    it "does not initiate legacy API object" do
+      expect(provider).to receive(:faraday).at_least(:once).and_return(faraday)
+      provider.trigger_build
+    end
+
+    example do
+      expect(provider).to receive(:log).with('triggering new deployment')
+      expect(provider).to receive(:faraday).at_least(:once).and_return(faraday)
+      expect(provider).to receive(:get_url).and_return 'http://example.com/source.tgz'
+      expect(provider).to receive(:version).and_return 'v1.3.0'
+      expect(provider.context).to receive(:shell).with("curl https://build-output.heroku.com/streams/01234567-89ab-cdef-0123-456789abcdef -H 'Accept: application/vnd.heroku+json; version=3'")
+      provider.trigger_build
+      expect(provider.build_id).to eq('01234567-89ab-cdef-0123-456789abcdef')
+    end
+  end
+
+  describe "#verify_build" do
+    context 'when build succeeds' do
+      example do
+        expect(provider).to receive(:faraday).at_least(:once).and_return(faraday)
+        expect(provider).to receive(:build_id).at_least(:once).and_return('01234567-89ab-cdef-0123-456789abcdef')
+        expect{ provider.verify_build }.not_to raise_error
+      end
+    end
+
+    context 'when build fails' do
+      example do
+        expect(provider).to receive(:faraday).at_least(:once).and_return(faraday)
+        expect(provider).to receive(:build_id).at_least(:once).and_return('01234567-89ab-cdef-0123-456789abcdef')
+        stubs.get("/apps/example/builds/01234567-89ab-cdef-0123-456789abcdef/result") {|env| [200, response_headers, build_result_response_body_failure]}
+        expect{ provider.verify_build }.to raise_error("deploy failed, build exited with code 1")
+      end
+    end
+
+    context 'when build is pending, then succeeds' do
+      example do
+        expect(provider).to receive(:faraday).at_least(:once).and_return(faraday)
+        expect(provider).to receive(:build_id).at_least(:once).and_return('01234567-89ab-cdef-0123-456789abcdef')
+        stubs.get("/apps/example/builds/01234567-89ab-cdef-0123-456789abcdef/result") {|env| [200, response_headers, build_result_response_body_in_progress]}
+        expect(provider).to receive(:sleep).with(5).and_return(true)
+        expect{ provider.verify_build }.not_to raise_error
+      end
+    end
+
+  end
+
+end
+
+
+describe DPL::Provider::Heroku, :git do
+  include_context "with faraday"
+
+  subject :provider do
+    described_class.new(DummyContext.new, :app => 'example', :key_name => 'key', :api_key => api_key, :strategy => "git")
+  end
+
+  describe "#api" do
+    it 'accepts an api key' do
+      expect(provider).to receive(:faraday).at_least(:once).and_return(faraday)
+      provider.check_auth
+    end
+  end
+
+  context "with faraday" do
+    before :each do
+      expect(provider).to receive(:faraday).at_least(:once).and_return(faraday)
+    end
+
+    describe "#check_auth" do
+      example do
+        expect(provider).to receive(:log).with("authenticated as username@example.com")
+        provider.check_auth
+      end
+    end
+
+    describe "#check_app" do
+      example do
+        expect(provider).to receive(:log).at_least(1).times.with(/example/)
+        provider.check_app
+      end
+    end
+
+    describe "#run" do
+      example do
+        expect(Rendezvous).to receive(:start).with(:url => "rendezvous://rendezvous.runtime.heroku.com:5000/rendezvous")
+        provider.run("that command")
+      end
+    end
+
+    describe "#restart" do
+      example do
+        provider.restart
+      end
+    end
+  end
+
+  context "without faraday" do
+    describe "#push_app" do
+      example do
+        provider.options[:git] = "git://something"
+        expect(provider.context).to receive(:shell).with("git fetch origin $TRAVIS_BRANCH --unshallow")
+        expect(provider.context).to receive(:shell).with("git push git://something HEAD:refs/heads/master -f")
+        provider.push_app
+        expect(provider.context.env['GIT_HTTP_USER_AGENT']).to include("dpl/#{DPL::VERSION}")
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dpl
 version: !ruby/object:Gem::Version
-  version: 1.8.37.travis.2118.5
+  version: 1.8.37.travis.2137.5
 platform: ruby
 authors:
 - Konstantin Haase
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-02 00:00:00.000000000 Z
+date: 2017-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -145,7 +145,6 @@ files:
 - lib/dpl/provider/gcs.rb
 - lib/dpl/provider/hackage.rb
 - lib/dpl/provider/heroku.rb
-- lib/dpl/provider/heroku/anvil.rb
 - lib/dpl/provider/heroku/api.rb
 - lib/dpl/provider/heroku/generic.rb
 - lib/dpl/provider/heroku/git.rb
@@ -195,10 +194,9 @@ files:
 - spec/provider/gae_spec.rb
 - spec/provider/gcs_spec.rb
 - spec/provider/hackage_spec.rb
-- spec/provider/heroku_anvil_spec.rb
-- spec/provider/heroku_api_spec.rb
 - spec/provider/heroku_git_deploy_key_spec.rb
-- spec/provider/heroku_git_spec.rb
+- spec/provider/heroku_git_ssh_spec.rb
+- spec/provider/heroku_spec.rb
 - spec/provider/lambda_spec.rb
 - spec/provider/launchpad_spec.rb
 - spec/provider/modulus_spec.rb

data/lib/dpl/provider/heroku/anvil.rb

@@ -1,72 +0,0 @@
-module DPL
-  class Provider
-    module Heroku
-      class Anvil < Git
-        HEROKU_BUILDPACKS = ['ruby', 'nodejs', 'clojure', 'python', 'java', 'gradle', 'grails', 'scala', 'play']
-        HEROKU_BUILDPACK_PREFIX = "https://github.com/heroku/heroku-buildpack-"
-        requires 'anvil-cli', :load => 'anvil/engine'
-        requires 'excon' # comes with heroku
-        requires 'json'
-
-        def api
-          raise Error, 'anvil deploy strategy only works with api_key' unless options[:api_key]
-          super
-        end
-
-        def deploy
-          warn ''
-          if options[:strategy]
-            warn 'You have explicitly set your deploy strategy to %p.' % options[:strategy]
-            warn 'Anvil support will be dropped in the near future.'
-            warn 'Please consider changing it to "api" or "git".'
-          else
-            warn 'The default strategy for Heroku deployments is currently "anvil".'
-            warn 'This will be changed to "api" in the near future.'
-            warn 'Consider setting it explicitly to "api" or "git".'
-          end
-          warn ''
-
-          super
-        end
-
-        def push_app
-          sha = context.env['TRAVIS_COMMIT'] || `git rev-parse HEAD`.strip
-          response = Excon.post release_url,
-            :body    => { "slug_url" => slug_url, "description" => "Deploy #{sha} via Travis CI" }.to_json,
-            :headers => { 'Content-Type' => 'application/json', 'Accept' => 'application/json' }
-
-          print "\nDeploying slug "
-          while response.status == 202
-            location = response.headers['Location']
-            response = Excon.get("https://:#{option(:api_key)}@cisaurus.heroku.com#{location}")
-            sleep(1)
-            print '.'
-          end
-
-          if response.status.between? 200, 299
-            puts " success!"
-          else
-            raise Error, "deploy failed, anvil response: #{response.body}"
-          end
-        end
-
-        def slug_url
-          @slug_url ||= begin
-            ::Anvil.headers["X-Heroku-User"] = user
-            ::Anvil.headers["X-Heroku-App"]  = option(:app)
-            if HEROKU_BUILDPACKS.include? options[:buildpack]
-              options[:buildpack] = HEROKU_BUILDPACK_PREFIX + options[:buildpack] + ".git"
-            end
-            ::Anvil::Engine.build ".", :buildpack => options[:buildpack]
-          rescue ::Anvil::Builder::BuildError => e
-            raise Error, "deploy failed, anvil build error: #{e.message}"
-          end
-        end
-
-        def release_url
-          "https://:#{option(:api_key)}@cisaurus.heroku.com/v1/apps/#{option(:app)}/release"
-        end
-      end
-    end
-  end
-end

data/spec/provider/heroku_anvil_spec.rb

@@ -1,80 +0,0 @@
-require 'spec_helper'
-require 'anvil'
-require 'heroku-api'
-require 'excon'
-require 'dpl/provider/heroku'
-
-describe DPL::Provider::Heroku do
-  subject :provider do
-    described_class.new(DummyContext.new, :app => 'example', :api_key => 'foo', :strategy => 'anvil', :buildpack => 'git://some-buildpack.git')
-  end
-
-  describe "#api" do
-    it 'accepts an api key' do
-      api = double(:api)
-      expect { provider.api }.not_to raise_error
-    end
-
-    it 'raises an error if an api key is not present' do
-      provider.options.delete :api_key
-      expect { provider.api }.to raise_error(DPL::Error)
-    end
-  end
-
-  context "with fake api" do
-    let :api do
-      double "api",
-        :get_user => double("get_user", :body => { "email" => "foo@bar.com" }),
-        :get_app  => double("get_app",  :body => { "name"  => "example", "git_url" => "GIT URL" })
-    end
-
-    before do
-      expect(::Heroku::API).to receive(:new).and_return(api)
-      provider.api
-    end
-
-    describe "#push_app" do
-      example do
-        response = double :response
-        allow(response).to receive_messages(:status => 202)
-        allow(response).to receive_messages(:headers => {'Location' => '/blah'})
-
-        second_response = double :second_response
-        allow(second_response).to receive_messages(:status => 200)
-
-        allow(provider).to receive_messages(:slug_url => "http://slug-url")
-
-        expect(provider.context.env).to receive(:[]).with('TRAVIS_COMMIT').and_return('123')
-        expect(::Excon).to receive(:post).with(provider.release_url,
-                                        :body => {"slug_url" => "http://slug-url", "description" => "Deploy 123 via Travis CI" }.to_json,
-                                         :headers => {"Content-Type" => 'application/json', 'Accept' => 'application/json'}).and_return(response)
-
-        expect(::Excon).to receive(:get).with("https://:#{provider.options[:api_key]}@cisaurus.heroku.com/blah").and_return(second_response)
-        provider.push_app
-      end
-    end
-
-    describe "#slug_url" do
-
-      before(:each) do
-        headers = double(:headers)
-        expect(::Anvil).to receive(:headers).at_least(:twice).and_return(headers)
-        expect(headers).to receive(:[]=).at_least(:once).with('X-Heroku-User', "foo@bar.com")
-        expect(headers).to receive(:[]=).at_least(:once).with('X-Heroku-App', "example")
-      end
-
-      example "with full buildpack url" do
-        expect(::Anvil::Engine).to receive(:build).with(".", :buildpack=>"git://some-buildpack.git")
-        provider.slug_url
-      end
-
-      example "with buildpack name expansion" do
-        DPL::Provider::Heroku::Anvil::HEROKU_BUILDPACKS.each do |b|
-          provider.options.update(:buildpack => b)
-          expect(::Anvil::Engine).to receive(:build).with(".", :buildpack=>described_class::Anvil::HEROKU_BUILDPACK_PREFIX + b + ".git")
-          provider.slug_url
-        end
-      end
-    end
-  end
-end

data/spec/provider/heroku_api_spec.rb

@@ -1,228 +0,0 @@
-require 'spec_helper'
-require 'dpl/provider/heroku'
-require 'faraday'
-
-describe DPL::Provider::Heroku do
-  let(:api_key) { 'foo' }
-  let(:stubs) { Faraday::Adapter::Test::Stubs.new }
-  let(:faraday) {
-    Faraday.new do |builder|
-      builder.adapter :test, stubs do |stub|
-        stub.get("/account") {|env| [200, response_headers, account_response_body]}
-        stub.post("/apps/example/builds") {|env| [201, response_headers, builds_response_body]}
-        stub.get("/apps/example/builds/01234567-89ab-cdef-0123-456789abcdef/result") {|env| [200, response_headers, build_result_response_body]}
-        stub.post("/sources") {|env| [201, response_headers, source_response_body] }
-      end
-    end
-  }
-
-  let(:response_headers) {
-    {'Content-Type' => 'application/json'}
-  }
-
-  let(:account_response_body) {
-'{
-  "allow_tracking": true,
-  "beta": false,
-  "created_at": "2012-01-01T12:00:00Z",
-  "email": "username@example.com",
-  "federated": false,
-  "id": "01234567-89ab-cdef-0123-456789abcdef",
-  "identity_provider": {
-    "id": "01234567-89ab-cdef-0123-456789abcdef",
-    "organization": {
-      "name": "example"
-    }
-  },
-  "last_login": "2012-01-01T12:00:00Z",
-  "name": "Tina Edmonds",
-  "sms_number": "+1 ***-***-1234",
-  "suspended_at": "2012-01-01T12:00:00Z",
-  "delinquent_at": "2012-01-01T12:00:00Z",
-  "two_factor_authentication": false,
-  "updated_at": "2012-01-01T12:00:00Z",
-  "verified": false,
-  "default_organization": {
-    "id": "01234567-89ab-cdef-0123-456789abcdef",
-    "name": "example"
-  }
-}'
-  }
-
-  let(:builds_response_body) {
-'{
-  "app": {
-    "id": "01234567-89ab-cdef-0123-456789abcdef"
-  },
-  "buildpacks": [
-    {
-      "url": "https://github.com/heroku/heroku-buildpack-ruby"
-    }
-  ],
-  "created_at": "2012-01-01T12:00:00Z",
-  "id": "01234567-89ab-cdef-0123-456789abcdef",
-  "output_stream_url": "https://build-output.heroku.com/streams/01234567-89ab-cdef-0123-456789abcdef",
-  "source_blob": {
-    "checksum": "SHA256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
-    "url": "https://example.com/source.tgz?token=xyz",
-    "version": "v1.3.0"
-  },
-  "release": {
-    "id": "01234567-89ab-cdef-0123-456789abcdef"
-  },
-  "slug": {
-    "id": "01234567-89ab-cdef-0123-456789abcdef"
-  },
-  "status": "succeeded",
-  "updated_at": "2012-01-01T12:00:00Z",
-  "user": {
-    "id": "01234567-89ab-cdef-0123-456789abcdef",
-    "email": "username@example.com"
-  }
-}'
-  }
-
-  let(:source_response_body) {
-'{
-  "source_blob": {
-    "get_url": "https://api.heroku.com/sources/1234.tgz",
-    "put_url": "https://api.heroku.com/sources/1234.tgz"
-  }
-}'
-  }
-
-  let(:build_result_response_body) {
-'{
-    "build": {
-    "id": "01234567-89ab-cdef-0123-456789abcdef",
-    "status": "succeeded",
-    "output_stream_url": "https://build-output.heroku.com/streams/01234567-89ab-cdef-0123-456789abcdef"
-  },
-  "exit_code": 0,
-  "lines": [
-    {
-      "line": "-----> Ruby app detected\n",
-      "stream": "STDOUT"
-    }
-  ]
-}'
-  }
-
-  let(:build_result_response_body_failure) {
-'{
-    "build": {
-    "id": "01234567-89ab-cdef-0123-456789abcdef",
-    "status": "failed",
-    "output_stream_url": "https://build-output.heroku.com/streams/01234567-89ab-cdef-0123-456789abcdef"
-  },
-  "exit_code": 1,
-  "lines": [
-    {
-      "line": "-----> Ruby app detected\n",
-      "stream": "STDOUT"
-    }
-  ]
-}'
-  }
-
-  let(:build_result_response_body_in_progress) {
-'{
-    "build": {
-    "id": "01234567-89ab-cdef-0123-456789abcdef",
-    "status": "failed",
-    "output_stream_url": "https://build-output.heroku.com/streams/01234567-89ab-cdef-0123-456789abcdef"
-  },
-  "lines": [
-    {
-      "line": "-----> Ruby app detected\n",
-      "stream": "STDOUT"
-    }
-  ]
-}'
-  }
-
-  subject(:provider) do
-    described_class.new(DummyContext.new, provider_options.merge({ :api_key => api_key}))
-  end
-
-  let(:provider_options) {
-    {:app => 'example', :key_name => 'key', :strategy => "api"}
-  }
-
-  let(:expected_headers) do
-    { "Authorization" => "Bearer #{api_key}", "Accept" => "application/vnd.heroku+json; version=3" }
-  end
-
-  let(:api_url) { 'https://api.heroku.com' }
-
-  describe "#ssh" do
-    it "doesn't require an ssh key" do
-      expect(provider.needs_key?).to eq(false)
-    end
-  end
-
-  describe "#api" do
-    it 'accepts an api key' do
-      expect(provider).to receive(:faraday).at_least(:once).and_return(faraday)
-      provider.check_auth
-    end
-
-    context "when api_key is not given" do
-      let(:provider) { described_class.new(DummyContext.new, provider_options) }
-      it 'raises DPL::Error' do
-        provider.options.update(:user => "foo", :password => "bar")
-        expect(::Heroku::API).not_to receive(:new)
-        expect { provider.check_auth }.to raise_error(DPL::Error)
-      end
-    end
-  end
-
-  describe "#trigger_build" do
-    it "does not initiate legacy API object" do
-      expect(provider).to receive(:faraday).at_least(:once).and_return(faraday)
-      expect(::Heroku::API).not_to receive(:new)
-      provider.trigger_build
-    end
-
-    example do
-      expect(provider).to receive(:log).with('triggering new deployment')
-      expect(provider).to receive(:faraday).at_least(:once).and_return(faraday)
-      expect(provider).to receive(:get_url).and_return 'http://example.com/source.tgz'
-      expect(provider).to receive(:version).and_return 'v1.3.0'
-      expect(provider.context).to receive(:shell).with("curl https://build-output.heroku.com/streams/01234567-89ab-cdef-0123-456789abcdef -H 'Accept: application/vnd.heroku+json; version=3'")
-      provider.trigger_build
-      expect(provider.build_id).to eq('01234567-89ab-cdef-0123-456789abcdef')
-    end
-  end
-
-  describe "#verify_build" do
-    context 'when build succeeds' do
-      example do
-        expect(provider).to receive(:faraday).at_least(:once).and_return(faraday)
-        expect(provider).to receive(:build_id).at_least(:once).and_return('01234567-89ab-cdef-0123-456789abcdef')
-        expect{ provider.verify_build }.not_to raise_error
-      end
-    end
-
-    context 'when build fails' do
-      example do
-        expect(provider).to receive(:faraday).at_least(:once).and_return(faraday)
-        expect(provider).to receive(:build_id).at_least(:once).and_return('01234567-89ab-cdef-0123-456789abcdef')
-        stubs.get("/apps/example/builds/01234567-89ab-cdef-0123-456789abcdef/result") {|env| [200, response_headers, build_result_response_body_failure]}
-        expect{ provider.verify_build }.to raise_error("deploy failed, build exited with code 1")
-      end
-    end
-
-    context 'when build is pending, then succeeds' do
-      example do
-        expect(provider).to receive(:faraday).at_least(:once).and_return(faraday)
-        expect(provider).to receive(:build_id).at_least(:once).and_return('01234567-89ab-cdef-0123-456789abcdef')
-        stubs.get("/apps/example/builds/01234567-89ab-cdef-0123-456789abcdef/result") {|env| [200, response_headers, build_result_response_body_in_progress]}
-        expect(provider).to receive(:sleep).with(5) # stub sleep
-        expect{ provider.verify_build }.not_to raise_error
-      end
-    end
-
-  end
-
-end