dpl 1.8.48.travis.2486.5 → 1.9.0

data/spec/provider/hackage_spec.rb

@@ -1,47 +0,0 @@
-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

@@ -1,357 +0,0 @@
-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

@@ -1,432 +0,0 @@
-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