deltacloud-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mar...@apache.org
Subject [27/31] git commit: Adds initial Deltacloud API tests
Date Wed, 25 Jul 2012 13:56:38 GMT
Adds initial Deltacloud API tests


Project: http://git-wip-us.apache.org/repos/asf/deltacloud/repo
Commit: http://git-wip-us.apache.org/repos/asf/deltacloud/commit/fef23f93
Tree: http://git-wip-us.apache.org/repos/asf/deltacloud/tree/fef23f93
Diff: http://git-wip-us.apache.org/repos/asf/deltacloud/diff/fef23f93

Branch: refs/heads/master
Commit: fef23f93453b70cae09d37840988f5d237268fd7
Parents: bf14ec9
Author: marios <marios@redhat.com>
Authored: Fri Jul 20 19:43:06 2012 +0300
Committer: marios <marios@redhat.com>
Committed: Tue Jul 24 12:01:36 2012 +0300

----------------------------------------------------------------------
 tests/Rakefile                    |   28 ++----
 tests/deltacloud/base_api_test.rb |  111 +++++++++++++++++++
 tests/deltacloud/buckets_test.rb  |  187 ++++++++++++++++++++++++++++++++
 tests/deltacloud/config.yaml      |   18 +++
 tests/deltacloud/test_setup.rb    |  119 ++++++++++++++++++++
 5 files changed, 443 insertions(+), 20 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/deltacloud/blob/fef23f93/tests/Rakefile
----------------------------------------------------------------------
diff --git a/tests/Rakefile b/tests/Rakefile
index dfdb209..0475ae5 100644
--- a/tests/Rakefile
+++ b/tests/Rakefile
@@ -19,28 +19,16 @@
 # Add your own tasks in files placed in lib/tasks ending in .rake,
 # for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
 
-require 'rake'
-require 'cucumber'
-require 'cucumber/rake/task'
+require 'rake/testtask'
+require 'deltacloud/test_setup.rb'
 
-DRIVER=ENV['API_DRIVER'] || 'mock'
+namespace :test do
 
-Cucumber::Rake::Task.new(:features) do |t|
-  t.cucumber_opts = "../tests/#{DRIVER} --format html --out ../tests/tmp/cucumber_#{DRIVER}.html"
-  t.rcov = false
-end
-
-Cucumber::Rake::Task.new(:cucumber) do |t|
-  t.cucumber_opts = "../tests/#{DRIVER} --format pretty"
-  t.rcov = false
-end
+    file_list = Rake::FileList.new(deltacloud_test_file_names)
+    Rake::TestTask.new(:deltacloud) do |t|
+      t.test_files = file_list << "deltacloud/base_api_test.rb"
+      t.options = "-v"
+    end
 
-Cucumber::Rake::Task.new(:rcov) do |t|
-  t.cucumber_opts = "../tests/#{DRIVER} --format pretty"
-  t.rcov = true
-  t.rcov_opts << %[-o "../tests/tmp/coverage_#{DRIVER}"]
 end
 
-Cucumber::Rake::Task.new(:junit) do |t|
-  t.cucumber_opts = "../tests/#{DRIVER} --format junit --out #{File.join(File.dirname(__FILE__),
"tmp", "junit_#{DRIVER}")}"
-end

http://git-wip-us.apache.org/repos/asf/deltacloud/blob/fef23f93/tests/deltacloud/base_api_test.rb
----------------------------------------------------------------------
diff --git a/tests/deltacloud/base_api_test.rb b/tests/deltacloud/base_api_test.rb
new file mode 100644
index 0000000..2035b8f
--- /dev/null
+++ b/tests/deltacloud/base_api_test.rb
@@ -0,0 +1,111 @@
+$:.unshift File.join(File.dirname(__FILE__), '..')
+require "deltacloud/test_setup.rb"
+
+describe "Deltacloud API Entry Point" do
+
+  it 'return status 200 OK when accessing API entrypoint' do
+    res = get
+    res.code.must_equal 200
+  end
+
+  it 'advertise the current driver in API entrypoint' do
+    res = get({:accept => :xml})
+    driver = xml_response(res).root[:driver]
+    driver.wont_be_nil
+    DRIVERS.include?(driver).must_equal true
+  end
+
+  it 'advertise the current API version in API entrypoint' do
+    res = get({:accept => :xml})
+    version = xml_response(res).root[:version]
+    version.wont_be_nil
+    version.must_equal API_VERSION
+  end
+
+  it 'advertise the current API version in HTTP headers' do
+    res = get
+    res.headers[:server].must_equal "Apache-Deltacloud/#{API_VERSION}"
+  end
+
+  it 'must include the ETag in HTTP headers' do
+    res = get
+    res.headers[:etag].wont_be_nil
+  end
+
+  it 'advertise collections in API entrypoint' do
+    res = get({:accept => :xml})
+    xml_response(res).xpath('//api/link').wont_be_empty
+  end
+
+  it 'include the :href and :rel attribute for each collection in API entrypoint' do
+    xml_response(get({:accept => :xml})).xpath("//api/link").each do |collection|
+      collection[:href].wont_be_nil
+      collection[:rel].wont_be_nil
+    end
+  end
+
+  it 'uses the absolute URI in the :href attribute for each collection in API entrypoint'
do
+    xml_response(get({:accept => :xml})).xpath("//api/link").each do |collection|
+      collection[:href].must_match /^http/
+    end
+  end
+
+  it 'advertise features for some collections in API entrypoint' do
+    xml_doc = xml_response(get({:accept => :xml}))
+    xml_doc.xpath("//api/link/feature").wont_be_empty
+  end
+
+  it 'advertise the name of the feature for some collections in API entrypoint' do
+    xml_response(get({:accept => :xml})).xpath("//api/link/feature").each do |feature|
+      feature[:name].wont_be_nil
+    end
+  end
+
+  it 'must change the media type from XML to JSON using Accept headers' do
+    res = get({:accept => :json})
+    res.headers[:content_type].must_equal 'application/json'
+  end
+
+  it 'must change the media type to JSON using the "?format" parameter in URL' do
+    res = get({}, "?format=json")
+    res.headers[:content_type].must_equal 'application/json'
+  end
+
+  it 'must change the driver when using X-Deltacloud-Driver HTTP header' do
+    res = xml_response(get({'X-Deltacloud-Driver'=> 'ec2', :accept=> :xml}))
+    res.root[:driver].must_equal 'ec2'
+    res = xml_response(get({'X-Deltacloud-Driver'=> 'mock', :accept=> :xml}))
+    res.root[:driver].must_equal 'mock'
+  end
+
+  it 'must change the features when driver is swapped using HTTP headers' do
+    res = xml_response(get({'X-Deltacloud-Driver'=> 'ec2', :accept=> :xml}))
+    # The 'user_name' feature is not supported currently for the EC2 driver
+    (res/'api/link/feature').map { |f| f[:name] }.wont_include 'user_name'
+    res = xml_response(get({'X-Deltacloud-Driver'=> 'mock', :accept=> :xml}))
+    # But it's supported in Mock driver
+    (res/'api/link/feature').map { |f| f[:name] }.must_include 'user_name'
+  end
+
+  it 'must re-validate the driver credentials when using "?force_auth" parameter in URL'
do
+    proc {get({ :params => {:force_auth => '1'} })}.must_raise RestClient::Request::Unauthorized
+    res = get({ "X-Deltacloud-Driver"=>"mock", :params=>{:force_auth => '1'}, :Authorization=>"Basic
#{Base64.encode64('mockuser:mockpassword')}" })
+    res.code.must_equal 200
+  end
+
+  it 'must change the API PROVIDER using the /api;provider matrix parameter in URI' do
+    res = xml_response(get({}, ';provider=test1'))
+    res.root[:provider].wont_be_nil
+    res.root[:provider].must_equal 'test1'
+    res = xml_response(get({}, ';provider=test2'))
+    res.root[:provider].must_equal 'test2'
+  end
+
+  it 'must change the API DRIVER using the /api;driver matrix parameter in URI' do
+    res = xml_response(get({}, ';driver=ec2'))
+    res.root[:driver].must_equal 'ec2'
+    res = xml_response(get({}, ';driver=mock'))
+    res.root[:driver].must_equal 'mock'
+  end
+
+end

http://git-wip-us.apache.org/repos/asf/deltacloud/blob/fef23f93/tests/deltacloud/buckets_test.rb
----------------------------------------------------------------------
diff --git a/tests/deltacloud/buckets_test.rb b/tests/deltacloud/buckets_test.rb
new file mode 100644
index 0000000..3a525ed
--- /dev/null
+++ b/tests/deltacloud/buckets_test.rb
@@ -0,0 +1,187 @@
+$:.unshift File.join(File.dirname(__FILE__), '..')
+require "deltacloud/test_setup.rb"
+
+
+require 'ruby-debug'
+BUCKETS = "/buckets"
+
+#make sure we have at least one bucket and blob to test
+bucket, blob = create_a_bucket_and_blob
+
+features_hash = discover_features
+
+describe 'Deltacloud API buckets collection' do
+
+MiniTest::Unit.after_tests{
+  #finally delete the bucket/blob we created for the tests:
+  delete_bucket_and_blob(bucket, blob)
+}
+
+  it 'must advertise the buckets collection in API entrypoint' do
+    res = xml_response(get)
+    (res/'api/link[@rel=buckets]').wont_be_empty
+  end
+
+  it 'must require authentication to access the "bucket" collection' do
+    proc {  get({},BUCKETS) }.must_raise RestClient::Request::Unauthorized
+  end
+
+  it 'should respond with HTTP_OK when accessing the :buckets collection with authentication'
do
+    res = get({}, BUCKETS, true)
+    res.code.must_equal 200
+  end
+
+  it 'should be possible to create bucket with POST /api/buckets and delete it with DELETE
/api/buckets/:id' do
+    bucket_name = random_name
+    #create bucket
+    res = post({:name=>bucket_name}, BUCKETS, {}, true)
+    #check response
+    res.code.must_equal 201
+    xml_res = xml_response(res)
+    xml_res.xpath("//bucket/name").text.must_equal bucket_name
+    xml_res.xpath("//bucket").size.must_equal 1
+    xml_res.xpath("//bucket")[0][:id].must_equal bucket_name
+    #GET bucket
+    res = get({}, BUCKETS+"/"+bucket_name, true)
+    res.code.must_equal 200
+    #DELETE bucket
+    res = delete({}, BUCKETS+"/"+bucket_name)
+    res.code.must_equal 204
+  end
+
+  it 'should be possible to specify location for POST /api/buckets if bucket_location feature'
do
+    skip("No bucket_location feature specified for driver #{API_DRIVER} running at #{API_URL}...
skipping test") unless features_hash["buckets"].include?("bucket_location")
+    bucket_name = random_name
+#    res = post({:name=>bucket_name, :bucket_location=>
+  end
+
+
+  it 'should support the JSON media type' do
+    res = get({:accept=>:json}, BUCKETS, true)
+    res.code.must_equal 200
+    res.headers[:content_type].must_equal 'application/json'
+    assert_silent {JSON.parse(res)}
+  end
+
+  it 'must include the ETag in HTTP headers' do
+    res = get({}, BUCKETS, true)
+    res.headers[:etag].wont_be_nil
+  end
+
+  it 'must have the "buckets" element on top level' do
+    xml_res = xml_response(get({:accept=>:xml}, BUCKETS, true))
+    xml_res.root.name.must_equal 'buckets'
+  end
+
+  it 'must have some "bucket" elements inside "buckets"' do
+    xml_res = xml_response(get({:accept=>:xml}, BUCKETS, true))
+    (xml_res/'buckets/bucket').wont_be_empty
+  end
+
+  it 'must provide the :id attribute for each bucket in collection' do
+    xml_res = xml_response(get({:accept=>:xml}, BUCKETS, true))
+    (xml_res/'buckets/bucket').each do |r|
+      r[:id].wont_be_nil
+    end
+  end
+
+  it 'must include the :href attribute for each "bucket" element in collection' do
+    xml_res = xml_response(get({:accept=>:xml}, BUCKETS, true))
+    (xml_res/'buckets/bucket').each do |r|
+      r[:href].wont_be_nil
+    end
+  end
+
+  it 'must use the absolute URL in each :href attribute' do
+    xml_res = xml_response(get({:accept=>:xml}, BUCKETS, true))
+    (xml_res/'buckets/bucket').each do |r|
+      r[:href].must_match /^http/
+    end
+  end
+
+  it 'must have the URL ending with the :id of the bucket' do
+    xml_res = xml_response(get({:accept=>:xml}, BUCKETS, true))
+    (xml_res/'buckets/bucket').each do |r|
+      r[:href].must_match /#{r[:id]}$/
+    end
+  end
+
+  it 'must have the "name" element defined for each bucket in collection' do
+    xml_res = xml_response(get({:accept=>:xml}, BUCKETS, true))
+    (xml_res/'buckets/bucket').each do |r|
+      (r/'name').wont_be_nil
+      (r/'name').wont_be_empty
+    end
+  end
+
+  it 'must have the "size" element defined for each bucket in collection' do
+    xml_res = xml_response(get({:accept=>:xml}, BUCKETS, true))
+    (xml_res/'buckets/bucket').each do |r|
+      (r/'size').wont_be_nil
+      (r/'size').wont_be_empty
+    end
+  end
+
+  it 'must return 200 OK when following the URL in bucket element' do
+    xml_res = xml_response(get({:accept=>:xml}, BUCKETS, true))
+    (xml_res/'buckets/bucket').each do |r|
+      bucket_res = RestClient.get(r[:href], {:Authorization=>BASIC_AUTH})
+      bucket_res.code.must_equal 200
+    end
+  end
+
+  it 'must have the "name" element for the bucket and it should match with the one in collection'
do
+    xml_res = xml_response(get({:accept=>:xml}, BUCKETS, true))
+    (xml_res/'buckets/bucket').each do |r|
+      bucket_xml = xml_response(get({:accept=>:xml}, BUCKETS+"/#{r[:id]}", true))
+      (bucket_xml/'name').wont_be_empty
+      (bucket_xml/'name').first.text.must_equal((r/'name').first.text)
+    end
+  end
+
+  it 'all "blob" elements for the bucket should match the ones in collection' do
+    xml_res = xml_response(get({:accept=>:xml}, BUCKETS, true))
+    (xml_res/'buckets/bucket').each do |r|
+      bucket_xml = xml_response(get({:accept=>:xml}, BUCKETS+"/#{r[:id]}", true))
+      (bucket_xml/'bucket/blob').each do |b|
+        b[:id].wont_be_nil
+        b[:href].wont_be_nil
+        b[:href].must_match /^http/
+        b[:href].must_match /#{r[:id]}\/#{b[:id]}$/
+      end
+    end
+  end
+
+  it 'must allow to get all blobs details and the details should be set correctly' do
+    xml_res = xml_response(get({:accept=>:xml}, BUCKETS, true))
+    (xml_res/'buckets/bucket').each do |r|
+      bucket_xml = xml_response(get({:accept=>:xml}, BUCKETS+"/#{r[:id]}", true))
+      (bucket_xml/'bucket/blob').each do |b|
+        blob_xml = xml_response(get({:accept=>:xml}, BUCKETS+"/#{r[:id]}/#{b[:id]}", true))
+        blob_xml.root.name.must_equal 'blob'
+        blob_xml.root[:id].must_equal b[:id]
+        (blob_xml/'bucket').wont_be_empty
+        (blob_xml/'bucket').size.must_equal 1
+        (blob_xml/'bucket').first.text.wont_be_nil
+        (blob_xml/'bucket').first.text.must_equal r[:id]
+        (blob_xml/'content_length').wont_be_empty
+        (blob_xml/'content_length').size.must_equal 1
+        (blob_xml/'content_length').first.text.must_match /^(\d+)$/
+        (blob_xml/'content_type').wont_be_empty
+        (blob_xml/'content_type').size.must_equal 1
+        (blob_xml/'content_type').first.text.wont_be_nil
+        (blob_xml/'last_modified').wont_be_empty
+        (blob_xml/'last_modified').size.must_equal 1
+        (blob_xml/'last_modified').first.text.wont_be_empty
+        (blob_xml/'content').wont_be_empty
+        (blob_xml/'content').size.must_equal 1
+        (blob_xml/'content').first[:rel].wont_be_nil
+        (blob_xml/'content').first[:rel].must_equal 'blob_content'
+        (blob_xml/'content').first[:href].wont_be_nil
+        (blob_xml/'content').first[:href].must_match /^http/
+        (blob_xml/'content').first[:href].must_match /\/content$/
+      end
+    end
+  end
+
+end

http://git-wip-us.apache.org/repos/asf/deltacloud/blob/fef23f93/tests/deltacloud/config.yaml
----------------------------------------------------------------------
diff --git a/tests/deltacloud/config.yaml b/tests/deltacloud/config.yaml
new file mode 100644
index 0000000..e94a29e
--- /dev/null
+++ b/tests/deltacloud/config.yaml
@@ -0,0 +1,18 @@
+---
+api_url: "http://localhost:3001/api"
+#MOCK DRIVER CONFIG:
+mock:
+  user: "mockuser"
+  password: "mockpassword"
+#EC2 DRIVER CONFIG:
+ec2:
+  user: #your EC2 KEY HERE
+  password: #your EC2 SECRET_KEY HERE
+  bucket_locations:
+  #location constraint : provider
+    "EU" : "eu-west-1"
+    "sa-east-1" : "sa-east-1"
+    "us-west-1" : "us-west-1"
+    "us-west-2" : "us-west-2"
+    "ap-southeast-1" : "ap-southeast-1"
+    "ap-northeast-1" : "ap-northeast-1"

http://git-wip-us.apache.org/repos/asf/deltacloud/blob/fef23f93/tests/deltacloud/hardware_profiles_test.rb
----------------------------------------------------------------------
diff --git a/tests/deltacloud/hardware_profiles_test.rb b/tests/deltacloud/hardware_profiles_test.rb
new file mode 100644
index 0000000..e69de29

http://git-wip-us.apache.org/repos/asf/deltacloud/blob/fef23f93/tests/deltacloud/images_test.rb
----------------------------------------------------------------------
diff --git a/tests/deltacloud/images_test.rb b/tests/deltacloud/images_test.rb
new file mode 100644
index 0000000..e69de29

http://git-wip-us.apache.org/repos/asf/deltacloud/blob/fef23f93/tests/deltacloud/instance_states_test.rb
----------------------------------------------------------------------
diff --git a/tests/deltacloud/instance_states_test.rb b/tests/deltacloud/instance_states_test.rb
new file mode 100644
index 0000000..e69de29

http://git-wip-us.apache.org/repos/asf/deltacloud/blob/fef23f93/tests/deltacloud/instances_test.rb
----------------------------------------------------------------------
diff --git a/tests/deltacloud/instances_test.rb b/tests/deltacloud/instances_test.rb
new file mode 100644
index 0000000..e69de29

http://git-wip-us.apache.org/repos/asf/deltacloud/blob/fef23f93/tests/deltacloud/keys_test.rb
----------------------------------------------------------------------
diff --git a/tests/deltacloud/keys_test.rb b/tests/deltacloud/keys_test.rb
new file mode 100644
index 0000000..e69de29

http://git-wip-us.apache.org/repos/asf/deltacloud/blob/fef23f93/tests/deltacloud/realms_test.rb
----------------------------------------------------------------------
diff --git a/tests/deltacloud/realms_test.rb b/tests/deltacloud/realms_test.rb
new file mode 100644
index 0000000..e69de29

http://git-wip-us.apache.org/repos/asf/deltacloud/blob/fef23f93/tests/deltacloud/storage_snapshots_test.rb
----------------------------------------------------------------------
diff --git a/tests/deltacloud/storage_snapshots_test.rb b/tests/deltacloud/storage_snapshots_test.rb
new file mode 100644
index 0000000..e69de29

http://git-wip-us.apache.org/repos/asf/deltacloud/blob/fef23f93/tests/deltacloud/storage_volumes_test.rb
----------------------------------------------------------------------
diff --git a/tests/deltacloud/storage_volumes_test.rb b/tests/deltacloud/storage_volumes_test.rb
new file mode 100644
index 0000000..e69de29

http://git-wip-us.apache.org/repos/asf/deltacloud/blob/fef23f93/tests/deltacloud/test_setup.rb
----------------------------------------------------------------------
diff --git a/tests/deltacloud/test_setup.rb b/tests/deltacloud/test_setup.rb
new file mode 100644
index 0000000..0c7fe6b
--- /dev/null
+++ b/tests/deltacloud/test_setup.rb
@@ -0,0 +1,119 @@
+require 'rubygems'
+require 'minitest/autorun'
+require 'rest_client'
+require 'nokogiri'
+require 'json'
+require 'base64'
+require 'yaml'
+
+#SETUP
+$:.unshift File.join(File.dirname(__FILE__), '..')
+CONFIG = YAML.load(File.open("deltacloud/config.yaml"))
+API_URL = CONFIG["api_url"]
+API_DRIVER = RestClient.get(API_URL) do |response, request, result|
+  Nokogiri::XML(response).root[:driver]
+end
+raise Exception.new("Can't find config for driver: #{API_DRIVER} currently running at #{API_URL}
in config.yaml file") unless CONFIG[API_DRIVER] and CONFIG[API_DRIVER]["user"] and CONFIG[API_DRIVER]["password"]
+USER    = CONFIG[API_DRIVER]["user"]
+PASSWORD= CONFIG[API_DRIVER]["password"]
+BASIC_AUTH="Basic #{Base64.encode64(USER+":"+PASSWORD)}"
+
+DRIVERS = RestClient.get(API_URL+"/drivers") do |response, request, result|
+  Nokogiri::XML(response).xpath("//driver/name").inject([]){|res, c| res << c.text.downcase;
res}
+end
+API_VERSION = Nokogiri::XML(RestClient.get API_URL).root[:version]
+#SETUP
+
+def xml_response(xml)
+  Nokogiri::XML(xml)
+end
+
+def json_response(json)
+  JSON.parse(json)
+end
+
+def get(params={}, path="", authenticate = false)
+  if authenticate
+    params.merge!({:Authorization=>BASIC_AUTH})
+  end
+  RestClient.get API_URL+path, params
+end
+
+def post(post_body = "", path= "", params={}, authenticate = false)
+  if authenticate
+    params.merge!({:Authorization=>BASIC_AUTH})
+  end
+  RestClient.post API_URL+path, post_body, params
+end
+
+def delete(params={}, path = "", authenticate = true)
+  if authenticate
+    params.merge!({:Authorization=>BASIC_AUTH})
+  end
+  RestClient.delete API_URL+path, params
+end
+
+def options(params={}, path="", authenticate = false)
+  if authenticate
+    params.merge!({:Authorization=>BASIC_AUTH})
+  end
+  RestClient.options API_URL+path, params
+end
+
+#the TEST_FILES hash and deltacloud_test_file_names method
+#which follows is used in the Rakefile for the rake test:deltacloud task
+TEST_FILES =  { :images             => "images_test.rb",
+                :realms             => "realms_test.rb",
+                :hardware_profiles  => "hardware_profiles_test.rb",
+                :instance_states    => "instance_states_test.rb",
+                :instances          => "instances_test.rb",
+                :keys               => "keys_test.rb",
+                :firewalls          => "firewalls_test.rb",
+                :addresses          => "addresses_test.rb",
+                :load_balancers     => "load_balancers_test.rb",
+                :storage_volumes    => "storage_volumes_test.rb",
+                :storage_snapshots  => "storage_snapshots_test.rb",
+                :buckets            => "buckets_test.rb"
+              }
+#gets the list of collections from the server running at API_URL and translates those into
file names accoring to TEST_FILES
+def deltacloud_test_file_names
+  driver_collections = xml_response(RestClient.get API_URL, {:accept=>:xml}).xpath("//api/link").inject([]){|res,
current| res<<current[:rel].to_sym ;res}
+  driver_collections.inject([]){|res, current| res << "deltacloud/#{TEST_FILES[current]}"
if TEST_FILES[current] ;res}
+end
+
+def create_a_bucket_and_blob
+  #random bucket and blob name - make sure starts with letter:
+  bucket_name = random_name
+  blob_name = random_name
+  #create bucket:
+#  res = RestClient.post "#{API_URL}/buckets", {:name=>bucket_name}, {:Authorization=>BASIC_AUTH}
+  res = post({:name=>bucket_name}, "/buckets", {}, true)
+  raise Exception.new("unable to create bucket with name #{bucket_name} for bucket_test.rb")
unless res.code == 201
+  #create blob:
+  res = RestClient.put "#{API_URL}/buckets/#{bucket_name}/#{blob_name}", "This is the test
blob content", {:Authorization=>BASIC_AUTH, :content_type=>"text/plain", "X-Deltacloud-Blobmeta-Version"=>"1.0",
"X-Deltacloud-Blobmeta-Author"=>"herpyderp"}
+  raise Exception.new("unable to create blob with name #{blob_name} for bucket_test.rb")
unless res.code == 200
+  return [bucket_name, blob_name]
+end
+
+def random_name
+  name = rand(36**10).to_s(36)
+  name.insert(0, "apitest")
+end
+
+def delete_bucket_and_blob(bucket, blob)
+#  res = RestClient.delete "#{API_URL}/buckets/#{bucket}/#{blob}", {:Authorization=>BASIC_AUTH}
+  res = delete({}, "/buckets/#{bucket}/#{blob}")
+  raise Exception.new("unable to delete blob with name #{blob} for bucket_test.rb") unless
res.code == 204
+#  res = RestClient.delete "#{API_URL}/buckets/#{bucket}", {:Authorization=>BASIC_AUTH}
+  res = delete({}, "/buckets/#{bucket}")
+  raise Exception.new("unable to delete bucket with name #{bucket} for bucket_test.rb") unless
res.code == 204
+end
+
+def discover_features
+  res = xml_response(get)
+  features_hash = res.xpath("//api/link").inject({}) do |result, collection|
+    result.merge!({collection[:rel] => []})
+    collection.children.inject([]){|features, current_child| result[collection[:rel]] <<
current_child[:name] if current_child.name == "feature"}
+    result
+  end
+end


Mime
View raw message