cloudservers 0.2.0 → 0.3.0

data/Rakefile

@@ -1,5 +1,6 @@
 require 'rubygems'
 require './lib/cloudservers.rb'
+require 'rake/testtask'
 
 begin
   require 'jeweler'
@@ -7,11 +8,17 @@ begin
     gemspec.name = "cloudservers"
     gemspec.summary = "Rackspace Cloud Servers Ruby API"
     gemspec.description = "A Ruby API to version 1.0 of the Rackspace Cloud Servers product."
-    gemspec.email = "wade.minter@rackspace.com"
+    gemspec.email = "minter@lunenburg.org"
     gemspec.homepage = "http://github.com/rackspace/cloudservers"
-    gemspec.authors = ["H. Wade Minter","Mike Mayo"]
+    gemspec.authors = ["H. Wade Minter","Mike Mayo","Dan Prince"]
     gemspec.add_dependency 'json'
   end
 rescue LoadError
   puts "Jeweler not available. Install it with: sudo gem install jeweler"
 end
+
+  Rake::TestTask.new(:test) do |t|
+    t.pattern = 'test/*_test.rb'
+    t.verbose = true
+  end
+  Rake::Task['test'].comment = "Unit"

data/TODO

@@ -1,9 +1,3 @@
-* There are caching bugs in the API, so that accurate information is not always returned (ie. if you add a server and
-  then list available servers, the new one will not show up.).  That needs to be corrected on the API end before
-  data will be accurate.
-
-* Add pagination in object listing.
-
 * Allow some sort of flag to get the stack trace when an exception is thrown.
 
 * Shared IP group modification code.

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/cloudservers.gemspec

@@ -5,13 +5,13 @@
 
 Gem::Specification.new do |s|
   s.name = %q{cloudservers}
-  s.version = "0.2.0"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["H. Wade Minter", "Mike Mayo"]
-  s.date = %q{2010-05-06}
+  s.authors = ["H. Wade Minter", "Mike Mayo", "Dan Prince"]
+  s.date = %q{2010-10-21}
   s.description = %q{A Ruby API to version 1.0 of the Rackspace Cloud Servers product.}
-  s.email = %q{wade.minter@rackspace.com}
+  s.email = %q{minter@lunenburg.org}
   s.extra_rdoc_files = [
     "README.rdoc",
      "TODO"
@@ -34,15 +34,21 @@ Gem::Specification.new do |s|
      "lib/cloudservers/server.rb",
      "lib/cloudservers/shared_ip_group.rb",
      "test/cloudservers_authentication_test.rb",
+     "test/cloudservers_connection_test.rb",
+     "test/cloudservers_exception_test.rb",
+     "test/cloudservers_servers_test.rb",
      "test/test_helper.rb"
   ]
   s.homepage = %q{http://github.com/rackspace/cloudservers}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.6}
+  s.rubygems_version = %q{1.3.7}
   s.summary = %q{Rackspace Cloud Servers Ruby API}
   s.test_files = [
     "test/cloudservers_authentication_test.rb",
+     "test/cloudservers_connection_test.rb",
+     "test/cloudservers_exception_test.rb",
+     "test/cloudservers_servers_test.rb",
      "test/test_helper.rb"
   ]
 
@@ -50,7 +56,7 @@ Gem::Specification.new do |s|
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<json>, [">= 0"])
     else
       s.add_dependency(%q<json>, [">= 0"])

data/lib/cloudservers/connection.rb

@@ -32,8 +32,8 @@ module CloudServers
     #
     #   cf = CloudServers::Connection.new(:username => 'YOUR_USERNAME', :api_key => 'YOUR_API_KEY')
     def initialize(options = {:retry_auth => true}) 
-      @authuser = options[:username] || (raise Authentication, "Must supply a :username")
-      @authkey = options[:api_key] || (raise Authentication, "Must supply an :api_key")
+      @authuser = options[:username] || (raise Exception::Authentication, "Must supply a :username")
+      @authkey = options[:api_key] || (raise Exception::Authentication, "Must supply an :api_key")
       @retry_auth = options[:retry_auth]
       @proxy_host = options[:proxy_host]
       @proxy_port = options[:proxy_port]
@@ -62,9 +62,9 @@ module CloudServers
       response
     rescue Errno::EPIPE, Timeout::Error, Errno::EINVAL, EOFError
       # Server closed the connection, retry
-      raise CloudServers::Exception::Connection, "Unable to reconnect to #{server} after #{count} attempts" if attempts >= 5
+      raise CloudServers::Exception::Connection, "Unable to reconnect to #{server} after #{attempts} attempts" if attempts >= 5
       attempts += 1
-      @http[server].finish
+      @http[server].finish if @http[server].started?
       start_http(server,path,port,scheme,headers)
       retry
     rescue CloudServers::Exception::ExpiredAuthToken
@@ -86,11 +86,18 @@ module CloudServers
     
     # Returns an array of hashes, one for each server that exists under this account.  The hash keys are :name and :id.
     #
+    # You can also provide :limit and :offset parameters to handle pagination.
+    #
     #   >> cs.list_servers
     #   => [{:name=>"MyServer", :id=>110917}]
+    #
+    #   >> cs.list_servers(:limit => 2, :offset => 3)
+    #   => [{:name=>"demo-standingcloud-lts", :id=>168867}, 
+    #       {:name=>"demo-aicache1", :id=>187853}]
     def list_servers(options = {})
-      url_params = "?limit=#{URI.escape(options[:limit].to_s)}&offset=#{URI.escape(options[:offset].to_s)}" if options[:limit] && options[:offset]
-      response = csreq("GET",svrmgmthost,"#{svrmgmtpath}/servers",svrmgmtport,svrmgmtscheme)
+      anti_cache_param="cacheid=#{Time.now.to_i}"
+      path = CloudServers.paginate(options).empty? ? "#{svrmgmtpath}/servers?#{anti_cache_param}" : "#{svrmgmtpath}/servers?#{CloudServers.paginate(options)}&#{anti_cache_param}"
+      response = csreq("GET",svrmgmthost,path,svrmgmtport,svrmgmtscheme)
       CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
       CloudServers.symbolize_keys(JSON.parse(response.body)["servers"])
     end
@@ -100,10 +107,16 @@ module CloudServers
     # includes public and private IP addresses, status, hostID, and more.  All hash keys are symbols except for the metadata
     # hash, which are verbatim strings.
     #
+    # You can also provide :limit and :offset parameters to handle pagination.
     #   >> cs.list_servers_detail
     #   => [{:name=>"MyServer", :addresses=>{:public=>["67.23.42.37"], :private=>["10.176.241.237"]}, :metadata=>{"MyData" => "Valid"}, :imageId=>10, :progress=>100, :hostId=>"36143b12e9e48998c2aef79b50e144d2", :flavorId=>1, :id=>110917, :status=>"ACTIVE"}]
-    def list_servers_detail
-      response = csreq("GET",svrmgmthost,"#{svrmgmtpath}/servers/detail",svrmgmtport,svrmgmtscheme)
+    #
+    #   >> cs.list_servers_detail(:limit => 2, :offset => 3)
+    #   => [{:status=>"ACTIVE", :imageId=>10, :progress=>100, :metadata=>{}, :addresses=>{:public=>["x.x.x.x"], :private=>["x.x.x.x"]}, :name=>"demo-standingcloud-lts", :id=>168867, :flavorId=>1, :hostId=>"xxxxxx"}, 
+    #       {:status=>"ACTIVE", :imageId=>8, :progress=>100, :metadata=>{}, :addresses=>{:public=>["x.x.x.x"], :private=>["x.x.x.x"]}, :name=>"demo-aicache1", :id=>187853, :flavorId=>3, :hostId=>"xxxxxx"}]
+    def list_servers_detail(options = {})
+      path = CloudServers.paginate(options).empty? ? "#{svrmgmtpath}/servers/detail" : "#{svrmgmtpath}/servers/detail?#{CloudServers.paginate(options)}"
+      response = csreq("GET",svrmgmthost,path,svrmgmtport,svrmgmtscheme)
       CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
       CloudServers.symbolize_keys(JSON.parse(response.body)["servers"])
     end
@@ -149,11 +162,19 @@ module CloudServers
     # Returns an array of hashes listing available server images that you have access too, including stock Cloud Servers images and 
     # any that you have created.  The "id" key in the hash can be used where imageId is required.
     #
+    # You can also provide :limit and :offset parameters to handle pagination.
+    #
     #   >> cs.list_images
     #   => [{:name=>"CentOS 5.2", :id=>2, :updated=>"2009-07-20T09:16:57-05:00", :status=>"ACTIVE", :created=>"2009-07-20T09:16:57-05:00"}, 
     #       {:name=>"Gentoo 2008.0", :id=>3, :updated=>"2009-07-20T09:16:57-05:00", :status=>"ACTIVE", :created=>"2009-07-20T09:16:57-05:00"},...
-    def list_images
-      response = csreq("GET",svrmgmthost,"#{svrmgmtpath}/images/detail",svrmgmtport,svrmgmtscheme)
+    #
+    #   >> cs.list_images(:limit => 3, :offset => 2) 
+    #   => [{:status=>"ACTIVE", :name=>"Fedora 11 (Leonidas)", :updated=>"2009-12-08T13:50:45-06:00", :id=>13}, 
+    #       {:status=>"ACTIVE", :name=>"CentOS 5.3", :updated=>"2009-08-26T14:59:52-05:00", :id=>7}, 
+    #       {:status=>"ACTIVE", :name=>"CentOS 5.4", :updated=>"2009-12-16T01:02:17-06:00", :id=>187811}]
+    def list_images(options = {})
+      path = CloudServers.paginate(options).empty? ? "#{svrmgmtpath}/images/detail" : "#{svrmgmtpath}/images/detail?#{CloudServers.paginate(options)}"
+      response = csreq("GET",svrmgmthost,path,svrmgmtport,svrmgmtscheme)
       CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
       CloudServers.symbolize_keys(JSON.parse(response.body)['images'])
     end
@@ -170,11 +191,19 @@ module CloudServers
     
     # Returns an array of hashes listing all available server flavors.  The :id key in the hash can be used when flavorId is required.
     #
+    # You can also provide :limit and :offset parameters to handle pagination.
+    #
     #   >> cs.list_flavors
     #   => [{:name=>"256 server", :id=>1, :ram=>256, :disk=>10}, 
     #       {:name=>"512 server", :id=>2, :ram=>512, :disk=>20},...
-    def list_flavors
-      response = csreq("GET",svrmgmthost,"#{svrmgmtpath}/flavors/detail",svrmgmtport,svrmgmtscheme)
+    #
+    #   >> cs.list_flavors(:limit => 3, :offset => 2)
+    #   => [{:ram=>1024, :disk=>40, :name=>"1GB server", :id=>3}, 
+    #       {:ram=>2048, :disk=>80, :name=>"2GB server", :id=>4}, 
+    #       {:ram=>4096, :disk=>160, :name=>"4GB server", :id=>5}]       
+    def list_flavors(options = {})
+      path = CloudServers.paginate(options).empty? ? "#{svrmgmtpath}/flavors/detail" : "#{svrmgmtpath}/flavors/detail?#{CloudServers.paginate(options)}"
+      response = csreq("GET",svrmgmthost,path,svrmgmtport,svrmgmtscheme)
       CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
       CloudServers.symbolize_keys(JSON.parse(response.body)['flavors'])
     end
@@ -191,10 +220,13 @@ module CloudServers
     
     # Returns an array of hashes for all Shared IP Groups that are available.  The :id key can be used to find that specific object.
     #
+    # You can also provide :limit and :offset parameters to handle pagination.
+    #
     #   >> cs.list_shared_ip_groups
     #   => [{:name=>"New Group", :id=>127}]
-    def list_shared_ip_groups
-      response = csreq("GET",svrmgmthost,"#{svrmgmtpath}/shared_ip_groups/detail",svrmgmtport,svrmgmtscheme)
+    def list_shared_ip_groups(options = {})
+      path = CloudServers.paginate(options).empty? ? "#{svrmgmtpath}/shared_ip_groups/detail" : "#{svrmgmtpath}/shared_ip_groups/detail?#{CloudServers.paginate(options)}"
+      response = csreq("GET",svrmgmthost,path,svrmgmtport,svrmgmtscheme)
       CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
       CloudServers.symbolize_keys(JSON.parse(response.body)['sharedIpGroups'])
     end
@@ -303,4 +335,4 @@ module CloudServers
     end
         
   end
-end
+end

data/lib/cloudservers/exception.rb

@@ -1,37 +1,50 @@
 module CloudServers
   class Exception
+
+    class CloudServersError < StandardError
+
+      attr_reader :response_body
+      attr_reader :response_code
+
+      def initialize(message, code, response_body)
+        @response_code=code
+        @response_body=response_body
+        super(message)
+      end
+
+    end
     
-    class CloudServersFault           < StandardError # :nodoc:
+    class CloudServersFault           < CloudServersError # :nodoc:
     end
-    class ServiceUnavailable          < StandardError # :nodoc:
+    class ServiceUnavailable          < CloudServersError # :nodoc:
     end
-    class Unauthorized                < StandardError # :nodoc:
+    class Unauthorized                < CloudServersError # :nodoc:
     end
-    class BadRequest                  < StandardError # :nodoc:
+    class BadRequest                  < CloudServersError # :nodoc:
     end
-    class OverLimit                   < StandardError # :nodoc:
+    class OverLimit                   < CloudServersError # :nodoc:
     end
-    class BadMediaType                < StandardError # :nodoc:
+    class BadMediaType                < CloudServersError # :nodoc:
     end
-    class BadMethod                   < StandardError # :nodoc:
+    class BadMethod                   < CloudServersError # :nodoc:
     end
-    class ItemNotFound                < StandardError # :nodoc:
+    class ItemNotFound                < CloudServersError # :nodoc:
     end
-    class BuildInProgress             < StandardError # :nodoc:
+    class BuildInProgress             < CloudServersError # :nodoc:
     end
-    class ServerCapacityUnavailable   < StandardError # :nodoc:
+    class ServerCapacityUnavailable   < CloudServersError # :nodoc:
     end
-    class BackupOrResizeInProgress    < StandardError # :nodoc:
+    class BackupOrResizeInProgress    < CloudServersError # :nodoc:
     end
-    class ResizeNotAllowed            < StandardError # :nodoc:
+    class ResizeNotAllowed            < CloudServersError # :nodoc:
     end
-    class NotImplemented              < StandardError # :nodoc:
+    class NotImplemented              < CloudServersError # :nodoc:
+    end
+    class Other                       < CloudServersError # :nodoc:
     end
     
     # Plus some others that we define here
     
-    class Other                       < StandardError # :nodoc:
-    end
     class ExpiredAuthToken            < StandardError # :nodoc:
     end
     class MissingArgument             < StandardError # :nodoc:
@@ -52,12 +65,17 @@ module CloudServers
     # proper error.  Note that all exceptions are scoped in the CloudServers::Exception namespace.
     def self.raise_exception(response)
       return if response.code =~ /^20.$/
-      fault,info = JSON.parse(response.body).first
       begin
+        fault = nil
+        info = nil
+        JSON.parse(response.body).each_pair do |key, val|
+			fault=key
+			info=val
+		end
         exception_class = self.const_get(fault[0,1].capitalize+fault[1,fault.length])
-        raise exception_class, info["message"]
+        raise exception_class.new(info["message"], response.code, response.body)
       rescue NameError
-        raise CloudServers::Exception::Other, "The server returned status #{response.code}"
+        raise CloudServers::Exception::Other.new("The server returned status #{response.code}", response.code, response.body)
       end
     end
     

data/lib/cloudservers/server.rb

@@ -249,6 +249,37 @@ module CloudServers
       CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
       true
     end
-    
+
+    # Share IP between servers in Shared IP group.
+    # Takes a hash of the form: {:sharedIpGroupId => "1234", :ipAddress => "67.23.10.132", :configureServer => false} as an argument.
+    # The :sharedIpGroupId key is required.
+    # The :ipAddress key is required.
+    # The :configureServer key is optional and defaults to false.
+    #
+    #   >> server.share_ip(:sharedIpGroupId => 100, :ipAddress => "67.23.10.132")
+    #   => true
+    def share_ip(options)
+      raise CloudServers::Exception::MissingArgument, "Shared IP Group ID must be supplied" unless options[:sharedIpGroupId]
+      raise CloudServers::Exception::MissingArgument, "Ip Address must be supplied" unless options[:ipAddress]
+      options[:configureServer] = false if options[:configureServer].nil?
+      data = JSON.generate(:shareIp => {:sharedIpGroupId => options[:sharedIpGroupId], :configureServer => options[:configureServer]})
+      response = @connection.csreq("PUT",@svrmgmthost,"#{@svrmgmtpath}/servers/#{URI.encode(self.id.to_s)}/ips/public/#{options[:ipAddress]}",@svrmgmtport,@svrmgmtscheme,{'content-type' => 'application/json'},data)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      true
+    end
+
+    # Unshare an IP address.
+    # Takes a hash of the form: {:ipAddress => "67.23.10.132"} as an argument.
+    # The :ipAddress key is required.
+    #
+    #   >> server.unshare_ip(:ipAddress => "67.23.10.132")
+    #   => true
+    def unshare_ip(options)
+      raise CloudServers::Exception::MissingArgument, "Ip Address must be supplied" unless options[:ipAddress]
+      response = @connection.csreq("DELETE",@svrmgmthost,"#{@svrmgmtpath}/servers/#{URI.encode(self.id.to_s)}/ips/public/#{options[:ipAddress]}",@svrmgmtport,@svrmgmtscheme)
+      CloudServers::Exception.raise_exception(response) unless response.code.match(/^20.$/)
+      true
+    end
+ 
   end
-end
+end

data/lib/cloudservers.rb

@@ -2,7 +2,7 @@
 # 
 # == Cloud Servers API
 # ==== Connects Ruby Applications to Rackspace's {Cloud Servers service}[http://www.rackspacecloud.com/cloud_hosting_products/servers]
-# By H. Wade Minter <wade.minter@rackspace.com> and Mike Mayo <mike.mayo@rackspace.com>
+# By H. Wade Minter <minter@lunenburg.org> and Mike Mayo <mike.mayo@rackspace.com>
 #
 # See COPYING for license information.
 # Copyright (c) 2009, Rackspace US, Inc.
@@ -23,6 +23,7 @@ module CloudServers
   require 'uri'
   require 'rubygems'
   require 'json'
+  require 'date'
 
   unless "".respond_to? :each_char
     require "jcode"
@@ -79,5 +80,12 @@ module CloudServers
     end
   end
   
+  def self.paginate(options = {})
+    path_args = []
+    path_args.push(URI.encode("limit=#{options[:limit]}")) if options[:limit]
+    path_args.push(URI.encode("offset=#{options[:offset]}")) if options[:offset]
+    path_args.join("&")
+  end
+  
 
 end

data/test/cloudservers_authentication_test.rb

@@ -1,16 +1,15 @@
 require File.dirname(__FILE__) + '/test_helper'
 
 class CloudserversAuthenticationTest < Test::Unit::TestCase
-  
-
+ 
   def test_good_authentication
-    response = {'x-cdn-management-url' => 'http://cdn.example.com/path', 'x-storage-url' => 'http://cdn.example.com/storage', 'authtoken' => 'dummy_token'}
+    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 => 'dummy_user', :authkey => 'dummy_key', :cdnmgmthost= => true, :cdnmgmtpath= => true, :cdnmgmtport= => true, :cdnmgmtscheme= => true, :storagehost= => true, :storagepath= => true, :storageport= => true, :storagescheme= => true, :authtoken= => true, :authok= => true)
-    result = CloudServers::Authentication.new(@connection)
+    connection = stub(:authuser => 'bad_user', :authkey => 'bad_key', :authok= => true, :authtoken= => true, :svrmgmthost= => "", :svrmgmtpath= => "", :svrmgmtpath => "", :svrmgmtport= => "", :svrmgmtscheme= => "", :proxy_host => nil, :proxy_port => nil)
+    result = CloudServers::Authentication.new(connection)
     assert_equal result.class, CloudServers::Authentication
   end
   
@@ -20,18 +19,18 @@ class CloudserversAuthenticationTest < Test::Unit::TestCase
     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', :authkey => 'bad_key', :authok= => true, :authtoken= => true)
-    assert_raises(AuthenticationException) do
-      result = CloudServers::Authentication.new(@connection)
+    connection = stub(:authuser => 'bad_user', :authkey => 'bad_key', :authok= => true, :authtoken= => true, :proxy_host => nil, :proxy_port => nil)
+    assert_raises(CloudServers::Exception::Authentication) do
+      result = CloudServers::Authentication.new(connection)
     end
   end
     
   def test_bad_hostname
-    Net::HTTP.stubs(:new).raises(ConnectionException)
-    @connection = stub(:authuser => 'bad_user', :authkey => 'bad_key', :authok= => true, :authtoken= => true)
-    assert_raises(ConnectionException) do
-      result = CloudServers::Authentication.new(@connection)
+    Net::HTTP.stubs(:new).raises(CloudServers::Exception::Connection)
+    connection = stub(:authuser => 'bad_user', :authkey => 'bad_key', :authok= => true, :authtoken= => true, :proxy_host => nil, :proxy_port => nil)
+    assert_raises(CloudServers::Exception::Connection) do
+      result = CloudServers::Authentication.new(connection)
     end
   end
     
-end
+end

data/test/cloudservers_connection_test.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class CloudServersConnectionTest < Test::Unit::TestCase
+  
+  def test_init_connection_no_credentials
+    assert_raises(CloudServers::Exception::Authentication) do
+      conn = CloudServers::Connection.new(:api_key => "AABBCCDD11")
+    end
+  end
+
+  def test_init_connection_no_password
+    assert_raises(CloudServers::Exception::Authentication) do
+      conn = CloudServers::Connection.new(:username => "test_account")
+    end
+  end
+    
+end

data/test/cloudservers_exception_test.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class CloudServersExceptionTest < Test::Unit::TestCase
+  
+  def test_400_cloud_servers_fault
+    response = mock()
+    response.stubs(:code => "400", :body => "{\"cloudServersFault\":{\"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.CloudServersFault: Fault occured\",\"code\":400}}" )
+    exception=nil
+    begin
+      CloudServers::Exception.raise_exception(response)
+    rescue Exception => e
+      exception=e
+    end
+    assert_equal(CloudServers::Exception::CloudServersFault, 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
+      CloudServers::Exception.raise_exception(response)
+    rescue Exception => e
+      exception=e
+    end
+    assert_equal(CloudServers::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
+      CloudServers::Exception.raise_exception(response)
+    rescue Exception => e
+      exception=e
+    end
+    assert_equal(CloudServers::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/cloudservers_servers_test.rb

@@ -0,0 +1,176 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class CloudServersServersTest < Test::Unit::TestCase
+
+  include TestConnection
+
+  def setup
+    @conn=get_test_connection
+  end
+  
+  def test_list_servers
+
+json_response = %{{
+  "servers" : [
+      {
+     "id" : 1234,
+      "name" : "sample-server",
+      "imageId" : 2,
+      "flavorId" : 1,
+      "hostId" : "e4d909c290d0fb1ca068ffaddf22cbd0",
+      "status" : "BUILD",
+      "progress" : 60,
+      "addresses" : {
+          "public" : [
+              "67.23.10.132",
+              "67.23.10.131"
+          ],
+          "private" : [
+              "10.176.42.16"
+          ]
+      },
+      "metadata" : {
+          "Server Label" : "Web Head 1",
+          "Image Version" : "2.1"
+      }
+      },
+      {
+    "id" : 5678,
+      "name" : "sample-server2",
+      "imageId" : 2,
+      "flavorId" : 1,
+      "hostId" : "9e107d9d372bb6826bd81d3542a419d6",
+      "status" : "ACTIVE",
+      "addresses" : {
+          "public" : [
+              "67.23.10.133"
+          ],
+          "private" : [
+              "10.176.42.17"
+          ]
+      },
+      "metadata" : {
+          "Server Label" : "DB 1"
+      }
+      }
+  ]
+}}
+    response = mock()
+    response.stubs(:code => "200", :body => json_response)
+
+    @conn.stubs(:csreq).returns(response)
+    servers=@conn.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 "sample-server", server.name
+    assert "2", server.imageId
+    assert "1", server.flavorId
+    assert "e4d909c290d0fb1ca068ffaddf22cbd0", server.hostId
+    assert "BUILD", server.status
+    assert "60", server.progress
+    assert "67.23.10.132", server.addresses[:public][0]
+    assert "67.23.10.131", server.addresses[:public][1]
+    assert "10.176.42.16", server.addresses[:private][1]
+
+  end
+
+  def test_share_ip
+
+    server=get_test_server
+    response = mock()
+    response.stubs(:code => "200")
+
+    @conn.stubs(:csreq).returns(response)
+
+    assert server.share_ip(:sharedIpGroupId => 100, :ipAddress => "67.23.10.132")
+  end
+
+  def test_share_ip_requires_shared_ip_group_id
+
+    server=get_test_server
+
+    assert_raises(CloudServers::Exception::MissingArgument) do
+      assert server.share_ip(:ipAddress => "67.23.10.132")
+    end
+
+  end
+
+  def test_share_ip_requires_ip_address
+
+    server=get_test_server
+
+    assert_raises(CloudServers::Exception::MissingArgument) do
+      assert server.share_ip(:sharedIpGroupId => 100)
+    end
+
+  end
+
+  def test_unshare_ip
+
+    server=get_test_server
+    response = mock()
+    response.stubs(:code => "200")
+
+    @conn.stubs(:csreq).returns(response)
+
+    assert server.unshare_ip(:ipAddress => "67.23.10.132")
+
+  end
+
+  def test_unshare_ip_requires_ip_address
+
+    server=get_test_server
+
+    assert_raises(CloudServers::Exception::MissingArgument) do
+      assert server.share_ip({})
+    end
+
+  end
+
+private
+  def get_test_server
+
+json_response = %{{
+  "server" : {
+      "id" : 1234,
+      "name" : "sample-server",
+      "imageId" : 2,
+      "flavorId" : 1,
+      "hostId" : "e4d909c290d0fb1ca068ffaddf22cbd0",
+      "status" : "BUILD",
+      "progress" : 60,
+      "addresses" : {
+          "public" : [
+               "67.23.10.132",
+               "67.23.10.131"
+          ],
+          "private" : [
+               "10.176.42.16"
+          ]
+      },
+      "metadata" : {
+          "Server Label" : "Web Head 1",
+          "Image Version" : "2.1"
+      }
+  }
+}}
+
+    response = mock()
+    response.stubs(:code => "200", :body => json_response)
+
+    @conn=get_test_connection
+
+    @conn.stubs(:csreq).returns(response)
+    return @conn.server(1234) 
+
+  end
+
+end

data/test/test_helper.rb

@@ -3,3 +3,19 @@ $:.unshift File.dirname(__FILE__) + '/../lib'
 require 'cloudservers'
 require 'rubygems'
 require 'mocha'
+
+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.stubs(:get).returns(conn_response)
+    Net::HTTP.stubs(:new).returns(server)
+
+    CloudServers::Connection.new(:username => "test_account", :api_key => "AABBCCDD11")
+
+end
+
+end

metadata

@@ -1,37 +1,41 @@
 --- !ruby/object:Gem::Specification 
 name: cloudservers
 version: !ruby/object:Gem::Version 
+  hash: 19
   prerelease: false
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - H. Wade Minter
 - Mike Mayo
+- Dan Prince
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-05-06 00:00:00 -07:00
+date: 2010-10-21 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: json
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         version: "0"
   type: :runtime
   version_requirements: *id001
 description: A Ruby API to version 1.0 of the Rackspace Cloud Servers product.
-email: wade.minter@rackspace.com
+email: minter@lunenburg.org
 executables: []
 
 extensions: []
@@ -57,6 +61,9 @@ files:
 - lib/cloudservers/server.rb
 - lib/cloudservers/shared_ip_group.rb
 - test/cloudservers_authentication_test.rb
+- test/cloudservers_connection_test.rb
+- test/cloudservers_exception_test.rb
+- test/cloudservers_servers_test.rb
 - test/test_helper.rb
 has_rdoc: true
 homepage: http://github.com/rackspace/cloudservers
@@ -68,26 +75,33 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Rackspace Cloud Servers Ruby API
 test_files: 
 - test/cloudservers_authentication_test.rb
+- test/cloudservers_connection_test.rb
+- test/cloudservers_exception_test.rb
+- test/cloudservers_servers_test.rb
 - test/test_helper.rb