rackspace-cloud 0.5

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/rackspace-cloud.rb'}"
+puts "Loading rackspace-cloud gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/test/test_base.rb

@@ -0,0 +1,149 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class Rackspace::CloudServers::BaseTest < ActiveSupport::TestCase
+  context "querying a resource with Rackspace" do
+    should "return the right resource name" do
+      mock_auth_response
+      assert_equal "bases", Rackspace::CloudServers::Base.resource
+    end
+    
+    should "build the right resource URL for the index" do
+      mock_auth_response
+      assert_equal "http://test/servers/bases", Rackspace::CloudServers::Base.resource_url
+    end
+
+    should "build the right resource URL for the retrieval" do
+      mock_auth_response
+      assert_equal "http://test/servers/bases/1", Rackspace::CloudServers::Base.resource_url(1)
+    end
+    
+    should "make the right request for find(:all)" do
+      mock_auth_response
+      expects_get("http://test/servers/bases/detail.json")
+      Rackspace::CloudServers::Base.find(:all)
+    end
+
+    should "make the right request for find(:first)" do
+      mock_auth_response
+      expects_get("http://test/servers/bases/detail.json")
+      Rackspace::CloudServers::Base.find(:first)
+    end
+
+    should "make the right request for find(:last)" do
+      mock_auth_response
+      expects_get("http://test/servers/bases/detail.json")
+      Rackspace::CloudServers::Base.find(:last)
+    end
+
+    should "make the right request for all and default to find(:all)" do
+      mock_auth_response
+      expects_get("http://test/servers/bases/detail.json")
+      Rackspace::CloudServers::Base.all
+    end
+
+    should "make the right request for count" do
+      mock_auth_response
+      expects_get("http://test/servers/bases/detail.json")
+      assert_equal 0, Rackspace::CloudServers::Base.count
+    end
+
+    should "make the right request for first and default to find(:first)" do
+      mock_auth_response
+      expects_get("http://test/servers/bases/detail.json")
+      Rackspace::CloudServers::Base.first
+    end
+
+    should "make the right request for last and default to find(:last)" do
+      mock_auth_response
+      expects_get("http://test/servers/bases/detail.json")
+      Rackspace::CloudServers::Base.last
+    end
+
+    should "make the right request for find and default to find(:all)" do
+      mock_auth_response
+      expects_get("http://test/servers/bases/detail.json")
+      Rackspace::CloudServers::Base.find
+    end
+
+    should "make the right request for find(1)" do
+      mock_auth_response
+      expects_get("http://test/servers/bases/1.json")
+      Rackspace::CloudServers::Base.find(1)
+    end
+
+    should "return the right data for find(:all)" do
+      mock_auth_response
+      expects_get("http://test/servers/bases/detail.json").returns({"bases" => [{"id" => 1}, {"id" => 2}]}.to_json)
+      result = Rackspace::CloudServers::Base.find(:all)
+      assert_equal 2, result.length
+      assert_equal Rackspace::CloudServers::Base, result.first.class
+      assert_equal 1, result.first.id
+      assert_equal false, result.first.new_record?
+      assert_equal Rackspace::CloudServers::Base, result.last.class
+      assert_equal 2, result.last.id
+      assert_equal false, result.last.new_record?
+    end
+
+    should "return the right data for find(1)" do
+      mock_auth_response
+      expects_get("http://test/servers/bases/1.json").returns({"base" => {"id" => 1}}.to_json)
+      result = Rackspace::CloudServers::Base.find(1)
+      assert_equal Rackspace::CloudServers::Base, result.class
+      assert_equal 1, result.id
+      assert_equal false, result.new_record?
+    end
+  end
+
+  context "creating a resource with Rackspace" do
+    should "be a new record" do
+      base = Rackspace::CloudServers::Base.new
+      assert_equal true, base.new_record?
+    end
+    
+    should "make the right POST request" do
+      mock_auth_response
+      expects_post("http://test/servers/bases.json", {"base" => {}}).returns({"base" => {"id" => 1}}.to_json)
+      base = Rackspace::CloudServers::Base.new
+      assert_equal true, base.save
+      assert_equal 1, base.id
+    end
+
+    should "make the right POST request on a direct create call too" do
+      mock_auth_response
+      expects_post("http://test/servers/bases.json", {"base" => {}}).returns({"base" => {"id" => 1}}.to_json)
+      base = Rackspace::CloudServers::Base.create
+      assert_equal 1, base.id
+    end
+  end
+
+  context "updating a resource with Rackspace" do
+    should "make the right PUT request" do
+      mock_auth_response
+      expects_put("http://test/servers/bases/1.json", {"base" => {}})
+      assert_equal true, Rackspace::CloudServers::Base.new(:id => 1).save
+    end
+  end
+      
+  context "deleting a resource with Rackspace" do
+    should "make the right DELETE request" do
+      mock_auth_response
+      expects_delete("http://test/servers/bases/1.json")
+      assert_equal true, Rackspace::CloudServers::Base.new(:id => 1).destroy
+    end
+  end
+
+  context "reloading a resource with Rackspace" do
+    should "not be allowed when it's a new record" do
+      assert_equal false, Rackspace::CloudServers::Base.new.reload
+    end
+    
+    should "make the GET request for the server" do
+      mock_auth_response
+      expects_get("http://test/servers/bases/1.json").returns({"base" => {"id" => 2}}.to_json)
+      result = Rackspace::CloudServers::Base.new(:id => 1)
+      updated = result.reload
+      assert_equal 2, updated.id
+      assert_equal 2, result.id
+    end
+  end
+end

data/test/test_connection.rb

@@ -0,0 +1,219 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class Rackspace::ConnectionTest < ActiveSupport::TestCase
+  context "working with Rackspace::Connection" do
+    should "have JSON as the default accept type" do
+      assert_equal "application/json", Rackspace::Connection.default_headers[:accept]
+    end
+
+    should "have JSON as the default content type" do
+      assert_equal "application/json", Rackspace::Connection.default_headers[:content_type]
+    end
+  end
+
+  context "querying for API versions" do
+    setup do
+      expects_versions_response
+    end
+    
+    should "receive the right arguments for the HTTP request" do
+      Rackspace::Connection.versions
+    end
+
+    should "return the right data" do
+      versions = Rackspace::Connection.versions
+      assert_equal 2, versions.length
+      assert_equal true, versions.include?("v1.1")
+      assert_equal true, versions.include?("v1.0")
+    end
+  end
+
+  context "initializing Rackspace::Connection with default version" do
+    setup do
+      expects_versions_response
+      Rackspace::Connection.init "test_user", "test_key"
+    end
+
+    should "have set API user" do
+      assert_equal "test_user", Rackspace::Connection.api_user
+    end
+
+    should "have set API key" do
+      assert_equal "test_key", Rackspace::Connection.api_key
+    end
+
+    should "have set API version" do
+      assert_equal "v1.0", Rackspace::Connection.api_version
+    end
+  end
+  
+  context "initializing Rackspace::Connection with specific version" do
+    setup do
+      expects_versions_response
+      Rackspace::Connection.init "test_user", "test_key", "v1.1"
+    end
+
+    should "have set API user" do
+      assert_equal "test_user", Rackspace::Connection.api_user
+    end
+
+    should "have set API key" do
+      assert_equal "test_key", Rackspace::Connection.api_key
+    end
+
+    should "have set API version" do
+      assert_equal "v1.1", Rackspace::Connection.api_version
+    end
+  end
+
+  context "initializing Rackspace::Connection with invalid version" do
+    setup do
+      expects_versions_response
+    end
+    
+    should "raise an exception" do
+      assert_raise Rackspace::InvalidVersion do
+        Rackspace::Connection.init "test_user", "test_key", "v1.2"
+      end
+    end
+  end
+  
+  context "before authenticating with Rackspace a call to authentication info" do
+    should "trigger an authentication first time ONLY (auth_response)" do
+      Rackspace::Connection.instance_variable_set("@auth_response", nil)
+      mock_api_init
+      expects_authentication
+      Rackspace::Connection.auth_response
+      Rackspace::Connection.auth_response
+    end
+    
+    should "call auth_response to find the right value (auth_token)" do
+      response = mock
+      response.expects(:[]).with(:auth_token).returns("123456789")
+      Rackspace::Connection.expects(:auth_response).returns(response)
+      token = Rackspace::Connection.auth_token
+      assert_equal "123456789", token
+    end
+
+    should "call auth_response to find the right value (storage_url)" do
+      response = mock
+      response.expects(:[]).with(:storage_url).returns("http://test/storage")
+      Rackspace::Connection.expects(:auth_response).returns(response)
+      url = Rackspace::Connection.storage_url
+      assert_equal "http://test/storage", url
+    end
+
+    should "call auth_response to find the right value (server_management_url)" do
+      response = mock
+      response.expects(:[]).with(:server_management_url).returns("http://test/servers")
+      Rackspace::Connection.expects(:auth_response).returns(response)
+      url = Rackspace::Connection.server_management_url
+      assert_equal "http://test/servers", url
+    end
+
+    should "call auth_response to find the right value (cdn_management_url)" do
+      response = mock
+      response.expects(:[]).with(:cdn_management_url).returns("http://test/content")
+      Rackspace::Connection.expects(:auth_response).returns(response)
+      url = Rackspace::Connection.cdn_management_url
+      assert_equal "http://test/content", url
+    end
+  end
+  
+  context "authenticating with Rackspace" do
+    setup do
+      mock_api_init
+      expects_authentication
+    end
+    
+    should "receive the right arguments for the HTTP request" do
+      Rackspace::Connection.authenticate
+    end
+
+    should "return the important authentication details" do
+      response = Rackspace::Connection.authenticate
+      assert_equal Hash, response.class
+      assert_equal 4, response.keys.length
+      assert_equal "123456789", response[:auth_token]
+      assert_equal "http://test/storage", response[:storage_url]
+      assert_equal "http://test/servers", response[:server_management_url]
+      assert_equal "http://test/content", response[:cdn_management_url]
+    end
+  end
+
+  context "authenticating with Rackspace without initializing" do
+    setup do
+      Rackspace::Connection.send(:instance_variable_set, "@initialized", false)
+    end
+    
+    should "raise an exception" do
+      assert_raise Rackspace::NotInitialized do
+        Rackspace::Connection.authenticate
+      end
+    end
+  end
+
+  context "making GET requests to Rackspace" do
+    should "build the right GET request" do
+      mock_auth_response "123456789"
+      expects_get("http://test/url.json", {"X-TestHeader" => "testing"})
+      Rackspace::Connection.get "http://test/url", {"X-TestHeader" => "testing"}
+    end
+
+    should "re-authenticate if it receives a 401 Unauthorized back" do
+      mock_auth_response "123456789"
+      expects_get("http://test/url.json").raises(RestClient::Unauthorized, "RestClient::Unauthorized")
+      expects_authentication "234567891"
+      expects_get("http://test/url.json", {"X-Auth-Token" => "234567891"})
+      Rackspace::Connection.get "http://test/url"
+    end
+  end
+
+  context "making POST requests to Rackspace" do
+    should "build the right POST request" do
+      mock_auth_response "123456789"
+      expects_post("http://test/url.json", {:data1 => "test", :data2 => "test"}, {"X-TestHeader" => "testing"})
+      Rackspace::Connection.post "http://test/url", {:data1 => "test", :data2 => "test"}, {"X-TestHeader" => "testing"}
+    end
+
+    should "re-authenticate if it receives a 401 Unauthorized back" do 
+      mock_auth_response "123456789"
+      expects_post("http://test/url.json", {:data1 => "test", :data2 => "test"}).raises(RestClient::Unauthorized, "RestClient::Unauthorized")
+      expects_authentication "234567891"
+      expects_post("http://test/url.json", {:data1 => "test", :data2 => "test"}, {"X-Auth-Token" => "234567891"})
+      Rackspace::Connection.post "http://test/url", {:data1 => "test", :data2 => "test"}
+    end
+  end
+  
+  context "making PUT requests to Rackspace" do
+    should "build the right PUT request" do
+      mock_auth_response "123456789"
+      expects_put("http://test/url.json", {:data1 => "test", :data2 => "test"}, {"X-TestHeader" => "testing"})
+      Rackspace::Connection.put "http://test/url", {:data1 => "test", :data2 => "test"}, {"X-TestHeader" => "testing"}
+    end
+
+    should "re-authenticate if it receives a 401 Unauthorized back" do 
+      mock_auth_response "123456789"
+      expects_put("http://test/url.json", {:data1 => "test", :data2 => "test"}).raises(RestClient::Unauthorized, "RestClient::Unauthorized")
+      expects_authentication "234567891"
+      expects_put("http://test/url.json", {:data1 => "test", :data2 => "test"}, {"X-Auth-Token" => "234567891"})
+      Rackspace::Connection.put "http://test/url", {:data1 => "test", :data2 => "test"}
+    end
+  end
+
+  context "making DELETE requests to Rackspace" do
+    should "build the right DELETE request" do
+      mock_auth_response "123456789"
+      expects_delete("http://test/url.json", {"X-TestHeader" => "testing"})
+      Rackspace::Connection.delete "http://test/url", {"X-TestHeader" => "testing"}
+    end
+
+    should "re-authenticate if it receives a 401 Unauthorized back" do
+      mock_auth_response "123456789"
+      expects_delete("http://test/url.json").raises(RestClient::Unauthorized, "RestClient::Unauthorized")
+      expects_authentication "234567891"
+      expects_delete("http://test/url.json", {"X-Auth-Token" => "234567891"})
+      Rackspace::Connection.delete "http://test/url"
+    end
+  end
+end

data/test/test_flavor.rb

@@ -0,0 +1,138 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class Rackspace::CloudServers::FlavorTest < ActiveSupport::TestCase
+  context "working with Rackspace::CloudServers::Flavor" do
+    should "inherit from Rackspace::CloudServers::Base" do
+      assert Rackspace::CloudServers::Flavor.ancestors.include?(Rackspace::CloudServers::Base)
+    end
+  end
+
+  context "an instance of Rackspace::CloudServers::Flavor" do
+    setup do
+      @flavor = Rackspace::CloudServers::Flavor.new
+    end
+    
+    [:id, :name, :ram, :disk].each do |attrib|
+      should "respond to #{attrib}" do
+        assert @flavor.respond_to?(attrib)
+      end
+    end
+  end
+
+  context "querying flavors" do
+    should "build the right resource URL for the index" do
+      mock_auth_response
+      assert_equal "http://test/servers/flavors", Rackspace::CloudServers::Flavor.resource_url
+    end
+
+    should "build the right resource URL for the retrieval" do
+      mock_auth_response
+      assert_equal "http://test/servers/flavors/1", Rackspace::CloudServers::Flavor.resource_url(1)
+    end
+    
+    should "make the right request for find(:all)" do
+      mock_auth_response
+      expects_get("http://test/servers/flavors/detail.json")
+      Rackspace::CloudServers::Flavor.find(:all)
+    end
+
+    should "make the right request for find and default to find(:all)" do
+      mock_auth_response
+      expects_get("http://test/servers/flavors/detail.json")
+      Rackspace::CloudServers::Flavor.find
+    end
+
+    should "make the right request for find(1)" do
+      mock_auth_response
+      expects_get("http://test/servers/flavors/1.json")
+      Rackspace::CloudServers::Flavor.find(1)
+    end
+
+    should "return the right data for find(:all)" do
+      mock_auth_response
+      expects_get("http://test/servers/flavors/detail.json").returns(find_all_response)
+      result = Rackspace::CloudServers::Flavor.find(:all)
+      assert_equal 2, result.length
+      assert_equal Rackspace::CloudServers::Flavor, result.first.class
+      assert_equal 1, result.first.id
+      assert_equal Rackspace::CloudServers::Flavor, result.last.class
+      assert_equal 2, result.last.id
+    end
+
+    should "return the right data for find(1)" do
+      mock_auth_response
+      expects_get("http://test/servers/flavors/1.json").returns(find_1_response)
+      result = Rackspace::CloudServers::Flavor.find(1)
+      assert_equal Rackspace::CloudServers::Flavor, result.class
+      assert_equal 1, result.id
+    end
+  end
+
+  context "creating a flavor" do
+    should "return false as it's read-only" do
+      assert_equal false, Rackspace::CloudServers::Flavor.new(:name => "test").save
+    end
+  end
+
+  context "deleting a flavor" do
+    should "return false as it's read-only" do
+      assert_equal false, Rackspace::CloudServers::Flavor.new(:id => 1).destroy
+    end
+  end
+  
+  context "reloading a flavor instance" do
+    should "not be allowed when it's a new record" do
+      assert_equal false, Rackspace::CloudServers::Flavor.new.reload
+    end
+    
+    should "make the GET request for the flavor" do
+      mock_auth_response
+      expects_get("http://test/servers/flavors/1.json").returns(find_1_response_reloaded)
+      result = Rackspace::CloudServers::Flavor.new(:id => 1)
+      updated = result.reload
+      assert_equal 100, updated.disk
+      assert_equal 100, result.disk
+    end
+  end
+  
+  def find_all_response
+    { 
+      "flavors" => [ 
+                    { 
+                      "id" => 1,
+                      "name" => "256 MB Server",
+                      "ram" => 256, 
+                      "disk" => 10
+                    }, 
+                    { 
+                      "id" => 2, 
+                      "name" => "512 MB Server",
+                      "ram" => 512, 
+                      "disk" => 20
+                    } 
+                   ] 
+    }.to_json
+  end
+
+  def find_1_response
+    { 
+      "flavor" => { 
+                      "id" => 1,
+                      "name" => "256 MB Server",
+                      "ram" => 256, 
+                      "disk" => 10
+      }
+    }.to_json
+  end
+
+  def find_1_response_reloaded
+    { 
+      "flavor" => { 
+                      "id" => 1,
+                      "name" => "256 MB Server",
+                      "ram" => 256, 
+                      "disk" => 100
+      }
+    }.to_json
+  end
+end