dropmyemail-openstack 1.0.9

data/lib/openstack/volume/connection.rb

@@ -0,0 +1,123 @@
+module OpenStack
+module Volume
+
+  class Connection
+
+    attr_accessor   :connection
+    attr_reader     :volumes_native
+
+    def initialize(connection)
+      @connection = connection
+      OpenStack::Authentication.init(@connection)
+      @volumes_native, @volume_path = check_if_native("volumes")
+      @snapshots_native, @snapshot_path = check_if_native("snapshots")
+    end
+
+    # Returns true if the authentication was successful and returns false otherwise.
+    #
+    #   cs.authok?
+    #   => true
+    def authok?
+      @connection.authok
+    end
+
+    #require params:  {:display_name, :size}
+    #optional params: {:display_description, :metadata=>{:key=>val, ...}, :availability_zone, :volume_type }
+    #returns OpenStack::Volume::Volume object
+    def create_volume(options)
+      raise OpenStack::Exception::MissingArgument, ":display_name and :size must be specified to create a volume" unless (options[:display_name] && options[:size])
+      data = JSON.generate(:volume => options)
+      response = @connection.csreq("POST",@connection.service_host,"#{@connection.service_path}/#{@volume_path}",@connection.service_port,@connection.service_scheme,{'content-type' => 'application/json'},data)
+      OpenStack::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      volume_info = JSON.parse(response.body)["volume"]
+      volume = OpenStack::Volume::Volume.new(volume_info)
+    end
+
+    #no options documented in API at Nov 2012
+    #(e.g. like limit/marker as used in Nova for servers)
+    def list_volumes
+      response = @connection.req("GET", "/#{@volume_path}")
+      volumes_hash = JSON.parse(response.body)["volumes"]
+      volumes_hash.inject([]){|res, current| res << OpenStack::Volume::Volume.new(current); res}
+    end
+    alias :volumes :list_volumes
+
+
+    def get_volume(vol_id)
+      response = @connection.req("GET", "/#{@volume_path}/#{vol_id}")
+      volume_hash = JSON.parse(response.body)["volume"]
+      OpenStack::Volume::Volume.new(volume_hash)
+    end
+    alias :volume :get_volume
+
+    def delete_volume(vol_id)
+      response = @connection.req("DELETE", "/#{@volume_path}/#{vol_id}")
+      true
+    end
+
+    def list_snapshots
+      response = @connection.req("GET", "/#{@snapshot_path}")
+      snapshot_hash = JSON.parse(response.body)["snapshots"]
+      snapshot_hash.inject([]){|res, current| res << OpenStack::Volume::Snapshot.new(current); res}
+    end
+    alias :snapshots :list_snapshots
+
+    def get_snapshot(snap_id)
+      response = @connection.req("GET", "/#{@snapshot_path}/#{snap_id}")
+      snapshot_hash = JSON.parse(response.body)["snapshot"]
+      OpenStack::Volume::Snapshot.new(snapshot_hash)
+    end
+    alias :snapshot :get_snapshot
+
+    #require params:  {:display_name, :volume_id}
+    #optional params: {:display_description, :metadata=>{:key=>val, ...}, :availability_zone, :volume_type }
+    #returns OpenStack::Volume::Snapshot object
+    def create_snapshot(options)
+      raise OpenStack::Exception::MissingArgument, ":volume_id and :display_name must be specified to create a snapshot" unless (options[:display_name] && options[:volume_id])
+      #:force documented in API but not explained... clarify (fails without)
+      options.merge!({:force=>"true"})
+      data = JSON.generate(:snapshot => options)
+      response = @connection.csreq("POST",@connection.service_host,"#{@connection.service_path}/#{@snapshot_path}",@connection.service_port,@connection.service_scheme,{'content-type' => 'application/json'},data)
+      OpenStack::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      snapshot_info = JSON.parse(response.body)["snapshot"]
+      OpenStack::Volume::Snapshot.new(snapshot_info)
+    end
+
+    def delete_snapshot(snap_id)
+      @connection.req("DELETE", "/#{@snapshot_path}/#{snap_id}")
+      true
+    end
+
+    private
+
+    #fudge... not clear if volumes support is available as 'native' volume API or
+    #as the os-volumes extension. Need to probe to find out (for now)
+    #see https://lists.launchpad.net/openstack/msg16601.html
+    def check_if_native(entity) #volumes or snapshots
+      native = extension = false
+      #check if 'native' volume API present:
+      begin
+        response = @connection.req("GET", "/#{entity}")
+        native = true if response.code.match(/^20.$/)
+        return true, entity
+      rescue OpenStack::Exception::ItemNotFound => not_found
+        native = false
+      end
+      #check if available as extension:
+      begin
+        response = @connection.req("GET", "/os-#{entity}")
+        extension = true if response.code.match(/^20.$/)
+        return false, "os-#{entity}"
+      rescue OpenStack::Exception::ItemNotFound => not_found
+        extension = false
+      end
+      raise OpenStack::Exception::NotImplemented.new("No Volumes support for this provider", 501, "No #{entity} Support") unless (native || extension)
+    end
+
+
+
+
+  end
+
+end
+end

data/lib/openstack/volume/snapshot.rb

@@ -0,0 +1,25 @@
+module OpenStack
+  module Volume
+    class Snapshot
+
+      attr_reader :id
+      attr_reader :display_name
+      attr_reader :display_description
+      attr_reader :volume_id
+      attr_reader :status
+      attr_reader :size
+      attr_reader :created_at
+
+      def initialize(snap_info)
+        @id = snap_info["id"]
+        @display_name = snap_info["display_name"] || snap_info["displayName"]
+        @display_description = snap_info["display_description"] || snap_info["displayDescription"]
+        @volume_id = snap_info["volume_id"] || snap_info["volumeId"]
+        @status = snap_info["status"]
+        @size  = snap_info["size"]
+        @created_at = snap_info["created_at"] || snap_info["createdAt"]
+      end
+
+    end
+  end
+end

data/lib/openstack/volume/volume.rb

@@ -0,0 +1,31 @@
+module OpenStack
+  module Volume
+    class Volume
+
+    attr_reader :id
+    attr_reader :display_name
+    attr_reader :display_description
+    attr_reader :size
+    attr_reader :volume_type
+    attr_reader :metadata
+    attr_reader :availability_zone
+    attr_reader :snapshot_id
+    attr_reader :attachments
+    attr_reader :created_at
+
+    def initialize(volume_info)
+      @id  = volume_info["id"]
+      @display_name  = volume_info["display_name"] || volume_info["displayName"]
+      @display_description  = volume_info["display_description"] || volume_info["displayDescription"]
+      @size  = volume_info["size"]
+      @volume_type  = volume_info["volume_type"] || volume_info["volumeType"]
+      @metadata  = volume_info["metadata"]
+      @availability_zone  = volume_info["availability_zone"] || volume_info["availabilityZone"]
+      @snapshot_id  = volume_info["snapshot_id"] || volume_info["snapshotId"]
+      @attachments  = volume_info["attachments"]
+      @created_at  = volume_info["created_at"] || volume_info["createdAt"]
+    end
+
+    end
+  end
+end

data/test/authentication_test.rb

@@ -0,0 +1,134 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class AuthenticationTest < Test::Unit::TestCase
+
+  def test_good_authentication
+    response = {'x-server-management-url' => 'http://server-manage.example.com/path', 'x-auth-token' => 'dummy_token'}
+    response.stubs(:code).returns('204')
+    server = mock(:use_ssl= => true, :verify_mode= => true, :start => true, :finish => true)
+    server.stubs(:get).returns(response)
+    Net::HTTP.stubs(:new).returns(server)
+    connection = stub(:authuser => 'good_user',:authtenant => {:type=>"tenantName", :value=>'good_tenant'}, :authkey => 'bad_key', :auth_host => "a.b.c", :auth_port => "443", :auth_scheme => "https", :auth_path => "/v1.0", :service_type=>"compute", :authok= => true, :authtoken= => true, :service_host= => "", :service_path= => "", :service_path => "", :service_port= => "", :service_scheme= => "", :proxy_host => nil, :proxy_port => nil, :api_path => '/foo')
+    result = OpenStack::Authentication.init(connection)
+    assert_equal result.class, OpenStack::AuthV10
+  end
+
+  def test_bad_authentication
+    response = mock()
+    response.stubs(:code).returns('499')
+    server = mock(:use_ssl= => true, :verify_mode= => true, :start => true)
+    server.stubs(:get).returns(response)
+    Net::HTTP.stubs(:new).returns(server)
+    connection = stub(:authuser => 'bad_user', :authtenant => {:type=>"tenantName", :value=>'good_tenant'}, :authkey => 'bad_key', :auth_host => "a.b.c", :auth_port => "443", :auth_scheme => "https", :auth_path => "/v1.0", :authok= => true, :authtoken= => true, :proxy_host => nil, :proxy_port => nil, :api_path => '/foo')
+    assert_raises(OpenStack::Exception::Authentication) do
+      result = OpenStack::Authentication.init(connection)
+    end
+  end
+
+  def test_bad_hostname
+    Net::HTTP.stubs(:new).raises(OpenStack::Exception::Connection)
+    connection = stub(:authuser => 'bad_user', :authtenant => {:type=>"tenantName", :value=>'good_tenant'}, :authkey => 'bad_key', :auth_host => "a.b.c", :auth_port => "443", :auth_scheme => "https", :auth_path => "/v1.0", :authok= => true, :authtoken= => true, :proxy_host => nil, :proxy_port => nil, :api_path => '/foo')
+    assert_raises(OpenStack::Exception::Connection) do
+      result = OpenStack::Authentication.init(connection)
+    end
+  end
+
+  def test_service_region
+    server = get_test_auth_server
+    Net::HTTP.stubs(:new).returns(server)
+    server.stubs(:started?).returns(true)
+    connection = stub(:authuser => 'good_user', :auth_method => "password",:authtenant => {:type=>"tenantName", :value=>'good_tenant'} , :authkey => 'bad_key', :auth_host => "a.b.c", :auth_port => "443", :auth_scheme => "https", :auth_path => "/v2.0", :authok= => true, :authtoken= => true, :service_host= => "", :service_path= => "", :service_path => "", :service_port= => "", :service_scheme= => "", :proxy_host => nil, :proxy_port => nil, :api_path => '/foo', :service_type => "compute", :service_name => "cloudServers", :region => "South")
+    result = OpenStack::Authentication.init(connection)
+    assert_equal("compute.south.host", result.uri.host)
+  end
+
+  def test_service_name
+    server = get_test_auth_server
+    Net::HTTP.stubs(:new).returns(server)
+    server.stubs(:started?).returns(true)
+    connection = stub(:authuser => 'good_user', :auth_method=>"password", :authtenant => {:type=>"tenantName", :value=>'good_tenant'}, :authkey => 'bad_key', :auth_host => "a.b.c", :auth_port => "443", :auth_scheme => "https", :auth_path => "/v2.0", :authok= => true, :authtoken= => true, :service_host= => "", :service_path= => "", :service_path => "", :service_port= => "", :service_scheme= => "", :proxy_host => nil, :proxy_port => nil, :api_path => '/foo', :service_type => "nova", :service_name => "cloudCompute", :region => "South")
+    result = OpenStack::Authentication.init(connection)
+    assert_equal("nova.south.host", result.uri.host)
+  end
+
+  def test_service_type
+    server = get_test_auth_server
+    Net::HTTP.stubs(:new).returns(server)
+    server.stubs(:started?).returns(true)
+    connection = stub(:authuser => 'good_user', :auth_method => "password", :authtenant => {:type=>"tenantName", :value=>'good_tenant'}, :authkey => 'bad_key', :auth_host => "a.b.c", :auth_port => "443", :auth_scheme => "https", :auth_path => "/v2.0", :authok= => true, :authtoken= => true, :service_host= => "", :service_path= => "", :service_path => "", :service_port= => "", :service_scheme= => "", :proxy_host => nil, :proxy_port => nil, :api_path => '/foo', :service_type => "nova", :service_name => nil, :region => "North")
+    result = OpenStack::Authentication.init(connection)
+    assert_equal("nova.north.host", result.uri.host)
+  end
+
+
+  private
+  def get_test_auth_server
+    json_response = %{{
+        "access":{
+            "token":{
+                "id":"asdasdasd-adsasdads-asdasdasd-adsadsasd",
+                "expires":"2010-11-01T03:32:15-05:00"
+            },
+            "user":{
+                "id":"123",
+                "name":"testName",
+                "roles":[{
+                        "id":"234",
+                        "name":"compute:admin"
+                    },
+    				{
+                        "id":"235",
+                        "name":"object-store:admin",
+                        "tenantId":"1"
+                    }
+                ],
+                "roles_links":[]
+            },
+            "serviceCatalog":[{
+                    "name":"cloudServers",
+                    "type":"compute",
+                    "endpoints":[{
+                            "publicURL":"https://compute.north.host/v1.1",
+                            "region":"North"
+                        },
+                        {
+                            "publicURL":"https://compute.south.host/v1.1",
+                            "region":"South"
+                        }
+                    ],
+                    "endpoints_links":[]
+                },
+                {
+                    "name":"cloudCompute",
+                    "type":"nova",
+                    "endpoints":[{
+                            "publicURL":"https://nova.north.host/v1.1",
+                            "region":"North"
+                        },
+                        {
+                            "publicURL":"https://nova.south.host/v1.1",
+                            "region":"South"
+                        }
+                    ],
+                    "endpoints_links":[{
+                            "rel":"next",
+                            "href":"https://identity.north.host/v2.0/endpoints?marker=2"
+                        }
+                    ]
+                }
+            ],
+            "serviceCatalog_links":[{
+                    "rel":"next",
+                    "href":"https://identity.host/v2.0/endpoints?session=2hfh8Ar&marker=2"
+                }
+            ]
+        }
+    }}
+
+    response = {'x-server-management-url' => 'http://server-manage.example.com/path', 'x-auth-token' => 'dummy_token'}
+    response.stubs(:code => "200", :body => json_response)
+    server = mock(:use_ssl= => true, :verify_mode= => true, :start => true, :finish => true)
+    server.stubs(:post).returns(response)
+    return server
+  end
+end

data/test/connection_test.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ComputeConnectionTest < Test::Unit::TestCase
+
+  def setup
+    connection = stub()
+    OpenStack::Authentication.stubs(:init).returns(connection)
+  end
+
+  def test_init_connection_no_credentials
+    assert_raises(OpenStack::Exception::MissingArgument) do
+      conn = OpenStack::Connection.create(:api_key => "AABBCCDD11", :auth_url => "a.b.c")
+    end
+  end
+
+  def test_init_connection_no_password
+    assert_raises(OpenStack::Exception::MissingArgument) do
+      conn = OpenStack::Connection.create(:username => "test_account", :auth_url => "a.b.c")
+    end
+  end
+
+  def test_init_connection_no_auth_url
+    assert_raises(OpenStack::Exception::MissingArgument) do
+      conn = OpenStack::Connection.create(:username => "test_account", :api_key => "AABBCCDD11")
+    end
+  end
+
+  def test_init_connection_bad_auth_url
+    assert_raises(OpenStack::Exception::InvalidArgument) do
+      conn = OpenStack::Connection.create(:username => "test_account", :api_key => "AABBCCDD11", :auth_url => "***")
+    end
+  end
+
+  def test_init_connection
+      conn = OpenStack::Connection.create(:username => "test_account", :api_key => "AABBCCDD11", :auth_url => "https://a.b.c")
+      assert_not_nil conn, "Connection.new returned nil."
+  end
+
+end

data/test/exception_test.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ExceptionTest < Test::Unit::TestCase
+
+  def test_400_cloud_servers_fault
+    response = mock()
+    response.stubs(:code => "400", :body => "{\"ComputeFault\":{\"message\":\"422 Unprocessable Entity: We could not process your request at this time. We have been notified and are looking into the issue.  [E03]\",\"details\":\"com.rackspace.cloud.service.servers.OpenStack::ComputeFault: Fault occured\",\"code\":400}}" )
+    exception=nil
+    begin
+      OpenStack::Exception.raise_exception(response)
+    rescue Exception => e
+      exception=e
+    end
+    assert_equal(OpenStack::Exception::ComputeFault, e.class)
+    assert_equal("400", e.response_code)
+    assert_not_nil(e.response_body)
+  end
+
+  def test_413_over_limit
+    response = mock()
+    response.stubs(:code => "413", :body => "{\"overLimit\":{\"message\":\"Too many requests...\",\"code\":413,\"retryAfter\":\"2010-08-25T10:47:57.890-05:00\"}}")
+    exception=nil
+    begin
+      OpenStack::Exception.raise_exception(response)
+    rescue Exception => e
+      exception=e
+    end
+    assert_equal(OpenStack::Exception::OverLimit, e.class)
+    assert_equal("413", e.response_code)
+    assert_not_nil(e.response_body)
+  end
+
+  def test_other
+    response = mock()
+    body="{\"blahblah\":{\"message\":\"Failed...\",\"code\":500}}"
+    response.stubs(:code => "500", :body => body)
+    exception=nil
+    begin
+      OpenStack::Exception.raise_exception(response)
+    rescue Exception => e
+      exception=e
+    end
+    assert_equal(OpenStack::Exception::Other, exception.class)
+    assert_equal("500", exception.response_code)
+    assert_not_nil(exception.response_body)
+    assert_equal(body, exception.response_body)
+  end
+
+end

data/test/metadata_test.rb

@@ -0,0 +1,210 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class MetadataTest < Test::Unit::TestCase
+
+  include TestConnection
+
+  def setup
+    @compute=get_test_connection
+  end
+
+  def test_metadata_uses_initial_values
+    data = {'key1' => 'value1', 'key2' => 'value2'}
+    metadata = OpenStack::Compute::Metadata.new(@conn, 'blah', data)
+    assert_equal('value1', metadata['key1'])
+    assert_equal('value2', metadata['key2'])
+    assert_equal(nil, metadata['key0'])
+  end
+
+  def test_metadata_presents_saved_values
+    metadata = OpenStack::Compute::Metadata.new(@conn, 'blah')
+    metadata['key3'] = 'value3'
+    assert_equal('value3', metadata['key3'])
+    assert_equal(nil, metadata['key0'])
+  end
+
+  def test_metadata_presents_stored_values
+    metadata = OpenStack::Compute::Metadata.new(@conn, 'blah')
+    metadata.store('key3', 'value3')
+    assert_equal('value3', metadata['key3'])
+    assert_equal(nil, metadata['key0'])
+  end
+
+  def test_metadata_looks_up_values_if_none_provided
+    data = {'metadata' => {'key4' => 'value4'}}
+    json = JSON.generate(data)
+    response = mock()
+    response.stubs(:code => "200", :body => json)
+    conn = mock()
+    @compute.stubs(:connection).returns(conn)
+    conn.stubs(:req).returns(response)
+    metadata = OpenStack::Compute::Metadata.new(@compute, 'blah')
+    assert_equal('value4', metadata['key4'])
+    assert_equal(nil, metadata['key0'])
+  end
+
+  def test_metadata_save_nil
+    conn = mock()
+    metadata = OpenStack::Compute::Metadata.new(conn, 'blah')
+    metadata.save # do nothing or we'd likely be deleting unintentionally
+  end
+
+  def test_metadata_save
+    data = {'key1' => 'value1', 'key3' => 'value3'}
+    json = JSON.generate({'metadata' => data})
+    response = mock()
+    response.stubs(:code => "200", :body => json)
+    compute = mock()
+    conn = mock()
+    compute.stubs(:connection).returns(conn)
+    conn.expects(:req).with('PUT', 'blah/metadata', :data => json).returns(response)
+    metadata = OpenStack::Compute::Metadata.new(compute, 'blah', data)
+    metadata.save
+  end
+
+  def test_metadata_update_all
+    data_in = {'key5' => 'value5', 'key6' => 'value6'}
+    data_out = {'key5' => 'value5', 'key6' => 'value6', 'key7' => 'value7'}
+    json_in = JSON.generate({'metadata' => data_in})
+    json_out = JSON.generate({'metadata' => data_out})
+    response = mock()
+    response.stubs(:code => "200", :body => json_out)
+    compute = mock()
+    conn = mock()
+    compute.stubs(:connection).returns(conn)
+    conn.expects(:req).with('POST', 'blah/metadata', :data => json_in).returns(response)
+    metadata = OpenStack::Compute::Metadata.new(compute, 'blah')
+    metadata['key5'] = 'value5'
+    metadata['key6'] = 'value6'
+    metadata.update
+    assert_equal('value5', metadata['key5'])
+    assert_equal('value6', metadata['key6'])
+    assert_equal('value7', metadata['key7'])
+  end
+
+  def test_metadata_update_some_keys
+    json1 = JSON.generate({'meta' => {'key1' => 'value1'}})
+    response1 = mock()
+    response1.stubs(:code => "200", :body => json1)
+    json2 = JSON.generate({'meta' => {'key2' => 'value2'}})
+    response2 = mock()
+    response2.stubs(:code => "200", :body => json2)
+    conn = mock()
+    compute = mock()
+    compute.stubs(:connection).returns(conn)
+    conn.expects(:req).with('PUT', 'blah/metadata/key1', :data => json1).returns(response1)
+    conn.expects(:req).with('PUT', 'blah/metadata/key2', :data => json2).returns(response2)
+    data = {'key1' => 'value1', 'key2' => 'value2', 'key3' => 'value3'}
+    metadata = OpenStack::Compute::Metadata.new(compute, 'blah', data)
+    metadata.update(['key1', 'key2'])
+  end
+
+  def test_metadata_update_one_key
+    json = JSON.generate({'meta' => {'key2' => 'value2'}})
+    response = mock()
+    response.stubs(:code => "200", :body => json)
+    compute = mock()
+    conn = mock()
+    compute.stubs(:connection).returns(conn)
+    conn.expects(:req).with('PUT', 'blah/metadata/key2', :data => json).returns(response)
+    data = {'key1' => 'value1', 'key2' => 'value2'}
+    metadata = OpenStack::Compute::Metadata.new(compute, 'blah', data)
+    metadata.update(['key2'])
+  end
+
+  def test_metadata_update_nonexistent_key
+    data = {'key1' => 'value1', 'key2' => 'value2'}
+    compute = mock()
+    conn = mock()
+    compute.stubs(:connection).returns(conn)
+    metadata = OpenStack::Compute::Metadata.new(compute, 'blah', data)
+    metadata.update(['key3']) # just asserting nothing is called on conn
+  end
+
+  def test_metadata_update_nil
+    compute = mock()
+    conn = mock()
+    compute.stubs(:connection).returns(conn)
+    metadata = OpenStack::Compute::Metadata.new(compute, 'blah')
+    metadata.update # just asserting nothing is called on the connection
+  end
+
+  def test_refresh_one_key
+    json = JSON.generate({'meta' => {'key1' => 'value1'}})
+    response = mock()
+    response.stubs(:code => "200", :body => json)
+    compute = mock()
+    conn = mock()
+    compute.stubs(:connection).returns(conn)
+    conn.expects(:req).with('GET', 'blah/metadata/key1').returns(response)
+    metadata = OpenStack::Compute::Metadata.new(compute, 'blah')
+    metadata.refresh(['key1'])
+    assert_equal('value1', metadata['key1'])
+  end
+
+  def test_refresh_some_keys_with_key_not_found
+    json = JSON.generate({'meta' => {'key1' => 'value1'}})
+    response = mock()
+    response.stubs(:code => "200", :body => json)
+    not_found = mock()
+    not_found.stubs(:code => "404")
+    compute = mock()
+    conn = mock()
+    compute.stubs(:connection).returns(conn)
+    conn.expects(:req).with('GET', 'blah/metadata/key1').returns(response)
+    conn.expects(:req).with('GET', 'blah/metadata/key0').returns(not_found)
+    metadata = OpenStack::Compute::Metadata.new(compute, 'blah')
+    metadata.refresh(['key1', 'key0'])
+    assert_equal('value1', metadata['key1'])
+    assert(metadata['key0'].nil?)
+  end
+
+  def test_delete_a_key
+    response = mock()
+    response.stubs(:code => "204")
+    connection = mock()
+    compute = mock()
+    compute.stubs(:connection).returns(connection)
+    connection.expects(:req).with('DELETE', 'blah/metadata/key1').returns(response)
+    metadata = OpenStack::Compute::Metadata.new(compute, 'blah')
+    metadata.delete!(['key1'])
+  end
+
+  def test_delete_a_key_with_prior_information
+    response = mock()
+    response.stubs(:code => "204")
+    comp = mock()
+    conn = mock()
+    comp.stubs(:connection).returns(conn)
+    conn.expects(:req).with('DELETE', 'blah/metadata/key1').returns(response)
+    data = {'key1' => 'value1', 'key2' => 'value2'}
+    metadata = OpenStack::Compute::Metadata.new(comp, 'blah', data)
+    metadata.delete!(['key1'])
+    assert(metadata['key1'].nil?)
+    assert_equal('value2', metadata['key2'])
+  end
+##
+  def test_delete_keys_softly
+    comp = mock()
+    conn = mock()
+    comp.stubs(:connection).returns(conn)
+    data = {'key1' => 'value1', 'key2' => 'value2', 'key3' => 'value3'}
+    metadata = OpenStack::Compute::Metadata.new(comp, 'blah', data)
+    metadata.delete(['key1', 'key3'])
+    assert(metadata['key1'].nil?)
+    assert_equal('value2', metadata['key2'])
+    assert(metadata['key3'].nil?)
+  end
+
+  def test_each_pair
+    comp = mock()
+    conn = mock()
+    comp.stubs(:connection).returns(conn)
+    data = {'key1' => 'value1', 'key2' => 'value2', 'key3' => 'value3'}
+    metadata = OpenStack::Compute::Metadata.new(comp, 'blah', data)
+    metadata.each_pair do |k,v|
+        assert_equal v, data[k]
+    end
+  end
+
+end