bosh_vsphere_cpi 0.6.0 → 1.5.0.pre.1100

data/spec/unit/cloud/vsphere/resources/datacenter_spec.rb

@@ -1,72 +0,0 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
-require File.expand_path("../../../../../spec_helper", __FILE__)
-
-describe VSphereCloud::Resources::Datacenter do
-  before(:each) do
-    @client = mock(:client)
-    VSphereCloud::Config.client = @client
-    VSphereCloud::Config.mem_overcommit = 1.0
-  end
-
-  describe :initialize do
-    it "should create a datacenter" do
-      dc_mob = mock(:dc_mob)
-      cluster_mob = mock(:cluster_mob)
-
-      @client.should_receive(:find_by_inventory_path).with("TEST_DC").
-          and_return(dc_mob)
-      @client.should_receive(:get_managed_objects).
-          with(VimSdk::Vim::ClusterComputeResource,
-               {:root=>dc_mob, :include_name=>true}).
-          and_return({"foo" => cluster_mob})
-      @client.should_receive(:get_properties).
-          with([cluster_mob], VimSdk::Vim::ClusterComputeResource,
-               %w(name datastore resourcePool host), {:ensure_all => true}).
-          and_return({cluster_mob => {:foo => :bar}})
-
-      folder_config = VSphereCloud::Config::FolderConfig.new
-      folder_config.vm = "vms"
-      folder_config.template = "templates"
-      folder_config.shared = false
-      cluster_config = VSphereCloud::Config::ClusterConfig.new("foo")
-      datastore_config = VSphereCloud::Config::DatastoreConfig.new
-      datastore_config.disk_path = "bosh_disks"
-
-      dc_config = mock(:dc_config)
-      dc_config.stub(:name).and_return("TEST_DC")
-      dc_config.stub(:folders).and_return(folder_config)
-      dc_config.stub(:clusters).and_return({"foo" => cluster_config})
-      dc_config.stub(:datastores).and_return(datastore_config)
-
-      vm_folder = mock(:vm_folder)
-      VSphereCloud::Resources::Folder.stub!(:new).
-          with(an_instance_of(VSphereCloud::Resources::Datacenter),
-               "vms", false).
-          and_return(vm_folder)
-
-      template_folder = mock(:template_folder)
-      VSphereCloud::Resources::Folder.stub!(:new).
-          with(an_instance_of(VSphereCloud::Resources::Datacenter),
-               "templates", false).
-          and_return(template_folder)
-
-      cluster = mock(:cluster)
-      cluster.stub(:name).and_return("foo")
-      VSphereCloud::Resources::Cluster.stub!(:new).
-          with(an_instance_of(VSphereCloud::Resources::Datacenter),
-               cluster_config, {:foo => :bar}).
-          and_return(cluster)
-
-      datacenter = VSphereCloud::Resources::Datacenter.new(dc_config)
-      datacenter.mob.should == dc_mob
-      datacenter.clusters.should == {"foo" => cluster}
-      datacenter.vm_folder.should == vm_folder
-      datacenter.template_folder.should == template_folder
-      datacenter.config.should == dc_config
-      datacenter.name.should == "TEST_DC"
-      datacenter.disk_path.should == "bosh_disks"
-    end
-
-  end
-end

data/spec/unit/cloud/vsphere/resources/datastore_spec.rb

@@ -1,43 +0,0 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
-require File.expand_path("../../../../../spec_helper", __FILE__)
-
-describe VSphereCloud::Resources::Datastore do
-  before(:each) do
-    @client = mock(:client)
-    VSphereCloud::Config.client = @client
-    VSphereCloud::Config.mem_overcommit = 1.0
-  end
-
-  describe :initialize do
-    it "should create a datastore" do
-      ds_mob = mock(:ds_mob)
-      datastore = VSphereCloud::Resources::Datastore.new({
-          :obj => ds_mob,
-          "name" => "foo_lun",
-          "summary.capacity" => 16 * 1024 * 1024 * 1024,
-          "summary.freeSpace" => 8 * 1024 * 1024 * 1024
-      })
-
-      datastore.mob.should == ds_mob
-      datastore.total_space.should == 16384
-      datastore.free_space.should == 8192
-      datastore.synced_free_space.should == 8192
-      datastore.allocated_after_sync.should == 0
-    end
-  end
-
-  describe :allocate do
-    it "should allocate space" do
-      ds_mob = mock(:ds_mob)
-      datastore = VSphereCloud::Resources::Datastore.new({
-         :obj => ds_mob,
-         "name" => "foo_lun",
-         "summary.capacity" => 16 * 1024 * 1024 * 1024,
-         "summary.freeSpace" => 8 * 1024 * 1024 * 1024
-      })
-      datastore.allocate(1024)
-      datastore.free_space.should == 7168
-    end
-  end
-end

data/spec/unit/cloud/vsphere/resources/folder_spec.rb

@@ -1,63 +0,0 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
-require File.expand_path("../../../../../spec_helper", __FILE__)
-
-describe VSphereCloud::Resources::Folder do
-  before(:each) do
-    @client = mock(:client)
-    VSphereCloud::Config.client = @client
-    VSphereCloud::Config.mem_overcommit = 1.0
-  end
-
-  describe :initialize do
-    it "should create a folder" do
-      datacenter = mock(:datacenter)
-      datacenter.stub(:name).and_return("TEST_DC")
-
-      folder_mob = mock(:folder_mob)
-
-      @client.should_receive(:find_by_inventory_path).with(%w(TEST_DC vm foo)).
-          and_return(folder_mob)
-
-      folder = VSphereCloud::Resources::Folder.new(datacenter, "foo", false)
-      folder.mob.should == folder_mob
-      folder.name.should == "foo"
-    end
-
-    it "should create a namespaced folder" do
-      datacenter = mock(:datacenter)
-      datacenter.stub(:name).and_return("TEST_DC")
-
-      folder_mob = mock(:folder_mob)
-      @client.should_receive(:find_by_inventory_path).with(%w(TEST_DC vm foo)).
-          and_return(folder_mob)
-
-      ns_folder_mob = mock(:ns_folder_mob)
-      @client.should_receive(:find_by_inventory_path).
-          with(["TEST_DC", "vm", %w(foo 123)]).and_return(ns_folder_mob)
-
-      folder = VSphereCloud::Resources::Folder.new(datacenter, "foo", true)
-      folder.mob.should == ns_folder_mob
-      folder.name.should == %w(foo 123)
-    end
-
-    it "should create a namespaced folder and create it in vSphere" do
-      datacenter = mock(:datacenter)
-      datacenter.stub(:name).and_return("TEST_DC")
-
-      folder_mob = mock(:folder_mob)
-      @client.should_receive(:find_by_inventory_path).with(%w(TEST_DC vm foo)).
-          and_return(folder_mob)
-      @client.should_receive(:find_by_inventory_path).
-          with(["TEST_DC", "vm", %w(foo 123)]).and_return(nil)
-
-      ns_folder_mob = mock(:ns_folder_mob)
-      folder_mob.should_receive(:create_folder).with("123").
-          and_return(ns_folder_mob)
-
-      folder = VSphereCloud::Resources::Folder.new(datacenter, "foo", true)
-      folder.mob.should == ns_folder_mob
-      folder.name.should == %w(foo 123)
-    end
-  end
-end

data/spec/unit/cloud/vsphere/resources/resource_pool_spec.rb

@@ -1,42 +0,0 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
-require File.expand_path("../../../../../spec_helper", __FILE__)
-
-describe VSphereCloud::Resources::ResourcePool do
-  before(:each) do
-    @client = mock(:client)
-    VSphereCloud::Config.client = @client
-    VSphereCloud::Config.mem_overcommit = 1.0
-  end
-
-  describe :initialize do
-    it "should create a resource pool" do
-      cluster = mock(:cluster)
-      cluster_config = VSphereCloud::Config::ClusterConfig.new("foo")
-      cluster.stub(:config).and_return(cluster_config)
-      root_resource_pool_mob = mock(:root_resource_pool)
-
-      resource_pool = VSphereCloud::Resources::ResourcePool.new(
-          cluster, root_resource_pool_mob)
-      resource_pool.mob.should == root_resource_pool_mob
-    end
-
-    it "should create a resource pool with the specified name" do
-      cluster = mock(:cluster)
-      cluster_config = VSphereCloud::Config::ClusterConfig.new(
-          {"foo" => {"resource_pool" => "bar"}})
-      cluster.stub(:config).and_return(cluster_config)
-      root_resource_pool_mob = mock(:root_resource_pool)
-
-      child_resource_pool_mob = mock(:child_resource_pool_mob)
-      @client.should_receive(:get_managed_object).
-          with(VimSdk::Vim::ResourcePool,
-               {:root=> root_resource_pool_mob, :name=>"bar"}).
-          and_return(child_resource_pool_mob)
-
-      resource_pool = VSphereCloud::Resources::ResourcePool.new(
-          cluster, root_resource_pool_mob)
-      resource_pool.mob.should == child_resource_pool_mob
-    end
-  end
-end

data/spec/unit/cloud/vsphere/resources/scorer_spec.rb

@@ -1,73 +0,0 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
-require File.expand_path("../../../../../spec_helper", __FILE__)
-
-describe VSphereCloud::Resources::Scorer do
-
-  def create_datastores(sizes)
-    datastores = {}
-    sizes.each_with_index do |size, i|
-      datastore = mock(:datastore)
-      datastore.stub(:free_space).and_return(size)
-      datastores["ds_#{i}"] = datastore
-    end
-    datastores
-  end
-
-  def create_cluster(memory, ephemeral, persistent, shared)
-    cluster = mock(:cluster)
-    cluster.stub(:name).and_return("foo")
-    cluster.stub(:free_memory).and_return(memory)
-    cluster.stub(:ephemeral_datastores).
-        and_return(create_datastores(ephemeral))
-    cluster.stub(:persistent_datastores).
-        and_return(create_datastores(persistent))
-    cluster.stub(:shared_datastores).
-        and_return(create_datastores(shared))
-    cluster
-  end
-
-  describe :score do
-    it "should return 0 when memory is not available" do
-      cluster = create_cluster(500, [32 * 1024], [32 * 1024], [])
-      scorer = VSphereCloud::Resources::Scorer.new(cluster, 512, 1, [])
-      scorer.score.should == 0
-    end
-
-    it "should return 0 when ephemeral space is not available" do
-      cluster = create_cluster(16 * 1024, [512], [32 * 1024], [])
-      scorer = VSphereCloud::Resources::Scorer.new(cluster, 1, 1024, [])
-      scorer.score.should == 0
-    end
-
-    it "should return 0 when persistent space is not available" do
-      cluster = create_cluster(16 * 1024, [32 * 1024], [512], [])
-      scorer = VSphereCloud::Resources::Scorer.new(cluster, 1, 1, [1024])
-      scorer.score.should == 0
-    end
-
-    it "should calculate memory bound score" do
-      cluster = create_cluster(16 * 1024, [32 * 1024], [32 * 1024], [])
-      scorer = VSphereCloud::Resources::Scorer.new(cluster, 512, 1, [])
-      scorer.score.should == 31
-    end
-
-    it "should calculate ephemeral bound score" do
-      cluster = create_cluster(16 * 1024, [32 * 1024], [32 * 1024], [])
-      scorer = VSphereCloud::Resources::Scorer.new(cluster, 1, 512, [])
-      scorer.score.should == 62
-    end
-
-    it "should calculate persistent bound score" do
-      cluster = create_cluster(16 * 1024, [32 * 1024], [32 * 1024], [])
-      scorer = VSphereCloud::Resources::Scorer.new(cluster, 1, 1, [512])
-      scorer.score.should == 62
-    end
-
-    it "should calculate shared bound score" do
-      cluster = create_cluster(16 * 1024, [], [], [32 * 1024])
-      scorer = VSphereCloud::Resources::Scorer.new(cluster, 1, 1024, [512])
-      scorer.score.should == 20
-    end
-  end
-end

data/spec/unit/cloud/vsphere/resources/util_spec.rb

@@ -1,35 +0,0 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
-require File.expand_path("../../../../../spec_helper", __FILE__)
-
-describe VSphereCloud::Resources::Util do
-  describe :average_csv do
-    it "should compute the average integer value" do
-      VSphereCloud::Resources::Util.average_csv("1,2,3").should == 2
-    end
-
-    it "should compute the average float value" do
-      VSphereCloud::Resources::Util.average_csv("1.5,2.5,3.5").should == 2.5
-    end
-
-    it "should return 0 when there is no data" do
-      VSphereCloud::Resources::Util.average_csv("").should == 0
-    end
-  end
-
-  describe :weighted_random do
-    it "should calculate the weighted random" do
-      util = VSphereCloud::Resources::Util
-      util.should_receive(:rand).with(3).and_return(0)
-      util.should_receive(:rand).with(3).and_return(1)
-      util.should_receive(:rand).with(3).and_return(2)
-      util.weighted_random([[:a, 1], [:b, 2]]).should == :a
-      util.weighted_random([[:a, 1], [:b, 2]]).should == :b
-      util.weighted_random([[:a, 1], [:b, 2]]).should == :b
-    end
-
-    it "should return nil when there are no elements" do
-      VSphereCloud::Resources::Util.weighted_random([]).should be_nil
-    end
-  end
-end

data/spec/unit/cloud/vsphere/resources_spec.rb

@@ -1,216 +0,0 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
-require File.expand_path("../../../../spec_helper", __FILE__)
-
-describe VSphereCloud::Resources do
-
-  describe :datacenters do
-    it "should fetch the datacenters the first time" do
-      vcenter_config = mock(:vcenter_config)
-      VSphereCloud::Config.vcenter = vcenter_config
-      dc_config = mock(:dc_config)
-      dc_config.stub(:name).and_return("foo")
-      vcenter_config.stub(:datacenters).and_return({"foo" => dc_config})
-      dc = mock(:dc)
-      VSphereCloud::Resources::Datacenter.should_receive(:new).with(dc_config).
-          once.and_return(dc)
-
-      resources = VSphereCloud::Resources.new
-      resources.datacenters.should == {"foo" => dc}
-    end
-
-    it "should use cached datacenters" do
-      vcenter_config = mock(:vcenter_config)
-      VSphereCloud::Config.vcenter = vcenter_config
-      dc_config = mock(:dc_config)
-      dc_config.stub(:name).and_return("foo")
-      vcenter_config.stub(:datacenters).and_return({"foo" => dc_config})
-      dc = mock(:dc)
-      VSphereCloud::Resources::Datacenter.should_receive(:new).with(dc_config).
-          once.and_return(dc)
-
-      resources = VSphereCloud::Resources.new
-      resources.datacenters.should == {"foo" => dc}
-      resources.datacenters.should == {"foo" => dc}
-    end
-
-    it "should flush stale cached datacenters" do
-      vcenter_config = mock(:vcenter_config)
-      VSphereCloud::Config.vcenter = vcenter_config
-      dc_config = mock(:dc_config)
-      dc_config.stub(:name).and_return("foo")
-      vcenter_config.stub(:datacenters).and_return({"foo" => dc_config})
-      dc = mock(:dc)
-      VSphereCloud::Resources::Datacenter.should_receive(:new).with(dc_config).
-          twice.and_return(dc)
-
-      now = Time.now.to_i
-      Time.should_receive(:now).and_return(now, now, now + 120, now + 120)
-
-      resources = VSphereCloud::Resources.new
-      resources.datacenters.should == {"foo" => dc}
-      resources.datacenters.should == {"foo" => dc}
-    end
-  end
-
-  describe :persistent_datastore do
-    it "should return the persistent datastore" do
-      dc = mock(:dc)
-      cluster = mock(:cluster)
-      dc.stub(:clusters).and_return({"bar" => cluster})
-      datastore = mock(:datastore)
-      cluster.stub(:persistent).with("baz").and_return(datastore)
-      resources = VSphereCloud::Resources.new
-      resources.stub(:datacenters).and_return({"foo" => dc})
-      resources.persistent_datastore("foo", "bar", "baz").should == datastore
-      resources.persistent_datastore("foo", "ba", "baz").should be_nil
-    end
-  end
-
-  describe :validate_persistent_datastore do
-    it "should return true if the provided datastore is still persistent" do
-      dc = mock(:dc)
-      cluster = mock(:cluster)
-      dc.stub(:clusters).and_return({"bar" => cluster})
-      datastore = mock(:datastore)
-      cluster.stub(:persistent).with("baz").and_return(datastore)
-      resources = VSphereCloud::Resources.new
-      resources.stub(:datacenters).and_return({"foo" => dc})
-      resources.validate_persistent_datastore("foo", "baz").should be_true
-    end
-
-    it "should return false if the provided datastore is not persistent" do
-      dc = mock(:dc)
-      cluster = mock(:cluster)
-      dc.stub(:clusters).and_return({"bar" => cluster})
-      cluster.stub(:persistent).with("baz").and_return(nil)
-      resources = VSphereCloud::Resources.new
-      resources.stub(:datacenters).and_return({"foo" => dc})
-      resources.validate_persistent_datastore("foo", "baz").should be_false
-    end
-  end
-
-  describe :place_persistent_datastore do
-    it "should return the datastore when it was placed successfully" do
-      dc = mock(:dc)
-      cluster = mock(:cluster)
-      dc.stub(:clusters).and_return({"bar" => cluster})
-      datastore = mock(:datastore)
-      datastore.should_receive(:allocate).with(1024)
-      cluster.should_receive(:pick_persistent).with(1024).and_return(datastore)
-      resources = VSphereCloud::Resources.new
-      resources.stub(:datacenters).and_return({"foo" => dc})
-      resources.place_persistent_datastore("foo", "bar", 1024).
-          should == datastore
-    end
-
-    it "should return nil when it wasn't placed successfully" do
-      dc = mock(:dc)
-      cluster = mock(:cluster)
-      dc.stub(:clusters).and_return({"bar" => cluster})
-      cluster.should_receive(:pick_persistent).with(1024).and_return(nil)
-      resources = VSphereCloud::Resources.new
-      resources.stub(:datacenters).and_return({"foo" => dc})
-      resources.place_persistent_datastore("foo", "bar", 1024).
-          should be_nil
-    end
-  end
-
-  describe :place do
-    it "should allocate memory and ephemeral disk space" do
-      dc = mock(:dc)
-      cluster = mock(:cluster)
-      dc.stub(:clusters).and_return({"bar" => cluster})
-      datastore = mock(:datastore)
-      cluster.stub(:name).and_return("bar")
-      cluster.stub(:persistent).with("baz").and_return(datastore)
-      resources = VSphereCloud::Resources.new
-      resources.stub(:datacenters).and_return({"foo" => dc})
-
-      scorer = mock(:scorer)
-      scorer.should_receive(:score).and_return(4)
-      VSphereCloud::Resources::Scorer.should_receive(:new).
-          with(cluster, 512, 1024, []).and_return(scorer)
-
-      cluster.should_receive(:allocate).with(512)
-      cluster.should_receive(:pick_ephemeral).with(1024).and_return(datastore)
-      datastore.should_receive(:allocate).with(1024)
-
-      resources.place(512, 1024, []).should == [cluster, datastore]
-    end
-
-    it "should prioritize persistent locality" do
-      dc = mock(:dc)
-      cluster_a = mock(:cluster_a)
-      cluster_b = mock(:cluster_b)
-      dc.stub(:clusters).and_return({"a" => cluster_a, "b" => cluster_b})
-
-      datastore_a = mock(:datastore_a)
-      cluster_a.stub(:name).and_return("ds_a")
-      cluster_a.stub(:persistent).with("ds_a").and_return(datastore_a)
-      cluster_a.stub(:persistent).with("ds_b").and_return(nil)
-
-      datastore_b = mock(:datastore_b)
-      cluster_b.stub(:name).and_return("ds_b")
-      cluster_b.stub(:persistent).with("ds_a").and_return(nil)
-      cluster_b.stub(:persistent).with("ds_b").and_return(datastore_b)
-
-      resources = VSphereCloud::Resources.new
-      resources.stub(:datacenters).and_return({"foo" => dc})
-
-      scorer_b = mock(:scorer_a)
-      scorer_b.should_receive(:score).and_return(4)
-      VSphereCloud::Resources::Scorer.should_receive(:new).
-          with(cluster_b, 512, 1024, [2048]).and_return(scorer_b)
-
-      cluster_b.should_receive(:allocate).with(512)
-      cluster_b.should_receive(:pick_ephemeral).with(1024).
-          and_return(datastore_b)
-      datastore_b.should_receive(:allocate).with(1024)
-
-      resources.place(512, 1024,
-                      [{:size => 2048, :dc_name => "foo", :ds_name => "ds_a"},
-                       {:size => 4096, :dc_name => "foo", :ds_name => "ds_b"}]).
-          should == [cluster_b, datastore_b]
-    end
-
-    it "should ignore locality when there is no space" do
-      dc = mock(:dc)
-      cluster_a = mock(:cluster_a)
-      cluster_b = mock(:cluster_b)
-      dc.stub(:clusters).and_return({"a" => cluster_a, "b" => cluster_b})
-
-      datastore_a = mock(:datastore_a)
-      cluster_a.stub(:name).and_return("ds_a")
-      cluster_a.stub(:persistent).with("ds_a").and_return(datastore_a)
-      cluster_a.stub(:persistent).with("ds_b").and_return(nil)
-
-      datastore_b = mock(:datastore_b)
-      cluster_b.stub(:name).and_return("ds_b")
-      cluster_b.stub(:persistent).with("ds_a").and_return(nil)
-      cluster_b.stub(:persistent).with("ds_b").and_return(datastore_b)
-
-      resources = VSphereCloud::Resources.new
-      resources.stub(:datacenters).and_return({"foo" => dc})
-
-      scorer_a = mock(:scorer_a)
-      scorer_a.should_receive(:score).twice.and_return(0)
-      VSphereCloud::Resources::Scorer.should_receive(:new).
-          with(cluster_a, 512, 1024, []).twice.and_return(scorer_a)
-
-      scorer_b = mock(:scorer_b)
-      scorer_b.should_receive(:score).and_return(4)
-      VSphereCloud::Resources::Scorer.should_receive(:new).
-          with(cluster_b, 512, 1024, [2048]).and_return(scorer_b)
-
-      cluster_b.should_receive(:allocate).with(512)
-      cluster_b.should_receive(:pick_ephemeral).with(1024).
-          and_return(datastore_b)
-      datastore_b.should_receive(:allocate).with(1024)
-
-      resources.place(512, 1024,
-                      [{:size => 2048, :dc_name => "foo", :ds_name => "ds_a"}]).
-          should == [cluster_b, datastore_b]
-    end
-  end
-end