bosh-workspace 0.7.0 → 0.8.0

data/spec/helpers/spiff_helper_spec.rb

@@ -1,7 +1,7 @@
-describe Bosh::Manifests::SpiffHelper do
+describe Bosh::Workspace::SpiffHelper do
   describe ".spiff" do
     class SpiffHelperTester
-      include Bosh::Manifests::SpiffHelper
+      include Bosh::Workspace::SpiffHelper
     end
     subject { SpiffHelperTester.new }
     let(:path) { asset_dir("bin") }

data/spec/helpers/stemcell_helper_spec.rb

@@ -0,0 +1,89 @@
+describe Bosh::Workspace::StemcellHelper do
+  class StemcellHelperTester
+    include Bosh::Workspace::StemcellHelper
+
+    attr_reader :director, :work_dir
+
+    def initialize(director, work_dir)
+      @director = director
+      @work_dir = work_dir
+    end
+  end
+
+  subject { stemcell_helper }
+  let(:stemcell_helper) { StemcellHelperTester.new(director, work_dir) }
+  let(:director) { instance_double('Bosh::Cli::Client::Director') }
+  let(:work_dir) { asset_dir("manifests-repo") }
+
+  context "with stemcell command" do
+    let(:stemcell_cmd) { instance_double("Bosh::Cli::Command::Stemcell") }
+    before { Bosh::Cli::Command::Stemcell.stub(:new).and_return(stemcell_cmd) }
+
+    describe "#stemcell_download" do
+      let(:name) { "foo" }
+      subject { stemcell_helper.stemcell_download(name) }
+      
+      it "downloads stemcell" do
+        Dir.should_receive(:chdir).and_yield
+        stemcell_cmd.should_receive(:download_public).with(name)
+        subject
+      end
+    end
+
+    describe "#stemcell_upload" do
+      let(:file) { "foo.tgz" }
+      subject { stemcell_helper.stemcell_upload(file) }
+      
+      it "uploads stemcell" do
+        stemcell_cmd.should_receive(:upload).with(file)
+        subject
+      end
+    end
+  end
+
+  describe "#stemcell_uploaded?" do
+    let(:stemcells) { [{ "name" => "foo", "version" => "1" }] }
+    subject { stemcell_helper.stemcell_uploaded?(name, 1) }
+    before { director.should_receive(:list_stemcells).and_return(stemcells) }
+
+    context "stemcell exists" do
+      let(:name) { "foo" }
+      it { should be_true }
+    end
+
+    context "stemcell not found" do
+      let(:name) { "bar" }
+      it { should be_false }
+    end
+  end
+  
+  describe "#stemcell_dir" do
+    let(:stemcells_dir) { File.join(work_dir, ".stemcells") }
+    subject { stemcell_helper.stemcells_dir }
+    
+    before { FileUtils.should_receive(:mkdir_p).once.with(stemcells_dir).and_return([stemcells_dir]) }
+
+    it { should eq stemcells_dir }
+
+    it "memoizes" do
+      subject
+      expect(subject).to eq stemcells_dir
+    end
+  end
+
+  describe "#project_deployment_stemcells" do
+    subject { stemcell_helper.project_deployment_stemcells }
+    let(:stemcell) { instance_double("Bosh::Workspace::Stemcell") }
+    let(:stemcell_data) { { name: "foo" } }
+    let(:stemcells) { [stemcell_data, stemcell_data] }
+
+    before { stemcell_helper.stub_chain("project_deployment.stemcells").and_return(stemcells) }
+
+    it "inits stemcells once" do
+      Bosh::Workspace::Stemcell.should_receive(:new).twice
+        .with(stemcell_data, /\/.stemcells/).and_return(stemcell)
+      subject
+      expect(subject).to eq [stemcell, stemcell]
+    end
+  end
+end

data/spec/manifest_builder_spec.rb

@@ -1,72 +1,45 @@
-describe Bosh::Manifests::ManifestBuilder do
-  let(:manifest) { instance_double("Bosh::Manifests::Manifest") }
+describe Bosh::Workspace::ManifestBuilder do
+  let(:project_deployment) { instance_double("Bosh::Workspace::Project_Deployment",
+    name: "bar",
+    templates: ["foo.yml"],
+    merged_file: ".deployments/foo.yml")
+  }
   let(:work_dir) { asset_dir("manifests-repo") }
-  let(:target_name) { "bar" }
-  let(:target_file) {
-    File.join(work_dir, ".manifests", "#{target_name}.yml") }
 
   describe ".build" do
-    subject { Bosh::Manifests::ManifestBuilder.build manifest, work_dir }
+    subject { Bosh::Workspace::ManifestBuilder.build project_deployment, work_dir }
     let(:manifest_builder) {
-      instance_double("Bosh::Manifests::ManifestBuilder") }
+      instance_double("Bosh::Workspace::ManifestBuilder") }
 
     it "creates builder and merges templates" do
-      Bosh::Manifests::ManifestBuilder.should_receive(:new)
-        .with(manifest, work_dir).and_return(manifest_builder)
+      Bosh::Workspace::ManifestBuilder.should_receive(:new)
+        .with(project_deployment, work_dir).and_return(manifest_builder)
       manifest_builder.should_receive(:merge_templates)
       subject
     end
   end
 
   describe "#merge_templates" do
-    subject { Bosh::Manifests::ManifestBuilder.new manifest, work_dir }
-    let(:templates) { ["foo.yml"] }
-    let(:template_path) { File.join(work_dir, "templates/foo.yml") }
-    let(:template_exists) { true }
+    subject { Bosh::Workspace::ManifestBuilder.new project_deployment, work_dir }
 
     before do
-      manifest.should_receive(:templates).and_return(templates)
-      File.should_receive(:exists?).with(template_path)
-        .and_return(template_exists)
+      File.stub(:exists?).with(/templates\//).and_return(template_exists)
     end
 
     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
 
     context "template exists" do
+      let(:template_exists) { true }
       let(:dir_exists) { true }
-      let(:target_dir) { File.join(work_dir, ".manifests" ) }
-      let(:uuid) { "foo-bar-uuid" }
-      let(:meta_file_path) do
-        File.join(work_dir, ".stubs", "#{target_name}.yml")
-      end
-      let(:meta_file) { instance_double("File") }
-      let(:meta) { { "foo" => "bar" } }
-      let(:release) { { "name" => "foo", "version" => "latest" } }
-      let(:releases) { [release] }
-      let(:raw_releases) { [release.merge("git" => "release_repo.git")] }
-      let(:meta_file_content) do
-        {
-          "director_uuid" => uuid,
-          "releases" => releases,
-          "meta" => meta
-        }
-      end
 
       before do
-        manifest.should_receive(:name).and_return(target_name)
-        manifest.should_receive(:meta).and_return(meta)
-        manifest.should_receive(:director_uuid).and_return(uuid)
-        manifest.should_receive(:releases).and_return(raw_releases)
-        manifest.should_receive(:merged_file).and_return(target_file)
-        File.should_receive(:exists?).and_return(dir_exists)
-        File.should_receive(:open).with(meta_file_path, "w")
-          .and_yield(meta_file)
-        meta_file.should_receive(:write).with(meta_file_content.to_yaml)
+        File.stub(:exists?).with(/\.stubs/).and_return(dir_exists)
+        Bosh::Workspace::StubFile.should_receive(:create).with(/\.stubs\/.+yml/, project_deployment)
       end
 
       context "no hidden dirs" do
@@ -79,8 +52,14 @@ describe Bosh::Manifests::ManifestBuilder do
       end
 
       it "generates manifest with spiff" do
-        subject.should_receive(:spiff_merge)
-          .with([template_path, meta_file_path], target_file)
+        subject.should_receive(:spiff_merge) do |args|
+          if args.is_a?(Array)
+            expect(args.first).to match(/\/templates\/.+yml/)
+            expect(args.last).to match(/\.stubs\/.+yml/)
+          else
+            expect(args).to match(/\.deployments\/.+yml/)
+          end
+        end
         subject.merge_templates
       end
     end

data/spec/project_deployment_spec.rb

@@ -0,0 +1,157 @@
+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) { [
+    { "name" => "foo", "version" => release_version, "git" => "example.com/foo.git" }
+  ] }
+  let(:release_version) { 1 }
+  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
+      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) }
+      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) }
+        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
+    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
+
+      context "invalid version" do
+        let(:missing) { "name" }
+        let(:stemcell_version) { "foo" }
+        it { should match(/name.*missing/i) }
+        it { should match(/version.*doesn't validate/i) }
+      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

data/spec/release_spec.rb

@@ -1,19 +1,20 @@
-describe Bosh::Manifests::Release do
+describe Bosh::Workspace::Release do
   let(:name) { "foo"}
   let(:version) { 3 }
   let(:repo) { extracted_asset_dir("foo", "foo-boshrelease-repo.zip") }
   let(:release_data) { { "name" => name, "version" => version, "git" => repo } }
   let(:releases_dir) { File.join(asset_dir("manifests-repo"), ".releases") }
-  let(:release) { Bosh::Manifests::Release.new release_data, releases_dir }
-  subject { Dir[File.join(releases_dir, name, "releases", "foo*.yml")].to_s }
+  let(:release) { Bosh::Workspace::Release.new release_data, releases_dir }
+
+  describe "#update_repo" do
+    subject { Dir[File.join(releases_dir, name, "releases", "foo*.yml")].to_s }
 
-  describe "#checkout_current_version" do
     context "latest version" do
       let(:version) { "latest" }
 
       it "checks out repo" do
-        release.checkout_current_version
-        expect(subject).to match /foo-11.yml/
+        release.update_repo
+        expect(subject).to match(/foo-11.yml/)
       end
     end
 
@@ -21,8 +22,17 @@ describe Bosh::Manifests::Release do
       let(:version) { "2" }
 
       it "checks out repo" do
-        release.checkout_current_version
-        expect(subject).to match /foo-2.yml/
+        release.update_repo
+        expect(subject).to match(/foo-2.yml/)
+      end
+    end
+
+    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/)
       end
     end
 
@@ -30,21 +40,21 @@ describe Bosh::Manifests::Release do
       let(:version) { "12" }
 
       it "raises an error" do
-        expect { release.checkout_current_version }.
-          to raise_error /Could not find version/
+        expect { release.update_repo }.
+          to raise_error(/Could not find version/)
       end
     end
 
     context "already cloned repo" do
       before do
         data = { "name" => name, "version" => 1, "git" => repo }
-        cloned_release = Bosh::Manifests::Release.new(data, releases_dir)
-        cloned_release.checkout_current_version
+        cloned_release = Bosh::Workspace::Release.new(data, releases_dir)
+        cloned_release.update_repo
       end
 
       it "version 3" do
-        release.checkout_current_version
-        expect(subject).to match /foo-3.yml/
+        release.update_repo
+        expect(subject).to match(/foo-3.yml/)
       end
     end
 
@@ -53,17 +63,28 @@ describe Bosh::Manifests::Release do
 
       before do
         data = { "name" => "bar", "version" => 2, "git" => repo }
-        other_release = Bosh::Manifests::Release.new(data, releases_dir)
-        other_release.checkout_current_version
+        other_release = Bosh::Workspace::Release.new(data, releases_dir)
+        other_release.update_repo
       end
 
       it "version 3" do
-        release.checkout_current_version
-        expect(subject).to match /foo-3.yml/
+        release.update_repo
+        expect(subject).to match(/foo-3.yml/)
       end
     end
   end
 
+  describe "attributes" do
+    subject { release }
+    its(:name){ should eq name }
+    its(:git_uri){ should eq repo }
+    its(:repo_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 }
+  end
+
   after do
     FileUtils.rm_r releases_dir
   end