tfe-cloudfiles 1.4.7

data/test/cf-testunit.rb

@@ -0,0 +1,157 @@
+#!/usr/bin/env ruby
+#
+# Major's live tests that go against the real Cloud Files system.  Requires a valid username and API key to function.
+
+require File.dirname(__FILE__) + '/../lib/cloudfiles'
+
+username = "YOUR_USERNAME"
+apikey = "YOUR_API_KEY"
+
+def assert_test(testtext,bool)
+  booltext = (bool)? " PASS" : "*FAIL*" ;
+  (testtext+"... ").ljust(50)+booltext
+end
+
+filename = File.dirname(__FILE__) + '/../lib/cloudfiles.rb'
+
+# Test initial connection
+cf = CloudFiles::Connection.new(username,apikey)
+puts assert_test("Connecting to CloudFiles",cf.class == CloudFiles::Connection)
+
+# Test container creation
+testingcontainer = "RubyCFTest"
+cntnr = cf.create_container(testingcontainer)
+puts assert_test("Creating test container",cntnr.class == CloudFiles::Container)
+
+# Checking container size
+bytes = cntnr.bytes
+puts assert_test("  Checking container size",bytes == 0)
+
+# Checking container count
+count = cntnr.count
+puts assert_test("  Checking container count",count == 0)
+
+# Add a file to the container - standard method
+cloudfilesfilesize = File.read(filename).length
+cloudfilesmd5 = Digest::MD5.hexdigest(File.read(filename))
+headers = { "ETag" => cloudfilesmd5, "Content-Type" => "text/ruby", "X-Object-Meta-Testmeta" => "value" }
+myobj = cntnr.create_object("cloudfiles-standard.rb")
+myobj.write(File.read(filename), headers)
+puts assert_test("    Uploading object (read into memory)",myobj.class == CloudFiles::StorageObject)
+cntnr.refresh
+
+# Check if object exists
+bool = cntnr.object_exists?("cloudfiles-standard.rb")
+puts assert_test("    Checking for object existence",bool)
+
+# Checking container size
+bytes = cntnr.bytes
+puts assert_test("  Checking container size with #{bytes} vs #{cloudfilesfilesize}",bytes == cloudfilesfilesize)
+
+# Checking container count
+count = cntnr.count
+puts assert_test("  Checking container count",count == 1)
+
+# Add a file to the container - stream method
+headers = { "ETag" => cloudfilesmd5, "Content-Type" => "text/ruby", "X-Object-Meta-Testmeta" => "value" }
+f = IO.read(filename)
+myobj = cntnr.create_object("cloudfiles-stream.rb")
+myobj.write(File.read(filename), headers)
+puts assert_test("    Uploading object (read from stream)",myobj.class == CloudFiles::StorageObject)
+cntnr.refresh
+
+# Check if object exists
+bool = cntnr.object_exists?("cloudfiles-stream.rb")
+puts assert_test("    Checking for object existence",bool)
+
+# Checking container size
+bytes = cntnr.bytes
+puts assert_test("  Checking container size",bytes == (cloudfilesfilesize*2))
+
+# Checking container count
+count = cntnr.count
+puts assert_test("  Checking container count",count == 2)
+
+# Check file size
+bytes = myobj.bytes.to_i
+puts assert_test("    Checking object size",bytes == cloudfilesfilesize)
+
+# Check content type
+content_type = myobj.content_type
+puts assert_test("    Checking object content type",content_type == "text/ruby")
+
+# Check metadata
+metadata = myobj.metadata
+puts assert_test("    Checking object metadata",metadata["testmeta"] == "value")
+
+# Set new metadata
+bool = myobj.set_metadata({ "testmeta2" => "differentvalue"})
+puts assert_test("    Setting new object metadata",bool)
+
+# Check new metadata
+myobj.refresh
+metadata = myobj.metadata
+puts assert_test("    Checking new object metadata",metadata["testmeta2"] == "differentvalue")
+
+# Get data via standard method
+data = myobj.data
+puts assert_test("    Retrieving object data (read into memory)",Digest::MD5.hexdigest(data) == cloudfilesmd5)
+
+# Get data via stream
+data = ""
+myobj.data_stream { |chunk|
+  data += chunk.to_s
+}
+puts assert_test("    Retrieving object data (read from stream)",Digest::MD5.hexdigest(data) == cloudfilesmd5)
+
+# Check md5sum
+etag = myobj.etag
+puts assert_test("    Checking object's md5sum",etag == cloudfilesmd5)
+
+# Make container public
+bool = cntnr.make_public
+puts assert_test("  Making container public",bool)
+
+# Verify that container is public
+bool = cntnr.public?
+puts assert_test("  Verifying container is public",bool)
+
+# Getting CDN URL
+cdnurl = cntnr.cdn_url
+puts assert_test("  Getting CDN URL",cdnurl)
+
+# Setting CDN URL
+bool = cntnr.make_public(:ttl => 7200)
+puts assert_test("  Setting CDN TTL",bool)
+
+# Make container private
+bool = cntnr.make_private
+puts assert_test("  Making container private",bool)
+
+# Check if container is empty
+bool = cntnr.empty?
+puts assert_test("  Checking if container empty",bool == false)
+
+# Remove standard object
+bool = cntnr.delete_object("cloudfiles-standard.rb")
+puts assert_test("    Deleting first object",bool)
+
+# Remove stream object
+bool = cntnr.delete_object("cloudfiles-stream.rb")
+puts assert_test("    Deleting second object",bool)
+cntnr.refresh
+
+# Check if container is empty
+bool = cntnr.empty?
+puts assert_test("  Checking if container empty",bool)
+
+# Remove testing container
+bool = cf.delete_container(testingcontainer)
+puts assert_test("Removing container",bool)
+
+# Check to see if container exists
+bool = cf.container_exists?(testingcontainer)
+puts assert_test("Checking container existence",bool == false)
+
+
+

data/test/cloudfiles_authentication_test.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class CloudfilesAuthenticationTest < 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.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, :snet? => false)
+    result = CloudFiles::Authentication.new(@connection)
+    assert_equal result.class, CloudFiles::Authentication
+  end
+  
+  def test_snet_authentication
+    response = {'x-cdn-management-url' => 'http://cdn.example.com/path', 'x-storage-url' => 'http://cdn.example.com/storage', 'authtoken' => '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, :snet? => true)
+    result = CloudFiles::Authentication.new(@connection)
+    assert_equal result.class, CloudFiles::Authentication
+  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', :authkey => 'bad_key', :authok= => true, :authtoken= => true)
+    assert_raises(AuthenticationException) do
+      result = CloudFiles::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 = CloudFiles::Authentication.new(@connection)
+    end
+  end
+    
+end

data/test/cloudfiles_connection_test.rb

@@ -0,0 +1,286 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class CloudfilesConnectionTest < Test::Unit::TestCase
+  
+  def setup
+    CloudFiles::Authentication.expects(:new).returns(true)
+    @connection = CloudFiles::Connection.new('dummy_user', 'dummy_key')
+    @connection.storagehost = "test.setup.example"
+    @connection.storagepath = "/dummypath/setup"
+    @connection.cdnmgmthost = "test.cdn.example"
+    @connection.cdnmgmtpath = "/dummycdnpath/setup"
+  end
+  
+  def test_initialize
+    assert_equal @connection.authuser, 'dummy_user'
+    assert_equal @connection.authkey, 'dummy_key'
+  end
+  
+  def test_authok
+    # This would normally be set in CloudFiles::Authentication
+    assert_equal @connection.authok?, false
+    @connection.expects(:authok?).returns(true)
+    assert_equal @connection.authok?, true
+  end
+  
+  def test_snet
+    # This would normally be set in CloudFiles::Authentication
+    assert_equal @connection.snet?, false
+    @connection.expects(:snet?).returns(true)
+    assert_equal @connection.snet?, true
+  end
+      
+  def test_cfreq_get
+    build_net_http_object
+    assert_nothing_raised do 
+      response = @connection.cfreq("GET", "test.server.example", "/dummypath", "80", "http")
+    end
+  end
+  
+  def test_cfreq_post
+    build_net_http_object
+    assert_nothing_raised do
+      response = @connection.cfreq("POST", "test.server.example", "/dummypath", "80", "http")
+    end
+  end
+  
+  def test_cfreq_put
+    build_net_http_object
+    assert_nothing_raised do
+      response = @connection.cfreq("PUT", "test.server.example", "/dummypath", "80", "http")
+    end
+  end
+  
+  def test_cfreq_delete
+    build_net_http_object
+    assert_nothing_raised do
+      response = @connection.cfreq("DELETE", "test.server.example", "/dummypath", "80", "http")
+    end
+  end
+  
+  def test_cfreq_with_static_data
+    build_net_http_object
+    assert_nothing_raised do
+      response = @connection.cfreq("PUT", "test.server.example", "/dummypath", "80", "http", {}, "This is string data")
+    end
+  end
+  
+  def test_cfreq_with_stream_data
+    build_net_http_object
+    require 'tempfile'
+    file = Tempfile.new("test")
+    assert_nothing_raised do
+      response = @connection.cfreq("PUT", "test.server.example", "/dummypath", "80", "http", {}, file)
+    end
+  end
+  
+  def test_cfreq_head
+    build_net_http_object
+    assert_nothing_raised do
+      response = @connection.cfreq("HEAD", "test.server.example", "/dummypath", "80", "http")
+    end
+  end
+  
+  def test_net_http_raises_connection_exception
+    Net::HTTP.expects(:new).raises(ConnectionException)
+    assert_raises(ConnectionException) do
+      response = @connection.cfreq("GET", "test.server.example", "/dummypath", "80", "http")
+    end
+  end
+  
+  def test_net_http_raises_one_eof_exception
+    response = {'x-cdn-management-url' => 'http://cdn.example.com/path', 'x-storage-url' => 'http://cdn.example.com/storage', 'authtoken' => 'dummy_token'}
+    response.stubs(:code).returns('204')
+    server = stub(:use_ssl= => true, :verify_mode= => true, :start => true, :finish => true)
+    server.stubs(:request).raises(EOFError).then.returns(response)
+    Net::HTTP.stubs(:new).returns(server)
+    assert_nothing_raised do
+      response = @connection.cfreq("GET", "test.server.example", "/dummypath", "443", "https")
+    end
+  end
+  
+  def test_net_http_raises_one_expired_token
+    CloudFiles::Authentication.expects(:new).returns(true)
+    response = {'x-cdn-management-url' => 'http://cdn.example.com/path', 'x-storage-url' => 'http://cdn.example.com/storage', 'authtoken' => 'dummy_token'}
+    response.stubs(:code).returns('401').then.returns('204')
+    server = stub(:use_ssl= => true, :verify_mode= => true, :start => true)
+    server.stubs(:request).returns(response)
+    Net::HTTP.stubs(:new).returns(server)
+    assert_nothing_raised do
+      response = @connection.cfreq("GET", "test.server.example", "/dummypath", "80", "http")
+    end
+  end
+  
+  def test_net_http_raises_continual_eof_exceptions
+    response = {'x-cdn-management-url' => 'http://cdn.example.com/path', 'x-storage-url' => 'http://cdn.example.com/storage', 'authtoken' => 'dummy_token'}
+    response.stubs(:code).returns('204')
+    server = stub(:use_ssl= => true, :verify_mode= => true, :start => true)
+    server.stubs(:finish).returns(true)
+    server.stubs(:request).raises(EOFError)
+    Net::HTTP.stubs(:new).returns(server)
+    assert_raises(ConnectionException) do
+      response = @connection.cfreq("GET", "test.server.example", "/dummypath", "80", "http")
+    end
+  end
+  
+  def test_get_info
+    build_net_http_object(:response => {'x-account-bytes-used' => '9999', 'x-account-container-count' => '5'}, :code => '204')
+    @connection.get_info
+    assert_equal @connection.bytes, 9999
+    assert_equal @connection.count, 5
+  end
+  
+  def test_get_info_fails
+    build_net_http_object(:response => {'x-account-bytes-used' => '9999', 'x-account-container-count' => '5'}, :code => '999')
+    assert_raises(InvalidResponseException) do
+      @connection.get_info
+    end
+  end
+  
+  def test_public_containers
+    build_net_http_object(:body => "foo\nbar\nbaz", :code => '200', :response => {})
+    public_containers = @connection.public_containers
+    assert_equal public_containers.size, 3
+    assert_equal public_containers.first, 'foo'
+  end
+  
+  def test_public_containers_empty
+    build_net_http_object
+    public_containers = @connection.public_containers
+    assert_equal public_containers.size, 0
+    assert_equal public_containers.class, Array
+  end
+  
+  def test_public_containers_exception
+    build_net_http_object(:code => '999')
+    assert_raises(InvalidResponseException) do
+      public_containers = @connection.public_containers
+    end
+  end
+  
+  def test_delete_container
+    build_net_http_object
+    response = @connection.delete_container("good_container")
+    assert_equal response, true
+  end
+  
+  def test_delete_nonempty_container
+    build_net_http_object(:code => '409')
+    assert_raises(NonEmptyContainerException) do
+      response = @connection.delete_container("not_empty")
+    end
+  end
+  
+  def test_delete_unknown_container
+    build_net_http_object(:code => '999')
+    assert_raises(NoSuchContainerException) do
+      response = @connection.delete_container("not_empty")
+    end
+  end
+  
+  def test_create_container
+    CloudFiles::Container.any_instance.stubs(:populate)
+    build_net_http_object(:code => '201')
+    container = @connection.create_container('good_container')
+    assert_equal container.name, 'good_container'
+  end
+  
+  def test_create_container_with_invalid_name
+    CloudFiles::Container.stubs(:new)
+    assert_raise(SyntaxException) do
+      container = @connection.create_container('a'*300)
+    end
+  end
+  
+  def test_create_container_name_filter
+    CloudFiles::Container.any_instance.stubs(:populate)
+    build_net_http_object(:code => '201')
+    assert_raises(SyntaxException) do 
+      container = @connection.create_container('this/has/bad?characters')
+    end
+  end
+  
+  def test_container_exists_true
+    build_net_http_object
+    assert_equal @connection.container_exists?('this_container_exists'), true
+  end
+  
+  def test_container_exists_false
+    build_net_http_object(:code => '999')
+    assert_equal @connection.container_exists?('this_does_not_exist'), false
+  end
+  
+  def test_fetch_exisiting_container
+    CloudFiles::Container.any_instance.stubs(:populate)
+    build_net_http_object
+    container = @connection.container('good_container')
+    assert_equal container.name, 'good_container'
+  end
+  
+  def test_fetch_nonexistent_container
+    CloudFiles::Container.any_instance.stubs(:populate).raises(NoSuchContainerException)
+    build_net_http_object
+    assert_raise(NoSuchContainerException) do
+      container = @connection.container('bad_container')
+    end
+  end
+  
+  def test_containers
+    build_net_http_object(:body => "foo\nbar\nbaz\nboo", :code => '200')
+    containers = @connection.containers
+    assert_equal containers.size, 4
+    assert_equal containers.first, 'foo'
+  end
+  
+  def test_no_containers_yet
+    build_net_http_object
+    containers = @connection.containers
+    assert_equal containers.size, 0
+    assert_equal containers.class, Array
+  end
+  
+  def test_containers_bad_result
+    build_net_http_object(:code => '999')
+    assert_raises(InvalidResponseException) do
+      containers = @connection.containers
+    end
+  end
+  
+  def test_containers_detail
+    body = %{<?xml version="1.0" encoding="UTF-8"?>
+    <account name="MossoCloudFS_012559c7-030d-4bbd-8538-7468896b0e7f">
+    <container><name>Books</name><count>0</count><bytes>0</bytes></container><container><name>cftest</name><count>0</count><bytes>0</bytes></container><container><name>cszsa</name><count>1</count><bytes>82804</bytes></container><container><name>CWX</name><count>3</count><bytes>3645134</bytes></container><container><name>test</name><count>2</count><bytes>20</bytes></container><container><name>video</name><count>2</count><bytes>34141298</bytes></container><container><name>webpics</name><count>1</count><bytes>177496</bytes></container></account>}
+    build_net_http_object(:body => body, :code => '200')
+    details = @connection.containers_detail
+    assert_equal details['CWX'][:count], "3"
+  end
+  
+  def test_empty_containers_detail
+    build_net_http_object
+    details = @connection.containers_detail
+    assert_equal details, {}
+  end
+  
+  def test_containers_detail_bad_response
+    build_net_http_object(:code => '999')
+    assert_raises(InvalidResponseException) do
+      details = @connection.containers_detail
+    end
+  end
+    
+  private
+  
+  def build_net_http_object(args={:code => '204' })
+    args[:response] = {} unless args[:response]
+    response = {'x-cdn-management-url' => 'http://cdn.example.com/path', 'x-storage-url' => 'http://cdn.example.com/storage', 'authtoken' => 'dummy_token'}.merge(args[:response])
+    response.stubs(:code).returns(args[:code])
+    response.stubs(:body).returns args[:body] || nil
+    server = mock()
+    server.stubs(:verify_mode= => true)
+    server.stubs(:start => true)
+    server.stubs(:use_ssl=).returns(true)
+    server.stubs(:request).returns(response)
+    Net::HTTP.stubs(:new).returns(server)
+  end
+  
+end