rackspace-cloud 0.5

data/test/test_helper.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(__FILE__), "..", "lib", "rackspace-cloud")
+require "rubygems"
+require "active_support/test_case"
+gem "mocha"
+require "mocha"
+gem "thoughtbot-shoulda"
+require "shoulda"
+
+ActiveSupport::Inflector.inflections do |inflect|
+   inflect.irregular 'base', 'bases'
+end
+
+class ActiveSupport::TestCase
+  # This sets up the expectation for the API version query
+  def expects_versions_response
+    RestClient.expects(:get).with("#{Rackspace::Connection::VERSION_URL}/.json", {:accept => "application/json", :content_type => "application/json"}).returns({"versions" => [{"id" => "v1.1", "status" => "BETA"}, {"id" => "v1.0", "status" => "CURRENT"}]}.to_json)
+  end
+  
+  # This sets up the expectations for authenticating against the API
+  def expects_authentication(auth_token = "123456789")
+    response = RestClient::Response.new "", nil
+    response.expects(:headers).returns({:x_auth_token => auth_token, :x_storage_url => "http://test/storage", :x_server_management_url => "http://test/servers", :x_cdn_management_url => "http://test/content"})
+    RestClient::Request.expects(:execute).with(:method => :get, :url => "#{Rackspace::Connection::AUTH_URL}/v1.0", :headers => {"X-Auth-User" => "test_user", "X-Auth-Key" => "test_key"}, :raw_response => true).returns(response)
+  end
+  
+  # This returns default headers used for expectations
+  def default_headers
+    {"X-Auth-Token" => "123456789", :accept => "application/json", :content_type => "application/json"}
+  end
+  
+  # Helper method for building GET expectations
+  def expects_get(url, headers = {})
+    RestClient.expects(:get).with(url, default_headers.merge(headers))
+  end
+  
+  # Helper method for building POST expectations
+  def expects_post(url, payload, headers = {})
+    RestClient.expects(:post).with(url, payload.to_json, default_headers.merge(headers))
+  end
+  
+  # Helper method for building PUT expectations
+  def expects_put(url, payload, headers = {})
+    RestClient.expects(:put).with(url, payload.to_json, default_headers.merge(headers))
+  end
+  
+  # Helper method for building DELETE expectations
+  def expects_delete(url, headers = {})
+    RestClient.expects(:delete).with(url, default_headers.merge(headers))
+  end
+  
+  # This sets up the necessary values to mock the authentication response as if we had authenticated
+  def mock_auth_response(auth_token = "123456789")
+    Rackspace::Connection.send(:instance_variable_set, "@auth_response", {:auth_token => auth_token, :storage_url => "http://test/storage", :server_management_url => "http://test/servers", :cdn_management_url => "http://test/content"})
+    mock_api_init
+  end
+  
+  # This sets up the necessary values to mock the configuration as if we had initialized
+  def mock_api_init
+    Rackspace::Connection.send(:instance_variable_set, "@user", "test_user")
+    Rackspace::Connection.send(:instance_variable_set, "@key", "test_key")
+    Rackspace::Connection.send(:instance_variable_set, "@version", "v1.0")
+    Rackspace::Connection.send(:instance_variable_set, "@initialized", true)
+  end
+end

data/test/test_image.rb

@@ -0,0 +1,177 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class Rackspace::CloudServers::ImageTest < ActiveSupport::TestCase
+  context "working with Rackspace::CloudServers::Image" do
+    should "inherit from Rackspace::CloudServers::Base" do
+      assert Rackspace::CloudServers::Image.ancestors.include?(Rackspace::CloudServers::Base)
+    end
+  end
+
+  context "an instance of Rackspace::CloudServers::Image" do
+    setup do
+      @image = Rackspace::CloudServers::Image.new
+    end
+    
+    [:id, :name, :updated, :created, :status, :serverId, :progress].each do |attrib|
+      should "respond to #{attrib}" do
+        assert @image.respond_to?(attrib)
+      end
+    end
+  end
+
+  context "querying images" do
+    should "build the right resource URL for the index" do
+      mock_auth_response
+      assert_equal "http://test/servers/images", Rackspace::CloudServers::Image.resource_url
+    end
+
+    should "build the right resource URL for the retrieval" do
+      mock_auth_response
+      assert_equal "http://test/servers/images/1", Rackspace::CloudServers::Image.resource_url(1)
+    end
+    
+    should "make the right request for find(:all)" do
+      mock_auth_response
+      expects_get("http://test/servers/images/detail.json")
+      Rackspace::CloudServers::Image.find(:all)
+    end
+
+    should "make the right request for find and default to find(:all)" do
+      mock_auth_response
+      expects_get("http://test/servers/images/detail.json")
+      Rackspace::CloudServers::Image.find
+    end
+
+    should "make the right request for find(1)" do
+      mock_auth_response
+      expects_get("http://test/servers/images/1.json")
+      Rackspace::CloudServers::Image.find(1)
+    end
+
+    should "return the right data for find(:all)" do
+      mock_auth_response
+      expects_get("http://test/servers/images/detail.json").returns(find_all_response)
+      result = Rackspace::CloudServers::Image.find(:all)
+      assert_equal 2, result.length
+      assert_equal Rackspace::CloudServers::Image, result.first.class
+      assert_equal 2, result.first.id
+      assert_equal Rackspace::CloudServers::Image, result.last.class
+      assert_equal 743, result.last.id
+    end
+
+    should "return the right data for find(2)" do
+      mock_auth_response
+      expects_get("http://test/servers/images/2.json").returns(find_2_response)
+      result = Rackspace::CloudServers::Image.find(2)
+      assert_equal Rackspace::CloudServers::Image, result.class
+      assert_equal 2, result.id
+    end
+  end
+
+  context "creating an image" do
+    should "make the right POST request and return the values expected" do
+      mock_auth_response
+      expects_post("http://test/servers/images.json", {"image" => {"name" => "new-image-test", "serverId" => 1}}).returns(create_response)
+      image = Rackspace::CloudServers::Image.create(:name => "new-image-test", :serverId => 1)
+      assert_equal 22, image.id
+      assert_equal "new-image-test", image.name
+      assert_equal 1, image.serverId
+      assert_equal "SAVING", image.status
+      assert_equal 0, image.progress
+    end
+  end
+
+  context "updating an image" do
+    should "not be allowed" do
+      assert_equal false, Rackspace::CloudServers::Image.new(:id => 1).update
+    end
+  end
+
+  context "deleting a image" do
+    should "make the DELETE request for the image" do
+      mock_auth_response
+      expects_delete("http://test/servers/images/1.json")
+      assert_equal true, Rackspace::CloudServers::Image.new(:id => 1).destroy
+    end
+  end
+
+  context "reloading an image instance" do
+    should "not be allowed when it's a new record" do
+      assert_equal false, Rackspace::CloudServers::Image.new.reload
+    end
+    
+    should "make the GET request for the image" do
+      mock_auth_response
+      expects_get("http://test/servers/images/2.json").returns(find_2_response_reloaded)
+      result = Rackspace::CloudServers::Image.new(:id => 2)
+      updated = result.reload
+      assert_equal 100, updated.progress
+      assert_equal 100, result.progress
+    end
+  end
+
+  def find_all_response
+    { 
+      "images" => [ 
+                    { 
+                     "id" => 2,
+                     "name" => "CentOS 5.2",
+                     "updated" => "2010-10-10T12:00:00Z", 
+                     "created" => "2010-08-10T12:00:00Z", 
+                     "status" => "ACTIVE"
+                    }, 
+                    { 
+                     "id" => 743, 
+                     "name" => "My Server Backup", 
+                     "serverId" => 12, 
+                     "updated" => "2010-10-10T12:00:00Z", 
+                     "created" => "2010-08-10T12:00:00Z", 
+                     "status" => "SAVING", 
+                     "progress" => 80 
+                   } 
+                  ] 
+    }.to_json
+  end
+
+  def find_2_response
+    { 
+      "image" => {
+        "id" => 2,
+        "name" => "CentOS 5.2",
+        "serverId" => 12, 
+        "updated" => "2010-10-10T12:00:00Z", 
+        "created" => "2010-08-10T12:00:00Z", 
+        "status" => "ACTIVE",
+        "progress" => 80 
+      }
+    }.to_json
+  end
+
+  def find_2_response_reloaded
+    { 
+      "image" => {
+        "id" => 2,
+        "name" => "CentOS 5.2",
+        "serverId" => 12, 
+        "updated" => "2010-10-10T12:00:00Z", 
+        "created" => "2010-08-10T12:00:00Z", 
+        "status" => "ACTIVE",
+        "progress" => 100
+      }
+    }.to_json
+  end
+
+  def create_response
+    { 
+      "image" =>
+      { 
+        "id" => 22, 
+        "serverId" => 1,
+        "name" => "new-image-test",
+        "created" => "2010-10-10T12:00:00Z", 
+        "status" => "SAVING", 
+        "progress" => 0 
+      }
+    }.to_json
+  end
+end

data/test/test_server.rb

@@ -0,0 +1,259 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class Rackspace::CloudServers::ServerTest < ActiveSupport::TestCase
+  context "working with Rackspace::CloudServers::Server" do
+    should "inherit from Rackspace::CloudServers::Base" do
+      assert Rackspace::CloudServers::Server.ancestors.include?(Rackspace::CloudServers::Base)
+    end
+  end
+
+  context "an instance of Rackspace::CloudServers::Server" do
+    setup do
+      @server = Rackspace::CloudServers::Server.new
+    end
+    
+    [:id, :name, :imageId, :flavorId, :hostId, :status, :progress, :addresses, :metadata].each do |attrib|
+      should "respond to #{attrib}" do
+        assert @server.respond_to?(attrib)
+      end
+    end
+  end
+
+  context "querying servers" do
+    should "build the right resource URL for the index" do
+      mock_auth_response
+      assert_equal "http://test/servers/servers", Rackspace::CloudServers::Server.resource_url
+    end
+
+    should "build the right resource URL for the retrieval" do
+      mock_auth_response
+      assert_equal "http://test/servers/servers/1", Rackspace::CloudServers::Server.resource_url(1)
+    end
+    
+    should "make the right request for find(:all)" do
+      mock_auth_response
+      expects_get("http://test/servers/servers/detail.json")
+      Rackspace::CloudServers::Server.find(:all)
+    end
+
+    should "make the right request for find and default to find(:all)" do
+      mock_auth_response
+      expects_get("http://test/servers/servers/detail.json")
+      Rackspace::CloudServers::Server.find
+    end
+
+    should "make the right request for find(1)" do
+      mock_auth_response
+      expects_get("http://test/servers/servers/1.json")
+      Rackspace::CloudServers::Server.find(1)
+    end
+
+    should "return the right data for find(:all)" do
+      mock_auth_response
+      expects_get("http://test/servers/servers/detail.json").returns(find_all_response)
+      result = Rackspace::CloudServers::Server.find(:all)
+      assert_equal 2, result.length
+      assert_equal Rackspace::CloudServers::Server, result.first.class
+      assert_equal 1234, result.first.id
+      assert_equal Rackspace::CloudServers::Server, result.last.class
+      assert_equal 5678, result.last.id
+    end
+
+    should "return the right figure for count" do
+      mock_auth_response
+      expects_get("http://test/servers/servers/detail.json").returns(find_all_response)
+      assert_equal 2, Rackspace::CloudServers::Server.count
+    end
+
+    should "return the right data for find(1)" do
+      mock_auth_response
+      expects_get("http://test/servers/servers/1234.json").returns(find_1234_response)
+      result = Rackspace::CloudServers::Server.find(1234)
+      assert_equal Rackspace::CloudServers::Server, result.class
+      assert_equal 1234, result.id
+    end
+  end
+
+  context "creating a server" do
+    should "make the right POST request and return the expected values" do
+      mock_auth_response
+      expects_post("http://test/servers/servers.json", {"server" => {"name" => "new-server-test", "imageId" => 2, "flavorId" => 1}}).returns(create_response)
+      server = Rackspace::CloudServers::Server.create(:name => "new-server-test", :imageId => 2, :flavorId => 1)
+      assert_equal 1235, server.id
+      assert_equal "new-server-test", server.name
+      assert_equal 2, server.imageId
+      assert_equal 1, server.flavorId
+      assert_equal "e4d909c290d0fb1ca068ffaddf22cbd0", server.hostId
+      assert_equal 0, server.progress
+      assert_equal "BUILD", server.status
+      assert_equal "GFf1j9aP", server.adminPass
+      assert server.metadata.keys.include?("internal-server-name")
+      assert_equal "test-1", server.metadata["internal-server-name"]
+      assert server.addresses.keys.include?("public")
+      assert server.addresses.keys.include?("private")
+      assert_equal 1, server.addresses["public"].length
+      assert_equal "67.23.10.138", server.addresses["public"].first
+      assert_equal 1, server.addresses["private"].length
+      assert_equal "10.176.42.19", server.addresses["private"].first
+    end
+  end
+
+  context "updating a server" do
+    should "make the PUT request for the server" do
+      mock_auth_response
+      expects_put("http://test/servers/servers/1.json", {"server" => {"name" => "test-name", :adminPass => "test-pass"}})
+      assert_equal true, Rackspace::CloudServers::Server.new(:id => 1, :name => "test-name", :adminPass => "test-pass").save
+    end
+  end
+
+  context "deleting a server" do
+    should "make the DELETE request for the server" do
+      mock_auth_response
+      expects_delete("http://test/servers/servers/1.json")
+      assert_equal true, Rackspace::CloudServers::Server.new(:id => 1).destroy
+    end
+  end
+
+  context "reloading a server instance" do
+    should "not be allowed when it's a new record" do
+      assert_equal false, Rackspace::CloudServers::Server.new.reload
+    end
+    
+    should "make the GET request for the server" do
+      mock_auth_response
+      expects_get("http://test/servers/servers/1234.json").returns(find_1234_response_reloaded)
+      result = Rackspace::CloudServers::Server.new(:id => 1234)
+      updated = result.reload
+      assert_equal 100, updated.progress
+      assert_equal 100, result.progress
+    end
+  end
+
+  def find_all_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" 
+                      } 
+                    } 
+                   ] 
+    }.to_json
+  end
+
+  def find_1234_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" 
+        } 
+      }
+    }.to_json
+  end
+
+  def find_1234_response_reloaded
+    { 
+      "server" => { 
+        "id" => 1234, 
+        "name" => "sample-server", 
+        "imageId" => 2, 
+        "flavorId" => 1, 
+        "hostId" => "e4d909c290d0fb1ca068ffaddf22cbd0", 
+        "status" => "BUILD", 
+        "progress" => 100, 
+        "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" 
+        } 
+      }
+    }.to_json
+  end
+
+  def create_response
+    {
+      "server" => {
+        "id" => 1235,
+        "name" => "new-server-test",
+        "imageId" => 2,
+        "flavorId" => 1,
+        "hostId" => "e4d909c290d0fb1ca068ffaddf22cbd0",
+        "progress" => 0,
+        "status" => "BUILD",
+        "adminPass" => "GFf1j9aP",
+        "metadata" => {
+          "internal-server-name" => "test-1"
+        },
+        "addresses" => {
+          "public" => [
+                       "67.23.10.138"
+                      ],
+          "private" => [
+                        "10.176.42.19"
+                       ]
+        }
+      }
+    }.to_json
+  end
+end