dpl-connect 1.8.43

data/spec/provider/launchpad_spec.rb

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

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

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

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

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

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

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