bosh-workspace 0.7.0 → 0.8.0

data/spec/assets/dns/networks-manual.yml

@@ -0,0 +1,19 @@
+---
+networks:
+  - name: floating
+    type: vip
+    cloud_properties: {}
+  - name: default
+    type: manual
+    subnets:
+      - name: private
+        range: 10.0.0.0/24
+        gateway: 10.0.0.254
+        reserved:
+          - 10.0.0.1 - 10.0.0.10
+        static:
+          - 10.0.0.50 - 10.0.0.100
+        cloud_properties:
+          net_id: 1202c961-504d-4afb-b044-623787746307
+
+jobs: []

data/spec/assets/dns/networks-no-manual.yml

@@ -0,0 +1,18 @@
+---
+networks:
+  - name: floating
+    type: vip
+    cloud_properties: {}
+  - name: default
+    subnets:
+      - name: private
+        range: 10.0.0.0/24
+        gateway: 10.0.0.254
+        reserved:
+          - 10.0.0.1 - 10.0.0.10
+        static:
+          - 10.0.0.50 - 10.0.0.100
+        cloud_properties:
+          net_id: 1202c961-504d-4afb-b044-623787746307
+
+jobs: []

data/spec/assets/dns/properties.yml

@@ -0,0 +1,29 @@
+name: foo
+
+networks:
+  - name: default
+    type: manual
+
+jobs:
+- name: first_job_az1
+  networks:
+  - name: default
+    static_ips:
+    - 10.0.0.50
+
+- name: second_job_az1
+  networks:
+  - name: default
+    static_ips:
+    - 10.0.0.51
+    - 10.0.0.52
+
+properties:
+  job1:
+    foo: bar
+    address: 10.0.0.50
+  job2:
+    machines: 
+      - 10.0.0.51
+      - 10.0.0.52
+    

data/spec/commands/prepare_spec.rb

@@ -0,0 +1,99 @@
+require "bosh/cli/commands/prepare"
+
+describe Bosh::Cli::Command::Prepare do
+  describe "#prepare" do
+    let(:command) { Bosh::Cli::Command::Prepare.new }
+    let(:release) do
+      instance_double("Bosh::Workspace::Release",
+        name: "foo", version: "1", repo_dir: ".releases/foo",
+        name_version: "foo/1", manifest_file: "releases/foo-1.yml")
+    end
+    let(:stemcell) do
+      instance_double("Bosh::Workspace::Stemcell",
+        name: "bar", version: "2", name_version: "bar/2",
+        file: ".stemcesll/bar-2.tgz", file_name: "bar-2.tgz")
+    end
+
+    before do
+      command.stub(:require_project_deployment)
+      command.stub(:auth_required)
+      command.stub(:project_deployment_releases).and_return(releases)
+      command.stub(:project_deployment_stemcells).and_return(stemcells)
+    end
+
+    describe "prepare_release(s/_repos)" do
+      let(:releases) { [ release ] }
+      let(:stemcells) { [] }
+
+      before do
+        release.should_receive(:update_repo) 
+        command.should_receive(:release_uploaded?)
+          .with(release.name, release.version).and_return(release_uploaded)
+      end
+
+      context "release uploaded" do
+        let(:release_uploaded) { true }
+
+        it "does not upload the release" do
+          command.should_not_receive(:release_upload)
+          command.prepare
+        end
+      end
+
+      context "release not uploaded" do
+        let(:release_uploaded) { false }
+
+        it "does not upload the release" do
+          command.should_receive(:release_upload).with(release.manifest_file)
+          command.prepare
+        end
+      end
+    end
+
+    describe "prepare_stemcells" do
+      let(:releases) { [] }
+      let(:stemcells) { [ stemcell ] }
+
+      before do
+        command.should_receive(:stemcell_uploaded?)
+          .with(stemcell.name, stemcell.version).and_return(stemcell_uploaded)
+      end
+
+      context "stemcell uploaded" do
+        let(:stemcell_uploaded) { true }
+      
+        it "does not upload the stemcell" do
+          command.should_not_receive(:stemcell_download)
+          command.should_not_receive(:stemcell_upload)
+          command.prepare
+        end
+      end
+
+      context "stemcell not uploaded" do
+        let(:stemcell_uploaded) { false }
+
+        before { stemcell.should_receive(:downloaded?).and_return(stemcell_downloaded) }
+
+        context "stemcell downloaded" do
+          let(:stemcell_downloaded) { true }
+
+          it "does not upload the stemcell" do
+            command.should_not_receive(:stemcell_download)
+            command.should_receive(:stemcell_upload).with(stemcell.file)
+            command.prepare
+          end
+        end
+
+        context "stemcell downloaded" do
+          let(:stemcell_downloaded) { false }
+
+          it "does not upload the stemcell" do
+            command.should_receive(:stemcell_download).with(stemcell.file_name)
+            command.should_receive(:stemcell_upload).with(stemcell.file)
+            command.prepare
+          end
+        end
+      end
+    end
+  end
+end

data/spec/commands/{command_make_manifest_spec.rb → project_deployment_spec.rb}

@@ -1,9 +1,9 @@
-require "bosh/cli/commands/01_make_manifest"
+require "bosh/cli/commands/project_deployment"
 
-describe Bosh::Cli::Command::Manifests do
-  let(:command) { Bosh::Cli::Command::Manifests.new }
+describe Bosh::Cli::Command::ProjectDeployment do
+  let(:command) { Bosh::Cli::Command::ProjectDeployment.new }
   let(:project_deployment) do
-    instance_double("Bosh::Manifests::DeploymentManifest")
+    instance_double("Bosh::Workspace::DeploymentManifest")
   end
 
   let(:deployment_cmd) { instance_double("Bosh::Cli::Command::Deployment") }
@@ -56,25 +56,6 @@ describe Bosh::Cli::Command::Manifests do
     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 }
 

data/spec/helpers/dns_helper_spec.rb

@@ -0,0 +1,59 @@
+describe Bosh::Workspace::DnsHelper do
+  describe ".transform" do
+    subject do
+      Bosh::Workspace::DnsHelper.transform(generated_manifest, domain_name)
+      YAML.load(IO.read(generated_manifest))
+    end
+
+    let(:generated_manifest) { get_tmp_file_path(content) }
+    let(:domain_name) { "microbosh" }
+
+    context "networks" do
+      let(:content) { asset_file("dns/networks-manual.yml") }
+
+      it "replaces manual networks" do
+        expect(subject["networks"][1]["type"]).to eq "dynamic"
+      end
+    end
+
+    context "no manual networks" do
+      let(:content) { asset_file("dns/networks-no-manual.yml") }
+
+      it "raises an error" do
+        expect { subject }.to raise_error /Missing manual network/
+      end
+    end
+
+    context "jobs" do
+      let(:content) { asset_file("dns/jobs.yml") }
+
+      it "removes static_ips of jobs with manual networks" do
+        expect(subject["jobs"][0]["networks"][0]).to_not include "static_ips"
+        expect(subject["jobs"][1]["networks"][0]).to_not include "static_ips"
+      end
+    end
+
+    context "properties" do
+      let(:content) { asset_file("dns/properties.yml") }
+
+      it "replaces ips with domains while keeping properties structure" do
+        expect(subject["properties"]["job1"]["address"])
+          .to eq "0.first-job-az1.default.foo.microbosh"
+        expect(subject["properties"]["job1"]["foo"]).to eq "bar"
+        expect(subject["properties"]["job2"]["machines"])
+          .to eq ["0.second-job-az1.default.foo.microbosh",
+                  "1.second-job-az1.default.foo.microbosh"]
+      end
+    end
+
+    context "job properties" do
+      let(:content) { asset_file("dns/job-properties.yml") }
+
+      it "replaces ips with domains while keeping properties structure" do
+        expect(subject["jobs"][1]["properties"]["job1"]["address"])
+          .to eq "0.first-job-az1.default.foo.microbosh"
+        expect(subject["jobs"][1]["properties"]["job1"]["foo"]).to eq "bar"
+      end
+    end
+  end
+end

data/spec/helpers/project_deployment_helper_spec.rb

@@ -1,6 +1,6 @@
-describe Bosh::Manifests::ProjectDeploymentHelper do
-  class HelperTester
-    include Bosh::Manifests::ProjectDeploymentHelper
+describe Bosh::Workspace::ProjectDeploymentHelper do
+  class ProjectDeploymentHelperTester
+    include Bosh::Workspace::ProjectDeploymentHelper
 
     attr_reader :director, :deployment
 
@@ -12,14 +12,17 @@ describe Bosh::Manifests::ProjectDeploymentHelper do
   end
 
   subject { project_deployment_helper }
-  let(:project_deployment_helper) { HelperTester.new(director, deployment) }
+  let(:project_deployment_helper) do
+    ProjectDeploymentHelperTester.new(director, deployment, project_deployment)
+  end
   let(:deployment) { nil }
   let(:director) { instance_double('Bosh::Cli::Client::Director') }
   let(:work_dir) { asset_dir("manifests-repo") }
-  let(:project_deployment) { instance_double("DeploymentManifest") }
+  let(:project_deployment) { instance_double("ProjectDeployment") }
 
   describe "project_deployment?" do
     subject { project_deployment_helper.project_deployment? }
+    let(:project_deployment_helper) { ProjectDeploymentHelperTester.new(director, deployment) }
     let(:deployment) { File.join work_dir, deployment_path }
 
     context "deployment" do
@@ -40,11 +43,12 @@ describe Bosh::Manifests::ProjectDeploymentHelper do
   end
 
   describe "#project_deployment(=)" do
+    let(:project_deployment_helper) { ProjectDeploymentHelperTester.new(director, deployment) }
     let(:deployment) { File.join work_dir, deployment_path }
     let(:deployment_path) { "deployments/foo.yml" }
 
     before do
-      Bosh::Manifests::DeploymentManifest.should_receive(:new)
+      Bosh::Workspace::ProjectDeployment.should_receive(:new)
         .with(deployment).and_return(project_deployment)
     end
 
@@ -76,6 +80,8 @@ describe Bosh::Manifests::ProjectDeploymentHelper do
   end
 
   describe "#require_project_deployment" do
+    let(:project_deployment_helper) { ProjectDeploymentHelperTester.new(director, deployment) }
+
     before do
       subject.should_receive(:project_deployment?)
         .and_return(:is_project_deployment)
@@ -93,16 +99,13 @@ describe Bosh::Manifests::ProjectDeploymentHelper do
       let(:deployment) { "foo" }
       let(:is_project_deployment) { false }
       it "raises and error" do
-        expect { subject.require_project_deployment }.to raise_error /foo/
+        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" }
@@ -121,38 +124,36 @@ describe Bosh::Manifests::ProjectDeploymentHelper do
   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/
+      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
+    let(:domain_name) { "bosh" }
+    let(:merged_file) { "foo/bar" }
 
     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)
+      project_deployment.should_receive(:domain_name).and_return(domain_name)
+      project_deployment.should_receive(:merged_file).and_return(merged_file)
+
+      Bosh::Workspace::ManifestBuilder.should_receive(:build)
         .with(project_deployment, work_dir)
+      Bosh::Workspace::DnsHelper.should_receive(:transform)
+        .with(merged_file, domain_name)
+
       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" }
 
@@ -184,7 +185,7 @@ describe Bosh::Manifests::ProjectDeploymentHelper do
       let(:uuid) { "current" }
       let(:cpi) { "not-warden" }
       it "raises an error" do
-        expect { subject }.to  raise_error /may not be used in production/
+        expect { subject }.to  raise_error(/may not be used in production/)
       end
     end
   end

data/spec/helpers/release_helper_spec.rb

@@ -0,0 +1,76 @@
+describe Bosh::Workspace::ReleaseHelper do
+  class ReleaseHelperTester
+    include Bosh::Workspace::ReleaseHelper
+
+    attr_reader :director, :work_dir
+
+    def initialize(director, work_dir)
+      @director = director
+      @work_dir = work_dir
+    end
+  end
+
+  subject { release_helper }
+  let(:release_helper) { ReleaseHelperTester.new(director, work_dir) }
+  let(:director) { instance_double('Bosh::Cli::Client::Director') }
+  let(:work_dir) { asset_dir("manifests-repo") }
+
+  describe "#release_upload" do
+    let(:release_cmd) { instance_double("Bosh::Cli::Command::Release") }
+    before { Bosh::Cli::Command::Release.stub(:new).and_return(release_cmd) }
+    
+    let(:manifest_file) { "foo-1.yml." }
+    subject { release_helper.release_upload(manifest_file) }
+      
+    it "uploads release" do
+      release_cmd.should_receive(:upload).with(manifest_file)
+      subject
+    end
+  end
+
+  describe "#release_uploaded?" do
+    let(:releases) { { "versions" => %w(1 2 3) } }
+    subject { release_helper.release_uploaded?("foo", version) }
+    before { director.should_receive(:get_release).with("foo").and_return(releases) }
+
+    context "release exists" do
+      let(:version) { 2 }
+      it { should be_true }
+    end
+
+    context "release not found" do
+      let(:version) { "8" }
+      it { should be_false }
+    end
+  end
+  
+  describe "#release_dir" do
+    let(:releases_dir) { File.join(work_dir, ".releases") }
+    subject { release_helper.releases_dir }
+    
+    before { FileUtils.should_receive(:mkdir_p).once.with(releases_dir).and_return([releases_dir]) }
+
+    it { should eq releases_dir }
+
+    it "memoizes" do
+      subject
+      expect(subject).to eq releases_dir
+    end
+  end
+
+  describe "#project_deployment_releases" do
+    subject { release_helper.project_deployment_releases }
+    let(:release) { instance_double("Bosh::Workspace::Release") }
+    let(:release_data) { { name: "foo" } }
+    let(:releases) { [release_data, release_data] }
+
+    before { release_helper.stub_chain("project_deployment.releases").and_return(releases) }
+
+    it "inits releases once" do
+      Bosh::Workspace::Release.should_receive(:new).twice
+        .with(release_data, /\/.releases/).and_return(release)
+      subject
+      expect(subject).to eq [release, release]
+    end
+  end
+end