bosh-workspace 0.9.2 → 0.9.3

data/spec/merge_tool_spec.rb

@@ -0,0 +1,98 @@
+module Bosh::Workspace
+  describe MergeTool do
+    
+    subject { Bosh::Workspace::MergeTool.new(tool_name) }
+    let(:templates) { %w(foo.yml bar.yml) }
+    let(:target_file) { 'spiffed_manifest.yml' }
+    let(:path) { asset_dir('bin') }
+
+    around do |example|
+      original_path = ENV['PATH']
+      ENV['PATH'] = path
+      example.run
+      ENV['PATH'] = original_path
+    end
+
+    context 'unknown tool' do
+      let(:tool_name) { 'unknown-tool' }
+      it 'raises an error' do
+        expect { subject.merge(templates, target_file).to raise_error }
+      end
+    end
+
+    %w(spiff spruce).each do |tool_name|
+      context tool_name do        
+        let(:file) { instance_double("File") }
+        before do
+          allow(File).to receive(:open).with(target_file, 'w').and_yield(file)
+          allow(file).to receive(:write).with(output)
+        end
+
+        context 'using tool name as a string' do
+          before do
+            expect(subject).to receive(:sh).at_least(:once).with(*args).and_yield(result)
+          end
+
+          let(:result) { Bosh::Exec::Result.new(tool_name, output, 0, false) }
+          let(:args) { [/#{tool_name} merge/, Hash] }
+          let(:tool_name) { tool_name }
+    
+          context 'not found error' do
+            let(:path) { asset_dir('empty_bin') }
+            let(:result) { Bosh::Exec::Result.new(tool_name, 'command not found', 1, false) }
+  
+            it 'raises an error' do
+              expect(subject).to receive(:say).with(/Command failed/)
+              expect { subject.merge(templates, target_file) }
+                .to raise_error /command not found/
+            end
+          end
+    
+          describe '#merge' do
+            let(:output) { "---\n{}" }
+  
+            it 'merges manifests' do
+              subject.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.merge(templates, target_file)
+              end
+            end
+          end
+        end
+      
+
+        context 'using tool name as a hash with version and name' do
+          subject { Bosh::Workspace::MergeTool.new('name' => tool_name, 'version' => '0.1.0') }
+          let(:result) { Bosh::Exec::Result.new(tool_name, output, 0, false) }
+
+          before do
+            expect(subject).to receive(:sh).with(/#{tool_name} -v/, Hash).and_yield(result)
+            expect(subject).to receive(:sh).with(/#{tool_name} merge/, Hash).and_yield(result)
+          end
+
+          describe 'with correct version' do
+            let(:output) { "#{tool_name} version 0.1.0" }
+            it 'merges manifests' do
+              subject.merge(templates, target_file)
+            end
+          end
+
+          describe 'with wrong version' do
+            let(:output) { "#{tool_name} version 0.2.0" }
+            it 'merges manifests' do
+              expect(subject).to receive(:warning).with(/0\.2\.0/)
+              subject.merge(templates, target_file)
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/spec/project_deployment_spec.rb

@@ -1,7 +1,8 @@
 module Bosh::Workspace
   describe ProjectDeployment do
     subject { Bosh::Workspace::ProjectDeployment.new manifest_file }
-    let(:manifest_file) { get_tmp_file_path(ruby_code + manifest.to_yaml, file_name) }
+    let(:manifest_content) { ruby_code + manifest.to_yaml }
+    let(:manifest_file) { get_tmp_file_path(manifest_content, file_name) }
     let(:file_name) { "foo.yml" }
     let(:manifest) { :manifest }
     let(:ruby_code) { "<% ruby_var=42 %>" }
@@ -15,6 +16,47 @@ module Bosh::Workspace
       end
     end
 
+    describe '#manifest' do
+      let(:stub_file) { /stubs\/#{file_name}/ }
+      before do
+        allow(File).to receive(:exist?).with(manifest_file).and_return(true)
+        allow(File).to receive(:read).with(manifest_file).and_return(manifest_content)
+      end
+
+      context 'with stub file' do
+        let(:manifest) { { 'director_uuid' => '<%= p("stub.value") %>' } }
+        let(:stub_content) { "---\nproperties:\n  stub:\n    value: litmus\n" }
+        before do
+          allow(File).to receive(:exist?).with(stub_file).and_return(true)
+          allow(File).to receive(:read).with(stub_file).and_return(stub_content)
+        end
+
+        it 'reads manifest using bosh-template render' do
+          expect(subject.manifest['director_uuid']).to eq('litmus')
+        end
+
+        context 'with missing properties' do
+          let(:stub_content) { "---\nproperties:\n  stub: litmus\n" }
+          it 'raises error' do
+            expect { subject.manifest }.to raise_error /Can't find property/
+          end
+        end
+
+      end
+
+      context 'without stub file' do
+        let(:manifest) { { 'director_uuid' => 'litmus' } }
+
+        before do
+          allow(File).to receive(:exist?).with(stub_file).and_return(false)
+        end
+
+        it 'reads manifest without errors' do
+          expect(subject.manifest['director_uuid']).to eq('litmus')
+        end
+      end
+    end
+
     describe "#perform_validation" do
       context "valid" do
         it "validates" do

data/spec/release_spec.rb

@@ -1,491 +1,506 @@
 require "fileutils"
 
-describe Bosh::Workspace::Release do
-  include Bosh::Workspace::GitCredentialsHelper
-  let(:name) { "foo" }
-  let(:release) { load_release(release_data) }
-  let(:version) { "3" }
-  let(:url) { "http://local.url/release" }
-  let(:release_data) { { "name" => name, "version" => version, "git" => repo } }
-  let(:releases_dir) { File.join(asset_dir("manifests-repo"), ".releases") }
-  let(:templates) { Dir[File.join(releases_dir, name, "templates/*.yml")].to_s }
-
-  def load_release(release_data)
-    Bosh::Workspace::Release.new(release_data, releases_dir).tap do |r|
-      fetch_or_clone_repo(r.repo_dir, repo)
+module Bosh::Workspace
+  describe Release do
+    let(:name) { "foo" }
+    let(:release) { load_release(release_data) }
+    let(:version) { "3" }
+    let(:url) { "http://local.url/release" }
+    let(:release_data) { { "name" => name, "version" => version, "git" => repo } }
+    let(:releases_dir) { File.join(asset_dir("manifests-repo"), ".releases") }
+    let(:templates) { Dir[File.join(releases_dir, name, "templates/*.yml")].to_s }
+    let(:callback) { proc {} }
+
+    def load_release(release_data, options = {}, skip_update = false)
+      Release.new(release_data, releases_dir, callback, options).tap do |r|
+        r.update_repo(options) unless skip_update
+      end
     end
-  end
 
-  context "with new structure within 'releases' folder" do
-    let(:repo) { extracted_asset_dir("foo", "foo-boshrelease-repo-new-structure.zip") }
+    context "with new structure within 'releases' folder" do
+      let(:repo) { extracted_asset_dir("foo", "foo-boshrelease-repo-new-structure.zip") }
 
-    describe "#update_repo" do
-      subject do
-        Dir[File.join(releases_dir, name, "releases/**/foo*.yml")].to_s
-      end
+      describe "#update_repo" do
+        subject do
+          Dir[File.join(releases_dir, name, "releases/**/foo*.yml")].to_s
+        end
 
-      context "latest version" do
-        before { release.update_repo }
+        context "latest version" do
+          before { release.update_repo }
 
-        let(:version) { "latest" }
+          let(:version) { "latest" }
 
-        it "checks out repo" do
-          expect(subject).to match(/releases\/foo\/foo-12.yml/)
+          it "checks out repo" do
+            expect(subject).to match(/releases\/foo\/foo-12.yml/)
+          end
         end
-      end
 
-      context "version from before new structure" do
-        before { release.update_repo }
+        context "version from before new structure" do
+          before { release.update_repo }
 
-        let(:version) { "11" }
+          let(:version) { "11" }
 
-        it "checks out repo" do
-          expect(subject).to match(/releases\/foo-11.yml/)
+          it "checks out repo" do
+            expect(subject).to match(/releases\/foo-11.yml/)
+          end
         end
       end
-    end
 
-    describe "attributes" do
-      let(:release_data) { { "name" => name, "version" => version, "git" => repo } }
-      let(:version) { "12" }
-
-      subject { release }
-
-      its(:name) { should eq name }
-      its(:git_url) { should eq repo }
-      its(:repo_dir) { should match(/\/#{name}$/) }
-      its(:release_dir) { should match(/\/#{name}$/) }
-      its(:manifest) { should match "releases/#{name}/#{name}-#{version}.yml$" }
-      its(:name_version) { should eq "#{name}/#{version}" }
-      its(:version) { should eq version }
-      its(:manifest_file) do
-        should match(/\/releases\/#{name}\/#{name}-#{version}.yml$/)
-      end
+      describe "attributes" do
+        let(:release_data) { { "name" => name, "version" => version, "git" => repo } }
+        let(:version) { "12" }
 
-      context ", using a local url" do
-        context "with a version placeholder" do
-          let(:url) { "http://local.url/release?^VERSION^" }
-          let(:version) { "12" }
-          let(:release_data) { { "name" => name, "version" => version, "url" => url } }
+        subject { release }
 
-          it 'replaces the version placeholder with the version number' do
-            expect(release.url).to eq "http://local.url/release?12"
-          end
+        its(:name) { should eq name }
+        its(:git_url) { should eq repo }
+        its(:repo_dir) { should match(/\/#{name}$/) }
+        its(:release_dir) { should match(/\/#{name}$/) }
+        its(:manifest) { should match "releases/#{name}/#{name}-#{version}.yml$" }
+        its(:name_version) { should eq "#{name}/#{version}" }
+        its(:version) { should eq version }
+        its(:manifest_file) do
+          should match(/\/releases\/#{name}\/#{name}-#{version}.yml$/)
         end
 
-        context 'with no version placeholder' do
-          let(:url) { "http://local.url/release" }
-          let(:version) { "12" }
-          let(:release_data) {{ "name" => name, "version" => version, "url" => url }}
+        context ", using a local url" do
+          context "with a version placeholder" do
+            let(:url) { "http://local.url/release?^VERSION^" }
+            let(:version) { "12" }
+            let(:release_data) { { "name" => name, "version" => version, "url" => url } }
+
+            it 'replaces the version placeholder with the version number' do
+              expect(release.url).to eq "http://local.url/release?12"
+            end
+          end
+
+          context 'with no version placeholder' do
+            let(:url) { "http://local.url/release" }
+            let(:version) { "12" }
+            let(:release_data) {{ "name" => name, "version" => version, "url" => url }}
 
-          it 'returns the same url' do
-            expect(release.url).to eq "http://local.url/release"
+            it 'returns the same url' do
+              expect(release.url).to eq "http://local.url/release"
+            end
           end
         end
       end
     end
-  end
-
-  context "given a release with index + release v1 last touched on the same commit" do
-    let(:repo) { extracted_asset_dir("foo-bar", "foo-bar-boshrelease-repo.zip") }
-    let(:name) { "foo-bar" }
 
-    before do
-      FileUtils.rm_rf(releases_dir)
-    end
+    context "given a release with index + release v1 last touched on the same commit" do
+      let(:repo) { extracted_asset_dir("foo-bar", "foo-bar-boshrelease-repo.zip") }
+      let(:name) { "foo-bar" }
 
-    describe "#update_repo" do
-      subject do
-        Dir[File.join(releases_dir, name, "releases/foo-bar/foo-bar*.yml")].to_s
+      before do
+        FileUtils.rm_rf(releases_dir)
       end
 
-      context "latest version" do
-        before { release.update_repo }
+      describe "#update_repo" do
+        subject do
+          Dir[File.join(releases_dir, name, "releases/foo-bar/foo-bar*.yml")].to_s
+        end
+
+        context "latest version" do
+          before { release.update_repo }
           let(:version) { "latest" }
           it "checks out repo" do
-          expect(subject).to match(/releases\/foo-bar\/foo-bar-2.yml/)
+            expect(subject).to match(/releases\/foo-bar\/foo-bar-2.yml/)
+          end
         end
       end
-    end
 
-    describe "attributes" do
-      let(:version) { "1" }
-      subject { release }
-      its(:name) { should eq name}
-      its(:git_url) { should eq repo }
-      its(:repo_dir) { should match(/\/#{name}$/) }
-      its(:manifest) { should match "releases/#{name}/#{name}-#{version}.yml$" }
-      its(:name_version) { should eq "#{name}/#{version}" }
-      its(:version) { should eq version }
-      its(:manifest_file) do
-        should match(/\/releases\/#{name}\/#{name}-#{version}.yml$/)
+      describe "attributes" do
+        let(:version) { "1" }
+        subject { release }
+        its(:name) { should eq name}
+        its(:git_url) { should eq repo }
+        its(:repo_dir) { should match(/\/#{name}$/) }
+        its(:manifest) { should match "releases/#{name}/#{name}-#{version}.yml$" }
+        its(:name_version) { should eq "#{name}/#{version}" }
+        its(:version) { should eq version }
+        its(:manifest_file) do
+          should match(/\/releases\/#{name}\/#{name}-#{version}.yml$/)
+        end
       end
     end
-  end
 
+    context "given a release with submodule templates" do
+      let(:repo) { extracted_asset_dir("supermodule", "supermodule-boshrelease-repo.zip") }
+      let(:subrepo) { extracted_asset_dir("submodule-boshrelease", "submodule-boshrelease-repo.zip") }
+      let(:name) { "supermodule" }
+      let(:version) { "2" }
 
-  context "given a release with submodule templates" do
-    let(:repo) { extracted_asset_dir("supermodule", "supermodule-boshrelease-repo.zip") }
-    let(:subrepo) { extracted_asset_dir("submodule-boshrelease", "submodule-boshrelease-repo.zip") }
-    let(:name) { "supermodule" }
+      before do
+        FileUtils.rm_rf(releases_dir)
+        allow_any_instance_of(Rugged::Submodule).to receive(:url).and_return(subrepo)
+      end
 
-    describe "#update_repo" do
-      subject { Rugged::Repository.new(File.join(releases_dir, name)) }
-      context "with templates in submodules" do
-        before do
-          FileUtils.rm_rf(releases_dir)
-          allow_any_instance_of(Rugged::Submodule).to receive(:url).and_return(subrepo)
+      describe "#update_repo" do
+        subject { Rugged::Repository.new(File.join(releases_dir, name)) }
 
-          release = load_release( "name" => name, "version" => 1, "git" => repo)
-          release.update_repo
-          release.required_submodules.each do |submodule|
-            fetch_or_clone_repo(File.join(release.repo_dir, submodule.path), submodule.url)
-            release.update_submodule(submodule)
+        context "with templates in submodules" do
+          before do
+            release = load_release("name" => name, "version" => 1, "git" => repo)
           end
-        end
 
-        it "clones + checks out required submodules" do
-          expect(subject.submodules["src/submodule"].workdir_oid)
-            .to eq "2244c436777f7c305fb81a8a6e29079c92a2ab9d"
-        end
-        it "doesn't clone/checkout extraneous submodules" do
-          expect(subject.submodules["src/other"].workdir_oid).to eq nil
-        end
-      end
-      context "with templates in submodules" do
-        before do
-          FileUtils.rm_rf(releases_dir)
-          allow_any_instance_of(Rugged::Submodule).to receive(:url).and_return(subrepo)
+          it "clones + checks out required submodules" do
+            expect(subject.submodules["src/submodule"].workdir_oid)
+              .to eq "2244c436777f7c305fb81a8a6e29079c92a2ab9d"
+          end
 
-          release = load_release( "name" => name, "version" => 2, "git" => repo)
-          release.update_repo
-          release.required_submodules.each do |submodule|
-            fetch_or_clone_repo(File.join(release.repo_dir, submodule.path), submodule.url)
-            release.update_submodule(submodule)
+          it "doesn't clone/checkout extraneous submodules" do
+            expect(subject.submodules["src/other"].workdir_oid).to eq nil
           end
         end
 
-        it "clones + checks out required submodules" do
-          expect(subject.submodules["src/submodule"].workdir_oid)
-            .to eq "95eed8c967af969d659a766b0551a75a729a7b65"
-        end
-        it "doesn't clone/checkout extraneous submodules" do
-          expect(subject.submodules["src/other"].workdir_oid).to eq nil
+        context "with templates in submodules" do
+          before { load_release(release_data) }
+
+          it "clones + checks out required submodules" do
+            expect(subject.submodules["src/submodule"].workdir_oid)
+              .to eq "95eed8c967af969d659a766b0551a75a729a7b65"
+          end
+          it "doesn't clone/checkout extraneous submodules" do
+            expect(subject.submodules["src/other"].workdir_oid).to eq nil
+          end
         end
-      end
 
-      context "from v1 to v2" do
-        before do
-          FileUtils.rm_rf(releases_dir)
-          allow_any_instance_of(Rugged::Submodule).to receive(:url).and_return(subrepo)
+        context "from v1 to v2" do
+          let(:version) { 1 }
+          before { load_release(release_data) }
+
+          it "updates the submodules appropriately" do
+            expect(subject.submodules["src/submodule"].workdir_oid)
+              .to eq "2244c436777f7c305fb81a8a6e29079c92a2ab9d"
+            expect(subject.submodules["src/other"].workdir_oid).to eq nil
+
+            # Now move to v2 on existing repo
+            release = load_release("name" => name, "version" => 2, "git" => repo)
+            release.update_repo
+            expect(subject.submodules["src/submodule"].workdir_oid)
+              .to eq "95eed8c967af969d659a766b0551a75a729a7b65"
+            expect(subject.submodules["src/other"].workdir_oid).to eq nil
+          end
         end
 
-        it "updates the submodules appropriately" do
-          release = load_release("name" => name, "version" => 1, "git" => repo)
-          release.update_repo
-          release.required_submodules.each do |submodule|
-            fetch_or_clone_repo(File.join(release.repo_dir, submodule.path), submodule.url)
-            release.update_submodule(submodule)
+        context "while being offline" do
+          subject { load_release(release_data, offline: true) }
+
+          it 'fails when repo does not yet exist' do
+            expect{ subject }.to raise_error /not allowed in offline mode/
           end
-          expect(subject.submodules["src/submodule"].workdir_oid)
-            .to eq "2244c436777f7c305fb81a8a6e29079c92a2ab9d"
-          expect(subject.submodules["src/other"].workdir_oid).to eq nil
 
-          # Now move to v2 on existing repo
-          release = load_release("name" => name, "version" => 2, "git" => repo)
-          release.update_repo
-          release.required_submodules.each do |submodule|
-            fetch_or_clone_repo(File.join(release.repo_dir, submodule.path), submodule.url)
-            release.update_submodule(submodule)
+          context "with an already cloned release" do
+            before { load_release(release_data) }
+
+            it 'validates local data exists' do
+              expect{ subject }.to_not raise_error
+            end
+
+            context "when using latest version" do
+              let(:version) { "latest" }
+              subject { load_release(release_data, { offline: true }, true) }
+              it 'warns when using latest while offline' do
+                expect(subject).to receive(:warning).with(/using 'latest' local/i)
+                subject.update_repo
+              end
+            end
           end
-          expect(subject.submodules["src/submodule"].workdir_oid)
-            .to eq "95eed8c967af969d659a766b0551a75a729a7b65"
-          expect(subject.submodules["src/other"].workdir_oid).to eq nil
         end
       end
     end
-  end
 
-  context "given a release with deprecated structure within 'releases' folder" do
-    let(:repo) { extracted_asset_dir("foo", "foo-boshrelease-repo.zip") }
+    context "given a release with deprecated structure within 'releases' folder" do
+      let(:repo) { extracted_asset_dir("foo", "foo-boshrelease-repo.zip") }
 
-    describe "#update_repo" do
-      subject { Dir[File.join(releases_dir, name, "releases/foo*.yml")].to_s }
+      describe "#update_repo" do
+        subject { Dir[File.join(releases_dir, name, "releases/foo*.yml")].to_s }
 
-      context "latest version" do
-        before { release.update_repo }
+        context "latest version" do
+          before { release.update_repo }
 
-        let(:version) { "latest" }
+          let(:version) { "latest" }
 
-        it "checks out repo" do
-          expect(subject).to match(/foo-12.yml/)
-        end
+          it "checks out repo" do
+            expect(subject).to match(/foo-12.yml/)
+          end
 
-        it "does not include templates from master" do
-          expect(templates).to_not match(/deployment.yml/)
+          it "does not include templates from master" do
+            expect(templates).to_not match(/deployment.yml/)
+          end
         end
-      end
 
-      context "specific version" do
-        let(:version) { "12" }
-        before { release.update_repo }
+        context "specific version" do
+          let(:version) { "12" }
+          before { release.update_repo }
 
-        it "checks out repo" do
-          expect(subject).to match(/foo-11.yml/)
-        end
+          it "checks out repo" do
+            expect(subject).to match(/foo-11.yml/)
+          end
 
-        it "does not include templates from master" do
-          expect(templates).to_not match(/deployment.yml/)
+          it "does not include templates from master" do
+            expect(templates).to_not match(/deployment.yml/)
+          end
         end
-      end
 
-      context "specific version" do
-        let(:version) { "2" }
+        context "specific version" do
+          let(:version) { "2" }
 
-        it "checks out repo" do
-          release.update_repo
-          expect(subject).to match(/foo-2.yml/)
+          it "checks out repo" do
+            release.update_repo
+            expect(subject).to match(/foo-2.yml/)
+          end
         end
-      end
 
-      context "specific ref with latest release" do
-        let(:release_data) do
-          {"name" => name, "version" => "latest", "ref" => "66658", "git" => repo}
-        end
+        context "specific ref with latest release" do
+          let(:release_data) do
+            {"name" => name, "version" => "latest", "ref" => "66658", "git" => repo}
+          end
 
-        it "checks out repo" do
-          release.update_repo
-          expect(subject).to match(/foo-2.yml/)
-          expect(subject).to_not match(/foo-3.yml/)
+          it "checks out repo" do
+            release.update_repo
+            expect(subject).to match(/foo-2.yml/)
+            expect(subject).to_not match(/foo-3.yml/)
+          end
         end
-      end
 
-      context "updated version" do
-        let(:version) { "11" }
+        context "updated version" do
+          let(:version) { "11" }
 
-        it "checks out file with multiple commits" do
-          release.update_repo
-          expect(subject).to match(/foo-11.yml/)
+          it "checks out file with multiple commits" do
+            release.update_repo
+            expect(subject).to match(/foo-11.yml/)
+          end
         end
-      end
 
-      context "non existing version " do
-        let(:version) { "13" }
+        context "non existing version " do
+          let(:version) { "13" }
 
-        it "raises an error" do
-          expect { release.update_repo }.
-            to raise_error(/Could not find version/)
+          it "raises an error" do
+            expect { release.update_repo }
+              .to raise_error(/Could not find version/)
+          end
         end
-      end
 
-      context "already cloned repo" do
-        before do
-          load_release("name" => name, "version" => 1, "git" => repo).update_repo
-        end
+        context "already cloned repo" do
+          before do
+            load_release("name" => name, "version" => 1, "git" => repo).update_repo
+          end
 
-        it "version 3" do
-          release.update_repo
-          expect(subject).to match(/foo-3.yml/)
+          it "version 3" do
+            release.update_repo
+            expect(subject).to match(/foo-3.yml/)
+          end
         end
-      end
 
-      context "multiple releases" do
-        let(:version) { "11" }
+        context "multiple releases" do
+          let(:version) { "11" }
 
-        before do
-          load_release("name" => "foo", "version" => 2, "git" => repo).update_repo
-        end
+          before do
+            load_release("name" => "foo", "version" => 2, "git" => repo).update_repo
+          end
 
-        it "version 11" do
-          release.update_repo
-          expect(subject).to match(/foo-11.yml/)
-          expect(templates).to_not match(/deployment.yml/)
+          it "version 11" do
+            release.update_repo
+            expect(subject).to match(/foo-11.yml/)
+            expect(templates).to_not match(/deployment.yml/)
+          end
         end
-      end
 
-      context "specific version" do
-        let(:version) { "11" }
-        before { release.update_repo }
+        context "specific version" do
+          let(:version) { "11" }
+          before { release.update_repo }
 
-        it "checks out repo" do
-          expect(subject).to match(/foo-11.yml/)
-        end
+          it "checks out repo" do
+            expect(subject).to match(/foo-11.yml/)
+          end
 
-        it "does not include templates from master" do
-          expect(templates).to_not match(/deployment.yml/)
+          it "does not include templates from master" do
+            expect(templates).to_not match(/deployment.yml/)
+          end
         end
-      end
 
-      context "specific version" do
-        let(:version) { "2" }
+        context "specific version" do
+          let(:version) { "2" }
 
-        it "checks out repo" do
-          release.update_repo
-          expect(subject).to match(/foo-2.yml/)
+          it "checks out repo" do
+            release.update_repo
+            expect(subject).to match(/foo-2.yml/)
+          end
         end
-      end
 
-      context "specific ref with latest release" do
-        let(:release_data) do
-          {"name" => name, "version" => "latest", "ref" => "66658", "git" => repo}
-        end
+        context "specific ref with latest release" do
+          let(:release_data) do
+            {"name" => name, "version" => "latest", "ref" => "66658", "git" => repo}
+          end
 
-        it "checks out repo" do
-          release.update_repo
-          expect(subject).to match(/foo-2.yml/)
-          expect(subject).to_not match(/foo-3.yml/)
+          it "checks out repo" do
+            release.update_repo
+            expect(subject).to match(/foo-2.yml/)
+            expect(subject).to_not match(/foo-3.yml/)
+          end
         end
-      end
 
-      context "updated version " do
-        let(:version) { "11" }
+        context "updated version " do
+          let(:version) { "11" }
 
-        it "checks out file with multiple commits" do
-          release.update_repo
-          expect(subject).to match(/foo-11.yml/)
+          it "checks out file with multiple commits" do
+            release.update_repo
+            expect(subject).to match(/foo-11.yml/)
+          end
         end
-      end
 
-      context "non existing version " do
-        let(:version) { "13" }
+        context "non existing version " do
+          let(:version) { "13" }
 
-        it "raises an error" do
-          expect { release.version }.
-            to raise_error(/Could not find version/)
+          it "raises an error" do
+            expect { release.version }.
+              to raise_error(/Could not find version/)
+          end
         end
-      end
 
-      context "already cloned repo" do
-        before do
-          load_release("name" => name, "version" => 1, "git" => repo).update_repo
-        end
+        context "already cloned repo" do
+          before do
+            load_release("name" => name, "version" => 1, "git" => repo).update_repo
+          end
 
-        it "version 3" do
-          release.update_repo
-          expect(subject).to match(/foo-3.yml/)
+          it "version 3" do
+            release.update_repo
+            expect(subject).to match(/foo-3.yml/)
+          end
         end
-      end
 
-      context "multiple releases" do
-        let(:version) { "11" }
+        context "multiple releases" do
+          let(:version) { "11" }
 
-        before do
-          load_release("name" => "foo", "version" => 2, "git" => repo).update_repo
-        end
+          before do
+            load_release("name" => "foo", "version" => 2, "git" => repo).update_repo
+          end
 
-        it "version 11" do
-          release.update_repo
-          expect(subject).to match(/foo-11.yml/)
-          expect(templates).to_not match(/deployment.yml/)
+          it "version 11" do
+            release.update_repo
+            expect(subject).to match(/foo-11.yml/)
+            expect(templates).to_not match(/deployment.yml/)
+          end
         end
-      end
 
-      context "new release in already cloned repo" do
-        let(:version) { "12" }
+        context "new release in already cloned repo" do
+          let(:version) { "12" }
 
-        before do
-          load_release("name" => name, "version" => 1, "git" => repo).update_repo
-          extracted_asset_dir("foo", "foo-boshrelease-repo-updated.zip")
-        end
+          before do
+            load_release("name" => name, "version" => 1, "git" => repo).update_repo
+            extracted_asset_dir("foo", "foo-boshrelease-repo-updated.zip")
+          end
 
-        it "version 12" do
-          release.update_repo
-          expect(subject).to match(/foo-12.yml/)
+          it "version 12" do
+            release.update_repo
+            expect(subject).to match(/foo-12.yml/)
+          end
         end
       end
-    end
-
-    describe "attributes" do
-      subject { release }
-      its(:name) { should eq name }
-      its(:git_url) { should eq repo }
-      its(:repo_dir) { should match(/\/#{name}$/) }
-      its(:release_dir) { should match(/\/#{name}$/) }
-      its(:manifest_file) { should match(/\/#{name}-#{version}.yml$/) }
-      its(:manifest) { should match "releases/#{name}-#{version}.yml$" }
-      its(:name_version) { should eq "#{name}/#{version}" }
-      its(:version) { should eq version.to_s }
-    end
-  end
 
-  context "given a release which is located in a subfolder" do
-    let(:repo) { extracted_asset_dir("foo", "foo-boshrelease-repo-subdir.zip") }
-    let(:release_data) do
-      { "name" => name, "version" => version, "git" => repo, "path" => "release"  }
+      describe "attributes" do
+        subject { release }
+        its(:name) { should eq name }
+        its(:git_url) { should eq repo }
+        its(:repo_dir) { should match(/\/#{name}$/) }
+        its(:release_dir) { should match(/\/#{name}$/) }
+        its(:manifest_file) { should match(/\/#{name}-#{version}.yml$/) }
+        its(:manifest) { should match "releases/#{name}-#{version}.yml$" }
+        its(:name_version) { should eq "#{name}/#{version}" }
+        its(:version) { should eq version.to_s }
+      end
     end
 
-    describe "#update_repo" do
-      subject do
-        Dir[File.join(releases_dir, name, "release/releases/**/*.yml")].to_s
+    context "given a release which is located in a subfolder" do
+      let(:repo) { extracted_asset_dir("foo", "foo-boshrelease-repo-subdir.zip") }
+      let(:release_data) do
+        { "name" => name, "version" => version, "git" => repo, "path" => "release"  }
       end
 
-      context "latest version" do
-        before { release.update_repo }
+      describe "#update_repo" do
+        subject do
+          Dir[File.join(releases_dir, name, "release/releases/**/*.yml")].to_s
+        end
 
-        let(:version) { "latest" }
+        context "latest version" do
+          before { release.update_repo }
 
-        it "checks out repo" do
-          expect(subject).to match(/release\/releases\/foo-12.yml/)
+          let(:version) { "latest" }
+
+          it "checks out repo" do
+            expect(subject).to match(/release\/releases\/foo-12.yml/)
+          end
         end
       end
-    end
 
-    describe "attributes" do
-      let(:version) { "12" }
-      subject { release }
-      its(:name) { should eq name }
-      its(:git_url) { should eq repo }
-      its(:repo_dir) { should match(/\/#{name}$/) }
-      its(:release_dir) { should match(/\/#{name}\/release$/) }
-      its(:manifest) { should match "release/releases/#{name}-#{version}.yml$" }
-      its(:name_version) { should eq "#{name}/#{version}" }
-      its(:version) { should eq version }
-      its(:manifest_file) do
-        should match(/\/release\/releases\/#{name}-#{version}.yml$/)
+      describe "attributes" do
+        let(:version) { "12" }
+        subject { release }
+        its(:name) { should eq name }
+        its(:git_url) { should eq repo }
+        its(:repo_dir) { should match(/\/#{name}$/) }
+        its(:release_dir) { should match(/\/#{name}\/release$/) }
+        its(:manifest) { should match "release/releases/#{name}-#{version}.yml$" }
+        its(:name_version) { should eq "#{name}/#{version}" }
+        its(:version) { should eq version }
+        its(:manifest_file) do
+          should match(/\/release\/releases\/#{name}-#{version}.yml$/)
+        end
       end
     end
-  end
 
-  context "correct checkout behavior:" do
-    let(:repo) { extracted_asset_dir("foo", "foo-boshrelease-repo.zip") }
-    let(:release_data) { { "name" => name, "version" => version,
-                           "git" => repo, "ref" => :fooref } }
-    let(:repo) { 'foo/bar' }
-    let(:repository) do
-      instance_double('Rugged::Repository', lookup: double(oid: :fooref))
-    end
+    context "correct checkout behavior:" do
+      let(:repo) { extracted_asset_dir("foo", "foo-boshrelease-repo.zip") }
+      let(:release_data) { { "name" => name, "version" => version,
+                             "git" => repo, "ref" => :fooref } }
+      let(:repo) { 'foo/bar' }
+      let(:repository) do
+        instance_double('Rugged::Repository', lookup: double(oid: :fooref))
+      end
 
-    describe "#update_repo_with_ref" do
-      subject { Bosh::Workspace::Release.new(release_data, releases_dir) }
+      describe "#update_repo_with_ref" do
+        subject do
+          Release.new(release_data, releases_dir, callback)
+        end
 
-      before do
-        expect(Rugged::Repository).to receive(:new).and_return(repository)
-      end
+        before do
+          expect(Rugged::Repository).to receive(:new)
+            .and_return(repository).at_least(:once)
+          expect(repository).to receive(:fetch)
+          expect(repository).to receive(:references) do
+            { 'refs/remotes/origin/HEAD' =>
+              double(resolve: double(target_id: :oid)) }
+          end
+        end
 
-      it "calls checkout_tree and checkout" do
-        expect(repository).to receive("checkout_tree").at_least(:once)
-        expect(repository).to receive("checkout").at_least(:once)
-        subject.update_repo
+        it "calls checkout_tree and checkout" do
+          expect(repository).to receive("checkout_tree").at_least(:once)
+          expect(repository).to receive("checkout").at_least(:once)
+          subject.update_repo
+        end
       end
     end
-  end
 
-  context "given a release which moved a directory to a symlink across versions" do
-    let(:repo) { extracted_asset_dir("symlinkreplacement", "symlinkreplacement-boshrelease-repo.zip") }
-    let(:name) { "symlinkreplacement" }
+    context "given a release which moved a directory to a symlink across versions" do
+      let(:repo) do
+        extracted_asset_dir("symlinkreplacement", "symlinkreplacement-boshrelease-repo.zip")
+      end
+      let(:name) { "symlinkreplacement" }
 
-    describe "#update_repo" do
-      subject { Rugged::Repository.new(File.join(releases_dir, name)) }
-      context "using a previous version should work" do
-        before do
-          FileUtils.rm_rf(releases_dir)
+      describe "#update_repo" do
+        subject { Rugged::Repository.new(File.join(releases_dir, name)) }
+        context "using a previous version should work" do
+          before do
+            FileUtils.rm_rf(releases_dir)
 
-          release = load_release("name" => name, "version" => "1", "git" => repo)
-          release.update_repo
-        end
-        it "git state is happy" do
-          expect(subject.head.target.oid).to eq "d96521d1940934b1941e0f4a462d3a5e9f31c75d"
-          expect(subject.diff_workdir(subject.head.target.oid).size).to eq 0
+            release = load_release("name" => name, "version" => "1", "git" => repo)
+            release.update_repo
+          end
+          it "git state is happy" do
+            expect(subject.head.target.oid).to eq "d96521d1940934b1941e0f4a462d3a5e9f31c75d"
+            expect(subject.diff_workdir(subject.head.target.oid).size).to eq 0
+          end
         end
       end
     end