dpl 1.8.48.travis.2486.5 → 1.9.0

data/spec/provider/launchpad_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-require 'dpl/provider/launchpad'
-
-describe DPL::Provider::Launchpad do
-  subject :provider do
-    described_class.new(DummyContext.new, :slug => '~user/repo/branch', :oauth_token => 'uezinoosinmxkewhochq', :oauth_token_secret => 'dinb6fao4jh0kfdn5mich31cbikdkpjplkmadhi80h93kbbaableeeg41mm0jab9jif8ch7i2k9a80n5')
-  end
-
-  its(:needs_key?) { should be false }
-
-  describe '#push_app' do
-    it 'on api success' do
-      expect(provider).to receive(:api_call).with('/1.0/~user/repo/branch/+code-import', {'ws.op' => 'requestImport'}).and_return Net::HTTPSuccess.new("HTTP/1.1", 200, "Ok")
-      provider.push_app
-    end
-
-    it 'on api failure' do
-      expect(provider).to receive(:api_call).with('/1.0/~user/repo/branch/+code-import', {'ws.op' => 'requestImport'}).and_return double("Net::HTTPUnauthorized", code: 401, body: "", class: Net::HTTPUnauthorized)
-      expect { provider.push_app }.to raise_error(DPL::Error)
-    end
-  end
-
-  describe 'private method' do
-    describe '#authorization' do
-      it 'should return correct oauth' do
-        result = provider.instance_eval { authorization }
-        expect(result).to include('oauth_token="uezinoosinmxkewhochq",')
-        expect(result).to include('oauth_signature="%26dinb6fao4jh0kfdn5mich31cbikdkpjplkmadhi80h93kbbaableeeg41mm0jab9jif8ch7i2k9a80n5",')
-      end
-    end
-  end
-
-end

data/spec/provider/modulus_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-require 'dpl/provider/modulus'
-
-describe DPL::Provider::Modulus do
-  subject :provider do
-    described_class.new(DummyContext.new, :api_key => 'test-token', :project_name => 'test-project')
-  end
-
-  describe "#check_auth" do
-    it 'should require an api key' do
-      provider.options.update(:api_key => nil)
-      expect{ provider.check_auth }.to raise_error("must supply an api key")
-    end
-  end
-
-  describe "#check_app" do
-    it 'should require a project name' do
-      provider.options.update(:project_name => nil)
-      expect{ provider.check_app }.to raise_error("must supply a project name")
-    end
-  end
-
-  describe "#push_app" do
-    it 'should include the api key and project name specified' do
-      expect(provider.context).to receive(:shell).with("env MODULUS_TOKEN=test-token modulus deploy -p test-project")
-      provider.push_app
-    end
-  end
-end

data/spec/provider/npm_spec.rb

@@ -1,95 +0,0 @@
-require 'spec_helper'
-require 'dpl/provider/npm'
-
-describe DPL::Provider::NPM do
-  before :each do
-    allow(subject).to receive(:npm_version).and_return('2.11.3')
-  end
-
-  subject :provider do
-    described_class.new(DummyContext.new, :email => 'foo@blah.com', :api_key => 'test')
-  end
-
-  describe "#check_auth" do
-    example do
-      expect(provider).to receive(:setup_auth)
-      expect(provider).to receive(:log).with("Authenticated with email foo@blah.com")
-      provider.check_auth
-    end
-  end
-
-  describe "#push_app" do
-    example do
-      expect(provider.context).to receive(:shell).with("env NPM_API_KEY=test npm publish")
-      expect(FileUtils).to receive(:rm).with(File.expand_path(DPL::Provider::NPM::NPMRC_FILE))
-      provider.setup_auth
-      provider.push_app
-    end
-  end
-
-  describe "#setup_auth" do
-    example do
-      test_setup_auth
-    end
-  end
-
-  context 'when NPM is version 1.x' do
-    before :each do
-      allow(subject).to receive(:npm_version).and_return('1.4.28')
-    end
-
-    describe "#setup_auth" do
-      example do
-        test_setup_auth(DPL::Provider::NPM::DEFAULT_NPM_REGISTRY, "_auth = ${NPM_API_KEY}\nemail = foo@blah.com")
-      end
-    end
-  end
-
-  context 'when package.json exists' do
-    let(:host) { 'npm.example.com' }
-    let(:custom_rpm_registry) { 'https://' + host }
-    before :each do
-      expect(File).to receive(:exists?).with('package.json').and_return(true)
-    end
-
-    context 'and it defines custom RPM registry' do
-      before { expect(File).to receive(:read).with('package.json').and_return("{\"publishConfig\":{\"registry\":\"#{custom_rpm_registry}\"}}") }
-
-      describe '#setup_auth' do
-        example do
-          test_setup_auth(host)
-        end
-      end
-    end
-
-    context 'and it defines custom RPM registry with trailing slash' do
-      let(:host) { 'npm.example.com' }
-      let(:custom_rpm_registry) { 'https://' + host + '/' }
-      before { expect(File).to receive(:read).with('package.json').and_return("{\"publishConfig\":{\"registry\":\"#{custom_rpm_registry}\"}}") }
-
-      describe '#setup_auth' do
-        example do
-          test_setup_auth(host)
-        end
-      end
-    end
-
-    context 'and it does not define custom RPM registry' do
-      before { expect(File).to receive(:read).with('package.json').and_return("{}") }
-
-      describe '#setup_auth' do
-        example do
-          test_setup_auth
-        end
-      end
-    end
-  end
-end
-
-def test_setup_auth(registry = DPL::Provider::NPM::DEFAULT_NPM_REGISTRY, content = "//#{registry}/:_authToken=${NPM_API_KEY}")
-  f = double(:npmrc)
-  expect(File).to receive(:open).with(File.expand_path(DPL::Provider::NPM::NPMRC_FILE), 'w').and_return(f)
-  expect(f).to receive(:puts).with(content)
-  allow(f).to receive(:flush)
-  provider.setup_auth
-end

data/spec/provider/openshift_spec.rb

@@ -1,91 +0,0 @@
-require 'spec_helper'
-require 'rhc'
-require 'dpl/provider/openshift'
-
-describe DPL::Provider::Openshift do
-  subject :provider do
-    described_class.new(DummyContext.new, :user => 'foo', :password => 'foo', :domain => 'foo', :app => 'example', :key_name => 'key')
-  end
-
-  describe "#api" do
-    it 'accepts a user and a password' do
-      api = double(:api)
-      provider.options.update(:user => "foo", :password => "bar")
-      expect(::RHC::Rest::Client).to receive(:new).with(:user => "foo", :password => "bar", :server => "openshift.redhat.com").and_return(api)
-      expect(provider.api).to eq(api)
-    end
-  end
-
-  context "with api" do
-    let :api do
-      double "api",
-        :user => double(:login => "foo@bar.com"),
-        :find_application => double(:name => "example", :git_url => "git://something"),
-        :add_key => double
-    end
-    let :app do
-      double "app",
-        :restart => double
-    end
-
-    before do
-      expect(::RHC::Rest::Client).to receive(:new).at_most(:once).and_return(api)
-      provider.api
-    end
-
-    its(:api) {should be == api}
-
-    describe "#check_auth" do
-      example do
-        expect(provider).to receive(:log).with("authenticated as foo@bar.com")
-        provider.check_auth
-      end
-    end
-
-    describe "#check_app" do
-      example do
-        expect(provider).to receive(:log).with("found app example")
-        provider.check_app
-      end
-    end
-
-    describe "#setup_key" do
-      example do
-        expect(File).to receive(:read).with("the file").and_return("ssh-rsa\nfoo")
-        expect(api).to receive(:add_key).with("key", "foo", "ssh-rsa")
-        provider.setup_key("the file")
-      end
-    end
-
-    describe "#remove_key" do
-      example do
-        expect(api).to receive(:delete_key).with("key")
-        provider.remove_key
-      end
-    end
-
-    describe "#push_app" do
-      example "when app.deployment_branch is not set" do
-        expect(provider.context).to receive(:shell).with("git push git://something -f")
-        provider.push_app
-      end
-    end
-
-    context "when app.deployment_branch is set" do
-      subject :provider do
-        described_class.new(DummyContext.new, :user => 'foo', :password => 'foo', :domain => 'foo', :app => 'example', :key_name => 'key', :deployment_branch => 'test-branch')
-
-      expect(provider.app).to receive(:deployment_branch=).with("test-branch")
-      expect(provider.context).to receive(:shell).with("git push git://something -f test-branch")
-      provider.push_app
-      end
-    end
-
-    describe "#restart" do
-      example do
-        expect(provider.app).to receive(:restart)
-        provider.restart
-      end
-    end
-  end
-end

data/spec/provider/ops_works_spec.rb

@@ -1,127 +0,0 @@
-require 'spec_helper'
-require 'aws-sdk'
-require 'dpl/provider'
-require 'dpl/provider/ops_works'
-
-describe DPL::Provider::OpsWorks do
-
-  subject :provider do
-    described_class.new(DummyContext.new, :access_key_id => 'qwertyuiopasdfghjklz', :secret_access_key => 'qwertyuiopasdfghjklzqwertyuiopasdfghjklz')
-  end
-
-  describe '#opsworks_options' do
-    context 'without region' do
-      example do
-        options = provider.opsworks_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.opsworks_options
-        expect(options[:region]).to eq(region)
-      end
-    end
-  end
-
-  describe "#check_auth" do
-    example do
-      expect(provider).to receive(:log).with('Logging in with Access Key: ****************jklz')
-      provider.check_auth
-    end
-  end
-
-  describe "#needs_key?" do
-    example do
-      expect(provider.needs_key?).to eq(false)
-    end
-  end
-
-  describe DPL::Provider::OpsWorks 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
-      expect(provider).to receive(:opsworks_options).and_return(client_options)
-    end
-
-    describe '#opsworks' do
-      example do
-        expect(Aws::OpsWorks::Client).to receive(:new).with(client_options).once
-        provider.opsworks
-      end
-    end
-
-    describe "#push_app" do
-      let(:client) { provider.opsworks }
-      let(:ops_works_app) { {shortname: 'app', stack_id: 'stack-id'} }
-      before do
-        expect(provider).to receive(:current_sha).and_return('sha')
-        expect(provider.context.env).to receive(:[]).with('TRAVIS_BUILD_NUMBER').and_return('123')
-      end
-
-      let(:custom_json) { "{\"deploy\":{\"app\":{\"migrate\":false,\"scm\":{\"revision\":\"sha\"}}}}" }
-      example 'without :migrate option' do
-        provider.options.update(app_id: 'app-id')
-        expect(client).to receive(:describe_apps).with(app_ids: ['app-id']).and_return({apps: [ops_works_app]})
-        expect(client).to receive(:create_deployment).with(
-          stack_id: 'stack-id', app_id: 'app-id', command: {name: 'deploy'}, comment: 'Deploy build 123 via Travis CI', custom_json: custom_json
-        ).and_return({})
-        provider.push_app
-      end
-
-      let(:custom_json_with_migrate) { "{\"deploy\":{\"app\":{\"migrate\":true,\"scm\":{\"revision\":\"sha\"}}}}" }
-      example 'with :migrate option' do
-        provider.options.update(app_id: 'app-id', migrate: true)
-        expect(client).to receive(:describe_apps).with(app_ids: ['app-id']).and_return({apps: [ops_works_app]})
-        expect(client).to receive(:create_deployment).with(
-          stack_id: 'stack-id', app_id: 'app-id', command: {name: 'deploy'}, comment: 'Deploy build 123 via Travis CI', custom_json: custom_json_with_migrate
-        ).and_return({})
-        provider.push_app
-      end
-
-      example 'with :wait_until_deployed' do
-        provider.options.update(app_id: 'app-id', wait_until_deployed: true)
-        expect(client).to receive(:describe_apps).with(app_ids: ['app-id']).and_return({apps: [ops_works_app]})
-        expect(client).to receive(:create_deployment).and_return({deployment_id: 'deployment_id'})
-        expect(client).to receive(:describe_deployments).with({deployment_ids: ['deployment_id']}).and_return({deployments: [status: 'running']}, {deployments: [status: 'successful']})
-        provider.push_app
-      end
-
-      example 'with :instance-ids' do
-        provider.options.update(app_id: 'app-id', instance_ids: ['instance-id'])
-        expect(client).to receive(:describe_apps).with(app_ids: ['app-id']).and_return({apps: [ops_works_app]})
-        expect(client).to receive(:create_deployment).with(
-          stack_id: 'stack-id', app_id: 'app-id', instance_ids:['instance-id'], command: {name: 'deploy'}, comment: 'Deploy build 123 via Travis CI', custom_json: custom_json
-        ).and_return({})
-        provider.push_app
-      end
-
-      example 'with :layer-ids' do
-        provider.options.update(app_id: 'app-id', layer_ids: ['layer-id'])
-        expect(client).to receive(:describe_apps).with(app_ids: ['app-id']).and_return({apps: [ops_works_app]})
-        expect(client).to receive(:create_deployment).with(
-          stack_id: 'stack-id', app_id: 'app-id', layer_ids:['layer-id'], command: {name: 'deploy'}, comment: 'Deploy build 123 via Travis CI', custom_json: custom_json
-        ).and_return({})
-        provider.push_app
-      end
-    end
-  end
-end

data/spec/provider/packagecloud_spec.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-require 'rubygems'
-require 'gems'
-require 'dpl/provider/packagecloud'
-
-describe DPL::Provider::Packagecloud do
-
-  subject :provider do
-    described_class.new(DummyContext.new, :username => 'joedamato', :repository => 'test_repo', :token => 'test_token')
-  end
-
-  describe "#setup_auth" do
-    it 'should get username and token' do
-      expect(provider).to receive(:log).with("Logging into https://packagecloud.io with joedamato:****************oken")
-      provider.setup_auth
-    end
-
-    it 'should require username' do
-      new_provider = described_class.new(DummyContext.new, {:token => 'test_token'})
-      expect{ new_provider.setup_auth }.to raise_error("missing username")
-    end
-
-    it 'should require token' do
-      new_provider = described_class.new(DummyContext.new, {:username => 'test_token'})
-      expect{ new_provider.setup_auth }.to raise_error("missing token")
-    end
-
-    it 'should require repository' do
-      new_provider = described_class.new(DummyContext.new, {:username => 'joedamato', :token => 'test_token'})
-      expect{ new_provider.setup_auth }.to raise_error("missing repository")
-    end
-
-  end
-
-  describe "#push_app" do
-    it 'defaults to searching everywhere' do
-      expect(Dir).to receive(:glob).with('**/*')
-      expect { provider.push_app }.to raise_error(DPL::Error)
-    end
-
-    it 'accepts and uses a string glob' do
-      provider.options.update(:package_glob => 'foo*.gem')
-
-      expect(Dir).to receive(:glob).with('foo*.gem')
-      expect { provider.push_app }.to raise_error(DPL::Error)
-    end
-
-    it 'accepts and uses an array of globs' do
-      provider.options.update(:package_glob => ['*.rpm', '**/*.deb'])
-
-      expect(Dir).to receive(:glob).with('*.rpm', '**/*.deb')
-      expect { provider.push_app }.to raise_error(DPL::Error)
-    end
-  end
-
-end

data/spec/provider/puppet_forge_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-require 'dpl/provider/puppet_forge'
-require 'puppet/face'
-require 'puppet_blacksmith'
-
-describe DPL::Provider::PuppetForge do
-  subject :provider do
-    described_class.new(DummyContext.new, :user => 'puppetlabs', :password => 's3cr3t')
-  end
-
-  describe "forge" do
-    it 'should include the user and password specified' do
-      expect(provider.forge.username).to eq(provider.options[:user])
-      expect(provider.forge.password).to eq(provider.options[:password])
-    end
-  end
-
-  describe "build" do
-    it 'should use Puppet module tool to build the module' do
-      pmt = double('pmt')
-      expect(::Puppet::Face).to receive(:[]).and_return(pmt)
-      expect(pmt).to receive(:build).with('./')
-      provider.build
-    end
-  end
-
-  describe "#check_auth" do
-    it 'should require a user' do
-      provider.options.update(:user => nil)
-      expect{ provider.check_auth }.to raise_error("must supply a user")
-    end
-
-    it 'should require a password' do
-      provider.options.update(:password => nil)
-      expect{ provider.check_auth }.to raise_error("must supply a password")
-    end
-  end
-
-  describe "#check_app" do
-    it 'should load module metadata using Blacksmith' do
-      modulefile = double('modulefile')
-      expect(::Blacksmith::Modulefile).to receive(:new).and_return(modulefile)
-      expect(modulefile).to receive(:metadata) { true }
-      provider.check_app
-    end
-  end
-
-  describe "#push_app" do
-    it 'should use Blacksmith to push to the Forge' do
-      forge = double('forge')
-      expect(provider).to receive(:build).and_return(true)
-      expect(provider).to receive(:modulefile).at_least(:once).and_return(double('modulefile', :name => 'test'))
-      expect(provider).to receive(:log).and_return(true)
-      expect(::Blacksmith::Forge).to receive(:new).and_return(forge)
-      expect(forge).to receive(:push!) { true }
-      expect(forge).to receive(:username) { provider.options[:user] }
-      provider.push_app
-    end
-  end
-end