fog-maestrodev 1.7.0.20121114190951

data/tests/openstack/requests/image/image_tests.rb

@@ -0,0 +1,119 @@
+Shindo.tests('Fog::Image[:openstack] | image requests', ['openstack']) do
+  openstack = Fog::Identity[:openstack]
+  @image_attributes = {
+    'name'            => 'new image',
+    'owner'           => openstack.current_tenant['id'],
+    'is_public'       => 'true',
+    'copy_from'       => 'http://website.com/image.iso',
+    'disk_format'     => 'iso',
+    'properties'      =>
+      {'user_id'      => openstack.current_user['id'],
+       'owner_id'     => openstack.current_tenant['id']},
+    'container_format'=> 'bare' }
+
+  @image_format = {
+    'name'             => String,
+    'container_format' => String,
+    'disk_format'      => String,
+    'checksum'         => String,
+    'id'               => String,
+    'size'             => Integer
+  }
+
+  @detailed_image_format = {
+    'id' => String,
+    'name' => String,
+    'size' => Integer,
+    'disk_format' => String,
+    'container_format' => String,
+    'checksum' => String,
+    'min_disk'  => Integer,
+    'created_at' => String,
+    'deleted_at' => Fog::Nullable::String,
+    'updated_at' => String,
+    'deleted' => Fog::Boolean,
+    'protected' => Fog::Boolean,
+    'is_public' => Fog::Boolean,
+    'status' => String,
+    'min_ram' => Integer,
+    'owner' => Fog::Nullable::String,
+    'properties' => Hash
+  }
+
+  @image_meta_format ={
+    'X-Image-Meta-Is_public'=>String,
+    'X-Image-Meta-Min_disk'=>Fog::Nullable::String,
+    'X-Image-Meta-Property-Ramdisk_id'=>Fog::Nullable::String,
+    'X-Image-Meta-Disk_format'=>Fog::Nullable::String,
+    'X-Image-Meta-Created_at'=>String,
+    'X-Image-Meta-Container_format'=>Fog::Nullable::String,
+    'Etag'=>String,
+    'Location'=>String,
+    'X-Image-Meta-Protected'=>String,
+    'Date'=>String,
+    'X-Image-Meta-Name'=>String,
+    'X-Image-Meta-Min_ram'=>String,
+    'Content-Type'=>String,
+    'X-Image-Meta-Updated_at'=>String,
+    'X-Image-Meta-Property-Kernel_id'=>Fog::Nullable::String,
+    'X-Image-Meta-Size'=>String,
+    'X-Image-Meta-Checksum'=>Fog::Nullable::String,
+    'X-Image-Meta-Deleted'=>String,
+    'Content-Length'=>String,
+    'X-Image-Meta-Status'=>String,
+    'X-Image-Meta-Owner'=>String,
+    'X-Image-Meta-Id'=>String
+  }
+
+  @image_members_format =[
+    {'can_share'=>Fog::Nullable::Boolean,
+      'member_id'=>String
+    }
+  ]
+
+  tests('success') do
+    tests('#list_public_images').formats({'images' => [@image_format]}) do
+      Fog::Image[:openstack].list_public_images.body
+    end
+
+    tests('#list_public_images_detailed').formats({'images' => [@detailed_image_format]}) do
+      Fog::Image[:openstack].list_public_images_detailed.body
+    end
+
+    tests('#create_image').formats({'image' => @detailed_image_format}) do
+      @instance = Fog::Image[:openstack].create_image(@image_attributes).body
+    end
+
+    tests('#get_image').formats(@image_meta_format) do
+       Fog::Image[:openstack].get_image(@instance['image']['id']).headers
+    end
+
+    tests('#update_image').formats(@detailed_image_format) do
+       Fog::Image[:openstack].update_image({:id => @instance['image']['id'],
+                                            :name => 'edit image'}).body['image']
+    end
+
+    tests('#add_member_to_image').succeeds do
+       Fog::Image[:openstack].add_member_to_image(
+           @instance['image']['id'], @instance['image']['owner'])
+    end
+
+    tests('#get_image_members').succeeds do
+       Fog::Image[:openstack].get_image_members(@instance['image']['id'])
+    end
+
+    tests('#get_shared_images').succeeds do
+       Fog::Image[:openstack].get_shared_images(@instance['image']['owner'])
+    end
+
+    tests('#remove_member_from_image').succeeds do
+       Fog::Image[:openstack].remove_member_from_image(
+           @instance['image']['id'], @instance['image']['owner'])
+    end
+
+    tests('#delete_image').succeeds do
+      Fog::Image[:openstack].delete_image(@instance['image']['id'])
+    end
+
+  end
+end

data/tests/openstack/requests/network/network_tests.rb

@@ -0,0 +1,56 @@
+Shindo.tests('Fog::Network[:openstack] | network requests', ['openstack']) do
+
+  @network_format = {
+    'id'             => String,
+    'name'           => String,
+    'subnets'        => Array,
+    'shared'         => Fog::Boolean,
+    'status'         => String,
+    'admin_state_up' => Fog::Boolean,
+    'tenant_id'      => String,
+  }
+
+  tests('success') do
+    tests('#create_network').formats({'network' => @network_format}) do
+      attributes = {:name => 'net_name', :shared => false,
+                    :admin_state_up => true, :tenant_id => 'tenant_id'}
+      Fog::Network[:openstack].create_network(attributes).body
+    end
+
+    tests('#list_networks').formats({'networks' => [@network_format]}) do
+      Fog::Network[:openstack].list_networks.body
+    end
+
+    tests('#get_network').formats({'network' => @network_format}) do
+      network_id = Fog::Network[:openstack].networks.all.first.id
+      Fog::Network[:openstack].get_network(network_id).body
+    end
+
+    tests('#update_network').formats({'network' => @network_format}) do
+      network_id = Fog::Network[:openstack].networks.all.first.id
+      attributes = {:name => 'net_name', :shared => false,
+                    :admin_state_up => true}
+      Fog::Network[:openstack].update_network(network_id, attributes).body
+    end
+
+    tests('#delete_network').succeeds do
+      network_id = Fog::Network[:openstack].networks.all.first.id
+      Fog::Network[:openstack].delete_network(network_id)
+    end
+  end
+
+  tests('failure') do
+    tests('#get_network').raises(Fog::Network::OpenStack::NotFound) do
+      Fog::Network[:openstack].get_network(0)
+    end
+
+    tests('#update_network').raises(Fog::Network::OpenStack::NotFound) do
+      Fog::Network[:openstack].update_network(0, {})
+    end
+
+    tests('#delete_network').raises(Fog::Network::OpenStack::NotFound) do
+      Fog::Network[:openstack].delete_network(0)
+    end
+  end
+
+end

data/tests/openstack/requests/network/port_tests.rb

@@ -0,0 +1,63 @@
+Shindo.tests('Fog::Network[:openstack] | port requests', ['openstack']) do
+
+  @port_format = {
+    'id'             => String,
+    'name'           => String,
+    'network_id'     => String,
+    'fixed_ips'      => Array,
+    'mac_address'    => String,
+    'status'         => String,
+    'admin_state_up' => Fog::Boolean,
+    'device_owner'   => String,
+    'device_id'      => String,
+    'tenant_id'      => String,
+  }
+
+  tests('success') do
+    tests('#create_port').formats({'port' => @port_format}) do
+      network_id = 'net_id'
+      attributes = {:name => 'port_name', :fixed_ips => [],
+                    :mac_address => 'fa:16:3e:62:91:7f', :admin_state_up => true,
+                    :device_owner => 'device_owner', :device_id => 'device_id',
+                    :tenant_id => 'tenant_id'}
+      Fog::Network[:openstack].create_port(network_id, attributes).body
+    end
+
+    tests('#list_port').formats({'ports' => [@port_format]}) do
+      Fog::Network[:openstack].list_ports.body
+    end
+
+    tests('#get_port').formats({'port' => @port_format}) do
+      port_id = Fog::Network[:openstack].ports.all.first.id
+      Fog::Network[:openstack].get_port(port_id).body
+    end
+
+    tests('#update_port').formats({'port' => @port_format}) do
+      port_id = Fog::Network[:openstack].ports.all.first.id
+      attributes = {:name => 'port_name', :fixed_ips => [],
+                    :admin_state_up => true, :device_owner => 'device_owner',
+                    :device_id => 'device_id'}
+      Fog::Network[:openstack].update_port(port_id, attributes).body
+    end
+
+    tests('#delete_port').succeeds do
+      port_id = Fog::Network[:openstack].ports.all.first.id
+      Fog::Network[:openstack].delete_port(port_id)
+    end
+  end
+
+  tests('failure') do
+    tests('#get_port').raises(Fog::Network::OpenStack::NotFound) do
+      Fog::Network[:openstack].get_port(0)
+    end
+
+    tests('#update_port').raises(Fog::Network::OpenStack::NotFound) do
+      Fog::Network[:openstack].update_port(0, {})
+    end
+
+    tests('#delete_port').raises(Fog::Network::OpenStack::NotFound) do
+      Fog::Network[:openstack].delete_port(0)
+    end
+  end
+
+end

data/tests/openstack/requests/network/subnet_tests.rb

@@ -0,0 +1,66 @@
+Shindo.tests('Fog::Network[:openstack] | subnet requests', ['openstack']) do
+
+  @subnet_format = {
+    'id'               => String,
+    'name'             => String,
+    'network_id'       => String,
+    'cidr'             => String,
+    'ip_version'       => Integer,
+    'gateway_ip'       => String,
+    'allocation_pools' => Array,
+    'dns_nameservers'  => Array,
+    'host_routes'      => Array,
+    'enable_dhcp'      => Fog::Boolean,
+    'tenant_id'        => String,
+  }
+
+  tests('success') do
+    tests('#create_subnet').formats({'subnet' => @subnet_format}) do
+      network_id = 'net_id'
+      cidr = '10.2.2.0/24'
+      ip_version = 4
+      attributes = {:name => 'subnet_name', :gateway_ip => '10.2.2.1',
+                    :allocation_pools => [], :dns_nameservers => [],
+                    :host_routes => [], :enable_dhcp => true,
+                    :tenant_id => 'tenant_id'}
+      Fog::Network[:openstack].create_subnet(network_id, cidr, ip_version, attributes).body
+    end
+
+    tests('#list_subnet').formats({'subnets' => [@subnet_format]}) do
+      Fog::Network[:openstack].list_subnets.body
+    end
+
+    tests('#get_subnet').formats({'subnet' => @subnet_format}) do
+      subnet_id = Fog::Network[:openstack].subnets.all.first.id
+      Fog::Network[:openstack].get_subnet(subnet_id).body
+    end
+
+    tests('#update_subnet').formats({'subnet' => @subnet_format}) do
+      subnet_id = Fog::Network[:openstack].subnets.all.first.id
+      attributes = {:name => 'subnet_name', :gateway_ip => '10.2.2.1',
+                    :dns_nameservers => [], :host_routes => [],
+                    :enable_dhcp => true}
+      Fog::Network[:openstack].update_subnet(subnet_id, attributes).body
+    end
+
+    tests('#delete_subnet').succeeds do
+      subnet_id = Fog::Network[:openstack].subnets.all.first.id
+      Fog::Network[:openstack].delete_subnet(subnet_id)
+    end
+  end
+
+  tests('failure') do
+    tests('#get_subnet').raises(Fog::Network::OpenStack::NotFound) do
+      Fog::Network[:openstack].get_subnet(0)
+    end
+
+    tests('#update_subnet').raises(Fog::Network::OpenStack::NotFound) do
+      Fog::Network[:openstack].update_subnet(0, {})
+    end
+
+    tests('#delete_subnet').raises(Fog::Network::OpenStack::NotFound) do
+      Fog::Network[:openstack].delete_subnet(0)
+    end
+  end
+
+end

data/tests/ovirt/compute_tests.rb

@@ -0,0 +1,24 @@
+Shindo.tests('Fog::Compute[:ovirt]', ['ovirt']) do
+
+  compute = Fog::Compute[:ovirt]
+
+  tests("Compute attributes") do
+    %w{ ovirt_attrs }.each do |attr|
+      test("it should respond to #{attr}") { compute.respond_to? attr }
+    end
+  end
+
+  tests("Compute collections") do
+    %w{ servers templates clusters interfaces }.each do |collection|
+      test("it should respond to #{collection}") { compute.respond_to? collection }
+    end
+  end
+
+  tests("Compute requests") do
+    %w{ add_interface create_vm datacenters destroy_interface destroy_vm get_cluster get_template
+        get_virtual_machine list_clusters list_networks list_template_interfaces list_templates
+        list_virtual_machines list_vm_interfaces storage_domains update_interface update_vm vm_action  }.each do |collection|
+      test("it should respond to #{collection}") { compute.respond_to? collection }
+    end
+  end
+end

data/tests/ovirt/models/compute/cluster_tests.rb

@@ -0,0 +1,31 @@
+Shindo.tests('Fog::Compute[:ovirt] | cluster model', ['ovirt']) do
+
+  clusters = Fog::Compute[:ovirt].clusters
+  cluster = clusters.last
+
+  tests('The cluster model should') do
+    tests('have the action') do
+      test('reload') { cluster.respond_to? 'reload' }
+      %w{ networks }.each do |action|
+        test(action) { cluster.respond_to? action }
+      end
+    end
+    tests('have attributes') do
+      model_attribute_hash = cluster.attributes
+      attributes = [ :id,
+        :name]
+      tests("The cluster model should respond to") do
+        attributes.each do |attribute|
+          test("#{attribute}") { cluster.respond_to? attribute }
+        end
+      end
+      tests("The attributes hash should have key") do
+        attributes.each do |attribute|
+          test("#{attribute}") { model_attribute_hash.has_key? attribute }
+        end
+      end
+    end
+    test('be a kind of Fog::Compute::Ovirt::Cluster') { cluster.kind_of? Fog::Compute::Ovirt::Cluster }
+  end
+
+end

data/tests/ovirt/models/compute/clusters_tests.rb

@@ -0,0 +1,9 @@
+Shindo.tests('Fog::Compute[:ovirt] | clusters collection', ['ovirt']) do
+
+  clusters = Fog::Compute[:ovirt].clusters
+
+  tests('The clusters collection') do
+    test('should be a kind of Fog::Compute::Ovirt::Clusters') { clusters.kind_of? Fog::Compute::Ovirt::Clusters }
+  end
+
+end

data/tests/ovirt/models/compute/interface_tests.rb

@@ -0,0 +1,27 @@
+Shindo.tests('Fog::Compute[:ovirt] | interface model', ['ovirt']) do
+
+  interfaces = Fog::Compute[:ovirt].servers.last.interfaces
+  interface = interfaces.last
+
+  tests('The interface model should') do
+    tests('have the action') do
+      test('reload') { interface.respond_to? 'reload' }
+    end
+    tests('have attributes') do
+      model_attribute_hash = interface.attributes
+      attributes = [ :id, :name, :network]
+      tests("The interface model should respond to") do
+        attributes.each do |attribute|
+          test("#{attribute}") { interface.respond_to? attribute }
+        end
+      end
+      tests("The attributes hash should have key") do
+        attributes.each do |attribute|
+          test("#{attribute}") { model_attribute_hash.has_key? attribute }
+        end
+      end
+    end
+    test('be a kind of Fog::Compute::Ovirt::Interface') { interface.kind_of? Fog::Compute::Ovirt::Interface }
+  end
+
+end

data/tests/ovirt/models/compute/interfaces_tests.rb

@@ -0,0 +1,9 @@
+Shindo.tests('Fog::Compute[:ovirt] | interfaces collection', ['ovirt']) do
+
+  interfaces = Fog::Compute[:ovirt].interfaces
+
+  tests('The interfaces collection') do
+    test('should be a kind of Fog::Compute::Ovirt::Interfaces') { interfaces.kind_of? Fog::Compute::Ovirt::Interfaces }
+  end
+
+end

data/tests/ovirt/models/compute/server_tests.rb

@@ -0,0 +1,51 @@
+Shindo.tests('Fog::Compute[:ovirt] | server model', ['ovirt']) do
+
+  servers = Fog::Compute[:ovirt].servers
+  server = servers.last
+
+  tests('The server model should') do
+    tests('have the action') do
+      test('reload') { server.respond_to? 'reload' }
+      %w{ start stop destroy reboot suspend }.each do |action|
+        test(action) { server.respond_to? action }
+      end
+      %w{ start reboot suspend stop }.each do |action|
+        test("#{action} returns successfully") {
+          begin
+            server.send(action.to_sym) ? true : false
+          rescue OVIRT::OvirtException
+            #ovirt exceptions are acceptable for the above actions.
+            true
+          end
+        }
+      end
+    end
+    tests('have attributes') do
+      model_attribute_hash = server.attributes
+      attributes = [ :id,
+        :name,
+        :description,
+        :profile,
+        :display,
+        :creation_time,
+        :os,
+        :status,
+        :cores,
+        :memory,
+        :cluster,
+        :template]
+      tests("The server model should respond to") do
+        attributes.each do |attribute|
+          test("#{attribute}") { server.respond_to? attribute }
+        end
+      end
+      tests("The attributes hash should have key") do
+        attributes.each do |attribute|
+          test("#{attribute}") { model_attribute_hash.has_key? attribute }
+        end
+      end
+    end
+    test('be a kind of Fog::Compute::Ovirt::Server') { server.kind_of? Fog::Compute::Ovirt::Server }
+  end
+
+end

data/tests/ovirt/models/compute/servers_tests.rb

@@ -0,0 +1,14 @@
+Shindo.tests('Fog::Compute[:ovirt] | servers collection', ['ovirt']) do
+
+  servers = Fog::Compute[:ovirt].servers
+
+  tests('The servers collection') do
+    test('should not be empty') { not servers.empty? }
+    test('should be a kind of Fog::Compute::Ovirt::Servers') { servers.kind_of? Fog::Compute::Ovirt::Servers }
+    tests('should be able to reload itself').succeeds { servers.reload }
+    tests('should be able to get a model') do
+      tests('by instance uuid').succeeds { servers.get servers.first.id }
+    end
+  end
+
+end

data/tests/ovirt/models/compute/template_tests.rb

@@ -0,0 +1,28 @@
+Shindo.tests('Fog::Compute[:ovirt] | template model', ['ovirt']) do
+
+  templates = Fog::Compute[:ovirt].templates
+  template = templates.last
+
+  tests('The template model should') do
+    tests('have the action') do
+      test('reload') { template.respond_to? 'reload' }
+    end
+    tests('have attributes') do
+      model_attribute_hash = template.attributes
+      attributes = [ :id,
+        :name]
+      tests("The template model should respond to") do
+        attributes.each do |attribute|
+          test("#{attribute}") { template.respond_to? attribute }
+        end
+      end
+      tests("The attributes hash should have key") do
+        attributes.each do |attribute|
+          test("#{attribute}") { model_attribute_hash.has_key? attribute }
+        end
+      end
+    end
+    test('be a kind of Fog::Compute::Ovirt::Template') { template.kind_of? Fog::Compute::Ovirt::Template }
+  end
+
+end

data/tests/ovirt/models/compute/templates_tests.rb

@@ -0,0 +1,9 @@
+Shindo.tests('Fog::Compute[:ovirt] | templates collection', ['ovirt']) do
+
+  templates = Fog::Compute[:ovirt].templates
+
+  tests('The templates collection') do
+    test('should be a kind of Fog::Compute::Ovirt::Templates') { templates.kind_of? Fog::Compute::Ovirt::Templates }
+  end
+
+end

data/tests/ovirt/requests/compute/create_vm_tests.rb

@@ -0,0 +1,26 @@
+Shindo.tests("Fog::Compute[:ovirt] | vm_create request", 'ovirt') do
+
+  compute = Fog::Compute[:ovirt]
+  name_base = Time.now.to_i
+
+  tests("Create VM") do
+    response = compute.create_vm(:name => 'fog-'+name_base.to_s, :cluster_name => 'Default')
+    test("should be a kind of OVIRT::VM") { response.kind_of?  OVIRT::VM}
+  end
+
+  tests("Create VM from template (clone)") do
+    response = compute.create_vm(:name => 'fog-'+(name_base+ 1).to_s, :template_name => 'hwp_small', :cluster_name => 'Default')
+    test("should be a kind of OVIRT::VM") { response.kind_of?  OVIRT::VM}
+  end
+
+  tests("Fail Creating VM") do
+    begin
+      response = compute.create_vm(:name => 'fog-'+name_base.to_s, :cluster_name => 'Default')
+      test("should be a kind of OVIRT::VM") { response.kind_of?  OVIRT::VM} #mock never raise exceptions
+    rescue => e
+      #should raise vm name already exist exception.
+      test("error should be a kind of OVIRT::OvirtException") { e.kind_of?  OVIRT::OvirtException}
+    end
+  end
+
+end

data/tests/ovirt/requests/compute/destroy_vm_tests.rb

@@ -0,0 +1,18 @@
+Shindo.tests('Fog::Compute[:ovirt] | vm_destroy request', ['ovirt']) do
+
+  compute = Fog::Compute[:ovirt]
+  if compute.servers.all(:search => 'fog-*').empty?
+    compute.create_vm(:name => 'fog-'+Time.now.to_i.to_s, :cluster_name => 'Default')
+  end
+  vm_id = compute.servers.all(:search => 'fog-*').last.id
+
+  tests('The response should') do
+    response = compute.destroy_vm(:id => vm_id)
+    test('be a success') { response ? true: false }
+  end
+
+  tests('The expected options') do
+    raises(ArgumentError, 'raises ArgumentError when id option is missing') { compute.destroy_vm }
+  end
+
+end

data/tests/ovirt/requests/compute/list_datacenters_tests.rb

@@ -0,0 +1,13 @@
+Shindo.tests('Fog::Compute[:ovirt] | datacenters request', ['ovirt']) do
+
+  compute = Fog::Compute[:ovirt]
+
+  tests("When listing all datacenters") do
+
+    response = compute.datacenters
+    tests("The response data format ...") do
+      test("it should be a kind of Array") { response.kind_of? Array }
+      test("be a kind of Hash") { response.first.kind_of? Hash }
+    end
+  end
+end

data/tests/ovirt/requests/compute/list_storage_domains_tests.rb

@@ -0,0 +1,13 @@
+Shindo.tests('Fog::Compute[:ovirt] | storage_domains request', ['ovirt']) do
+
+  compute = Fog::Compute[:ovirt]
+
+  tests("When listing all storage_domains") do
+
+    response = compute.storage_domains
+    tests("The response data format ...") do
+      test("it should be a kind of Array") { response.kind_of? Array }
+      test("be a kind of OVIRT::StorageDomain") { response.first.kind_of? OVIRT::StorageDomain }
+    end
+  end
+end

data/tests/ovirt/requests/compute/update_vm_tests.rb

@@ -0,0 +1,18 @@
+Shindo.tests('Fog::Compute[:ovirt] | vm_update request', ['ovirt']) do
+
+  compute = Fog::Compute[:ovirt]
+  if compute.servers.all(:search => 'fog-*').empty?
+    compute.create_vm(:name => 'fog-'+Time.now.to_i.to_s, :cluster_name => 'Default')
+  end
+  vm = compute.servers.all(:search => 'fog-*').last
+
+  tests('The response should') do
+    response = compute.update_vm(:id => vm.id, :name => vm.name + 'updated')
+    test("be a kind of OVIRT::VM") { response.kind_of?  OVIRT::VM}
+  end
+
+  tests('The expected options') do
+    raises(ArgumentError, 'raises ArgumentError when id option is missing') { compute.update_vm }
+  end
+
+end

data/tests/rackspace/databases_tests.rb

@@ -0,0 +1,26 @@
+Shindo.tests('Fog::Rackspace::Databases', ['rackspace']) do |variable|
+
+  pending if Fog.mocking?
+
+  @service = Fog::Rackspace::Databases.new
+
+  tests('#flavors').succeeds do
+    data = @service.flavors
+    returns(true) { data.is_a? Array }
+  end
+
+  tests('#instances').succeeds do
+    data = @service.instances
+    returns(true) { data.is_a? Array }
+  end
+
+  tests('#databases').succeeds do
+    data = @service.databases
+    returns(true) { data.is_a? Array }
+  end
+
+  tests('#users').succeeds do
+    data = @service.users
+    returns(true) { data.is_a? Array }
+  end
+end

data/tests/rackspace/helper.rb

@@ -0,0 +1,24 @@
+module Shindo
+  class Tests
+    def given_a_load_balancer_service(&block)
+      @service = Fog::Rackspace::LoadBalancers.new
+      instance_eval(&block)
+    end
+    def given_a_load_balancer(&block)
+        @lb = @service.load_balancers.create({
+            :name => ('fog' + Time.now.to_i.to_s),
+            :protocol => 'HTTP',
+            :port => 80,
+            :virtual_ips => [{ :type => 'PUBLIC'}],
+            :nodes => [{ :address => '1.1.1.1', :port => 80, :condition => 'ENABLED'}]
+          })
+        @lb.wait_for { ready? }
+      begin
+        instance_eval(&block)
+      ensure
+        @lb.wait_for { ready? }
+        @lb.destroy
+      end
+    end
+  end
+end