bosh-workspace 0.7.0

data/spec/commands/command_make_manifest_spec.rb

@@ -0,0 +1,107 @@
+require "bosh/cli/commands/01_make_manifest"
+
+describe Bosh::Cli::Command::Manifests do
+  let(:command) { Bosh::Cli::Command::Manifests.new }
+  let(:project_deployment) do
+    instance_double("Bosh::Manifests::DeploymentManifest")
+  end
+
+  let(:deployment_cmd) { instance_double("Bosh::Cli::Command::Deployment") }
+
+  before do
+    setup_home_dir
+    command.add_option(:config, home_file(".bosh_config"))
+    command.add_option(:non_interactive, true)
+    deployment_cmd.stub(:add_option)
+  end
+
+  describe "#deployment" do
+    subject { command.set_current(filename) }
+
+    let(:filename) { "foo" }
+
+    before do
+      Bosh::Cli::Command::Deployment.should_receive(:new)
+        .and_return(deployment_cmd)
+    end
+
+    context "with project deployment" do
+      let(:deployment) { "deployments/foo.yml" }
+      let(:merged_file) { ".manifests/foo.yml" }
+
+      it "sets filename to merged file" do
+        command.should_receive(:find_deployment).with(filename)
+          .and_return(deployment)
+        command.should_receive(:project_deployment_file?).with(deployment)
+          .and_return(true)
+        command.should_receive(:project_deployment=).with(deployment)
+        command.should_receive(:validate_project_deployment)
+        File.should_receive(:exists?).with(merged_file).and_return(false)
+        command.should_receive(:create_placeholder_deployment)
+        command.should_receive(:project_deployment)
+          .and_return(project_deployment)
+        project_deployment.should_receive(:merged_file).and_return(merged_file)
+        deployment_cmd.should_receive(:set_current).with(merged_file)
+        subject
+      end
+    end
+
+    context "without filename" do
+      let(:filename) { nil }
+
+      it "returns current deployment" do
+        deployment_cmd.should_receive(:set_current).with(filename)
+        subject
+      end
+    end
+  end
+
+  describe "#prepare" do
+    subject { command.prepare }
+    let(:releases) { ["foo", "bar"] }
+    let(:release_manager) { instance_double("Bosh::Manifests::ReleaseManager") }
+    let(:work_dir) { asset_dir("manifests-repo") }
+
+    it "resolves deployment requirements" do
+      command.should_receive(:require_project_deployment)
+      command.should_receive(:auth_required)
+      command.should_receive(:project_deployment).and_return(project_deployment)
+      project_deployment.should_receive(:releases).and_return(releases)
+      command.should_receive(:work_dir).and_return(work_dir)
+      Bosh::Manifests::ReleaseManager.should_receive(:new)
+        .with(releases, work_dir).and_return(release_manager)
+      release_manager.should_receive(:update_release_repos)
+      subject
+    end
+  end
+
+  describe "deploy" do
+    subject { command.deploy }
+
+    before do
+      Bosh::Cli::Command::Deployment.should_receive(:new)
+        .and_return(deployment_cmd)
+      command.should_receive(:project_deployment?)
+        .and_return(is_project_deployment)
+      deployment_cmd.should_receive(:perform)
+    end
+
+    context "with project deployment" do
+      let(:is_project_deployment) { true }
+
+      it "requires project deployment" do
+        command.should_receive(:require_project_deployment)
+        command.should_receive(:build_project_deployment)
+        subject
+      end
+    end
+
+    context "with normal deployment" do
+      let(:is_project_deployment) { false }
+
+      it "deploys" do
+        subject
+      end
+    end
+  end
+end

data/spec/deployment_manifest_spec.rb

@@ -0,0 +1,93 @@
+describe Bosh::Manifests::DeploymentManifest do
+  subject { Bosh::Manifests::DeploymentManifest.new manifest_file }
+  let(:manifest_file) { get_tmp_file_path(manifest.to_yaml) }
+  let(:name) { "foo" }
+  let(:uuid) { "foo-bar-uuid" }
+  let(:templates) { ["path_to_bar", "path_to_baz"] }
+  let(:releases) { [
+    { "name" => "foo", "version" => "latest", "git" => "example.com/foo.git" }
+  ] }
+  let(:meta) { { "foo" => "bar" } }
+  let(:manifest) { {
+    "name" => name,
+    "director_uuid" => uuid,
+    "templates" => templates,
+    "releases" => releases,
+    "meta" => meta,
+  } }
+
+  context "invalid manifest" do
+    let(:invalid_manifest) { manifest.tap { |m| m.delete(missing) } }
+    let(:manifest_file) { get_tmp_file_path(invalid_manifest.to_yaml) }
+
+    before do
+      subject.validate
+      expect(subject).to_not be_valid
+    end
+
+    context "not a hash" do
+      let(:invalid_manifest) { "foo" }
+      it "raises an error" do
+        expect(subject.errors).to eq ["Manifest should be a hash"]
+      end
+    end
+
+    context "missing name" do
+      let(:missing) { "name" }
+      it "raises an error" do
+        expect(subject.errors).to eq ["Manifest should contain a name"]
+      end
+    end
+
+    context "missing director_uuid" do
+      let(:missing) { "director_uuid" }
+      it "raises an error" do
+        expect(subject.errors).to eq ["Manifest should contain a director_uuid"]
+      end
+    end
+
+    context "missing templates" do
+      let(:missing) { "templates" }
+      it "raises an error" do
+        expect(subject.errors).to eq ["Manifest should contain templates"]
+      end
+    end
+
+    context "missing releases" do
+      let(:missing) { "releases" }
+      it "raises an error" do
+        expect(subject.errors).to eq ["Manifest should contain releases"]
+      end
+    end
+
+    context "missing meta" do
+      let(:missing) { "meta" }
+      it "raises an error" do
+        expect(subject.errors).to eq ["Manifest should contain meta hash"]
+      end
+    end
+  end
+
+  context "valid manifest" do
+    it "has properties" do
+      subject.validate
+      expect(subject).to be_valid
+      expect(subject.name).to eq name
+      expect(subject.director_uuid).to eq uuid
+      expect(subject.templates).to eq templates
+      expect(subject.releases).to eq releases
+      expect(subject.meta).to eq meta
+    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\//
+    end
+  end
+end

data/spec/helpers/project_deployment_helper_spec.rb

@@ -0,0 +1,191 @@
+describe Bosh::Manifests::ProjectDeploymentHelper do
+  class HelperTester
+    include Bosh::Manifests::ProjectDeploymentHelper
+
+    attr_reader :director, :deployment
+
+    def initialize(director, deployment, project_deployment = nil)
+      @director = director
+      @deployment = deployment
+      @project_deployment = project_deployment
+    end
+  end
+
+  subject { project_deployment_helper }
+  let(:project_deployment_helper) { HelperTester.new(director, deployment) }
+  let(:deployment) { nil }
+  let(:director) { instance_double('Bosh::Cli::Client::Director') }
+  let(:work_dir) { asset_dir("manifests-repo") }
+  let(:project_deployment) { instance_double("DeploymentManifest") }
+
+  describe "project_deployment?" do
+    subject { project_deployment_helper.project_deployment? }
+    let(:deployment) { File.join work_dir, deployment_path }
+
+    context "deployment" do
+      context "without associated project deployment" do
+        let(:deployment_path) { "deployments/bar.yml" }
+        it { should be_false }
+      end
+      context "with associated project deployment" do
+        let(:deployment_path) { ".manifests/foo.yml" }
+        it { should be_true }
+      end
+    end
+
+    context "project deployment" do
+      let(:deployment_path) { "deployments/foo.yml" }
+      it { should be_true }
+    end
+  end
+
+  describe "#project_deployment(=)" do
+    let(:deployment) { File.join work_dir, deployment_path }
+    let(:deployment_path) { "deployments/foo.yml" }
+
+    before do
+      Bosh::Manifests::DeploymentManifest.should_receive(:new)
+        .with(deployment).and_return(project_deployment)
+    end
+
+    it "loads deployment manifest" do
+      expect(subject.project_deployment).to eq project_deployment
+    end
+
+    it "memoizes deployment manifest" do
+      subject.project_deployment = deployment
+      expect(subject.project_deployment).to eq project_deployment
+    end
+  end
+
+  describe "#project_deployment_file?" do
+    subject do
+      project_deployment_helper.project_deployment_file? deployment_file
+    end
+    let(:deployment_file) { get_tmp_file_path(content.to_yaml) }
+
+    context "project deployment" do
+      let(:content) { { "name" => "foo", "templates" => ["bar.yml"] } }
+      it { should be_true }
+    end
+
+    context "normal deployment" do
+      let(:content) { { "name" => "foo" } }
+      it { should be_false }
+    end
+  end
+
+  describe "#require_project_deployment" do
+    before do
+      subject.should_receive(:project_deployment?)
+        .and_return(:is_project_deployment)
+    end
+
+    context "project deployment" do
+      let(:is_project_deployment) { true }
+      it "validates & builds" do
+        subject.should_receive(:validate_project_deployment)
+        subject.require_project_deployment
+      end
+    end
+
+    context "normal deployment" do
+      let(:deployment) { "foo" }
+      let(:is_project_deployment) { false }
+      it "raises and error" do
+        expect { subject.require_project_deployment }.to raise_error /foo/
+      end
+    end
+  end
+
+  describe "#create_placeholder_deployment" do
+    subject { project_deployment_helper.create_placeholder_deployment }
+    let(:project_deployment_helper) do
+      HelperTester.new(director, deployment, project_deployment)
+    end
+    let(:deployment) { "deployments/bar.yml" }
+    let(:file) { instance_double('File') }
+    let(:merged_file) { ".deployments/bar.yml" }
+    let(:uuid) { "8451a282-4073" }
+    let(:content) { "director_uuid #{uuid}" }
+
+    it "creates placeholder deployment" do
+      project_deployment_helper.should_receive(:resolve_director_uuid)
+      project_deployment.should_receive(:merged_file).and_return(merged_file)
+      project_deployment.should_receive(:file).and_return(deployment)
+      project_deployment.should_receive(:director_uuid).and_return(uuid)
+      File.should_receive(:open).with(merged_file, "w").and_yield(file)
+      file.should_receive(:write).with(/#{uuid}\s# Don't edit/)
+      subject
+    end
+  end
+
+  describe "#validate_project_deployment" do
+    let(:project_deployment_helper) do
+      HelperTester.new(director, deployment, project_deployment)
+    end
+
+    it "raises an error" do
+      project_deployment.should_receive(:valid?).and_return(false)
+      project_deployment.should_receive(:errors).and_return(["foo"])
+      project_deployment.should_receive(:file).and_return(["foo.yml"])
+      expect { subject.validate_project_deployment }.to raise_error /foo/
+    end
+  end
+
+  describe "#build_project_deployment" do
+    subject { project_deployment_helper.build_project_deployment }
+    let(:project_deployment_helper) do
+      HelperTester.new(director, deployment, project_deployment)
+    end
+
+    it "builds project deployment manifest" do
+      project_deployment_helper.should_receive(:resolve_director_uuid)
+      project_deployment_helper.should_receive(:work_dir).and_return(work_dir)
+      Bosh::Manifests::ManifestBuilder.should_receive(:build)
+        .with(project_deployment, work_dir)
+      subject
+    end
+  end
+
+  describe "#resolve_director_uuid" do
+    subject { project_deployment_helper.resolve_director_uuid }
+    let(:project_deployment_helper) do
+      HelperTester.new(director, deployment, project_deployment)
+    end
+    let(:status) { { "uuid" => current_uuid, "cpi" => cpi } }
+    let(:current_uuid) { "current-uuid" }
+
+    before do
+      project_deployment.should_receive(:director_uuid).and_return(uuid)
+      director.stub(:get_status).and_return(status)
+    end
+
+    context "using the warden cpi" do
+      let(:cpi) { "warden" }
+
+      context "with director uuid current" do
+        let(:uuid) { "current" }
+        it "builds manifest" do
+          project_deployment.should_receive(:director_uuid=).with(current_uuid)
+          subject
+        end
+      end
+
+      context "with director uuid" do
+        let(:uuid) { "8451a282-4073" }
+        it "builds manifest" do
+          subject
+        end
+      end
+    end
+
+    context "and without warden cpi" do
+      let(:uuid) { "current" }
+      let(:cpi) { "not-warden" }
+      it "raises an error" do
+        expect { subject }.to  raise_error /may not be used in production/
+      end
+    end
+  end
+end

data/spec/helpers/spiff_helper_spec.rb

@@ -0,0 +1,55 @@
+describe Bosh::Manifests::SpiffHelper do
+  describe ".spiff" do
+    class SpiffHelperTester
+      include Bosh::Manifests::SpiffHelper
+    end
+    subject { SpiffHelperTester.new }
+    let(:path) { asset_dir("bin") }
+    let(:templates) { ["foo.yml", "bar.yml"] }
+    let(:target_file) { "spiffed_manifest.yml" }
+
+    around do |example|
+      original_path = ENV["PATH"]
+      ENV["PATH"] = path
+      example.run
+      ENV["PATH"] = original_path
+    end
+
+    before do
+      subject.should_receive(:sh).and_yield(result)
+    end
+
+    context "spiff not in path" do
+      let(:path) { asset_dir("empty_bin") }
+      let(:result) { Bosh::Exec::Result.new("spiff", "", 0, true) }
+
+      it "raises an error" do
+        expect{ subject.spiff_merge templates, target_file }
+          .to raise_error /make sure spiff is installed/
+      end
+    end
+
+    context "spiff error" do
+      let(:path) { asset_dir("empty_bin") }
+      let(:result) { Bosh::Exec::Result.new("spiff", "spiff error", 1, false) }
+
+      it "raises an error" do
+        subject.should_receive(:say).with(/Command failed/)
+        expect{ subject.spiff_merge templates, target_file }
+          .to raise_error /spiff error/
+      end
+    end
+
+    describe ".merge" do
+      let(:file) { instance_double("File") }
+      let(:output) { "---\n{}" }
+      let(:result) { Bosh::Exec::Result.new("spiff", output, 0, false) }
+
+      it "merges manifests" do
+        File.should_receive(:open).with(target_file, 'w').and_yield(file)
+        file.should_receive(:write).with(output)
+        subject.spiff_merge templates, target_file
+      end
+    end
+  end
+end

data/spec/manifest_builder_spec.rb

@@ -0,0 +1,88 @@
+describe Bosh::Manifests::ManifestBuilder do
+  let(:manifest) { instance_double("Bosh::Manifests::Manifest") }
+  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 }
+    let(:manifest_builder) {
+      instance_double("Bosh::Manifests::ManifestBuilder") }
+
+    it "creates builder and merges templates" do
+      Bosh::Manifests::ManifestBuilder.should_receive(:new)
+        .with(manifest, 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 }
+
+    before do
+      manifest.should_receive(:templates).and_return(templates)
+      File.should_receive(:exists?).with(template_path)
+        .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/
+      end
+    end
+
+    context "template exists" do
+      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)
+      end
+
+      context "no hidden dirs" do
+        let(:dir_exists) { false }
+        it "creates hidden dirs" do
+          subject.stub(:spiff_merge)
+          Dir.should_receive(:mkdir).with(/.stubs/)
+          subject.merge_templates
+        end
+      end
+
+      it "generates manifest with spiff" do
+        subject.should_receive(:spiff_merge)
+          .with([template_path, meta_file_path], target_file)
+        subject.merge_templates
+      end
+    end
+  end
+end

data/spec/release_manager_spec.rb

@@ -0,0 +1,17 @@
+describe Bosh::Manifests::ReleaseManager do
+  let(:releases) { [ release_data ] }
+  let(:release_data)  { { "name" => "foo" } }
+  let(:work_dir) { asset_dir("manifests-repo") }
+  let(:releases_dir) { File.join(work_dir, ".releases") }
+  let(:release) { instance_double("Bosh::Manifests::Release") }
+  subject { Bosh::Manifests::ReleaseManager.new(releases, work_dir) }
+
+  describe "#update_release_repos" do
+    it "invokes checkout_current_version" do
+      Bosh::Manifests::Release.should_receive(:new)
+        .with(release_data, releases_dir).and_return(release)
+      release.should_receive(:checkout_current_version)
+      subject.update_release_repos
+    end
+  end
+end

data/spec/release_spec.rb

@@ -0,0 +1,74 @@
+describe Bosh::Manifests::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 }
+
+  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/
+      end
+    end
+
+    context "specific version" do
+      let(:version) { "2" }
+
+      it "checks out repo" do
+        release.checkout_current_version
+        expect(subject).to match /foo-2.yml/
+      end
+    end
+
+    context "non existing version " do
+      let(:version) { "12" }
+
+      it "raises an error" do
+        expect { release.checkout_current_version }.
+          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
+      end
+
+      it "version 3" do
+        release.checkout_current_version
+        expect(subject).to match /foo-3.yml/
+      end
+    end
+
+    context "multiple releases" do
+      let(:version) { "3" }
+
+      before do
+        data = { "name" => "bar", "version" => 2, "git" => repo }
+        other_release = Bosh::Manifests::Release.new(data, releases_dir)
+        other_release.checkout_current_version
+      end
+
+      it "version 3" do
+        release.checkout_current_version
+        expect(subject).to match /foo-3.yml/
+      end
+    end
+  end
+
+  after do
+    FileUtils.rm_r releases_dir
+  end
+
+  after(:all) do
+    FileUtils.rm_r repo
+  end
+end