bosh_cli 1.0.3 → 1.5.0.pre.1113

data/spec/unit/blob_manager_spec.rb

@@ -1,288 +0,0 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
-require "spec_helper"
-
-describe Bosh::Cli::BlobManager do
-
-  def make_manager(release)
-    Bosh::Cli::BlobManager.new(release)
-  end
-
-  before(:each) do
-    @blobstore = mock("blobstore")
-    @dir = Dir.mktmpdir
-    @src_dir = FileUtils.mkdir(File.join(@dir, "src"))
-    @config_dir = File.join(@dir, "config")
-    FileUtils.mkdir(@config_dir)
-    @blobs_dir = File.join(@dir, "blobs")
-    @release = mock("release", :dir => @dir, :blobstore => @blobstore)
-  end
-
-  describe "initialization" do
-    it "fails if 'src' directory is missing" do
-      FileUtils.rm_rf(@src_dir)
-      expect {
-        make_manager(@release)
-      }.to raise_error("`src' directory is missing")
-    end
-
-    it "fails if blobstore is not configured" do
-      @release.stub!(:blobstore).and_return(nil)
-      expect {
-        make_manager(@release)
-      }.to raise_error("Blobstore is not configured")
-    end
-
-    it "creates necessary directories in release dir" do
-      make_manager(@release)
-      File.directory?(File.join(@dir, "blobs")).should be_true
-      File.directory?(File.join(@dir, ".blobs")).should be_true
-    end
-
-    it "has dirty flag cleared and upload list empty" do
-      manager = make_manager(@release)
-      manager.dirty?.should be_false
-      manager.blobs_to_upload.should == []
-    end
-
-    it "doesn't like bad index file'" do
-      File.open(File.join(@config_dir, "blobs.yml"), "w") do |f|
-        YAML.dump("string", f)
-      end
-      expect {
-        make_manager(@release)
-      }.to raise_error(/Incorrect file format/)
-    end
-
-    it "migrates legacy index file" do
-      legacy_file = File.join(@release.dir, "blob_index.yml")
-      test_hash = { "foo" => "bar" }
-
-      File.open(legacy_file, "w") do |f|
-        YAML.dump({ "foo" => "bar" }, f)
-      end
-
-      make_manager(@release)
-      File.exists?(legacy_file).should be_false
-      YAML.load_file(File.join(@config_dir, "blobs.yml")).should == test_hash
-    end
-  end
-
-  describe "adding a blob" do
-    before(:each) do
-      @manager = make_manager(@release)
-      @blob = Tempfile.new("blob")
-      @blob.write("blob contents")
-      @blob.close
-    end
-
-    it "cannot add non-existing file" do
-      expect {
-        @manager.add_blob("tmp/foobar.tgz", "test")
-      }.to raise_error("File `tmp/foobar.tgz' not found")
-    end
-
-    it "cannot add directory" do
-      tmp_dir = Dir.mktmpdir
-      expect {
-        @manager.add_blob(tmp_dir, "test")
-      }.to raise_error("`#{tmp_dir}' is a directory")
-    end
-
-    it "cannot use absolute path as blob destination" do
-      expect {
-        @manager.add_blob(@blob.path, "/test")
-      }.to raise_error("Blob path should be a relative path")
-    end
-
-    it "cannot use 'blobs' prefix for blob destination" do
-      expect {
-        @manager.add_blob(@blob.path, "blobs/foo/bar")
-      }.to raise_error("Blob path should not start with `blobs/'")
-    end
-
-    it "cannot use directory as blob destination" do
-      foo_dir = File.join(@blobs_dir, "foo")
-      FileUtils.mkdir(foo_dir)
-      expect {
-        @manager.add_blob(@blob.path, "foo")
-      }.to raise_error("`#{foo_dir}' is a directory, " +
-                       "please pick a different path")
-    end
-
-    it "adds blob to a blobs directory" do
-      blob_dst = File.join(@blobs_dir, "foo", "blob")
-      @manager.add_blob(@blob.path, "foo/blob")
-      File.exists?(blob_dst).should be_true
-      File.read(blob_dst).should == "blob contents"
-      File.symlink?(blob_dst).should be_false
-      File.stat(blob_dst).mode.to_s(8)[-4..-1].should == "0644"
-      File.exists?(@blob.path).should be_true # original still exists
-
-      @manager.process_blobs_directory
-      @manager.dirty?.should be_true
-      @manager.new_blobs.should == %w(foo/blob)
-      @manager.updated_blobs.should == []
-    end
-
-    it "prevents double adds of the same file" do
-      @manager.add_blob(@blob.path, "foo/blob")
-      expect {
-        @manager.add_blob(@blob.path, "foo/blob")
-      }.to raise_error(/Already tracking/)
-    end
-
-    it "updates blob" do
-      new_blob = Tempfile.new("new-blob")
-      new_blob.write("foobar")
-      new_blob.close
-      blob_dst = File.join(@blobs_dir, "foo", "blob")
-      @manager.add_blob(@blob.path, "foo/blob")
-      File.read(blob_dst).should == "blob contents"
-      @manager.add_blob(new_blob.path, "foo/blob")
-      File.read(blob_dst).should == "foobar"
-    end
-  end
-
-  describe "downloading a blob" do
-    it "cannot download blob if path is not in index" do
-      @manager = make_manager(@release)
-
-      expect {
-        @manager.download_blob("foo")
-      }.to raise_error(/Unknown blob path/)
-    end
-
-    it "downloads blob from blobstore" do
-      index = {
-        "foo" => {
-          "size" => "1000",
-          "object_id" => "deadbeef",
-          "sha" => Digest::SHA1.hexdigest("blob contents")
-        }
-      }
-
-      File.open(File.join(@config_dir, "blobs.yml"), "w") do |f|
-        YAML.dump(index, f)
-      end
-
-      @manager = make_manager(@release)
-      @blobstore.should_receive(:get).with("deadbeef",
-                                           an_instance_of(File)).
-        and_return { |_, f | f.write("blob contents") }
-
-      path = @manager.download_blob("foo")
-      File.read(path).should == "blob contents"
-    end
-  end
-
-  describe "uploading a blob" do
-    before(:each) do
-      @manager = make_manager(@release)
-    end
-
-    it "needs blob path to exist" do
-      expect {
-        @manager.upload_blob("foo")
-      }.to raise_error(/doesn't exist/)
-    end
-
-    it "doesn't follow symlinks" do
-      FileUtils.touch(File.join(@dir, "blob"))
-      FileUtils.ln_s(File.join(@dir, "blob"), File.join(@blobs_dir, "foo"))
-      expect {
-        @manager.upload_blob("foo")
-      }.to raise_error(/is a symlink/)
-    end
-
-    it "uploads file to a blobstore, updates index and symlinks blob" do
-      new_blob = File.join(@dir, "blob")
-      File.open(new_blob, "w") { |f| f.write("test blob") }
-      @manager.add_blob(new_blob, "foo")
-
-      @blobstore.should_receive(:create).and_return("deadbeef")
-      @manager.upload_blob("foo").should == "deadbeef"
-
-      blob_dst = File.join(@blobs_dir, "foo")
-      checksum = Digest::SHA1.hexdigest("test blob")
-
-      File.symlink?(blob_dst).should be_true
-      File.readlink(blob_dst).should == File.join(@dir, ".blobs", checksum)
-      File.read(blob_dst).should == "test blob"
-    end
-  end
-
-  describe "syncing blobs" do
-    it "includes several steps" do
-      @manager = make_manager(@release)
-      @manager.should_receive(:remove_symlinks).ordered
-      @manager.should_receive(:process_blobs_directory).ordered
-      @manager.should_receive(:process_index).ordered
-      @manager.sync
-    end
-
-    it "processes blobs directory" do
-      @manager = make_manager(@release)
-      @blobstore.stub!(:create).and_return("new-object-id")
-
-      new_blob = Tempfile.new("new-blob")
-      new_blob.write("test")
-      new_blob.close
-
-      @manager.add_blob(new_blob.path, "foo")
-      @manager.process_blobs_directory
-      @manager.new_blobs.should == %w(foo)
-
-      @manager.add_blob(new_blob.path, "bar")
-      @manager.process_blobs_directory
-      @manager.new_blobs.sort.should == %w(bar foo)
-
-      @manager.upload_blob("bar")
-
-      new_blob.open
-      new_blob.write("stuff")
-      new_blob.close
-
-      @manager.add_blob(new_blob.path, "bar")
-      @manager.process_blobs_directory
-      @manager.new_blobs.sort.should == %w(foo)
-      @manager.updated_blobs.sort.should == %w(bar)
-    end
-
-    it "downloads missing blobs" do
-      index = {
-        "foo" => {
-          "size" => 1000,
-          "sha" => Digest::SHA1.hexdigest("foo"),
-          "object_id" => "da-foo"
-        },
-        "bar" => {
-          "size" => 500,
-          "sha" => Digest::SHA1.hexdigest("bar"),
-          "object_id" => "da-bar"
-        }
-      }
-
-      File.open(File.join(@config_dir, "blobs.yml"), "w") do |f|
-        YAML.dump(index, f)
-      end
-
-      foo = Tempfile.new("foo")
-      foo.write("foo")
-      foo.close
-
-      bar = Tempfile.new("bar")
-      bar.write("bar")
-      bar.close
-
-      @manager = make_manager(@release)
-      @manager.should_receive(:download_blob).with("foo").and_return(foo.path)
-      @manager.should_receive(:download_blob).with("bar").and_return(bar.path)
-
-      @manager.process_index
-
-      File.read(File.join(@blobs_dir, "foo")).should == "foo"
-      File.read(File.join(@blobs_dir, "bar")).should == "bar"
-    end
-  end
-end

data/spec/unit/cache_spec.rb

@@ -1,36 +0,0 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
-require 'spec_helper'
-require 'fileutils'
-
-describe Bosh::Cli::Cache do
-
-  before :each do
-    @cache_dir = File.join(Dir.mktmpdir, "bosh_cache")
-  end
-
-  after :each do
-    FileUtils.rm_rf(@cache_dir)
-  end
-
-  it "whines if cache directory turned out to be a file" do
-    FileUtils.touch(@cache_dir)
-    lambda {
-      Bosh::Cli::Cache.new(@cache_dir)
-    }.should raise_error(Bosh::Cli::CacheDirectoryError)
-  end
-
-  it "creates cache directory" do
-    File.directory?(@cache_dir).should be_false
-    cache = Bosh::Cli::Cache.new(@cache_dir)
-    File.directory?(@cache_dir).should be_true    
-  end
-
-  it "performs read/write in an expected way" do
-    cache = Bosh::Cli::Cache.new(@cache_dir)
-    cache.read("foo").should be_nil
-    cache.write("foo", "12321")
-    cache.read("foo").should == "12321"    
-  end
-  
-end

data/spec/unit/cli_commands_spec.rb

@@ -1,356 +0,0 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
-require "spec_helper"
-
-describe Bosh::Cli::Command::Base do
-
-  before :each do
-    tmpdir = Dir.mktmpdir
-    @config = File.join(tmpdir, "bosh_config")
-    @cache = File.join(tmpdir, "bosh_cache")
-    @director = mock(Bosh::Cli::Director)
-    Bosh::Cli::Director.stub!(:new).and_return(@director)
-    @director.stub!(:get_status).and_return("name" => "ZB")
-  end
-
-  describe Bosh::Cli::Command::Misc do
-
-    before :each do
-      @cmd = Bosh::Cli::Command::Misc.new
-      @cmd.add_option(:config, @config)
-      @cmd.add_option(:cache_dir, @cache)
-      @cmd.add_option(:non_interactive, true)
-    end
-
-    it "sets the target" do
-      @cmd.target.should be_nil
-      @cmd.set_target("http://example.com:232")
-      @cmd.target.should == "http://example.com:232"
-    end
-
-    it "normalizes target" do
-      @cmd.target.should be_nil
-      @cmd.set_target("test")
-      @cmd.target.should == "http://test:25555"
-    end
-
-    it "handles director errors when setting target" do
-      @director.should_receive(:get_status).and_raise(Bosh::Cli::DirectorError)
-
-      lambda {
-        @cmd.set_target("test")
-      }.should raise_error(Bosh::Cli::CliError, /cannot talk to director/i)
-
-      @cmd.target.should be_nil
-    end
-
-    it "sets target" do
-      @cmd.set_target("test")
-      @cmd.target.should == "http://test:25555"
-    end
-
-    it "supports named targets" do
-      @cmd.set_target("test", "mytarget")
-      @cmd.target.should == "http://test:25555"
-
-      @cmd.set_target("foo", "myfoo")
-
-      @cmd.set_target("mytarget")
-      @cmd.target.should == "http://test:25555"
-
-      @cmd.set_target("myfoo")
-      @cmd.target.should == "http://foo:25555"
-    end
-
-    it "logs user in" do
-      @director.should_receive(:authenticated?).and_return(true)
-      @director.should_receive(:user=).with("user")
-      @director.should_receive(:password=).with("pass")
-      @cmd.set_target("test")
-      @cmd.login("user", "pass")
-      @cmd.logged_in?.should be_true
-      @cmd.username.should == "user"
-      @cmd.password.should == "pass"
-    end
-
-    it "logs user out" do
-      @cmd.set_target("test")
-      @director.should_receive(:authenticated?).and_return(true)
-      @director.should_receive(:user=).with("user")
-      @director.should_receive(:password=).with("pass")
-      @cmd.login("user", "pass")
-      @cmd.logout
-      @cmd.logged_in?.should be_false
-    end
-
-    it "respects director checks option when logging in" do
-      @director.stub!(:get_status).
-        and_return({ "user" => "user", "name" => "ZB" })
-      @director.stub(:authenticated?).and_return(true)
-
-      @cmd.set_target("test")
-      @director.should_receive(:user=).with("user")
-      @director.should_receive(:password=).with("pass")
-      @cmd.login("user", "pass")
-      @cmd.logged_in?.should be_true
-      @cmd.username.should == "user"
-      @cmd.password.should == "pass"
-    end
-  end
-
-  describe Bosh::Cli::Command::Stemcell do
-    before :each do
-      @director = mock(Bosh::Cli::Director)
-      @director.stub(:list_stemcells).
-          and_return([{ "name" => "foo", "version" => "123" }])
-      @director.should_receive(:list_stemcells)
-
-      @cmd = Bosh::Cli::Command::Stemcell.new
-      @cmd.add_option(:non_interactive, true)
-
-      @cmd.stub!(:target).and_return("test")
-      @cmd.stub!(:username).and_return("user")
-      @cmd.stub!(:password).and_return("pass")
-      @cmd.stub!(:director).and_return(@director)
-    end
-
-    it "allows deleting the stemcell" do
-      @director.should_receive(:delete_stemcell).with("foo", "123")
-      @cmd.delete("foo", "123")
-    end
-
-    it "needs confirmation to delete stemcell" do
-      @cmd.remove_option(:non_interactive)
-      @director.should_not_receive(:delete_stemcell)
-
-      @cmd.stub!(:ask).and_return("")
-      @cmd.delete("foo", "123")
-    end
-
-    it "raises error when deleting if stemcell does not exist" do
-      @director.should_not_receive(:delete_stemcell)
-
-      @cmd.add_option(:non_interactive, true)
-      lambda {
-        @cmd.delete("foo", "111")
-      }.should raise_error(Bosh::Cli::CliError,
-                           "Stemcell `foo/111' does not exist")
-    end
-  end
-
-  describe Bosh::Cli::Command::Deployment do
-    before :each do
-      @cmd = Bosh::Cli::Command::Deployment.new
-      @cmd.add_option(:non_interactive, true)
-    end
-
-    it "allows deleting the deployment" do
-      mock_director = mock(Bosh::Cli::Director)
-      mock_director.should_receive(:delete_deployment).
-          with("foo", :force => false)
-
-      @cmd.stub!(:interactive?).and_return(false)
-      @cmd.stub!(:target).and_return("test")
-      @cmd.stub!(:username).and_return("user")
-      @cmd.stub!(:password).and_return("pass")
-      @cmd.stub!(:director).and_return(mock_director)
-      @cmd.delete("foo")
-    end
-
-    it "needs confirmation to delete deployment" do
-      mock_director = mock(Bosh::Cli::Director)
-      mock_director.should_not_receive(:delete_deployment)
-
-      @cmd.remove_option(:non_interactive)
-      @cmd.stub!(:target).and_return("test")
-      @cmd.stub!(:username).and_return("user")
-      @cmd.stub!(:password).and_return("pass")
-      @cmd.stub!(:director).and_return(mock_director)
-      @cmd.stub!(:ask).and_return("")
-      @cmd.delete("foo")
-    end
-  end
-
-  describe Bosh::Cli::Command::Release do
-    before :each do
-      @director = mock(Bosh::Cli::Director)
-
-      @cmd = Bosh::Cli::Command::Release.new
-      @cmd.add_option(:non_interactive, true)
-
-      @cmd.stub!(:target).and_return("test")
-      @cmd.stub!(:username).and_return("user")
-      @cmd.stub!(:password).and_return("pass")
-      @cmd.stub!(:director).and_return(@director)
-    end
-
-    it "allows deleting the release (non-force)" do
-      @director.should_receive(:delete_release).
-          with("foo", :force => false, :version => nil)
-
-      @cmd.delete("foo")
-    end
-
-    it "allows deleting the release (force)" do
-      @director.should_receive(:delete_release).
-          with("foo", :force => true, :version => nil)
-
-      @cmd.add_option(:force, true)
-      @cmd.delete("foo")
-    end
-
-    it "allows deleting a particular release version (non-force)" do
-      @director.should_receive(:delete_release).
-          with("foo", :force => false, :version => "42")
-
-      @cmd.delete("foo", "42")
-    end
-
-    it "allows deleting a particular release version (force)" do
-      @director.should_receive(:delete_release).
-          with("foo", :force => true, :version => "42")
-
-      @cmd.add_option(:force, true)
-      @cmd.delete("foo", "42")
-    end
-
-    it "requires confirmation on deleting release" do
-      @director.should_not_receive(:delete_release)
-      @cmd.remove_option(:non_interactive)
-
-      @cmd.stub!(:ask).and_return("")
-      @cmd.delete("foo")
-    end
-
-  end
-
-  describe Bosh::Cli::Command::JobManagement do
-    before :each do
-      @manifest_path = spec_asset("deployment.MF")
-      @manifest_yaml = YAML.dump({ "name" => "foo" })
-
-      @cmd = Bosh::Cli::Command::JobManagement.new
-      @cmd.add_option(:non_interactive, true)
-      @cmd.stub!(:prepare_deployment_manifest).
-        with(:yaml => true).and_return(@manifest_yaml)
-      @cmd.stub!(:deployment).and_return(@manifest_path)
-      @cmd.stub!(:target).and_return("test.com")
-      @cmd.stub!(:target_name).and_return("dev2")
-      @cmd.stub!(:username).and_return("user")
-      @cmd.stub!(:password).and_return("pass")
-      @director = mock(Bosh::Cli::Director)
-      @cmd.stub!(:director).and_return(@director)
-    end
-
-    it "allows starting jobs" do
-      @director.should_receive(:change_job_state).
-        with("foo", @manifest_yaml, "dea", nil, "started")
-      @cmd.start_job("dea")
-    end
-
-    it "allows starting job instances" do
-      @director.should_receive(:change_job_state).
-        with("foo", @manifest_yaml, "dea", 3, "started")
-      @cmd.start_job("dea", 3)
-    end
-
-    it "allows stopping jobs" do
-      @director.should_receive(:change_job_state).
-        with("foo", @manifest_yaml, "dea", nil, "stopped")
-      @cmd.stop_job("dea")
-    end
-
-    it "allows stopping job instances" do
-      @director.should_receive(:change_job_state).
-        with("foo", @manifest_yaml, "dea", 3, "stopped")
-      @cmd.stop_job("dea", 3)
-    end
-
-    it "allows restarting jobs" do
-      @director.should_receive(:change_job_state).
-        with("foo", @manifest_yaml, "dea", nil, "restart")
-      @cmd.restart_job("dea")
-    end
-
-    it "allows restart job instances" do
-      @director.should_receive(:change_job_state).
-        with("foo", @manifest_yaml, "dea", 3, "restart")
-      @cmd.restart_job("dea", 3)
-    end
-
-    it "allows recreating jobs" do
-      @director.should_receive(:change_job_state).
-        with("foo", @manifest_yaml, "dea", nil, "recreate")
-      @cmd.recreate_job("dea")
-    end
-
-    it "allows recreating job instances" do
-      @director.should_receive(:change_job_state).
-        with("foo", @manifest_yaml, "dea", 3, "recreate")
-      @cmd.recreate_job("dea", 3)
-    end
-
-    it "allows hard stop" do
-      @director.should_receive(:change_job_state).
-        with("foo", @manifest_yaml, "dea", 3, "detached")
-      @cmd.add_option(:hard, true)
-      @cmd.stop_job("dea", 3)
-    end
-
-    it "allows soft stop (= regular stop)" do
-      @director.should_receive(:change_job_state).
-        with("foo", @manifest_yaml, "dea", 3, "stopped")
-      @cmd.add_option(:soft, true)
-      @cmd.stop_job("dea", 3)
-    end
-
-  end
-
-  describe Bosh::Cli::Command::BlobManagement do
-    before :each do
-      @cmd = Bosh::Cli::Command::BlobManagement.new
-      @cmd.add_option(:non_interactive, true)
-
-      @blob_manager = mock("blob manager")
-      @release = mock("release")
-
-      @cmd.should_receive(:check_if_release_dir)
-      Bosh::Cli::Release.stub!(:new).and_return(@release)
-      Bosh::Cli::BlobManager.stub!(:new).with(@release).
-        and_return(@blob_manager)
-    end
-
-    it "prints blobs status" do
-      @blob_manager.should_receive(:print_status)
-      @cmd.status
-    end
-
-    it "adds blob under provided directory" do
-      @blob_manager.should_receive(:add_blob).with("foo/bar.tgz", "bar/bar.tgz")
-      @cmd.add("foo/bar.tgz", "bar")
-    end
-
-    it "adds blob with no directory provided" do
-      @blob_manager.should_receive(:add_blob).with("foo/bar.tgz", "bar.tgz")
-      @cmd.add("foo/bar.tgz")
-    end
-
-    it "uploads blobs" do
-      @blob_manager.should_receive(:print_status)
-      @blob_manager.stub!(:blobs_to_upload).and_return(%w(foo bar baz))
-      @blob_manager.should_receive(:upload_blob).with("foo")
-      @blob_manager.should_receive(:upload_blob).with("bar")
-      @blob_manager.should_receive(:upload_blob).with("baz")
-
-      @cmd.should_receive(:confirmed?).exactly(3).times.and_return(true)
-      @cmd.upload
-    end
-
-    it "syncs blobs" do
-      @blob_manager.should_receive(:sync).ordered
-      @blob_manager.should_receive(:print_status).ordered
-      @cmd.sync
-    end
-  end
-
-end