openstack 1.1.2 → 2.0.2

data/lib/openstack/version.rb

@@ -1,3 +0,0 @@
-module OpenStack
-  VERSION = '1.1.2'
-end

data/test/authentication_test.rb

@@ -1,120 +0,0 @@
-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_uri
-    server = get_test_auth_server
-    Net::HTTP.stubs(:new).returns(server)
-    server.stubs(:started?).returns(true)
-    connection = v2_auth_connection_stub
-    result = OpenStack::Authentication.init(connection)
-    assert_equal("compute.south.host", result.uri.host)
-  end
-
-  private
-
-  def v2_auth_connection_stub
-    stub(:authuser => 'good_user', :auth_method => "password",:authtenant => {:type=>"tenantName", :value=>'good_tenant'} , :regions_list => {"North"=> [{:service=>"compute", :versionId=>nil}, {:service=>"nova", :versionId=>nil}], "South"=>[{:service=>"compute", :versionId=>nil}, {:service=>"nova", :versionId=>nil}] }, :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")
-  end
-
-  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

@@ -1,39 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,210 +0,0 @@
-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

@@ -1,210 +0,0 @@
-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