bosh_cli 0.16

data/spec/unit/director_task_spec.rb

@@ -0,0 +1,48 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+require "spec_helper"
+
+describe Bosh::Cli::DirectorTask do
+
+  before :each do
+    @director = Bosh::Cli::Director.new("http://target", "user", "pass")
+  end
+
+  it "tracks partial output responses from director" do
+    @task = Bosh::Cli::DirectorTask.new(@director, 10)
+
+    @director.stub!(:get).
+      with("/tasks/10/output", nil, nil, "Range" => "bytes=0-").
+      and_return([206, "test\nout", { :content_range => "bytes 0-7/100" }])
+
+    @director.stub!(:get).
+      with("/tasks/10/output", nil, nil, "Range" => "bytes=8-").
+      and_return([206, "put", { :content_range => "bytes 8-10/100" }])
+
+    @director.stub!(:get).
+      with("/tasks/10/output", nil, nil, "Range" => "bytes=11-").
+      and_return([206, " success\n", { :content_range => "bytes 11-19/100" }])
+
+    @director.stub!(:get).
+      with("/tasks/10/output", nil, nil, "Range" => "bytes=20-").
+      and_return([416, "done", {}])
+
+    @task.output.should == "test\n"
+    @task.output.should == nil     # No newline yet
+    @task.output.should == "output success\n" # Got a newline
+    @task.output.should == "done\n" # Flushed
+  end
+
+  it "supports explicit output flush" do
+    @task = Bosh::Cli::DirectorTask.new(@director, 10)
+
+    @director.stub!(:get).
+      with("/tasks/10/output", nil, nil, "Range" => "bytes=0-").
+      and_return([206, "test\nout", { :content_range => "bytes 0-7/100" }])
+
+    @task.output.should == "test\n"
+    @task.flush_output.should == "out\n"
+    # Nothing in buffer at this point
+    @task.flush_output.should == nil
+  end
+end

data/spec/unit/event_log_renderer_spec.rb

@@ -0,0 +1,171 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+require "spec_helper"
+
+describe Bosh::Cli::EventLogRenderer do
+
+  def make_event(stage, task, index, total,
+      state = "started", tags = [], progress = 0)
+    event = {
+      "time"  => Time.now.to_i,
+      "stage" => stage,
+      "task"  => task,
+      "index" => index,
+      "total" => total,
+      "state" => state,
+      "tags"  => tags,
+      "progress" => progress
+    }
+    JSON.generate(event)
+  end
+
+  def make_renderer(*args)
+    Bosh::Cli::EventLogRenderer.new(*args)
+  end
+
+  it "allows adding events" do
+    renderer = make_renderer
+    renderer.add_event(make_event("Preparing", "Binding release",
+                                  1, 9, "started"))
+    renderer.add_event(make_event("Preparing", "Binding existing deployment",
+                                  2, 9, "started"))
+    renderer.events_count.should == 2
+  end
+
+  it "silently ignores malformed events" do
+    renderer = make_renderer
+    renderer.add_event(make_event(nil, "Binding release", 1, 9, nil, []))
+    renderer.add_event(make_event("Preparing", "Binding existing deployment",
+                                  2, nil, nil))
+    renderer.add_event(JSON.generate("a" => "b"))
+    renderer.events_count.should == 0
+  end
+
+  it "sets current stage based on the most recent event " +
+     "but ignores events from non-current stages" do
+    renderer = make_renderer
+    renderer.add_event(make_event("Preparing", "Binding release", 1, 9))
+    renderer.current_stage.should == "Preparing"
+    renderer.add_event(make_event("Preparing", "Binding existing deployment",
+                                  2, 9))
+    renderer.current_stage.should == "Preparing"
+    renderer.add_event(make_event("Updating resource pool",
+                                  "Deleting outdated VM", 1, 5))
+    renderer.current_stage.should == "Updating resource pool"
+    renderer.events_count.should == 3
+    renderer.add_event(make_event("Preparing", "Some additional stuff", 3, 9))
+    renderer.current_stage.should == "Updating resource pool"
+    renderer.events_count.should == 3
+    renderer.add_event(make_event("Updating job router", "Canary update", 1, 1))
+    renderer.current_stage.should == "Updating job router"
+    renderer.events_count.should == 4
+  end
+
+  it "can render event log with progress bar" do
+    buf = StringIO.new
+    Bosh::Cli::Config.output = buf
+
+    renderer = make_renderer
+    renderer.add_event(make_event("Preparing", "Binding release", 1, 9))
+
+    lines = renderer.render.split("\n")
+
+    lines.count.should == 3
+    lines[1].should == "Preparing"
+    lines[2].should =~ /Binding release/
+    lines[2].should =~ /\|\s+\| 0\/9/
+
+    renderer.add_event(make_event("Preparing", "Moving stuff", 2, 9))
+
+    lines = renderer.render.split("\n")
+    lines.count.should == 1
+    lines[0].should =~ /Binding release/
+    lines[0].should =~ /\|\s+\| 0\/9/
+
+    renderer.add_event(make_event("Preparing", "Moving stuff",
+                                  2, 9, "finished"))
+
+    lines = renderer.render.split("\n")
+    lines.count.should == 2
+    lines[0].should =~ /moving stuff/
+    lines[1].should =~ /Binding release/
+    lines[1].should =~ /\|o+\s+\| 1\/9/
+
+    # throwing in out-of-order event
+    renderer.add_event(make_event("Preparing", "Binding release",
+                                  1, 9, "finished"))
+
+    (3..9).each do |i|
+      renderer.add_event(make_event("Preparing", "event #{i}",
+                                    i, 9))
+      renderer.add_event(make_event("Preparing", "event #{i}",
+                                    i, 9, "finished"))
+    end
+
+    lines = renderer.render.split("\n")
+    lines.count.should == 9
+    lines[-1].should =~ /\|o+\| 9\/9/
+
+    renderer.add_event(make_event("Updating", "prepare update",
+                                  1, 2, "started", ["stuff", "thing"]))
+
+    lines = renderer.render.split("\n")
+    lines.count.should == 4
+
+    lines[0].should =~ /Done/
+    lines[0].should =~ /9\/9/
+    lines[1].should == ""
+    lines[2].should == "Updating %s" % ["stuff, thing".green]
+    lines[3].should =~ /0\/2/
+
+    lines = renderer.finish(:done).split("\n")
+    lines[0].should =~ /Done/
+    lines[0].should =~ /2\/2/
+  end
+
+  it "renders erorr state properly" do
+    buf = StringIO.new
+    Bosh::Cli::Config.output = buf
+
+    renderer = make_renderer
+    renderer.add_event(make_event("Preparing", "Binding release", 1, 9))
+    renderer.add_event(make_event("Preparing", "Moving stuff", 2, 9))
+    renderer.add_event(make_event("Preparing", "Moving stuff", 2, 9, "finished"))
+    renderer.add_event(make_event("Updating", "prepare update",
+                                  1, 2, "started", ["stuff", "thing"]))
+
+    lines = renderer.finish(:error).split("\n")
+    lines[-1].should =~ /Error/
+    lines[-1].should =~ /0\/2/
+  end
+
+  it "supports tracking individual tasks progress" do
+    renderer = make_renderer
+    renderer.add_event(make_event("Preparing", "Binding release",
+                                  1, 2, "started", [], 0))
+    renderer.add_event(make_event("Preparing", "Binding release",
+                                  1, 2, "in_progress", [], 25))
+
+    lines = renderer.render.split("\n")
+
+    lines[1].should =~ /Preparing/
+    lines[2].should =~ /\|o+\s+\| 0\/2/
+    lines[2].should =~ /Binding release/
+
+    renderer.add_event(make_event("Preparing", "Binding release",
+                                  1, 2, "in_progress", [], 50))
+
+    lines = renderer.render.split("\n")
+
+    lines[0].should =~ /\|o+\s+\| 0\/2/
+    lines[0].should =~ /Binding release/
+
+    renderer.add_event(make_event("Preparing", "Binding release",
+                                  1, 2, "finished", []))
+
+    lines = renderer.render.split("\n")
+    lines[1].should_not =~ /Binding release/
+    lines[1].should =~ /\|o+\s+\| 1\/2/
+  end
+
+end

data/spec/unit/hash_changeset_spec.rb

@@ -0,0 +1,73 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+require "spec_helper"
+
+describe Bosh::Cli::HashChangeset do
+
+  def changeset(m1, m2)
+    cs = Bosh::Cli::HashChangeset.new
+    cs.add_hash(m1, :old)
+    cs.add_hash(m2, :new)
+    cs
+  end
+
+  it "contains changeset for two hashes" do
+    m1 = {
+      :foo => {
+        :bar => 1,
+        :baz => "purr",
+        :nc => "nc",
+        :properties => {
+          :a => "1",
+          :b => "2",
+          :c => "3"
+        },
+        :arr => %w(a b c)
+      },
+      :arr => [1, 2, 3],
+      :zb => { :a => 2, :b => 3}
+    }
+
+    m2 = {
+      :foo => {
+        :bar => 2,
+        :baz => "meow",
+        :nc => "nc",
+        :properties => {
+          :a => "2",
+          :d => "7",
+          :c => 3
+        },
+        :arr => %w(a b c d e)
+      },
+      :arr => [1, 2, 3],
+      :zb => "test"
+    }
+
+    mc = changeset(m1, m2)
+
+    mc[:foo][:bar].changed?.should be_true
+    mc[:foo][:bar].old.should == 1
+    mc[:foo][:bar].new.should == 2
+
+    mc[:foo][:baz].changed?.should be_true
+    mc[:foo][:baz].old.should == "purr"
+    mc[:foo][:baz].new.should == "meow"
+
+    mc[:foo][:nc].changed?.should be_false
+    mc[:foo][:nc].same?.should be_true
+    mc[:foo][:nc].old.should == "nc"
+    mc[:foo][:nc].new.should == "nc"
+
+    mc[:foo][:properties][:a].changed?.should be_true
+    mc[:foo][:properties][:b].removed?.should be_true
+    mc[:foo][:properties][:c].mismatch?.should be_true
+    mc[:foo][:properties][:d].added?.should be_true
+
+    mc[:foo][:arr].changed?.should be_true
+    mc[:arr].same?.should be_true
+
+    mc[:zb].mismatch?.should be_true
+  end
+
+end

data/spec/unit/job_builder_spec.rb

@@ -0,0 +1,454 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+require "spec_helper"
+
+describe Bosh::Cli::JobBuilder do
+
+  before(:each) do
+    @release_dir = Dir.mktmpdir
+  end
+
+  def new_builder(name, packages = [], templates = { }, built_packages = [],
+      create_spec = true, final = false, blobstore = mock("blobstore"))
+    # Workaround for Hash requirement
+    if templates.is_a?(Array)
+      templates = templates.inject({ }) { |h, e| h[e] = e; h }
+    end
+
+    spec = {
+      "name"       => name,
+      "packages"   => packages,
+      "templates"  => templates
+    }
+    add_spec(name) if create_spec
+
+    Bosh::Cli::JobBuilder.new(spec, @release_dir,
+                              final, blobstore, built_packages)
+  end
+
+  def add_file(job_name, file, contents = nil)
+    job_dir = File.join(@release_dir, "jobs", job_name)
+    file_path = File.join(job_dir, file)
+    FileUtils.mkdir_p(File.dirname(file_path))
+    FileUtils.touch(file_path)
+    if contents
+      File.open(file_path, "w") { |f| f.write(contents) }
+    end
+  end
+
+  def add_spec(job_name)
+    add_file(job_name, "spec")
+  end
+
+  def add_monit(job_name, file="monit")
+    add_file(job_name, file)
+  end
+
+  def add_templates(job_name, *files)
+    job_template_path = File.join(@release_dir, "jobs", job_name, "templates")
+    FileUtils.mkdir_p(job_template_path)
+
+    files.each do |file|
+      add_file(job_name, "templates/#{file}")
+    end
+  end
+
+  def remove_templates(job_name, *files)
+    job_template_path = File.join(@release_dir, "jobs", job_name, "templates")
+
+    files.each do |file|
+      FileUtils.rm_rf(File.join(job_template_path, file))
+    end
+  end
+
+  it "creates a new builder" do
+    add_templates("foo", "a.conf", "b.yml")
+    add_monit("foo")
+    builder = new_builder("foo", ["foo", "bar", "baz"],
+                          ["a.conf", "b.yml"], ["foo", "bar", "baz"])
+    builder.packages.should    == ["foo", "bar", "baz"]
+    builder.templates.should     =~ ["a.conf", "b.yml"]
+    builder.release_dir.should == @release_dir
+  end
+
+  it "has a fingerprint" do
+    add_templates("foo", "a.conf", "b.yml")
+    add_monit("foo")
+    builder = new_builder("foo", ["foo", "bar"],
+                          ["a.conf", "b.yml"], ["foo", "bar"])
+    builder.fingerprint.should == "457a3618ecca5fcf375e479627eb0a574c63574d"
+  end
+
+  it "has a stable portable fingerprint" do
+    add_templates("foo", "a.conf", "b.yml")
+    add_monit("foo")
+    b1 = new_builder("foo", ["foo", "bar"],
+                     ["a.conf", "b.yml"], ["foo", "bar"])
+    f1 = b1.fingerprint
+    b1.reload.fingerprint.should == f1
+
+    b2 = new_builder("foo", ["foo", "bar"],
+                     ["a.conf", "b.yml"], ["foo", "bar"])
+    b2.fingerprint.should == f1
+  end
+
+  it "changes fingerprint when new template file is added" do
+    add_templates("foo", "a.conf", "b.yml")
+    add_monit("foo")
+
+    b1 = new_builder("foo", ["foo", "bar"],
+                     ["a.conf", "b.yml"], ["foo", "bar"])
+    f1 = b1.fingerprint
+
+    add_templates("foo", "baz")
+    b2 = new_builder("foo", ["foo", "bar"],
+                     ["a.conf", "b.yml", "baz"], ["foo", "bar"])
+    b2.fingerprint.should_not == f1
+  end
+
+  it "changes fingerprint when template files is changed" do
+    add_templates("foo", "a.conf", "b.yml")
+    add_monit("foo")
+
+    b1 = new_builder("foo", ["foo", "bar"],
+                     ["a.conf", "b.yml"], ["foo", "bar"])
+    f1 = b1.fingerprint
+
+    add_file("foo", "templates/a.conf", "bzz")
+    b1.reload.fingerprint.should_not == f1
+  end
+
+  it "changes fingerprint when new monit file is added" do
+    add_templates("foo", "a.conf", "b.yml")
+    add_monit("foo", "foo.monit")
+
+    b1 = new_builder("foo", ["foo", "bar"],
+                     ["a.conf", "b.yml"], ["foo", "bar"])
+    f1 = b1.fingerprint
+
+    add_monit("foo", "bar.monit")
+    b2 = new_builder("foo", ["foo", "bar"],
+                     ["a.conf", "b.yml"], ["foo", "bar"])
+    b2.fingerprint.should_not == f1
+  end
+
+  it "can read template file names from hash" do
+    add_templates("foo", "a.conf", "b.yml")
+    add_monit("foo")
+    builder = new_builder("foo", ["foo", "bar", "baz"],
+                          { "a.conf" => 1, "b.yml" => 2 },
+                          ["foo", "bar", "baz"])
+    builder.templates.should =~ ["a.conf", "b.yml"]
+  end
+
+  it "whines if name is blank" do
+    lambda {
+      new_builder("")
+    }.should raise_error(Bosh::Cli::InvalidJob, "Job name is missing")
+  end
+
+  it "whines on funny characters in name" do
+    lambda {
+      new_builder("@#!", [])
+    }.should raise_error(Bosh::Cli::InvalidJob,
+                         "`@#!' is not a valid BOSH identifier")
+  end
+
+  it "whines if some templates are missing" do
+    add_templates("foo", "a.conf", "b.conf")
+
+    lambda {
+      new_builder("foo", [], ["a.conf", "b.conf", "c.conf"])
+    }.should raise_error(Bosh::Cli::InvalidJob,
+                         "Some template files required by 'foo' job " +
+                         "are missing: c.conf")
+  end
+
+  it "whines about extra packages" do
+    add_templates("foo", "a.conf", "b.conf")
+
+    lambda {
+      new_builder("foo", [], ["a.conf"], [])
+    }.should raise_error(Bosh::Cli::InvalidJob,
+                         "There are unused template files for job 'foo'" +
+                         ": b.conf")
+  end
+
+  it "whines if some packages are missing" do
+    lambda {
+      new_builder("foo", ["foo", "bar", "baz", "app42"], { }, ["foo", "bar"])
+    }.should raise_error(Bosh::Cli::InvalidJob,
+                         "Some packages required by 'foo' job are missing: " +
+                         "baz, app42")
+  end
+
+  it "whines if there is no spec file" do
+    lambda {
+      new_builder("foo", ["foo", "bar", "baz", "app42"], { },
+                  ["foo", "bar", "baz", "app42"], false)
+    }.should raise_error(Bosh::Cli::InvalidJob,
+                         "Cannot find spec file for 'foo'")
+  end
+
+  it "whines if there is no monit file" do
+    lambda {
+      add_templates("foo", "a.conf", "b.yml")
+      new_builder("foo", ["foo", "bar", "baz", "app42"],
+                  ["a.conf", "b.yml"], ["foo", "bar", "baz", "app42"])
+    }.should raise_error(Bosh::Cli::InvalidJob,
+                         "Cannot find monit file for 'foo'")
+
+    add_monit("foo")
+    lambda {
+      new_builder("foo", ["foo", "bar", "baz", "app42"],
+                  ["a.conf", "b.yml"], ["foo", "bar", "baz", "app42"])
+    }.should_not raise_error
+  end
+
+  it "supports preparation script" do
+    spec = {
+      "name"       => "foo",
+      "packages"   => ["bar", "baz"],
+      "templates"  => ["a.conf", "b.yml"]
+    }
+    spec_yaml = YAML.dump(spec)
+
+    script = <<-SCRIPT.gsub(/^\s*/, "")
+    #!/bin/sh
+    mkdir templates
+    touch templates/a.conf
+    touch templates/b.yml
+    echo '#{spec_yaml}' > spec
+    touch monit
+    SCRIPT
+
+    add_file("foo", "prepare", script)
+    script_path = File.join(@release_dir, "jobs", "foo", "prepare")
+    FileUtils.chmod(0755, script_path)
+    Bosh::Cli::JobBuilder.run_prepare_script(script_path)
+
+    builder = new_builder("foo", ["bar", "baz"], ["a.conf", "b.yml"],
+                          ["foo", "bar", "baz", "app42"], false)
+    builder.copy_files.should == 4
+
+    Dir.chdir(builder.build_dir) do
+      File.directory?("templates").should be_true
+      ["templates/a.conf", "templates/b.yml"].each do |file|
+        File.file?(file).should be_true
+      end
+      File.file?("job.MF").should be_true
+      File.read("job.MF").should == File.read(
+          File.join(@release_dir, "jobs", "foo", "spec"))
+      File.exists?("monit").should be_true
+      File.exists?("prepare").should be_false
+    end
+  end
+
+  it "copies job files" do
+    add_templates("foo", "a.conf", "b.yml")
+    add_monit("foo")
+    builder = new_builder("foo", ["foo", "bar", "baz", "app42"],
+                          ["a.conf", "b.yml"], ["foo", "bar", "baz", "app42"])
+
+    builder.copy_files.should == 4
+
+    Dir.chdir(builder.build_dir) do
+      File.directory?("templates").should be_true
+      ["templates/a.conf", "templates/b.yml"].each do |file|
+        File.file?(file).should be_true
+      end
+      File.file?("job.MF").should be_true
+      File.read("job.MF").should == File.read(
+          File.join(@release_dir, "jobs", "foo", "spec"))
+      File.exists?("monit").should be_true
+    end
+  end
+
+  it "generates tarball" do
+    add_templates("foo", "bar", "baz")
+    add_monit("foo")
+
+    builder = new_builder("foo", ["p1", "p2"], ["bar", "baz"], ["p1", "p2"])
+    builder.generate_tarball.should be_true
+  end
+
+  it "supports versioning" do
+    add_templates("foo", "bar", "baz")
+    add_monit("foo")
+
+    builder = new_builder("foo", [], ["bar", "baz"], [])
+
+    File.exists?(@release_dir + "/.dev_builds/jobs/foo/0.1-dev.tgz").
+        should be_false
+    builder.build
+    File.exists?(@release_dir + "/.dev_builds/jobs/foo/0.1-dev.tgz").
+        should be_true
+    v1_fingerprint = builder.fingerprint
+
+    add_templates("foo", "zb.yml")
+    builder = new_builder("foo", [], ["bar", "baz", "zb.yml"], [])
+    builder.build
+
+    File.exists?(@release_dir + "/.dev_builds/jobs/foo/0.1-dev.tgz").
+        should be_true
+    File.exists?(@release_dir + "/.dev_builds/jobs/foo/0.2-dev.tgz").
+        should be_true
+
+    remove_templates("foo", "zb.yml")
+
+    builder = new_builder("foo", [], ["bar", "baz"], [])
+    builder.build
+    builder.version.should == "0.1-dev"
+
+    builder.fingerprint.should == v1_fingerprint
+    File.exists?(@release_dir + "/.dev_builds/jobs/foo/0.1-dev.tgz").
+        should be_true
+    File.exists?(@release_dir + "/.dev_builds/jobs/foo/0.2-dev.tgz").
+        should be_true
+    File.exists?(@release_dir + "/.dev_builds/jobs/foo/0.3-dev.tgz").
+        should be_false
+  end
+
+  it "can point to either dev or a final version of a job" do
+    add_templates("foo", "bar", "baz")
+    add_monit("foo")
+    fingerprint = "34586bac103c208361ae5dcadd101807110c4546"
+
+    final_versions = Bosh::Cli::VersionsIndex.new(
+        File.join(@release_dir, ".final_builds", "jobs", "foo"))
+    dev_versions   = Bosh::Cli::VersionsIndex.new(
+        File.join(@release_dir, ".dev_builds", "jobs", "foo"))
+
+    final_versions.add_version(fingerprint,
+                               { "version" => "4", "blobstore_id" => "12321" },
+                               "payload")
+    dev_versions.add_version(fingerprint,
+                             { "version" => "0.7-dev" },
+                             "dev_payload")
+
+    builder = new_builder("foo", [], ["bar", "baz"], [])
+
+    builder.fingerprint.should == fingerprint
+
+    builder.use_final_version
+    builder.version.should == "4"
+    builder.tarball_path.should == File.join(
+        @release_dir, ".final_builds", "jobs", "foo", "4.tgz")
+
+    builder.use_dev_version
+    builder.version.should == "0.7-dev"
+    builder.tarball_path.should == File.join(
+        @release_dir, ".dev_builds", "jobs", "foo", "0.7-dev.tgz")
+  end
+
+  it "bumps major dev version in sync with final version" do
+    add_templates("foo", "bar", "baz")
+    add_monit("foo")
+
+    builder = new_builder("foo", [], ["bar", "baz"], [])
+    builder.build
+
+    builder.version.should == "0.1-dev"
+
+    blobstore = mock("blobstore")
+    blobstore.should_receive(:create).and_return("object_id")
+    final_builder = new_builder("foo", [], ["bar", "baz"], [],
+                                true, true, blobstore)
+    final_builder.build
+
+    final_builder.version.should == 1
+
+    add_templates("foo", "bzz")
+    builder2 = new_builder("foo", [], ["bar", "baz", "bzz"], [])
+    builder2.build
+    builder2.version.should == "1.1-dev"
+  end
+
+  it "whines on attempt to create final build if not matched " +
+     "by existing final or dev build" do
+    add_templates("foo", "bar", "baz")
+    add_monit("foo")
+
+    blobstore = mock("blobstore")
+
+    final_builder = new_builder("foo", [], ["bar", "baz"],
+                                [], true, true, blobstore)
+    lambda {
+      final_builder.build
+    }.should raise_error(Bosh::Cli::CliExit)
+
+    dev_builder = new_builder("foo", [], ["bar", "baz"],
+                              [], true, false, blobstore)
+    dev_builder.build
+
+    final_builder2 = new_builder("foo", [], ["bar", "baz"],
+                                 [], true, true, blobstore)
+    blobstore.should_receive(:create)
+    final_builder2.build
+
+    add_templates("foo", "bzz")
+    final_builder3 = new_builder("foo", [], ["bar", "baz", "bzz"],
+                                 [], true, true, blobstore)
+
+    lambda {
+      final_builder3.build
+    }.should raise_error(Bosh::Cli::CliExit)
+  end
+
+  it "allows template subdirectories" do
+    add_templates("foo", "foo/bar", "bar/baz")
+    add_monit("foo")
+
+    blobstore = mock("blobstore")
+    builder = new_builder("foo", [], ["foo/bar", "bar/baz"],
+                          [], true, false, blobstore)
+    builder.build
+
+    Dir.chdir(builder.build_dir) do
+      File.directory?("templates").should be_true
+      ["templates/foo/bar", "templates/bar/baz"].each do |file|
+        File.file?(file).should be_true
+      end
+    end
+  end
+
+  it "supports dry run" do
+    add_templates("foo", "bar", "baz")
+    add_monit("foo")
+
+    builder = new_builder("foo", [], ["bar", "baz"], [])
+    builder.dry_run = true
+    builder.build
+
+    builder.version.should == "0.1-dev"
+    File.exists?(@release_dir + "/.dev_builds/jobs/foo/0.1-dev.tgz").
+        should be_false
+
+    builder.dry_run = false
+    builder.reload.build
+    File.exists?(@release_dir + "/.dev_builds/jobs/foo/0.1-dev.tgz").
+        should be_true
+
+    blobstore = mock("blobstore")
+    blobstore.should_not_receive(:create)
+    final_builder = new_builder("foo", [], ["bar", "baz"], [],
+                                true, true, blobstore)
+    final_builder.dry_run = true
+    final_builder.build
+
+    # Shouldn't be promoted during dry run:
+    final_builder.version.should == "0.1-dev"
+    File.exists?(@release_dir + "/.final_builds/jobs/foo/1.tgz").should be_false
+
+    add_templates("foo", "bzz")
+    builder2 = new_builder("foo", [], ["bar", "baz", "bzz"], [])
+    builder2.dry_run = true
+    builder2.build
+    builder2.version.should == "0.2-dev"
+    File.exists?(@release_dir + "/.dev_builds/jobs/foo/0.1-dev.tgz").
+        should be_true
+    File.exists?(@release_dir + "/.dev_builds/jobs/foo/0.2-dev.tgz").
+        should be_false
+  end
+
+end