bosh-workspace 0.8.5 → 0.9.0.rc1

data/spec/deployment_patch_spec.rb

@@ -0,0 +1,171 @@
+module Bosh::Workspace
+  describe DeploymentPatch do
+    let(:stemcells) { [{ 'name' => 'foo', 'version' => 1 }] }
+    let(:releases) { [{ 'name' => 'bar', 'version' => 2 }] }
+    let(:templates_dir) do
+      home = extracted_asset_dir("home", "foo-boshworkspace.zip")
+      workspace = File.join(home, "foo-boshworkspace")
+      Dir[File.join(workspace, ".git/**/config")].each do |c|
+        IO.write(c, IO.read(c).gsub(/(\/U.+tmp)/, home))
+      end
+      File.join(workspace, "templates")
+    end
+    let(:templates_ref) { 'bb802816a44d0fd23fd0120f4fdd42578089d025' }
+    let(:patch) { DeploymentPatch.new(stemcells, releases, templates_ref) }
+    let(:patch_yaml_data) { patch_data.to_yaml }
+    let(:deployment_file) { get_tmp_file_path deployment.to_yaml }
+    let(:patch_data) do
+      { "stemcells" => stemcells, "releases" => releases, "templates_ref" => templates_ref }
+    end
+    let(:deployment) do
+      {
+        'name' => 'foo',
+        'stemcells' => stemcells,
+        'releases' => releases,
+        'templates' => [ 'foo/bar.yml' ],
+        'meta' => { 'foo' => 'bar' }
+      }
+    end
+
+    describe '#create' do
+      subject { DeploymentPatch.create deployment_file, templates_dir }
+
+      context "with templates submodule" do
+        its(:stemcells) { should eq stemcells }
+        its(:releases) { should eq releases }
+        its(:templates_ref) { should eq templates_ref }
+      end
+
+      context "without templates submodule" do
+        let(:templates_dir) do
+          asset_dir("manifests-repo/templates")
+        end
+
+        it "ignores templates directory" do
+          expect(subject.templates_ref).to be_nil
+        end
+      end
+    end
+
+    describe '.from_file' do
+      subject { DeploymentPatch.from_file get_tmp_file_path(patch_yaml_data) }
+      its(:stemcells) { should eq stemcells }
+      its(:releases) { should eq releases }
+      its(:templates_ref) { should eq templates_ref }
+    end
+
+    describe '#perform_validation' do
+      context "valid" do
+        it "validates" do
+          allow_any_instance_of(Schemas::DeploymentPatch)
+            .to receive(:validate).with(patch_data)
+          expect(patch).to be_valid
+        end
+      end
+
+      context "invalid" do
+        it "has errors" do
+          allow_any_instance_of(Schemas::DeploymentPatch)
+            .to receive(:validate).with(patch_data)
+            .and_raise(Membrane::SchemaValidationError.new("foo"))
+          expect(patch).to_not be_valid
+          expect(patch.errors).to include "foo"
+        end
+      end
+    end
+
+    describe '#to_hash' do
+      subject { patch.to_hash }
+      it { should eq patch_data }
+
+      context "without templates_ref" do
+        let(:templates_ref) { nil }
+        before { patch_data.delete "templates_ref" }
+        it { should eq patch_data }
+      end
+    end
+
+    describe '#to_yaml' do
+      subject { patch.to_yaml }
+      it { should eq patch_yaml_data }
+    end
+
+    describe '#to_file' do
+      let(:patch_file) { get_tmp_file_path '{}' }
+
+      it 'writes to file' do
+        patch.to_file(patch_file)
+        expect(IO.read(patch_file)).to eq patch_yaml_data
+      end
+    end
+
+    describe '#apply' do
+      let(:templates_ref) { '505b82012133673a9150d4e83aede1a07598154b' }
+      let(:deployment) { { "stemcells" => [], "releases" => [] } }
+      let(:deployment_new) { { "stemcells" => stemcells, "releases" => releases } }
+      let(:template_files) { Dir.entries(templates_dir) }
+
+      subject { patch.apply(deployment_file, templates_dir) }
+
+      it 'applies changes' do
+        subject
+        expect(IO.read(deployment_file)).to eq deployment_new.to_yaml
+        expect(template_files).to include "bar.yml"
+      end
+
+      context "without templates_ref" do
+        let(:templates_ref) { nil }
+        it 'leaves templates dir as is' do
+          subject
+          expect(template_files).to include "foo.yml"
+          expect(template_files).to_not include "bar.yml"
+        end
+      end
+    end
+
+    describe '#changes' do
+      context 'with changes' do
+        let(:new_patch) do
+          DeploymentPatch.new(
+            [{ 'name' => 'foo', 'version' => 2 }, { 'name' => 'baz', 'version' => 1 }],
+            [{ 'name' => 'qux', 'version' => 3 }],
+            'e598fece364ba7447b2e897d71d7008f8390fb86'
+          )
+        end
+        subject { patch.changes(new_patch) }
+
+        its([:stemcells]) { should eq "changed foo 1 2, added baz 1" }
+        its([:releases]) { should eq "removed bar 2, added qux 3" }
+        its([:templates_ref]) { should eq "changed bb80281 e598fec" }
+
+        context 'without templates_ref' do
+          subject { patch.changes(new_patch) }
+          let(:templates_ref) { nil }
+
+          its([:stemcells]) { should eq "changed foo 1 2, added baz 1" }
+          its([:releases]) { should eq "removed bar 2, added qux 3" }
+          its([:templates_ref]) { should be_nil }
+        end
+      end
+
+      context 'without changes' do
+        subject { patch.changes(patch) }
+        it { should be_a(Hash) }
+        it { should be_empty }
+      end
+    end
+
+    describe '#changes?' do
+      context 'with changes' do
+        let(:new_patch) { DeploymentPatch.new(stemcells, releases, 'foo') }
+        subject { patch.changes?(new_patch) }
+        it { should be true }
+      end
+
+      context 'without changes' do
+        subject { patch.changes?(patch) }
+        it { should be false }
+      end
+    end
+  end
+end

data/spec/helpers/git_credentials_helper_spec.rb

@@ -0,0 +1,160 @@
+module Bosh::Workspace
+  describe GitCredenialsHelper do
+    class GitCredenialsHelperTester
+      include Bosh::Workspace::GitCredenialsHelper
+
+      attr_reader :work_dir
+
+      def initialize(work_dir)
+        @work_dir = work_dir
+      end
+    end
+
+    let(:work_dir) { asset_dir("manifests-repo") }
+    let(:url) { "foo/bar.git" }
+    let(:dir) { File.join(work_dir, '.releases', 'foo') }
+    let(:repo) { instance_double 'Rugged::Repository' }
+    let(:remote) { instance_double 'Rugged::Remote', url: url }
+
+    before do
+      allow(Rugged::Repository).to receive(:new).with(dir).and_return(repo)
+      allow(File).to receive(:exist?).with(dir).and_return(dir_exist)
+      allow(repo).to receive_message_chain("remotes.[]").and_return(remote)
+      allow(repo).to receive_message_chain("remotes.create_anonymous")
+        .with(url).and_return(remote)
+      allow(remote).to receive(:check_connection).with(:fetch, Hash)
+        .and_return(!auth_required, credentials_auth_valid)
+      allow(repo).to receive(:checkout).with(/origin\/HEAD/, strategy: :force)
+    end
+
+    def expect_no_credentials
+      expect(repo).to receive(:fetch).with('origin', Array, {})
+    end
+
+    let(:dir_exist) { true }
+    let(:auth_required) { false }
+    let(:credentials_auth_valid) { true }
+
+    describe "fetch_repo" do
+      subject do
+        GitCredenialsHelperTester.new(work_dir).fetch_repo(dir)
+      end
+
+      context "with existing repo" do
+        it do
+          expect_no_credentials
+          subject
+        end
+      end
+    end
+
+    describe "fetch_or_clone_repo" do
+      subject do
+        GitCredenialsHelperTester.new(work_dir).fetch_or_clone_repo(dir, url)
+      end
+
+      context "with existing repo" do
+        it do
+          expect_no_credentials
+          subject
+        end
+      end
+
+      context "repo does not yet exist" do
+        let(:dir_exist) { false }
+
+        it "initializes a new repository and sets up a remote" do
+          expect(Rugged::Repository).to receive(:init_at).with(dir)
+            .and_return(repo)
+          expect(repo).to receive_message_chain("remotes.create")
+            .with('origin', url)
+          expect_no_credentials
+          subject
+        end
+      end
+
+      context "repo requires authentication" do
+        let(:auth_required) { true }
+        let(:credentials_file_exist) { true }
+        let(:credentials_valid) { true }
+        let(:credentials) { instance_double "Bosh::Workspace::Credentials" }
+        let(:creds_hash) { {} }
+
+        def expect_credentials(credentials)
+          expect(repo).to receive(:fetch)
+            .with('origin', Array, credentials: credentials)
+        end
+
+        before do
+          allow(File).to receive(:exist?).with(/.credentials.yml/)
+            .and_return(credentials_file_exist)
+          allow(Bosh::Workspace::Credentials).to receive(:new)
+            .with(/.credentials.yml/).and_return(credentials)
+          allow(credentials).to receive(:valid?).and_return(credentials_valid)
+          allow(credentials).to receive(:find_by_url)
+            .with(url).and_return(creds_hash)
+        end
+
+        context "with sshkey" do
+          let(:creds_hash) { { private_key: "foobarkey" } }
+
+          it "uses a key" do
+            expect(Rugged::Credentials::SshKey).to receive(:new) do |args|
+              expect(IO.read(args[:privatekey])).to eq "foobarkey"
+              :ssh_credentials
+            end
+            expect_credentials :ssh_credentials
+            subject
+          end
+        end
+
+        context "with username/password" do
+          let(:creds_hash) { { username: "foo", password: "bar" } }
+
+          it "uses a username/password" do
+            expect(Rugged::Credentials::UserPassword).to receive(:new) do |args|
+              expect(args[:username]).to eq "foo"
+              expect(args[:password]).to eq "bar"
+              :user_pw_credentials
+            end
+            expect_credentials :user_pw_credentials
+            subject
+          end
+        end
+
+        context "with invalid credentials" do
+          let(:credentials_auth_valid) { false }
+
+          it "raises and error" do
+            expect { subject }.to raise_error /invalid credentials/i
+          end
+        end
+
+        context "without credentials file" do
+          let(:credentials_file_exist) { false }
+
+          it "raises and error" do
+            expect { subject }.to raise_error /credentials file does not exist/i
+          end
+        end
+
+        context "with invalid credentials file" do
+          let(:credentials_valid) { false }
+
+          it "raises and error" do
+            expect(credentials).to receive(:errors) { ["fooerror"] }
+            expect { subject }.to raise_error /not valid/
+          end
+        end
+
+        context "without credentials for given url" do
+          let(:creds_hash) { nil }
+
+          it "raises and error" do
+            expect { subject }.to raise_error /no credentials found/i
+          end
+        end
+      end
+    end
+  end
+end

data/spec/helpers/spiff_helper_spec.rb

@@ -7,6 +7,7 @@ describe Bosh::Workspace::SpiffHelper do
     let(:path) { asset_dir("bin") }
     let(:templates) { ["foo.yml", "bar.yml"] }
     let(:target_file) { "spiffed_manifest.yml" }
+    let(:args) { [/spiff merge/, Hash] }
 
     around do |example|
       original_path = ENV["PATH"]
@@ -16,7 +17,7 @@ describe Bosh::Workspace::SpiffHelper do
     end
 
     before do
-      expect(subject).to receive(:sh).and_yield(result)
+      expect(subject).to receive(:sh).with(*args).and_yield(result)
     end
 
     context "spiff not in path" do
@@ -40,16 +41,28 @@ describe Bosh::Workspace::SpiffHelper do
       end
     end
 
-    describe ".merge" do
+    describe ".spiff_merge" do
       let(:file) { instance_double("File") }
       let(:output) { "---\n{}" }
       let(:result) { Bosh::Exec::Result.new("spiff", output, 0, false) }
 
-      it "merges manifests" do
+      before do
         expect(File).to receive(:open).with(target_file, 'w').and_yield(file)
         expect(file).to receive(:write).with(output)
+      end
+
+      it "merges manifests" do
         subject.spiff_merge templates, target_file
       end
+
+      context "spaces in template paths" do
+        let(:templates) { ["space test/foo space test.yml"] }
+        let(:args) { [/space\\ test\/foo\\ space\\ test.yml/, Hash] }
+
+        it "merges manifests" do
+          subject.spiff_merge templates, target_file
+        end
+      end
     end
   end
 end

data/spec/project_deployment_spec.rb

@@ -1,182 +1,71 @@
-describe Bosh::Workspace::ProjectDeployment do
-  let(:project_deployment) { Bosh::Workspace::ProjectDeployment.new manifest_file }
-  let(:manifest_file) { get_tmp_file_path(manifest.to_yaml, file_name) }
-  let(:file_name) { "foo.yml" }
-  let(:name) { "foo" }
-  let(:uuid) { "e55134c3-0a63-47be-8409-c9e53e965d5c" }
-  let(:domain_name) { "bosh" }
-  let(:templates) { ["path_to_bar", "path_to_baz"] }
-  let(:releases) do 
-    [{
-       "name" => "foo",
-       "version" => release_version,
-       "ref" => release_ref,
-       "git" => "example.com/foo.git"
-    }]
-  end
-  let(:release_version) { 1 }
-  let(:release_ref) { "eb8ccf" }
-  let(:stemcells) { [
-    { "name" => "bar", "version" => stemcell_version }
-  ] }
-  let(:stemcell_version) { 1 }
-  let(:meta) { { "foo" => "bar" } }
-  let(:manifest) { {
-    "name" => name,
-    "director_uuid" => uuid,
-    "domain_name" => domain_name,
-    "templates" => templates,
-    "releases" => releases,
-    "stemcells" => stemcells,
-    "meta" => meta,
-  } }
-
-  subject { project_deployment }
-
-  describe "#perform_validation" do
-    subject { project_deployment.errors.first }
-    let(:invalid_manifest) do
-      if defined?(missing)
-        manifest.delete_if { |key| Array(missing).include?(key) }
-      else
-        manifest
+module Bosh::Workspace
+  describe ProjectDeployment do
+    subject { Bosh::Workspace::ProjectDeployment.new manifest_file }
+    let(:manifest_file) { get_tmp_file_path(manifest.to_yaml, file_name) }
+    let(:file_name) { "foo.yml" }
+    let(:manifest) { :manifest }
+
+    describe ".new" do
+      context "deployment file does not exist" do
+        before do
+          allow(File).to receive(:exist?).with(manifest_file).and_return(false)
+        end
+        it { expect { subject }.to raise_error(/deployment file.+not exist/i) }
       end
     end
-    let(:manifest_file) { get_tmp_file_path(invalid_manifest.to_yaml) }
-
-    before do
-      project_deployment.validate
-      expect(project_deployment).to_not be_valid
-    end
 
-    context "not a hash" do
-      let(:invalid_manifest) { "foo" }
-      it { should match(/Expected instance of Hash/) }
-    end
-
-    %w(name director_uuid releases templates meta stemcells).each do |field|
-      context "missing #{field}" do
-        let(:missing) { field }
-        it { should match(/#{field}.*missing/i) }
+    describe "#perform_validation" do
+      context "valid" do
+        it "validates" do
+          allow_any_instance_of(Schemas::ProjectDeployment)
+            .to receive(:validate).with(manifest)
+          expect(subject).to be_valid
+        end
       end
-    end
-
-    context "optional domain_name" do
-      let(:missing) { ["domain_name", "director_uuid"] }
-      it { should match(/director_uuid/) }
-      it { should_not match(/domain_name/) }
-    end
 
-    context "director_uuid" do
       context "invalid" do
-        let(:uuid) { "invalid_uuid" }
-        it { should match(/director_uuid.*doesn't validate/) }
-      end
-
-      context "current" do
-        let(:uuid) { "current" }
-        let(:missing) { "name" }
-        it { should_not match(/director_uuid/) }
-        it { should match(/name/) }
-      end
-    end
-
-    context "releases" do
-      let(:invalid_manifest) do
-        manifest["releases"].map! { |r| r.delete_if { |key| Array(missing).include?(key) } }
-        manifest
-      end
-
-      %w(name version git).each do |field_name|
-        context "missing #{field_name}" do
-          let(:missing) { field_name }
-          it { should match(/#{field_name}.*missing/i) }
+        it "has errors" do
+          allow_any_instance_of(Schemas::ProjectDeployment)
+            .to receive(:validate).with(manifest)
+            .and_raise(Membrane::SchemaValidationError.new("foo"))
+          expect(subject).to_not be_valid
+          expect(subject.errors).to include "foo"
         end
       end
-
-      context "latest version" do
-        let(:missing) { "git" }
-        let(:release_version) { "latest" }
-        it { should match(/git.*missing/i) }
-        it { should_not match(/version/i) }
-      end
-
-      context "invalid version" do
-        let(:missing) { "git" }
-        let(:release_version) { "foo" }
-        it { should match(/git.*missing/i) }
-        it { should match(/version.*doesn't validate/i) }
-      end
-
-      context "optional ref" do
-        let(:missing) { ["git", "ref"] }
-        it { should match(/git.*missing/i) }
-      end
     end
 
-    context "stemcells" do
-      let(:invalid_manifest) do
-        manifest["stemcells"].map! { |r| r.delete_if { |key| Array(missing).include?(key) } }
-        manifest
-      end
-
-      %w(name version).each do |field_name|
-        context "missing #{field_name}" do
-          let(:missing) { field_name }
-          it { should match(/#{field_name}.*missing/i) }
-        end
-      end
-
-      context "latest version" do
-        let(:missing) { "name" }
-        let(:stemcell_version) { "latest" }
-        it { should match(/name.*missing/i) }
-        it { should_not match(/version/i) }
-      end
+    describe "#director_uuid=" do
+      before { subject.director_uuid = "foo-bar" }
+      its(:director_uuid) { should eq "foo-bar" }
+    end
 
-      context "patch version string" do
-        let(:missing) { "name" }
-        let(:stemcell_version) { "2719.1" }
-        it { should match(/name.*missing/i) }
-        it { should_not match(/version/i) }
+    describe "attr readers" do
+      let(:manifest) { {
+          "name" => :name,
+          "director_uuid" => :director_uuid,
+          "templates" => :templates,
+          "releases" => :releases,
+          "stemcells" => :stemcells,
+          "meta" => :meta,
+          "domain_name" => :domain_name,
+        } }
+
+      let(:director_uuid) { uuid }
+      %w(name director_uuid templates releases stemcells meta domain_name)
+        .each do |attr|
+        its(attr.to_sym) { should eq attr.to_sym }
       end
+    end
 
-      context "patch version float" do
-        let(:missing) { "name" }
-        let(:stemcell_version) { 2719.1 }
-        it { should match(/name.*missing/i) }
-        it { should_not match(/version/i) }
+    describe "#merged_file" do
+      it "creates parent directory" do
+        dir = File.dirname(subject.merged_file)
+        expect(File.directory?(dir)).to be true
       end
 
-      context "invalid version" do
-        let(:missing) { "name" }
-        let(:stemcell_version) { "foo" }
-        it { should match(/name.*missing/i) }
-        it { should match(/version.*should match/i) }
+      it "retruns merged file" do
+        expect(subject.merged_file).to match(/\.deployments\/#{file_name}/)
       end
     end
   end
-
-  describe "#director_uuid=" do
-    before { subject.director_uuid = "foo-bar" }
-    its(:director_uuid) { should eq "foo-bar" }
-  end
-
-  describe "attr readers" do
-    let(:director_uuid) { uuid }
-    %w(name director_uuid templates releases stemcells meta).each do |attr|
-      its(attr.to_sym) { should eq eval(attr) }
-    end
-  end
-
-  describe "#merged_file" do
-    it "creates parent directory" do
-      dir = File.dirname(subject.merged_file)
-      expect(File.directory?(dir)).to be true
-    end
-
-    it "retruns merged file" do
-      expect(subject.merged_file).to match(/\.deployments\/#{file_name}/)
-    end
-  end
 end