bosh_openstack_cpi 0.0.4 → 0.0.5

data/spec/unit/create_vm_spec.rb

@@ -26,7 +26,7 @@ describe Bosh::OpenStackCloud::Cloud, "create_vm" do
 
   def openstack_params(unique_name, user_data, security_groups=[])
     {
-      :name=>"vm-#{unique_name}",
+      :name => "vm-#{unique_name}",
       :image_ref => "sc-id",
       :flavor_ref => "f-test",
       :key_name => "test_key",
@@ -53,10 +53,13 @@ describe Bosh::OpenStackCloud::Cloud, "create_vm" do
     server = double("server", :id => "i-test", :name => "i-test")
     image = double("image", :id => "sc-id", :name => "sc-id")
     flavor = double("flavor", :id => "f-test", :name => "m1.tiny")
-    address = double("address", :id => "a-test", :ip => "10.0.0.1", :instance_id => "i-test")
+    address = double("address", :id => "a-test", :ip => "10.0.0.1",
+                     :instance_id => "i-test")
 
     cloud = mock_cloud do |openstack|
-      openstack.servers.should_receive(:create).with(openstack_params(unique_name, user_data)).and_return(server)
+      openstack.servers.should_receive(:create).
+          with(openstack_params(unique_name, user_data, %w[default])).
+          and_return(server)
       openstack.images.should_receive(:find).and_return(image)
       openstack.flavors.should_receive(:find).and_return(flavor)
       openstack.addresses.should_receive(:each).and_yield(address)
@@ -64,10 +67,10 @@ describe Bosh::OpenStackCloud::Cloud, "create_vm" do
 
     cloud.should_receive(:generate_unique_name).and_return(unique_name)
     address.should_receive(:server=).with(nil)
-    server.should_receive(:state).and_return(:build)
-    cloud.should_receive(:wait_resource).with(server, :build, :active, :state)
+    cloud.should_receive(:wait_resource).with(server, :active, :state)
 
-    @registry.should_receive(:update_settings).with("i-test", agent_settings(unique_name))
+    @registry.should_receive(:update_settings).
+        with("i-test", agent_settings(unique_name))
 
     vm_id = cloud.create_vm("agent-id", "sc-id",
                             resource_pool_spec,
@@ -86,26 +89,29 @@ describe Bosh::OpenStackCloud::Cloud, "create_vm" do
         "name" => "vm-#{unique_name}"
       }
     }
-    security_groups = %w[foo bar]
+    security_groups = %w[bar foo]
     network_spec = dynamic_network_spec
     network_spec["cloud_properties"] = { "security_groups" => security_groups }
     server = double("server", :id => "i-test", :name => "i-test")
     image = double("image", :id => "sc-id", :name => "sc-id")
     flavor = double("flavor", :id => "f-test", :name => "m1.tiny")
-    address = double("address", :id => "a-test", :ip => "10.0.0.1", :instance_id => nil)
+    address = double("address", :id => "a-test", :ip => "10.0.0.1",
+                     :instance_id => nil)
 
     cloud = mock_cloud do |openstack|
-      openstack.servers.should_receive(:create).with(openstack_params(unique_name, user_data, security_groups)).and_return(server)
+      openstack.servers.should_receive(:create).
+          with(openstack_params(unique_name, user_data, security_groups)).
+          and_return(server)
       openstack.images.should_receive(:find).and_return(image)
       openstack.flavors.should_receive(:find).and_return(flavor)
       openstack.addresses.should_receive(:each).and_yield(address)
     end
 
     cloud.should_receive(:generate_unique_name).and_return(unique_name)
-    server.should_receive(:state).and_return(:build)
-    cloud.should_receive(:wait_resource).with(server, :build, :active, :state)
+    cloud.should_receive(:wait_resource).with(server, :active, :state)
 
-    @registry.should_receive(:update_settings).with("i-test", agent_settings(unique_name, network_spec))
+    @registry.should_receive(:update_settings).
+        with("i-test", agent_settings(unique_name, network_spec))
 
     vm_id = cloud.create_vm("agent-id", "sc-id",
                             resource_pool_spec,
@@ -118,19 +124,19 @@ describe Bosh::OpenStackCloud::Cloud, "create_vm" do
     server = double("server", :id => "i-test", :name => "i-test")
     image = double("image", :id => "sc-id", :name => "sc-id")
     flavor = double("flavor", :id => "f-test", :name => "m1.tiny")
-    address = double("address", :id => "a-test", :ip => "10.0.0.1", :instance_id => "i-test")
+    address = double("address", :id => "a-test", :ip => "10.0.0.1",
+                     :instance_id => "i-test")
 
     cloud = mock_cloud do |openstack|
       openstack.servers.should_receive(:create).and_return(server)
       openstack.images.should_receive(:find).and_return(image)
       openstack.flavors.should_receive(:find).and_return(flavor)
-      openstack.addresses.should_receive(:each).and_yield(address)
+      openstack.addresses.should_receive(:find).and_return(address)
     end
 
     address.should_receive(:server=).with(nil)
     address.should_receive(:server=).with(server)
-    server.should_receive(:state).and_return(:build)
-    cloud.should_receive(:wait_resource).with(server, :build, :active, :state)
+    cloud.should_receive(:wait_resource).with(server, :active, :state)
 
     @registry.should_receive(:update_settings)
 
@@ -139,4 +145,62 @@ describe Bosh::OpenStackCloud::Cloud, "create_vm" do
                             combined_network_spec)
   end
 
+  def volume(zone)
+    vol = double("volume")
+    vol.stub(:availability_zone).and_return(zone)
+    vol
+  end
+
+  describe "#select_availability_zone" do
+    it "should return nil when all values are nil" do
+      cloud = mock_cloud
+      cloud.select_availability_zone(nil, nil).should == nil
+    end
+
+    it "should select the resource pool availability_zone when disks are nil" do
+      cloud = mock_cloud
+      cloud.select_availability_zone(nil, "foobar-1a").should == "foobar-1a"
+    end
+
+    it "should select the zone from a list of disks" do
+      cloud = mock_cloud do |openstack|
+        openstack.volumes.stub(:get).and_return(volume("foo"), volume("foo"))
+      end
+      cloud.select_availability_zone(%w[cid1 cid2], nil).should == "foo"
+    end
+
+    it "should select the zone from a list of disks and a default" do
+      cloud = mock_cloud do |openstack|
+        openstack.volumes.stub(:get).and_return(volume("foo"), volume("foo"))
+      end
+      cloud.select_availability_zone(%w[cid1 cid2], "foo").should == "foo"
+    end
+  end
+
+  describe "#ensure_same_availability_zone" do
+    it "should raise an error when the zones differ" do
+      cloud = mock_cloud
+      expect {
+        cloud.ensure_same_availability_zone([volume("foo"), volume("bar")],
+                                            nil)
+      }.to raise_error Bosh::Clouds::CloudError
+    end
+
+    it "should raise an error when the zones differ" do
+      cloud = mock_cloud
+      expect {
+        cloud.ensure_same_availability_zone([volume("foo"), volume("bar")],
+                                            "foo")
+      }.to raise_error Bosh::Clouds::CloudError
+    end
+
+    it "should raise an error when the zones differ" do
+      cloud = mock_cloud
+      expect {
+        cloud.ensure_same_availability_zone([volume("foo"), volume("foo")],
+                                            "bar")
+      }.to raise_error Bosh::Clouds::CloudError
+    end
+  end
+
 end

data/spec/unit/delete_disk_spec.rb

@@ -8,12 +8,13 @@ describe Bosh::OpenStackCloud::Cloud do
     volume = double("volume", :id => "v-foobar")
 
     cloud = mock_cloud do |openstack|
-      openstack.volumes.should_receive(:get).with("v-foobar").and_return(volume)
+      openstack.volumes.should_receive(:get).
+        with("v-foobar").and_return(volume)
     end
 
     volume.should_receive(:status).and_return(:available)
     volume.should_receive(:destroy).and_return(true)
-    cloud.should_receive(:wait_resource).with(volume, :available, :deleted)
+    cloud.should_receive(:wait_resource).with(volume, :deleted, :status, true)
 
     cloud.delete_disk("v-foobar")
   end
@@ -29,7 +30,8 @@ describe Bosh::OpenStackCloud::Cloud do
 
     expect {
       cloud.delete_disk("v-foobar")
-    }.to raise_error(Bosh::Clouds::CloudError, "Cannot delete volume `v-foobar', state is busy")
+    }.to raise_error(Bosh::Clouds::CloudError,
+                     "Cannot delete volume `v-foobar', state is busy")
   end
 
 end

data/spec/unit/delete_stemcell_spec.rb

@@ -4,7 +4,7 @@ require File.expand_path("../../spec_helper", __FILE__)
 
 describe Bosh::OpenStackCloud::Cloud do
 
-  it "deregisters OpenStack image with no kernel nor ramdisk associated" do
+  it "deletes stemcell (only image)" do
     image = double("image", :id => "i-foo", :name => "i-foo",
                    :properties => {})
 
@@ -17,11 +17,14 @@ describe Bosh::OpenStackCloud::Cloud do
     cloud.delete_stemcell("i-foo")
   end
 
-  it "deregisters OpenStack image, kernel and ramdisk" do
+  it "deletes stemcell (image, kernel and ramdisk)" do
     image = double("image", :id => "i-foo", :name => "i-foo",
-                   :properties => {"kernel_id" => "k-id", "ramdisk_id" => "r-id"})
-    kernel = double("image", :id => "k-id", :properties => {"stemcell" => "i-foo"})
-    ramdisk = double("image", :id => "r-id", :properties => {"stemcell" => "i-foo"})
+                   :properties => {"kernel_id" => "k-id",
+                                   "ramdisk_id" => "r-id"})
+    kernel = double("image", :id => "k-id",
+                    :properties => {"stemcell" => "i-foo"})
+    ramdisk = double("image", :id => "r-id",
+                     :properties => {"stemcell" => "i-foo"})
 
     cloud = mock_glance do |glance|
       glance.images.stub(:find_by_id).with("i-foo").and_return(image)
@@ -36,9 +39,10 @@ describe Bosh::OpenStackCloud::Cloud do
     cloud.delete_stemcell("i-foo")
   end
 
-  it "deregisters OpenStack image with kernel and ramdisk not uploaded by the CPI" do
+  it "deletes stemcell (kernel and ramdisk not uploaded by the CPI)" do
     image = double("image", :id => "i-foo", :name => "i-foo",
-                   :properties => {"kernel_id" => "k-id", "ramdisk_id" => "r-id"})
+                   :properties => {"kernel_id" => "k-id",
+                                   "ramdisk_id" => "r-id"})
     kernel = double("image", :id => "k-id", :properties => {})
     ramdisk = double("image", :id => "r-id", :properties => {})
 
@@ -53,11 +57,14 @@ describe Bosh::OpenStackCloud::Cloud do
     cloud.delete_stemcell("i-foo")
   end
 
-  it "deregisters OpenStack image with kernel and ramdisk that belongs to other stemcell" do
+  it "deletes stemcell (kernel and ramdisk that do not belong to stemcell)" do
     image = double("image", :id => "i-foo", :name => "i-foo",
-                   :properties => {"kernel_id" => "k-id", "ramdisk_id" => "r-id"})
-    kernel = double("image", :id => "k-id", :properties => {"stemcell" => "i-bar"})
-    ramdisk = double("image", :id => "r-id", :properties => {"stemcell" => "i-bar"})
+                   :properties => {"kernel_id" => "k-id",
+                                   "ramdisk_id" => "r-id"})
+    kernel = double("image", :id => "k-id",
+                    :properties => {"stemcell" => "i-bar"})
+    ramdisk = double("image", :id => "r-id",
+                     :properties => {"stemcell" => "i-bar"})
 
     cloud = mock_glance do |glance|
       glance.images.stub(:find_by_id).with("i-foo").and_return(image)

data/spec/unit/delete_vm_spec.rb

@@ -15,9 +15,8 @@ describe Bosh::OpenStackCloud::Cloud do
       openstack.servers.should_receive(:get).with("i-foobar").and_return(server)
     end
 
-    server.should_receive(:state).and_return(:active)
     server.should_receive(:destroy).and_return(true)
-    cloud.should_receive(:wait_resource).with(server, :active, :terminated, :state)
+    cloud.should_receive(:wait_resource).with(server, :terminated, :state, true)
 
     @registry.should_receive(:delete_settings).with("i-foobar")
 

data/spec/unit/detach_disk_spec.rb

@@ -11,17 +11,21 @@ describe Bosh::OpenStackCloud::Cloud do
   it "detaches an OpenStack volume from a server" do
     server = double("server", :id => "i-test", :name => "i-test")
     volume = double("volume", :id => "v-foobar")
-    volume_attachments = double("body", :body => {"volumeAttachments" => [{"volumeId" => "v-foobar"}, {"volumeId" => "v-barfoo"}]})
+    volume_attachments = double("body", :body => {"volumeAttachments" =>
+                                                   [{"volumeId" => "v-foobar"},
+                                                   {"volumeId" => "v-barfoo"}]})
 
     cloud = mock_cloud do |openstack|
-      openstack.servers.should_receive(:get).with("i-test").and_return(server)
-      openstack.volumes.should_receive(:get).with("v-foobar").and_return(volume)
-      openstack.should_receive(:get_server_volumes).and_return(volume_attachments)
+      openstack.servers.should_receive(:get).
+        with("i-test").and_return(server)
+      openstack.volumes.should_receive(:get).
+        with("v-foobar").and_return(volume)
+      openstack.should_receive(:get_server_volumes).
+        and_return(volume_attachments)
     end
 
-    volume.should_receive(:status).and_return(:"in-use")
     volume.should_receive(:detach).with(server.id, "v-foobar").and_return(true)
-    cloud.should_receive(:wait_resource).with(volume, :"in-use", :available)
+    cloud.should_receive(:wait_resource).with(volume, :available)
 
     old_settings = {
       "foo" => "bar",
@@ -42,8 +46,10 @@ describe Bosh::OpenStackCloud::Cloud do
       }
     }
 
-    @registry.should_receive(:read_settings).with("i-test").and_return(old_settings)
-    @registry.should_receive(:update_settings).with("i-test", new_settings)
+    @registry.should_receive(:read_settings).
+      with("i-test").and_return(old_settings)
+    @registry.should_receive(:update_settings).
+      with("i-test", new_settings)
 
     cloud.detach_disk("i-test", "v-foobar")
   end
@@ -51,12 +57,17 @@ describe Bosh::OpenStackCloud::Cloud do
   it "raises an error when volume is not attached to a server" do
     server = double("server", :id => "i-test", :name => "i-test")
     volume = double("volume", :id => "v-barfoo")
-    volume_attachments = double("body", :body => {"volumeAttachments" => [{"volumeId" => "v-foobar"}]})
+    volume_attachments = double("body",
+                                :body => {"volumeAttachments" =>
+                                            [{"volumeId" => "v-foobar"}]})
 
     cloud = mock_cloud do |openstack|
-      openstack.servers.should_receive(:get).with("i-test").and_return(server)
-      openstack.volumes.should_receive(:get).with("v-barfoo").and_return(volume)
-      openstack.should_receive(:get_server_volumes).and_return(volume_attachments)
+      openstack.servers.should_receive(:get).
+        with("i-test").and_return(server)
+      openstack.volumes.should_receive(:get).
+        with("v-barfoo").and_return(volume)
+      openstack.should_receive(:get_server_volumes).
+        and_return(volume_attachments)
     end
 
     expect {

data/spec/unit/helpers_spec.rb

@@ -3,6 +3,10 @@
 require File.expand_path("../../spec_helper", __FILE__)
 
 describe Bosh::OpenStackCloud::Helpers do
+  before(:each) do
+    Bosh::Clouds::Config.stub(:task_checkpoint)
+  end
+
   it "should time out" do
     cloud = mock_cloud
 
@@ -12,9 +16,9 @@ describe Bosh::OpenStackCloud::Helpers do
     resource.stub(:status).and_return(:start)
     cloud.stub(:sleep)
 
-    lambda {
-      cloud.wait_resource(resource, :start, :stop, :status, 0.1)
-    }.should raise_error Bosh::Clouds::CloudError, /Timed out/
+    expect {
+      cloud.wait_resource(resource, :stop, :status, false, 0.1)
+    }.to raise_error Bosh::Clouds::CloudError, /Timed out/
   end
 
   it "should not time out" do
@@ -26,9 +30,45 @@ describe Bosh::OpenStackCloud::Helpers do
     resource.stub(:status).and_return(:start, :stop)
     cloud.stub(:sleep)
 
-    lambda {
-      cloud.wait_resource(resource, :start, :stop, :status, 0.1)
-    }.should_not raise_error Bosh::Clouds::CloudError
+    cloud.wait_resource(resource, :stop, :status, false, 0.1)
+  end
+
+  it "should raise Bosh::Clouds::CloudError if state is error" do
+    cloud = mock_cloud
+
+    resource = double("resource")
+    resource.stub(:id).and_return("foobar")
+    resource.stub(:reload).and_return(cloud)
+    resource.stub(:status).and_return(:error)
+    cloud.stub(:sleep)
+
+    expect {
+      cloud.wait_resource(resource, :stop, :status, false, 0.1)
+    }.to raise_error Bosh::Clouds::CloudError, /state is error/
+  end
+
+  it "should raise Bosh::Clouds::CloudError if resource not found" do
+    cloud = mock_cloud
+
+    resource = double("resource")
+    resource.stub(:id).and_return("foobar")
+    resource.stub(:reload).and_return(nil)
+    cloud.stub(:sleep)
+
+    expect {
+      cloud.wait_resource(resource, :deleted, :status, false, 0.1)
+    }.to raise_error Bosh::Clouds::CloudError, /Resource not found/
   end
 
+  it "should not raise and exception if resource not found" do
+    cloud = mock_cloud
+
+    resource = double("resource")
+    resource.stub(:id).and_return("foobar")
+    resource.stub(:reload).and_return(nil)
+    resource.stub(:status).and_return(:deleted)
+    cloud.stub(:sleep)
+
+    cloud.wait_resource(resource, :deleted, :status, true, 0.1)
+  end
 end

data/spec/unit/network_configurator_spec.rb

@@ -11,13 +11,13 @@ describe Bosh::OpenStackCloud::NetworkConfigurator do
   end
 
   it "should raise an error if the spec isn't a hash" do
-    lambda {
+    expect {
       Bosh::OpenStackCloud::NetworkConfigurator.new("foo")
-    }.should raise_error ArgumentError
+    }.to raise_error ArgumentError
   end
 
   describe "security groups" do
-    it "should only be extracted from dynamic network" do
+    it "should be extracted from both dynamic and vip network" do
       spec = {}
       spec["network_a"] = dynamic_network_spec
       set_security_groups(spec["network_a"], %w[foo])
@@ -25,12 +25,12 @@ describe Bosh::OpenStackCloud::NetworkConfigurator do
       set_security_groups(spec["network_b"], %w[bar])
 
       nc = Bosh::OpenStackCloud::NetworkConfigurator.new(spec)
-      nc.security_groups(nil).should == %w[foo]
+      nc.security_groups(nil).should == %w[bar foo]
     end
 
     it "should return the default groups if none are extracted" do
       spec = {}
-      spec["network_a"] = dynamic_network_spec
+      spec["network_a"] = {"type" => "dynamic"}
 
       nc = Bosh::OpenStackCloud::NetworkConfigurator.new(spec)
       nc.security_groups(%w[foo]).should == %w[foo]
@@ -38,7 +38,7 @@ describe Bosh::OpenStackCloud::NetworkConfigurator do
 
     it "should return an empty list if no default group is set" do
       spec = {}
-      spec["network_a"] = dynamic_network_spec
+      spec["network_a"] = {"type" => "dynamic"}
 
       nc = Bosh::OpenStackCloud::NetworkConfigurator.new(spec)
       nc.security_groups(nil).should == []
@@ -49,9 +49,9 @@ describe Bosh::OpenStackCloud::NetworkConfigurator do
       spec["network_a"] = dynamic_network_spec
       set_security_groups(spec["network_a"], "foo")
 
-      lambda {
+      expect {
         Bosh::OpenStackCloud::NetworkConfigurator.new(spec)
-      }.should raise_error ArgumentError, "security groups must be an Array"
+      }.to raise_error ArgumentError, "security groups must be an Array"
     end
   end
 end

data/spec/unit/reboot_vm_spec.rb

@@ -19,15 +19,13 @@ describe Bosh::OpenStackCloud::Cloud do
 
   it "soft reboots an OpenStack server" do
     @server.should_receive(:reboot)
-    @server.should_receive(:state).and_return(:reboot)
-    @cloud.should_receive(:wait_resource).with(@server, :reboot, :active, :state)
+    @cloud.should_receive(:wait_resource).with(@server, :active, :state)
     @cloud.send(:soft_reboot, @server)
   end
 
   it "hard reboots an OpenStack server" do
     @server.should_receive(:reboot)
-    @server.should_receive(:state).and_return(:reboot)
-    @cloud.should_receive(:wait_resource).with(@server, :reboot, :active, :state)
+    @cloud.should_receive(:wait_resource).with(@server, :active, :state)
     @cloud.send(:hard_reboot, @server)
   end