openstack 1.0.4 → 1.0.6

data/README.rdoc

@@ -6,7 +6,7 @@ Ruby Openstack Compute and Object-Store bindings for the v1.0 OSAPI.
 
 Currently supports both v1.0 and v2.0 (keystone) auth.
 
-Use OpenStack::Connection.create to get a handle to an OpenStack service - set the :service_type parameter to either 'compute' or 'object-store' (defaults to 'compute')
+Use OpenStack::Connection.create to get a handle to an OpenStack service - set the :service_type parameter to either 'compute' or 'object-store' (defaults to 'compute'). If the requested service is not deployed the gem will throw a OpenStack::Exception::NotImplemented (501) - e.g. :service_type is 'object-store' but swift service isn't deployed.
 
 The OpenStack::Connection.create class method is a factory constructor which will return the appropriate Connection object, depending on the ':service_type' parameter passed with the options hash: set to either 'compute' or 'object-store' (defaults to 'compute') - see below for examples.
 

data/VERSION

@@ -1 +1 @@
-1.0.4
+1.0.6

data/lib/openstack/connection.rb

@@ -245,7 +245,6 @@ end
 
 class AuthV20
   attr_reader :uri
-
   def initialize(connection)
     begin
       server = Net::HTTP::Proxy(connection.proxy_host, connection.proxy_port).new(connection.auth_host, connection.auth_port)
@@ -275,6 +274,9 @@ class AuthV20
     if (response.code =~ /^20./)
       resp_data=JSON.parse(response.body)
       connection.authtoken = resp_data['access']['token']['id']
+      implemented_services = resp_data["access"]["serviceCatalog"].inject([]){|res, current| res << current["type"] ;res}
+      raise OpenStack::Exception::NotImplemented.new("The requested service: \"#{connection.service_type}\" is not present " +
+        "in the returned service catalogue.", 501, "#{resp_data["access"]["serviceCatalog"]}") unless implemented_services.include?(connection.service_type)
       resp_data['access']['serviceCatalog'].each do |service|
         if service['type'] == connection.service_type
           endpoints = service["endpoints"]

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

data/test/servers_test.rb

@@ -0,0 +1,210 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ServersTest < Test::Unit::TestCase
+
+  include TestConnection
+
+  def setup
+    @comp=get_test_connection
+  end
+
+  def test_list_servers
+
+    json_response = %{{
+      "servers" : [
+        {
+          "id" : 1234,
+          "name" : "sample-server",
+          "image" : { "id": "2" },
+          "flavor" : { "id" : "1" },
+          "hostId" : "e4d909c290d0fb1ca068ffaddf22cbd0",
+          "status" : "BUILD",
+          "progress" : 60,
+          "addresses" : {
+              "public" : [
+                  { "version" : 4, "addr" : "67.23.10.132" },
+                  { "version" : 4, "addr" : "67.23.10.131" }
+              ],
+              "private" : [
+                  { "version" : 4, "addr" : "10.176.42.16" }
+              ]
+          },
+          "metadata" : {
+              "Server Label" : "Web Head 1",
+              "Image Version" : "2.1"
+          }
+        },
+        {
+          "id" : 5678,
+          "name" : "sample-server2",
+          "image" : { "id": "2" },
+          "flavor" : { "id" : "1" },
+          "hostId" : "9e107d9d372bb6826bd81d3542a419d6",
+          "status" : "ACTIVE",
+          "addresses" : {
+              "public" : [
+                  { "version" : 4, "addr" : "67.23.10.133" }
+              ],
+              "private" : [
+                  { "version" : 4, "addr" : "10.176.42.17" }
+              ]
+          },
+          "metadata" : {
+              "Server Label" : "DB 1"
+          }
+        }
+      ]
+    }}
+    response = mock()
+    response.stubs(:code => "200", :body => json_response)
+    @comp.connection.stubs(:csreq).returns(response)
+    servers=@comp.list_servers
+    assert_equal 2, servers.size
+    assert_equal 1234, servers[0][:id]
+    assert_equal "sample-server", servers[0][:name]
+  end
+
+  def test_get_server
+
+    server=get_test_server
+    assert_equal "sample-server", server.name
+    assert_equal "2", server.image['id']
+    assert_equal "1", server.flavor['id']
+    assert_equal "e4d909c290d0fb1ca068ffaddf22cbd0", server.hostId
+    assert_equal "BUILD", server.status
+    assert_equal 60, server.progress
+    assert_equal "67.23.10.132", server.addresses[:public][0].address
+    assert_equal "67.23.10.131", server.addresses[:public][1].address
+    assert_equal "10.176.42.16", server.addresses[:private][0].address
+
+  end
+
+  def test_rebuild_server
+
+    json_response = %{{
+    "server": {
+        "id": "52415800-8b69-11e0-9b19-734f565bc83b",
+        "tenantId": "1234",
+        "userId": "5678",
+        "name": "newName",
+        "created": "2010-11-11T12:00:00Z",
+        "hostId": "e4d909c290d0fb1ca068ffaddf22cbd0",
+        "accessIPv4" : "67.23.10.138",
+        "accessIPv6" : "::babe:67.23.10.138",
+        "progress": 0,
+        "status": "REBUILD",
+        "adminPass": "GFf1j9aP",
+        "image" : {
+            "id": "52415800-8b69-11e0-9b19-734f6f006e54",
+            "name": "CentOS 5.2",
+            "links": [
+                {
+                    "rel": "self",
+                    "href": "http://servers.api.openstack.org/v1.1/1234/images/52415800-8b69-11e0-9b19-734f6f006e54"
+                },
+                {
+                    "rel": "bookmark",
+                    "href": "http://servers.api.openstack.org/1234/images/52415800-8b69-11e0-9b19-734f6f006e54"
+                }
+            ]
+        },
+        "flavor" : {
+            "id": "52415800-8b69-11e0-9b19-734f1195ff37",
+            "name": "256 MB Server",
+            "links": [
+                {
+                    "rel": "self",
+                    "href": "http://servers.api.openstack.org/v1.1/1234/flavors/52415800-8b69-11e0-9b19-734f1195ff37"
+                },
+                {
+                    "rel": "bookmark",
+                    "href": "http://servers.api.openstack.org/1234/flavors/52415800-8b69-11e0-9b19-734f1195ff37"
+                }
+            ]
+        },
+        "metadata": {
+            "My Server Name": "Apache1"
+        },
+        "addresses": {
+            "public" : [
+                {
+                    "version": 4,
+                    "addr": "67.23.10.138"
+                },
+                {
+                    "version": 6,
+                    "addr": "2001:0db8:85a3:0000:0000:8a2e:0370:7334"
+                }
+            ],
+            "private" : [
+                {
+                    "version": 4,
+                    "addr": "10.176.42.19"
+                },
+                {
+                    "version": 6,
+                    "addr": "fe80:0000:0000:0000:0202:b3ff:fe1e:8329"
+                }
+            ]
+        },
+        "links": [
+            {
+                "rel": "self",
+                "href": "http://servers.api.openstack.org/v1.1/1234/servers/52415800-8b69-11e0-9b19-734fcece0043"
+            },
+            {
+                "rel": "bookmark",
+                "href": "http://servers.api.openstack.org/1234/servers/52415800-8b69-11e0-9b19-734fcece0043"
+            }
+        ]
+    }
+    }}
+
+    server=get_test_server
+
+    response = mock()
+    response.stubs(:code => "200", :body => json_response)
+
+    @comp.connection.stubs(:csreq).returns(response)
+    server.rebuild!(:name => "newName")
+
+    assert_not_nil server.adminPass
+    assert_equal "newName", server.name
+
+  end
+
+private
+  def get_test_server
+
+    json_response = %{{
+      "server" : {
+          "id" : 1234,
+          "name" : "sample-server",
+          "image" : { "id": "2" },
+          "flavor" : { "id" : "1" },
+          "hostId" : "e4d909c290d0fb1ca068ffaddf22cbd0",
+          "status" : "BUILD",
+          "progress" : 60,
+          "addresses" : {
+              "public" : [
+                  { "version" : 4, "addr" : "67.23.10.132" },
+                  { "version" : 4, "addr" : "67.23.10.131" }
+              ],
+              "private" : [
+                  { "version" : 4, "addr" : "10.176.42.16" }
+              ]
+          },
+          "metadata" : {
+              "Server Label" : "Web Head 1",
+              "Image Version" : "2.1"
+          }
+      }
+    }}
+
+    response = mock()
+    response.stubs(:code => "200", :body => json_response)
+    @comp.connection.stubs(:csreq).returns(response)
+    return @comp.server(1234)
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'test/unit'
+require 'mocha'
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'openstack'
+
+module TestConnection
+
+def get_test_connection
+
+    conn_response = {'x-server-management-url' => 'http://server-manage.example.com/path', 'x-auth-token' => 'dummy_token'}
+    conn_response.stubs(:code).returns('204')
+    #server = mock(:use_ssl= => true, :verify_mode= => true, :start => true, :finish => true)
+    server = mock(:start => true, :finish => true)
+    server.stubs(:get => conn_response, :use_ssl= => true, :verify_mode= => true)
+    #server.stubs(:get).returns(conn_response)
+    Net::HTTP.stubs(:new).returns(server)
+    OpenStack::Connection.create(:username => "test_account", :api_key => "AABBCCDD11", :auth_url => "http://a.b.c")
+
+end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openstack
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -10,8 +10,40 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-05 00:00:00.000000000 Z
+date: 2012-09-13 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +84,12 @@ files:
 - lib/openstack/swift/connection.rb
 - lib/openstack/swift/container.rb
 - lib/openstack/swift/storage_object.rb
+- test/authentication_test.rb
+- test/connection_test.rb
+- test/exception_test.rb
+- test/metadata_test.rb
+- test/servers_test.rb
+- test/test_helper.rb
 homepage: https://github.com/ruby-openstack/ruby-openstack
 licenses: []
 post_install_message: