deltacloud-core 1.0.2 → 1.0.3

data/tests/deprecated/api/common.rb

@@ -1 +0,0 @@
-require 'minitest/autorun'

data/tests/deprecated/api/driver_test.rb

@@ -1,79 +0,0 @@
-require_relative './common'
-require_relative '../../lib/deltacloud/api'
-
-begin
-  require 'arguments'
-rescue LoadError
-  puts "You don't have 'rdp-arguments' gems installed. (gem install rdp-arguments)"
-  exit(1)
-end
-require 'pp'
-
-describe 'Deltacloud drivers API' do
-
-  before do
-    @stderr = $stderr.clone
-    $stderr = StringIO.new
-  end
-
-  after do
-    $stderr = @stderr
-  end
-
-  it 'should pass the known method to Deltacloud driver' do
-    Deltacloud.new(:mock).hardware_profiles.must_be_kind_of Array
-    Deltacloud.new(:mock).hardware_profiles.wont_be_empty
-  end
-
-  it 'should raise NoMethodError when driver does not respond to method' do
-    lambda { Deltacloud.new(:mock).non_existing_method }.must_raise NoMethodError
-  end
-
-  it 'should apply the credentials to methods that require them' do
-    Deltacloud.new(:mock).realms.must_be_kind_of Array
-    Deltacloud.new(:mock).realms.wont_be_empty
-  end
-
-  it 'should allow to use different drivers' do
-    Deltacloud.new(:ec2).backend.must_be_instance_of Deltacloud::Drivers::Ec2::Ec2Driver
-    Deltacloud.new(:mock).backend.must_be_instance_of Deltacloud::Drivers::Mock::MockDriver
-  end
-
-  it 'should support loading all supported drivers' do
-    Deltacloud.drivers.keys.each do |key|
-      Deltacloud.new(key).current_driver.must_equal key.to_s
-    end
-  end
-
-  METHODS = {
-    :firewalls => [[:credentials], [:opts, "{  }"]],
-    :firewall  => [[:credentials], [:opts, "{  }"]],
-    :keys    => [[:credentials], [:opts, "{  }"]],
-    :key     => [[:credentials], [:opts]],
-    :storage_snapshots => [[:credentials], [:opts, "{  }"]],
-    :storage_snapshot  => [[:credentials], [:opts]],
-    :storage_volumes => [[:credentials], [:opts, "{  }"]],
-    :storage_volume  => [[:credentials], [:opts]],
-    :realms    => [[:credentials], [:opts, "{  }"]],
-    :realm     => [[:credentials], [:opts]],
-    :images    => [[:credentials], [:opts, "{  }"]],
-    :image     => [[:credentials], [:opts]],
-    :instances => [[:credentials], [:opts, "{  }"]],
-    :instance  => [[:credentials], [:opts]],
-    :create_instance => [[:credentials], [:image_id], [:opts, "{  }"]],
-    :destroy_instance => [[:credentials], [:id]],
-    :stop_instance => [[:credentials], [:id]],
-    :start_instance => [[:credentials], [:id]],
-    :reboot_instance => [[:credentials], [:id]],
-  }
-
-  Deltacloud.drivers.keys.each do |key|
-    METHODS.each do |m, definition|
-      it "should have the correct parameters for the :#{m} method in #{key} driver" do
-        next unless Deltacloud.new(key).backend.respond_to? m
-        Arguments.names(Deltacloud.new(key).backend.class, m).must_equal definition
-      end
-    end
-  end
-
-end

data/tests/deprecated/api/library_test.rb

@@ -1,6 +0,0 @@
-require_relative './common'
-require_relative '../../lib/deltacloud/api'
-
-require 'pp'
-
-

data/tests/deprecated/cimi/features/step_definitions/common_steps.rb

@@ -1,59 +0,0 @@
-World(Rack::Test::Methods)
-
-Given /^Cloud Entry Point URL is provided$/ do
-  get '/cimi'
-  last_response.status.should == 301
-  last_response.location.should == "http://example.org/cimi/cloudEntryPoint"
-end
-
-Given /^client retrieve the Cloud Entry Point$/ do
-  get "/cimi/cloudEntryPoint"
-  header 'Accept', 'application/xml'
-  last_response.status.should == 200
-end
-
-When /^client lists ([\w ]+) collection$/ do |col_name|
-  authorize 'mockuser', 'mockpassword'
-  header 'Accept', 'application/xml'
-  get "/cimi/%s" % col_name.to_collection_uri
-  last_response.status.should == 200
-end
-
-Then /^client should get list of all ([\w ]+)$/ do |col_name|
-  root_name = "#{col_name.to_collection_name}Collection"
-  last_xml_response.root.name.should == root_name
-  (last_xml_response/"#{root_name}/name").size.should == 1
-  (last_xml_response/"#{root_name}/name").first.text.should == 'default'
-  (last_xml_response/"#{root_name}/id").size.should == 1
-  (last_xml_response/"#{root_name}/id").first.text.should == last_request.url
-  (last_xml_response/"#{root_name}/#{col_name.to_entity_name}").size.should == 3
-  (last_xml_response/"#{root_name}/#{col_name.to_entity_name}").each do |machine_img|
-    machine_img[:href].should_not be_nil
-    machine_img[:href].should =~ /http:\/\/example\.org\/cimi\/#{col_name.to_collection_uri}\/img(\d)/
-  end
-end
-
-When /^client( should be able to)? query for '(\w+)' ([\w ]+) entity$/ do |s, entity_id, entity_name|
-  authorize 'mockuser', 'mockpassword'
-  header 'Accept', 'application/xml'
-  get "/cimi/%s/%s" % [entity_name.to_entity_uri, entity_id]
-  last_response.status.should == 200
-  @entity_id = entity_id
-end
-
-Then /^client should verify that this ([\w ]+) exists$/ do |entity_name|
-  root_name = entity_name.to_class_name
-  last_xml_response.root.name.should == root_name
-  @entity = last_xml_response
-end
-
-Then /^client should verify that this ([\w ]+) has set$/ do |entity, attrs|
-  model = CIMI::Model.const_get(entity.to_class_name).from_xml(last_response.body)
-  attrs.rows_hash.each do |key, value|
-    if key =~ /^\*/
-      model.send(key.gsub(/^\*/, '').intern).href.should == value
-    else
-      model.send(key.intern).to_s.should == value
-    end
-  end
-end

data/tests/deprecated/cimi/features/step_definitions/machines_steps.rb

@@ -1,100 +0,0 @@
-When /^client specifies a Machine Image$/ do |machine_image|
-  header 'Accept', 'application/xml'
-  authorize 'mockuser', 'mockpassword'
-  get machine_image.raw[0][1]
-  last_response.status.should == 200
-  @machine_image = CIMI::Model::MachineImage.from_xml(last_response.body)
-  @machine_image.should_not be_nil
-  @machine_image.id.should == machine_image.raw[0][1]
-end
-
-When /^client specifies a Machine Configuration$/ do |machine_conf|
-  header 'Accept', 'application/xml'
-  authorize 'mockuser', 'mockpassword'
-  get machine_conf.raw[0][1]
-  last_response.status.should == 200
-  @machine_configuration = CIMI::Model::MachineImage.from_xml(last_response.body)
-  @machine_configuration.should_not be_nil
-  @machine_configuration.id.should == machine_conf.raw[0][1]
-end
-
-When /^client specifies a new Machine using$/ do |machine|
-  @machine_image.should_not be_nil
-  @machine_configuration.should_not be_nil
-  @new_machine_name = machine.raw[0][1]
-  @builder = Nokogiri::XML::Builder.new do |xml|
-    xml.MachineCreate(:xmlns => CMWG_NAMESPACE) {
-      xml.name @new_machine_name
-      xml.description machine.raw[1][1]
-      xml.machineTemplate {
-        xml.machineConfig( :href => @machine_configuration.id )
-        xml.machineImage( :href => @machine_image.id )
-      }
-    }
-  end
-end
-
-Then /^client should be able to create this Machine$/ do
-  authorize 'mockuser', 'mockpassword'
-  header 'Content-Type', 'application/xml'
-  post '/cimi/machines', @builder.to_xml
-  if [500, 501, 502].include? last_response.status
-    puts last_response.body
-  end
-  last_response.status.should == 201
-  set_new_machine(CIMI::Model::Machine.from_xml(last_response.body))
-end
-
-Then /^client query for created Machine entity$/ do
-  authorize 'mockuser', 'mockpassword'
-  header 'Content-Type', 'application/xml'
-  get "/cimi/machines/%s" % new_machine.name
-  if [500, 501, 502].include? last_response.status
-    puts last_response.body
-  end
-  if @delete_operation
-    last_response.status.should == 404
-  else
-    last_response.status.should == 200
-    @machine = CIMI::Model::Machine.from_xml(last_response.body)
-    @machine.name.should == new_machine.name
-  end
-
-end
-
-Then /^client should verify that this Machine has been created properly$/ do |attrs|
-  attrs.rows_hash.each do |key, value|
-    if key == 'memory'
-      @machine.memory['quantity'].to_s.should == value
-    else
-      @machine.send(key.intern).to_s.should == value
-    end
-  end
-end
-
-When /^client executes (\w+) operation on created Machine$/ do |operation|
-  builder = Nokogiri::XML::Builder.new do |xml|
-    xml.Action(:xmlns => CMWG_NAMESPACE) {
-      xml.action "http://www.dmtf.org/cimi/action/#{operation}"
-    }
-  end
-  authorize 'mockuser', 'mockpassword'
-  header 'Content-Type', 'application/xml'
-  if operation == 'delete'
-    delete "/cimi/machines/%s" % new_machine.name
-    puts last_response.body
-    last_response.status.should == 200
-    last_response.body.should be_empty
-    @delete_operation = true
-  else
-    post "/cimi/machines/%s/%s" % [new_machine.name, operation], builder.to_xml
-    last_response.status.should == 202
-    last_response.body.should be_empty
-  end
-end
-
-Then /^client should verify that this machine is (\w+)$/ do |status|
-  unless @delete_operation
-    @machine.state.should == status.upcase
-  end
-end

data/tests/deprecated/cimi/features/step_definitions/volumes_steps.rb

@@ -1,115 +0,0 @@
-When /^client specifies a Volume Configuration$/ do |volume_config|
-  header 'Accept', 'application/xml'
-  authorize 'mockuser', 'mockpassword'
-  get volume_config.raw[0][1]
-  last_response.status.should==200
-  @volume_config = CIMI::Model::VolumeConfiguration.from_xml(last_response.body)
-  @volume_config.class.should == CIMI::Model::VolumeConfiguration
-  @volume_config.attribute_values[:capacity].quantity.should == "2"
-  @volume_config.id.should == volume_config.raw[0][1]
-end
-
-When /^client specifies a new Volume using$/ do |volume|
-  @volume_config.should_not be_nil
-  volume_name = volume.raw[0][1]
-  volume_description = volume.raw[1][1]
-  @builder = Nokogiri::XML::Builder.new do |xml|
-    xml.Volume(:xmlns => CMWG_NAMESPACE) {
-      xml.name volume_name
-      xml.description volume_description
-      xml.volumeTemplate {
-        xml.volumeConfig( :href => @volume_config.id )
-      }
-    }
-  end
-end
-
-Then /^client should be able to create this Volume$/ do
-  authorize 'mockuser', 'mockpassword'
-  header 'Content-Type', 'application/xml'
-  post '/cimi/volumes', @builder.to_xml
-  last_response.status.should == 200
-  @@created_volume = CIMI::Model::Volume.from_xml(last_response.body)
-end
-
-When /^client GET the Volumes Collection$/ do
-  authorize 'mockuser', 'mockpassword'
-  header 'Content-Type', 'application/xml'
-  get "/cimi/volumes"
-  last_response.status.should == 200
-  @@volume_collection = CIMI::Model::VolumeCollection.from_xml(last_response.body)
-end
-
-Then /^client should get a list of volumes$/ do
-  @@volume_collection.id.end_with?("/cimi/volumes").should == true
-  @@volume_collection.attribute_values.has_key?(:volumes).should == true
-end
-
-Then /^list of volumes should contain newly created volume$/ do
-  volumes = @@volume_collection.attribute_values[:volumes].map{|v| v.href.split("/").last}
-  volumes.include?(@@created_volume.name).should == true
-end
-
-When /^client GET the newly created Volume in json format$/ do
-  authorize 'mockuser', 'mockpassword'
-  get "/cimi/volumes/#{@@created_volume.name}?format=json"
-  last_response.status.should == 200
-  @@retrieved_volume = CIMI::Model::Volume.from_json(last_response.body)
-end
-
-Then /^client should verify that this Volume was created correctly$/ do |capacity|
-  @@retrieved_volume.name.should == @@created_volume.name
-  @@retrieved_volume.id.should == @@created_volume.id
-  @@retrieved_volume.capacity[:quantity].should == capacity.raw[0][1]
-end
-
-When /^client specifies a running Machine using$/ do |machine|
-  @machine_id = machine.raw[0][1]
-  authorize 'mockuser', 'mockpassword'
-  header 'Content-Type', 'application/xml'
-  get "/cimi/machines/#{@machine_id}?format=xml"
-  last_response.status.should==200
-  @@machine = CIMI::Model::Machine.from_xml(last_response.body)
-  @@machine.name.should == @machine_id
-  @@machine.state.should == "STARTED"
-end
-
-When /^client specifies the new Volume with attachment point using$/ do |attach|
-  @builder = Nokogiri::XML::Builder.new do |xml|
-    xml.VolumeAttach {
-      xml.volume( :href => @@created_volume.id, :attachmentPoint=>attach.raw[0][1])
-    }
-  end
-end
-
-Then /^client should be able to attach the new volume to the Machine$/ do
-  authorize 'mockuser', 'mockpassword'
-  header 'Content-Type', 'application/CIMI-Machine+xml'
-  put "/cimi/machines/#{@@machine.name}/attach_volume?format=xml", @builder.to_xml
-  last_response.status.should == 200
-end
-
-When /^client should be able to detach the volume$/ do
-  authorize 'mockuser', 'mockpassword'
-  header 'Content-Type', 'application/CIMI-Machine+xml'
-  @builder = Nokogiri::XML::Builder.new do |xml|
-    xml.VolumeDetach {
-      xml.volume(:href => @@created_volume.id)
-    }
-  end
-  put "/cimi/machines/#{@@machine.name}/detach_volume", @builder.to_xml
-  last_response.status.should == 200
-end
-
-When /^client deletes the newly created Volume$/ do
-  authorize 'mockuser', 'mockpassword'
-  delete "/cimi/volumes/#{@@created_volume.name}"
-  last_response.status.should == 200
-end
-
-Then /^client should verify the volume was deleted$/ do
-  authorize 'mockuser', 'mockpassword'
-  get "/cimi/volumes/#{@@created_volume.name}"
-  last_response.status.should == 404
-end
-

data/tests/deprecated/cimi/features/support/env.rb

@@ -1,75 +0,0 @@
-require 'rubygems'
-require 'nokogiri'
-require 'rack/test'
-
-ENV['API_FRONTEND'] = 'cimi'
-
-load File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'lib', 'deltacloud_rack.rb')
-
-Deltacloud::configure do |server|
-  server.root_url '/cimi'
-  server.version '1.0.0'
-  server.klass 'CIMI::API'
-end.require_frontend!
-
-def last_xml_response
-  Nokogiri::XML(last_response.body)
-end
-
-class IndexEntrypoint < Sinatra::Base
-  get "/" do
-    redirect Deltacloud[:root_url], 301
-  end
-end
-
-=begin
-def app
-  Rack::URLMap.new(
-    "/" => IndexEntrypoint.new,
-    Deltacloud[:root_url] => CIMI::API,
-    "/stylesheets" =>  Rack::Directory.new( "public/stylesheets" ),
-    "/javascripts" =>  Rack::Directory.new( "public/javascripts" )
-  )
-end
-=end
-
-def app
-  Rack::Builder.new {
-    map '/' do
-      use Rack::Static, :urls => ["/stylesheets", "/javascripts"], :root => "public"
-      run Rack::Cascade.new([CIMI::API])
-    end
-  }
-end
-
-def new_machine
-  @@new_machine
-end
-
-def set_new_machine(machine)
-  @@new_machine = machine
-end
-
-class String
-
-  def to_class_name
-    to_collection_name
-  end
-
-  def to_entity_name
-    to_collection_name.uncapitalize
-  end
-
-  def to_collection_name
-    self.tr(' ', '').singularize
-  end
-
-  def to_collection_uri
-    self.tr(' ', '_').downcase
-  end
-
-  def to_entity_uri
-    to_collection_uri.pluralize
-  end
-
-end

data/tests/deprecated/common.rb

@@ -1,279 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.  The
-# ASF licenses this file to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance with the
-# License.  You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-# License for the specific language governing permissions and limitations
-# under the License.
-#
-ENV.delete 'API_VERBOSE'
-
-$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
-$top_srcdir = File::dirname(File::dirname(__FILE__))
-
-require 'rubygems'
-require 'yaml'
-require 'rspec/core'
-require 'rspec/matchers'
-require 'test/unit'
-require 'nokogiri'
-require 'json'
-require 'digest/sha1'
-require 'base64'
-require 'rack/test'
-
-load File.join(File.dirname(__FILE__), '..', 'lib', 'deltacloud_rack.rb')
-
-Deltacloud::configure do |server|
-  server.root_url '/api'
-  server.version '1.0.0'
-  server.klass 'Deltacloud::API'
-end.require_frontend!
-
-# Set proper environment variables for running test
-
-ENV['RACK_ENV']     = 'test'
-ENV['API_HOST']     = 'localhost'
-ENV['API_PORT']     = '4040'
-
-RSpec.configure do |conf|
-  conf.include Rack::Test::Methods
-  conf.expect_with :rspec
-end
-
-module DeltacloudTestCommon
-
-  def recording?
-    @use_recording
-  end
-
-  def record!
-    @use_recording = true
-  end
-
-
-  # Authentication helper for Basic HTTP authentication
-  # To change default user credentials stored in ENV['API_USER|PASSWORD'] you
-  # need to set opts[:credentials] = { :user => '...', :password => '...'}
-  #
-  def authenticate(opts={})
-    credentials = opts[:credentials] || { :user => ENV['API_USER'], :password => ENV['API_PASSWORD']}
-    return {
-      'HTTP_AUTHORIZATION' => "Basic " + Base64.encode64("#{credentials[:user]}:#{credentials[:password]}")
-    }
-  end
-
-  # HTTP Accept header helper.
-  # Will set appropriate value for this header.
-  # Available options for format are: :json, :html or :xml
-  # By default :xml is used
-  #
-  def accept(format=:xml)
-    case format
-      when :json then 'application/json;q=0.9'
-      when :html then 'text/html;q=0.9'
-      when :xml then 'application/xml;q=0.9'
-      else 'application/xml;q=0.9'
-    end
-  end
-
-  # This helper will execute GET operation on given URI.
-  # You can set additional parameters using params Hash, which will be passed to
-  # request.
-  # You can change format used for communication using opts[:format] = :xml | :html :json
-  # You can turn on recording (you need to configure it first in setup.rb) using
-  # opts[:record] (true/false)
-  # You can force authentication using opts[:auth] parameter or use
-  # 'get_auth_url' which will do it for you ;-)
-  #
-  def get_url(uri, params={}, opts={})
-    header 'Accept', accept(opts[:format] || :xml)
-    if DeltacloudTestCommon::recording?
-      VCR.use_cassette("get-" + Digest::SHA1.hexdigest("#{uri}-#{params}}")) do
-        get(uri, params || {}, opts[:auth] ? authenticate(opts) : {})
-      end
-    else
-      get(uri, params || {}, opts[:auth] ? authenticate(opts) : {})
-      if last_response.status.to_s =~ /5(\d{2})/
-        puts "============= [ ERROR ] ================"
-        puts last_response.body
-        puts "============= [ RESPONSE ] ================"
-        puts last_response.errors
-        puts "========================================"
-      end
-    end
-    last_response.status.should_not == 401
-  end
-
-  def get_auth_url(uri, params={}, opts={})
-    opts.merge!(:auth => true)
-    get_url(uri, params, opts)
-    if last_response.status.to_s =~ /5(\d{2})/
-      puts "============= [ ERROR ] ================"
-      puts last_response.body
-      puts "============= [ RESPONSE ] ================"
-      puts last_response.errors
-      puts "========================================"
-    end
-  end
-
-  def post_url(uri, params={}, opts={})
-    header 'Accept', accept(opts[:format] || :xml)
-    if DeltacloudTestCommon::recording?
-      if opts['vcr_cassette']
-        VCR.use_cassette(opts['vcr_cassette']) do
-          post(uri, params || {}, authenticate(opts))
-        end
-      else
-        VCR.use_cassette("post-" + Digest::SHA1.hexdigest("#{uri}-#{params}")) do
-          post(uri, params || {}, authenticate(opts))
-        end
-      end
-    else
-      post(uri, params || {}, authenticate(opts))
-      if last_response.status.to_s =~ /5(\d{2})/
-        puts "============= [ ERROR ] ================"
-        puts last_response.body
-        puts "============= [ RESPONSE ] ================"
-        puts last_response.errors
-        puts "========================================"
-      end
-    end
-  end
-
-  def delete_url(uri, params={}, opts={})
-    header 'Accept', accept(opts[:format] || :xml)
-    if DeltacloudTestCommon::recording?
-      VCR.use_cassette("delete-"+Digest::SHA1.hexdigest("#{uri}-#{params}")) do
-        delete(uri, params || {}, authenticate(opts))
-      end
-    else
-      delete(uri, params || {}, authenticate(opts))
-      if last_response.status.to_s =~ /5(\d{2})/
-        puts "============= [ ERROR ] ================"
-        puts last_response.body
-        puts "============= [ RESPONSE ] ================"
-        puts last_response.errors
-      end
-    end
-  end
-
-  def head_url(uri, params={}, opts={})
-    header 'Accept', accept(opts[:format] || :xml)
-    if DeltacloudTestCommon::recording?
-      VCR.use_cassette("head-"+Digest::SHA1.hexdigest("#{uri}-#{params}")) do
-        head(uri, params || {}, authenticate(opts))
-      end
-    else
-       head(uri, params || {}, authenticate(opts))
-      if last_response.status.to_s =~ /5(\d{2})/
-        puts "============= [ ERROR ] ================"
-        puts last_response.inspect
-        puts "========================================"
-      end
-    end
-  end
-
-  def put_url(uri, params={}, opts={})
-    header 'Accept', accept(opts[:format] || :xml)
-    if DeltacloudTestCommon::recording?
-      VCR.use_cassette("put-"+Digest::SHA1.hexdigest("#{uri}-#{params}-#{authenticate(opts)}")) do
-        put(uri, params || {}, authenticate(opts))
-      end
-    else
-       put(uri, params || {}, authenticate(opts))
-      if last_response.status.to_s =~ /5(\d{2})/
-        puts "============= [ ERROR ] ================"
-        puts last_response.body
-        puts "============= [ RESPONSE ] ================"
-        puts last_response.errors
-      end
-    end
-  end
-
-  # This helper will automatically convert output from method above to Nokogiri
-  # XML object
-  def last_xml_response
-    Nokogiri::XML(last_response.body) #if last_response.status.to_s =~ /2(\d+)/
-  end
-
-  # Check if given URI require authentication
-  def require_authentication?(uri)
-    # We need to make sure we don't have both API_USER and API_PASSWORD
-    # set in the environment; otherwise LazyAuth will use those instead
-    # of asking for credentials
-    api_user = ENV.delete("API_USER")
-    get uri, {}
-    ENV["API_USER"] = api_user
-    last_response.status == 401
-  end
-
-  def with_provider(new_provider, &block)
-    old_provider = ENV["API_PROVIDER"]
-    begin
-      ENV["API_PROVIDER"] = new_provider
-      yield
-    ensure
-      ENV["API_PROVIDER"] = old_provider
-    end
-  end
-
-  def add_created_instance(id)
-    $created_instances ||= []
-    $created_instances << id
-  end
-
- #common variables used by the bucket/blob unit tests across clouds
-  @@created_bucket_name="testbucki2rpux3wdelme"
-  @@created_blob_name="testblobk1ds91kVdelme"
-  @@created_blob_local_file="#{File.dirname(__FILE__)}/drivers/common_fixtures/deltacloud_blob_test.png"
-
-  def check_bucket_basics(bucket, cloud)
-    (bucket/'bucket/name').first.text.should == "#{@@created_bucket_name}#{cloud}"
-    (bucket/'bucket').attribute("id").text.should == "#{@@created_bucket_name}#{cloud}"
-    (bucket/'bucket').length.should > 0
-    (bucket/'bucket/name').first.text.should_not == nil
-    (bucket/'bucket').attribute("href").text.should_not == nil
-  end
-
-  def check_blob_basics(blob, cloud)
-    (blob/'blob').length.should == 1
-    (blob/'blob').attribute("id").text.should_not == nil
-    (blob/'blob').attribute("href").text.should_not==nil
-    (blob/'blob/bucket').text.should_not == nil
-    (blob/'blob/content_length').text.should_not == nil
-    (blob/'blob/content_type').text.should_not == nil
-    (blob/'blob').attribute("id").text.should == "#{@@created_blob_name}#{cloud}"
-    (blob/'blob/bucket').text.should == "#{@@created_bucket_name}#{cloud}"
-    (blob/'blob/content_length').text.to_i.should == File.size(@@created_blob_local_file)
-  end
-
-  def check_blob_metadata(blob, metadata_hash)
-    meta_from_blob = {}
-    #extract metadata from nokogiri blob xml
-    (0.. (((blob/'blob/user_metadata').first).elements.size - 1) ).each do |i|
-      meta_from_blob[(((blob/'blob/user_metadata').first).elements[i].attribute("key").value)] =
-                                  (((blob/'blob/user_metadata').first).elements[i].children[1].text)
-    end
-    #remove any 'x-goog-meta-' prefixes (problem for google blobs and vcr...)
-    meta_from_blob.gsub_keys(/x-.*-meta-/i, "")
-    meta_from_blob.eql?(metadata_hash).should == true
-  end
-
-  #hash ordering is unpredictable - sort the params hash
-  #so we get same vcr cassette name each time
-  def stable_vcr_cassette_name(method, uri, params)
-    digest = Digest::SHA1.hexdigest("#{uri}-#{params.sort_by {|k,v| k.to_s}}")
-    return "#{method}-#{digest}"
-  end
-
-end
-
-include DeltacloudTestCommon