dpl-connect 1.8.43

data/spec/provider/hackage_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'dpl/provider/hackage'
+
+describe DPL::Provider::Hackage do
+  subject :provider do
+    described_class.new(DummyContext.new, :username => 'FooUser', :password => 'bar')
+  end
+
+  describe "#check_auth" do
+    it 'should require username' do
+      provider.options.update(:username => nil)
+      expect {
+        provider.check_auth
+      }.to raise_error(DPL::Error)
+    end
+
+    it 'should require password' do
+      provider.options.update(:password => nil)
+      expect {
+        provider.check_auth
+      }.to raise_error(DPL::Error)
+    end
+  end
+
+  describe "#check_app" do
+    it 'calls cabal' do
+      expect(provider.context).to receive(:shell).with("cabal check").and_return(true)
+      provider.check_app
+    end
+
+    it 'fails when cabal complains' do
+      expect(provider.context).to receive(:shell).with("cabal check").and_return(false)
+      expect {
+        provider.check_app
+      }.to raise_error(DPL::Error)
+    end
+  end
+
+  describe "#push_app" do
+    example do
+      expect(provider.context).to receive(:shell).with("cabal sdist").and_return(true)
+      expect(Dir).to receive(:glob).and_yield('dist/package-0.1.2.3.tar.gz')
+      expect(provider.context).to receive(:shell).with("cabal upload --username=FooUser --password=bar dist/package-0.1.2.3.tar.gz")
+      provider.push_app
+    end
+  end
+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("authentication succeeded")
+        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

data/spec/provider/lambda_spec.rb

@@ -0,0 +1,432 @@
+require 'spec_helper'
+require 'aws-sdk'
+require 'dpl/error'
+require 'dpl/provider'
+require 'dpl/provider/lambda'
+
+describe DPL::Provider::Lambda do
+
+  subject :provider do
+    described_class.new(DummyContext.new, :access_key_id => 'qwertyuiopasdfghjklz', :secret_access_key => 'qwertyuiopasdfghjklzqwertyuiopasdfghjklz')
+  end
+
+  describe '#lambda_options' do
+    context 'without region' do
+      example do
+        options = provider.lambda_options
+        expect(options[:region]).to eq('us-east-1')
+      end
+    end
+
+    context 'with region' do
+      example do
+        region = 'us-west-1'
+        provider.options.update(:region => region)
+        options = provider.lambda_options
+        expect(options[:region]).to eq(region)
+      end
+    end
+  end
+end
+
+describe DPL::Provider::Lambda do
+  access_key_id = 'someaccesskey'
+  secret_access_key = 'somesecretaccesskey'
+  region = 'us-east-1'
+
+  client_options = {
+    stub_responses: true,
+    region: region,
+    credentials: Aws::Credentials.new(access_key_id, secret_access_key)
+  }
+
+  subject :provider do
+    described_class.new(DummyContext.new, {
+      access_key_id: access_key_id,
+      secret_access_key: secret_access_key
+    })
+  end
+
+  before :each do
+    provider.stub(:lambda_options).and_return(client_options)
+  end
+
+  describe '#lambda' do
+    example do
+      expect(Aws::Lambda::Client).to receive(:new).with(client_options).once
+      provider.lambda
+    end
+  end
+
+  describe '#push_app' do
+    lambda_options = {
+      function_name: 'test-function',
+      role: 'some-role',
+      module_name: 'index',
+      handler_name: 'handler'
+    }
+
+    example_get_function_response = {
+      code: {
+        location: 'location',
+        repository_type: 's3',
+      },
+      configuration: {
+        function_name: 'test-function'
+      }
+    }
+
+    example_response = {
+      function_name: 'test-function',
+      function_arn: 'arn:lambda:region:account-id:function:test-function',
+      role: 'some-role',
+      handler: 'index.handler'
+    }
+
+    before(:each) do
+      old_options = provider.options
+      provider.stub(:options) { old_options.merge(lambda_options) }
+    end
+
+    context 'by creating a new function' do
+      before do
+        provider.lambda.stub_responses(:get_function, 'ResourceNotFoundException')
+        provider.lambda.stub_responses(:create_function, example_response)
+      end
+
+      example do
+
+        expect(provider).to receive(:log).with(/Function #{lambda_options[:function_name]} does not exist, creating\./)
+        expect(provider).to receive(:log).with(/Created lambda: #{lambda_options[:function_name]}\./)
+        provider.push_app
+      end
+    end
+
+    context 'by updating an existing function' do
+      before do
+        provider.lambda.stub_responses(:get_function, example_get_function_response)
+        provider.lambda.stub_responses(:update_function_configuration, example_response)
+        provider.lambda.stub_responses(:update_function_code, example_response)
+      end
+
+      example do
+        expect(provider).to receive(:log).with(/Function #{lambda_options[:function_name]} already exists, updating\./)
+        expect(provider).to receive(:log).with(/Updated configuration of function: #{lambda_options[:function_name]}\./)
+        expect(provider).to receive(:log).with(/Updated code of function: #{lambda_options[:function_name]}\./)
+        provider.push_app
+      end
+    end
+
+    context 'by updating an existing function with new tags' do
+      before do
+        lambda_options[:function_tags] = [ 'TAG_KEY=some-value' ]
+        provider.lambda.stub_responses(:get_function, example_get_function_response)
+        provider.lambda.stub_responses(:update_function_configuration, example_response)
+        provider.lambda.stub_responses(:tag_resource)
+        provider.lambda.stub_responses(:update_function_code, example_response)
+      end
+
+      example do
+        expect(provider).to receive(:log).with(/Function #{lambda_options[:function_name]} already exists, updating\./)
+        expect(provider).to receive(:log).with(/Updated configuration of function: #{lambda_options[:function_name]}\./)
+        expect(provider).to receive(:log).with(/Add tags to function #{lambda_options[:function_name]}\./)
+        expect(provider).to receive(:log).with(/Updated code of function: #{lambda_options[:function_name]}\./)
+        provider.push_app
+      end
+    end
+
+    context 'with a ServiceException response' do
+      before do
+        provider.lambda.stub_responses(:get_function, 'ResourceNotFoundException')
+        provider.lambda.stub_responses(:create_function, 'ServiceException')
+      end
+
+      example do
+        expect(provider).to receive(:error).once
+        provider.push_app
+      end
+    end
+
+    context 'with a InvalidParameterValueException response' do
+      before do
+        provider.lambda.stub_responses(:get_function, 'InvalidParameterValueException')
+      end
+
+      example do
+        expect(provider).to receive(:error).once
+        provider.push_app
+      end
+    end
+
+    context 'with a ResourceNotFoundException response' do
+      before do
+        provider.lambda.stub_responses(:get_function, 'ResourceNotFoundException')
+        provider.lambda.stub_responses(:create_function, 'ResourceNotFoundException')
+      end
+
+      example do
+        expect(provider).to receive(:error).once
+        provider.push_app
+      end
+    end
+  end
+
+  describe "#handler" do
+    context "without a module name" do
+      module_name = 'index'
+      handler_name = 'HandlerName'
+      expected_handler = "#{module_name}.#{handler_name}"
+
+      before do
+        expect(provider.options).to receive(:[]).with(:module_name).and_return(nil)
+        expect(provider.options).to receive(:fetch).with(:handler_name).and_return(handler_name)
+      end
+
+      example do
+        expect(provider.handler).to eq(expected_handler)
+      end
+    end
+
+    context "with a module name" do
+      module_name = 'ModuleName'
+      handler_name = 'HandlerName'
+      expected_handler = "#{module_name}.#{handler_name}"
+
+      before do
+        expect(provider.options).to receive(:[]).with(:module_name).and_return(module_name)
+        expect(provider.options).to receive(:fetch).with(:handler_name).and_return(handler_name)
+      end
+
+      example do
+        expect(provider.handler).to eq(expected_handler)
+      end
+    end
+  end
+
+  describe '#function_zip' do
+    context 'when zip is not specified' do
+      path = Dir.pwd
+      output_file_path = '/some/path.zip'
+
+      before do
+        expect(provider.options).to receive(:[]).with(:zip).and_return(nil)
+        expect(provider).to receive(:output_file_path).and_return(output_file_path)
+        expect(File).to receive(:directory?).with(path).and_return(true)
+        expect(provider).to receive(:zip_directory).with(output_file_path, path)
+        expect(File).to receive(:new).with(output_file_path)
+      end
+
+      example do
+        provider.function_zip
+      end
+    end
+
+    context 'when zip is a file path' do
+      path = '/some/file/path.zip'
+      output_file_path = '/some/path.zip'
+
+      before do
+        expect(provider.options).to receive(:[]).with(:zip).and_return(path)
+        expect(provider).to receive(:output_file_path).and_return(output_file_path)
+        expect(File).to receive(:directory?).with(path).and_return(false)
+        expect(File).to receive(:file?).with(path).and_return(true)
+        expect(provider).to receive(:zip_file).with(output_file_path, path)
+        expect(File).to receive(:new).with(output_file_path)
+      end
+
+      example do
+        provider.function_zip
+      end
+    end
+
+    context 'when zip is a directory' do
+      path = '/some/dir/path'
+      output_file_path = '/some/path.zip'
+
+      before do
+        expect(provider.options).to receive(:[]).with(:zip).and_return(path)
+        expect(provider).to receive(:output_file_path).and_return(output_file_path)
+        expect(File).to receive(:directory?).with(path).and_return(true)
+        expect(provider).to receive(:zip_directory).with(output_file_path, path)
+        expect(File).to receive(:new).with(output_file_path)
+      end
+
+      example do
+        provider.function_zip
+      end
+    end
+
+    context 'with an invalid zip option' do
+      path = '/some/file/path.zip'
+      output_file_path = '/some/path.zip'
+      error = 'Invalid zip option. If set, must be path to directory, js file, or a zip file.'
+
+      before do
+        expect(provider.options).to receive(:[]).with(:zip).and_return(path)
+        expect(provider).to receive(:output_file_path).and_return(output_file_path)
+        expect(File).to receive(:directory?).with(path).and_return(false)
+        expect(File).to receive(:file?).with(path).and_return(false)
+      end
+
+      example do
+        expect { provider.function_zip }.to raise_error(DPL::Error, error)
+      end
+    end
+  end
+
+  describe '#zip_file' do
+    dest = '/some/path/to/write.zip'
+
+    context 'when zip is a file path' do
+      dir = '/some/target'
+      target = File.join(dir, 'file.js')
+
+      before do
+        expect(File).to receive(:extname).with(target).and_return('.js')
+        expect(provider).to receive(:create_zip).with(dest, dir, [ target ])
+      end
+
+      example do
+        provider.zip_file(dest, target)
+      end
+    end
+
+    context 'when zip is an existing zip file' do
+      dir = '/some/target'
+      target = File.join(dir, 'file.js')
+
+      before do
+        expect(File).to receive(:extname).with(target).and_return('.zip')
+        expect(FileUtils).to receive(:cp).with(target, dest)
+      end
+
+      example do
+        provider.zip_file(dest, target)
+      end
+    end
+  end
+
+  describe '#zip_directory' do
+    dest = '/some/path/to/write.zip'
+    target = '/some/dir'
+    glob = File.join(target, '**', '**')
+    files = %w[ 'one' 'two' ]
+
+    before do
+      expect(Dir).to receive(:[]).with(glob).and_return(files)
+      expect(provider).to receive(:create_zip).with(dest, target, files)
+    end
+
+    example do
+      provider.zip_directory(dest, target)
+    end
+  end
+
+  describe '#create_zip' do
+    dest = '/some/dest.zip'
+    src = '/some/src/dir'
+    file_one = 'one.js'
+    file_two = 'two.js'
+    files = [
+      File.join(src, file_one),
+      File.join(src, file_two)
+    ]
+
+    before do
+      zip_file = double(Zip::File)
+      expect(Zip::File).to receive(:open).with(dest, Zip::File::CREATE).and_yield(zip_file)
+      expect(zip_file).to receive(:add).once.with(file_one, File.join(src, file_one))
+      expect(zip_file).to receive(:add).once.with(file_two, File.join(src, file_two))
+    end
+
+    example do
+      provider.create_zip(dest, src, files)
+    end
+  end
+
+  describe '#needs_key?' do
+    example do
+      expect(provider.needs_key?).to eq(false)
+    end
+  end
+
+  describe '#check_auth' do
+    example do
+      expect(provider).to receive(:log).with("Using Access Key: #{access_key_id[-4..-1].rjust(20, '*')}")
+      provider.check_auth
+    end
+  end
+
+  describe '#output_file_path' do
+    example do
+      expect(provider.output_file_path).to match(/tmp\/\w{8}\-lambda\.zip/)
+    end
+  end
+
+  describe '#default_runtime' do
+    example do
+      expect(provider.default_runtime).to eq('nodejs')
+    end
+  end
+
+  describe '#default_timeout' do
+    example do
+      expect(provider.default_timeout).to eq(3)
+    end
+  end
+
+  describe '#default_description' do
+    build_number = 2
+
+    before do
+      provider.context.env.stub(:[]).with('TRAVIS_BUILD_NUMBER').and_return(build_number)
+    end
+
+    let(:build_number) { provider.context.env['TRAVIS_BUILD_NUMBER'] }
+
+    example do
+      expect(provider.default_description).to eq(
+        "Deploy build #{build_number} to AWS Lambda via Travis CI"
+      )
+    end
+  end
+
+  describe '#default_memory_size' do
+    example do
+      expect(provider.default_memory_size).to eq(128)
+    end
+  end
+
+  describe '#publish' do
+    context 'is default turned off' do
+      example do
+        expect(provider.publish).to eq(false)
+      end
+    end
+    context 'can be turned on' do
+      before do
+        expect(provider.options).to receive(:[]).with(:publish).and_return(true)
+      end
+
+      example do
+        expect(provider.publish).to eq(true)
+      end
+    end
+  end
+
+  describe '#random_chars' do
+    context 'without specifying count' do
+      example do
+        expect(provider.random_chars.length).to eq(8)
+      end
+    end
+
+    context 'with specified count' do
+      count = 4
+      example do
+        expect(provider.random_chars(count).length).to eq(count)
+      end
+    end
+  end
+
+end