bosh-workspace 0.9.2 → 0.9.3

data/spec/credentials_spec.rb

@@ -23,6 +23,14 @@ module Bosh::Workspace
       end
     end
 
+    describe '#url_protocols' do
+      it "returns credentials when found multiple times" do
+        expect(subject).to receive(:git_protocol_from_url)
+          .with('foo').and_return(:https)
+        expect(subject.url_protocols).to eq('foo' => :https)
+      end
+    end
+
     describe '#perform_validation' do
       context "valid" do
         it "validates" do

data/spec/git_credentials_provider_spec.rb

@@ -0,0 +1,82 @@
+module Bosh::Workspace
+  describe GitCredentialsProvider do
+    let!(:credentials_provider) { GitCredentialsProvider.new(file) }
+    let(:file) { "credentials_file" }
+    let(:file_exist) { true }
+    let(:valid) { true }
+    let(:url_protocols) { [] }
+    let(:url) { 'http://foo.com/bar.git' }
+    let(:user) { nil }
+    let(:result) { nil }
+    let(:allowed_types) { [:plain_text] }
+    let(:credentials) do
+      instance_double "Bosh::Workspace::Credentials",
+                      :valid? => valid, url_protocols: url_protocols
+    end
+
+    subject { credentials_provider.callback.call url, user, allowed_types }
+
+    before do
+      allow(Credentials).to receive(:new).and_return(credentials)
+      allow(File).to receive(:exist?).and_return(file_exist)
+      allow(credentials).to receive(:find_by_url).with(url).and_return(result)
+    end
+
+    describe '#callback' do
+      context "with sshkey" do
+        let(:user) { 'git' }
+        let(:result) { { private_key: 'barkey' } }
+        let(:allowed_types) { [:ssh_key] }
+
+        it 'returns Rugged sshkey credentials' do
+          expect(Rugged::Credentials::SshKey).to receive(:new) do |args|
+            expect(args[:username]).to eq user
+            expect(IO.read(args[:privatekey])).to eq('barkey')
+          end; subject
+        end
+      end
+
+      context "with username/password" do
+        let(:result) { { username: user, password: 'barpw' } }
+        let(:allowed_types) { [:plain_text] }
+
+        it 'returns Rugged user password credentials' do
+          expect(Rugged::Credentials::UserPassword).to receive(:new) do |args|
+            expect(args[:username]).to eq user
+            expect(args[:password]).to eq 'barpw'
+          end; subject
+        end
+      end
+
+      context "without credentials file" do
+        let(:file_exist) { false }
+        it 'raises an error' do
+          expect{ subject }.to raise_error /credentials file does not exist/i
+        end
+      end
+
+      context "with invalid credentials file" do
+        let(:valid) { false }
+        before { expect(credentials).to receive(:errors) { ['foo error'] } }
+        it 'raises an error' do
+          expect{ subject }.to raise_error /is not valid/i
+        end
+      end
+
+      context "without credentials for given url" do
+        let(:result) { nil }
+        it 'raises an error' do
+          expect{ subject }.to raise_error /no credentials found/i
+        end
+      end
+
+      context "without protocol support" do
+        let(:url_protocols) { {"https://foo.com" => :https } }
+        before { expect(Rugged).to receive(:features).and_return([]) }
+        it 'raises an error' do
+          expect{ subject }.to raise_error /requires https support/i
+        end
+      end
+    end
+  end
+end

data/spec/{git_remote_url_spec.rb → helpers/git_protocol_helper_spec.rb}

@@ -1,38 +1,37 @@
 module Bosh::Workspace
-  describe GitRemoteUrl do
-    describe '.protocol' do
-      subject { GitRemoteUrl.new(url) }
+  describe GitProtocolHelper do
+    include GitProtocolHelper
+    describe '#git_protocol_from_url' do
+      subject { git_protocol_from_url(url) }
 
       context 'git protocol' do
         let(:url) { "git://example.com/foo" }
-        its(:protocol) { is_expected.to eq(:git) }
+        it { is_expected.to eq(:git) }
       end
 
       context 'https protocol' do
         let(:url) { "https://example.com/foo" }
-        its(:protocol) { is_expected.to eq(:https) }
+        it { is_expected.to eq(:https) }
       end
 
       context 'http protocol' do
         let(:url) { "http://example.com/foo" }
-        its(:protocol) { is_expected.to eq(:http) }
+        it { is_expected.to eq(:http) }
       end
 
       context 'ssh protocol style 1' do
         let(:url) { "foo@example.com:foo" }
-        its(:protocol) { is_expected.to eq(:ssh) }
+        it { is_expected.to eq(:ssh) }
       end
 
       context 'ssh protocol style 2' do
         let(:url) { "ssh://foo@example.com/foo" }
-        its(:protocol) { is_expected.to eq(:ssh) }
+        it { is_expected.to eq(:ssh) }
       end
 
       context 'unsupported protocol' do
         let(:url) { "foo://foo@example.com/foo" }
-        it 'raises' do
-          expect { subject.protocol() }.to raise_error /unsupported protocol/i
-        end
+        it { is_expected.to eq(nil) }
       end
     end
   end

data/spec/helpers/project_deployment_helper_spec.rb

@@ -23,7 +23,7 @@ describe Bosh::Workspace::ProjectDeploymentHelper do
   describe "project_deployment?" do
     subject { project_deployment_helper.project_deployment? }
     let(:project_deployment_helper) { ProjectDeploymentHelperTester.new(director, deployment) }
-    let(:deployment) { File.join work_dir, deployment_path }
+    let(:deployment) { File.join(work_dir, deployment_path) }
 
     context "deployment" do
       context "without associated project deployment" do
@@ -206,4 +206,15 @@ describe Bosh::Workspace::ProjectDeploymentHelper do
       end
     end
   end
+
+  describe "#offline!" do
+    it "enforces offline mode" do
+      subject.offline!
+      expect(subject.offline?).to eq(true)
+    end
+
+    it "defaults to online" do
+      expect(subject.offline?).to eq(nil)
+    end
+  end
 end

data/spec/helpers/release_helper_spec.rb

@@ -1,92 +1,176 @@
-describe Bosh::Workspace::ReleaseHelper do
-  class ReleaseHelperTester
-    include Bosh::Workspace::ReleaseHelper
+module Bosh::Workspace
+  describe ReleaseHelper do
+    class ReleaseHelperTester
+      include ReleaseHelper
 
-    attr_reader :director, :work_dir
+      attr_reader :director, :work_dir
 
-    def initialize(director, work_dir)
-      @director = director
-      @work_dir = work_dir
+      def initialize(director, work_dir)
+        @director = director
+        @work_dir = work_dir
+      end
     end
-  end
-
-  subject { release_helper }
-  let(:release_helper) { ReleaseHelperTester.new(director, work_dir) }
-  let(:director) { instance_double('Bosh::Cli::Client::Director') }
-  let(:work_dir) { asset_dir("manifests-repo") }
 
-  describe "#release_upload" do
-    let(:release_cmd) do
-      instance_double "Bosh::Cli::Command::Release::UploadRelease"
-    end
+    subject { release_helper }
+    let(:release_helper) { ReleaseHelperTester.new(director, work_dir) }
+    let(:director) { instance_double('Bosh::Cli::Client::Director') }
+    let(:work_dir) { asset_dir("manifests-repo") }
 
-    before do
-      allow(Bosh::Cli::Command::Release::UploadRelease).to receive(:new)
-        .and_return(release_cmd)
+    def expect_option(subject, *args)
+      expect(subject).to receive(:add_option).with(*args)
     end
 
-    let(:manifest_file) { "foo-1.yml." }
-    subject { release_helper.release_upload(manifest_file, work_dir) }
-
-    it "uploads release" do
-      expect(release_cmd).to receive(:upload).with(manifest_file)
-      subject
+    context "with upload release command" do
+      let(:upload_release_cmd) do
+        instance_double "Bosh::Cli::Command::Release::UploadRelease"
+      end
+
+      before do
+        allow(Bosh::Cli::Command::Release::UploadRelease)
+          .to receive(:new).and_return(upload_release_cmd)
+      end
+
+      describe "#release_upload_from_url" do
+        let(:url) { "http://example.com/release.tgz" }
+        subject { release_helper.release_upload_from_url(url) }
+
+        it "uploads release" do
+          expect(upload_release_cmd).to receive(:upload).with(url)
+          subject
+        end
+      end
+
+      describe "#release_upload" do
+        let(:manifest) { "foo-1.yml" }
+        let(:tarball) { "foo-1.tgz" }
+        let(:release_dir) { "foo-release" }
+        let(:exist) { true }
+        let(:create_release_cmd) do
+          instance_double("Bosh::Cli::Command::Release::CreateRelease")
+        end
+
+        subject { release_helper.release_upload(manifest, release_dir) }
+
+        before do
+          allow(Bosh::Cli::Command::Release::CreateRelease)
+            .to receive(:new).and_return(create_release_cmd)
+          allow(File).to receive(:exist?).with(tarball).and_return(exist)
+        end
+
+        context "when offline" do
+          before { release_helper.offline! }
+
+          context "with final release tarball" do
+            it "uploads final release" do
+              expect(upload_release_cmd).to receive(:upload).with(tarball)
+              subject
+            end
+          end
+
+          context "without final release tarball" do
+            let(:exist) { false }
+            it "raises an error" do
+              expect{subject}.to raise_error /tarball missing.+#{tarball}/
+            end
+          end
+        end
+
+        context "when online" do
+          context "with final release tarball" do
+            it "uploads final release" do
+              expect(upload_release_cmd).to receive(:upload).with(tarball)
+              subject
+            end
+          end
+
+          context "without final release tarball" do
+            let(:exist) { false }
+            it "creates and uploads final release" do
+              expect_option(create_release_cmd, :with_tarball, true)
+              expect_option(create_release_cmd, :dir, release_dir)
+              expect(create_release_cmd).to receive(:create).with(manifest)
+              expect(upload_release_cmd).to receive(:upload).with(tarball)
+              subject
+            end
+          end
+        end
+      end
     end
-  end
 
-  describe "#release_uploaded?" do
-    let(:releases) { { "versions" => %w(1 2 3) } }
-    subject { release_helper.release_uploaded?("foo", version) }
-    before do
-      expect(director).to receive(:get_release)
-        .with("foo").and_return(releases)
+    describe "#release_uploaded?" do
+      let(:releases) { { "versions" => %w(1 2 3) } }
+      subject { release_helper.release_uploaded?("foo", version) }
+      before do
+        expect(director).to receive(:get_release)
+          .with("foo").and_return(releases)
+      end
+
+      context "release exists" do
+        let(:version) { 2 }
+        it { should be true }
+      end
+
+      context "release not found" do
+        let(:version) { "8" }
+        it { should be false }
+      end
     end
 
-    context "release exists" do
-      let(:version) { 2 }
-      it { should be true }
-    end
+    describe "#release_dir" do
+      let(:releases_dir) { File.join(work_dir, ".releases") }
+      subject { release_helper.releases_dir }
 
-    context "release not found" do
-      let(:version) { "8" }
-      it { should be false }
-    end
-  end
-
-  describe "#release_dir" do
-    let(:releases_dir) { File.join(work_dir, ".releases") }
-    subject { release_helper.releases_dir }
-
-    before do
-      expect(FileUtils).to receive(:mkdir_p).once
-        .with(releases_dir).and_return([releases_dir])
-    end
-
-    it { should eq releases_dir }
-
-    it "memoizes" do
-      subject
-      expect(subject).to eq releases_dir
-    end
-  end
+      before do
+        expect(FileUtils).to receive(:mkdir_p).once
+          .with(releases_dir).and_return([releases_dir])
+      end
 
-  describe "#project_deployment_releases" do
-    subject { release_helper.project_deployment_releases }
-    let(:release) { instance_double("Bosh::Workspace::Release") }
-    let(:release_data) { { name: "foo" } }
-    let(:releases) { [release_data, release_data] }
+      it { should eq releases_dir }
 
-    before do
-      expect(release_helper)
-        .to receive_message_chain("project_deployment.releases")
-        .and_return(releases)
+      it "memoizes" do
+        subject
+        expect(subject).to eq releases_dir
+      end
     end
 
-    it "inits releases once" do
-      expect(Bosh::Workspace::Release).to receive(:new).twice
-        .with(release_data, /\/.releases/).and_return(release)
-      subject
-      expect(subject).to eq [release, release]
+    describe "#project_deployment_releases" do
+      subject { release_helper.project_deployment_releases }
+      let(:release) { instance_double("Bosh::Workspace::Release") }
+      let(:release_data) { { name: "foo" } }
+      let(:releases) { [release_data, release_data] }
+      let(:options) { { offline: offline } }
+      let(:offline) { nil }
+      let(:credentials_provider) do
+        instance_double('Bosh::Workspace::GitCredentialsProvider',
+                        callback: :callback)
+      end
+
+      before do
+        expect(release_helper)
+          .to receive_message_chain("project_deployment.releases")
+          .and_return(releases)
+        expect(GitCredentialsProvider).to receive(:new).with(/.credentials.yml/)
+          .and_return(credentials_provider)
+      end
+
+      it "inits releases" do
+        expect(Release).to receive(:new).twice
+          .with(release_data, /\/.releases/, :callback, options)
+          .and_return(release)
+        expect(subject).to eq [release, release]
+      end
+
+      context "when offline" do
+        before { release_helper.offline! }
+        let(:offline) { true }
+
+        it "inits releases" do
+          expect(Release).to receive(:new).twice
+            .with(release_data, /\/.releases/, :callback, options)
+            .and_return(release)
+          expect(subject).to eq [release, release]
+        end
+      end
     end
   end
 end

data/spec/manifest_builder_spec.rb

@@ -2,7 +2,8 @@ describe Bosh::Workspace::ManifestBuilder do
   let(:project_deployment) { instance_double("Bosh::Workspace::Project_Deployment",
     name: "bar",
     templates: ["foo.yml"],
-    merged_file: ".deployments/foo.yml")
+    merged_file: ".deployments/foo.yml",
+    merge_tool: Bosh::Workspace::MergeTool.new)
   }
   let(:work_dir) { asset_dir("manifests-repo") }
 
@@ -20,7 +21,7 @@ describe Bosh::Workspace::ManifestBuilder do
   end
 
   describe "#merge_templates" do
-    subject { Bosh::Workspace::ManifestBuilder.new project_deployment, work_dir }
+    subject { Bosh::Workspace::ManifestBuilder.new(project_deployment, work_dir) }
 
     before do
       allow(File).to receive(:exists?).with(/templates\//)
@@ -30,7 +31,7 @@ describe Bosh::Workspace::ManifestBuilder do
     context "missing template" do
       let(:template_exists) { false }
       it "raises error" do
-        expect{ subject.merge_templates }.to raise_error(/does not exist/)
+        expect { subject.merge_templates }.to raise_error(/does not exist/)
       end
     end
 
@@ -47,14 +48,14 @@ describe Bosh::Workspace::ManifestBuilder do
       context "no hidden dirs" do
         let(:dir_exists) { false }
         it "creates hidden dirs" do
-          expect(subject).to receive(:spiff_merge)
+          expect(subject.merge_tool).to receive(:merge)
           expect(Dir).to receive(:mkdir).with(/.stubs/)
           subject.merge_templates
         end
       end
 
       it "generates manifest with spiff" do
-        expect(subject).to receive(:spiff_merge) do |args|
+          expect(subject.merge_tool).to receive(:merge) do |args|
           if args.is_a?(Array)
             expect(args.first).to match(/\/templates\/.+yml/)
             expect(args.last).to match(/\.stubs\/.+yml/)