fog 1.37.0 → 1.38.0

data/tests/rackspace/helper.rb

@@ -1,106 +0,0 @@
-LINKS_FORMAT = [{
-  'href' => String,
-  'rel' => String
-}]
-
-module Shindo
-  class Tests
-    def given_a_load_balancer_service(&block)
-      @service = Fog::Rackspace::LoadBalancers.new
-      instance_eval(&block)
-    end
-
-    def given_a_load_balancer(&block)
-        @lb = @service.load_balancers.create({
-            :name => ('fog' + Time.now.to_i.to_s),
-            :protocol => 'HTTP',
-            :port => 80,
-            :virtual_ips => [{ :type => 'PUBLIC'}],
-            :nodes => [{ :address => '1.1.1.1', :port => 80, :condition => 'ENABLED'}]
-          })
-        @lb.wait_for { ready? }
-      begin
-        instance_eval(&block)
-      ensure
-        @lb.wait_for { ready? }
-        @lb.destroy
-      end
-    end
-
-   def wait_for_request(description = "waiting", &block)
-     return if Fog.mocking?
-     tests(description) do
-       Fog.wait_for &block
-     end
-   end
-
-   def wait_for_server_deletion(server)
-     return if Fog.mocking?
-     begin
-       @instance.wait_for { state = 'DELETED' }
-     rescue Fog::Compute::RackspaceV2::NotFound => e
-       # do nothing
-     end
-   end
-
-    def wait_for_server_state(service, server_id, state, error_states=nil)
-      current_state = nil
-      until current_state == state
-        current_state = service.get_server(server_id).body['server']['status']
-        if error_states
-          error_states = Array(error_states)
-          if error_states.include?(current_state)
-            Fog::Logger.warning caller
-            Fog::Logger.warning "ERROR! Server should have transitioned to '#{state}' not '#{current_state}'"
-            return
-          end
-        end
-        sleep 10 unless Fog.mocking?
-      end
-      sleep 30 unless Fog.mocking?
-    end
-
-    def wait_for_volume_state(service, volume_id, state)
-      current_state = nil
-      until current_state == state
-        current_state = service.get_volume(volume_id).body['volume']['status']
-        if current_state == 'error'
-          Fog::Logger.warning caller
-          Fog::Logger.warning "Volume is in an error state!"
-          return
-        end
-        sleep 10 unless Fog.mocking?
-      end
-    end
-
-    def rackspace_test_image_id(service)
-      image_id  = Fog.credentials[:rackspace_image_id]
-      # I chose to use the first Ubuntu because it will work with the smallest flavor and it doesn't require a license
-      image_id ||= Fog.mocking? ? service.images.first.id : service.images.find {|image| image.name =~ /Ubuntu/}.id # use the first Ubuntu image
-    end
-
-    def rackspace_test_flavor_id(service)
-      @flavor_id ||= Fog.credentials[:rackspace_flavor_id] || service.flavors.first.id
-    end
-
-    # After a server has been successfully deleted they are still being reported as attached to a cloud network
-    # causing delete calls to fail. This method attempts to address that.
-    def delete_test_network(network)
-      return false if Fog.mocking? || network.nil?
-      attempt = 0
-      begin
-        network.destroy
-      rescue Fog::Compute::RackspaceV2::ServiceError => e
-        if attempt == 3
-           Fog::Logger.warning "Unable to delete #{network.label}"
-          return false
-        end
-         Fog::Logger.warning "Network #{network.label} Delete Fail Attempt #{attempt}- #{e.inspect}"
-        attempt += 1
-        sleep 60
-        retry
-      end
-      return true
-    end
-  end
-end

data/tests/rackspace/identity_tests.rb

@@ -1,26 +0,0 @@
-Shindo.tests('Fog::Rackspace::Identity', ['rackspace']) do
-
-  tests('current authentication') do
-    tests('variables populated').returns(200)  do
-      @service = Fog::Rackspace::Identity.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :connection_options => {:ssl_verify_peer => true}
-      returns(true, "auth token populated") { !@service.auth_token.nil? }
-      returns(false, "path populated") { @service.instance_variable_get("@uri").host.nil? }
-      returns(false, "service catalog populated") { @service.service_catalog.nil? }
-
-      @service.list_tenants.status
-    end
-  end
-
-  tests('reauthentication') do
-    tests('should reauth with valid credentials') do
-      @service = Fog::Rackspace::Identity.new  :rackspace_region => :ord
-      returns(true, "auth token populated") { !@service.auth_token.nil? }
-      @service.instance_variable_set("@auth_token", "bad-token")
-      returns(true) { [200, 203].include? @service.list_tenants.status }
-    end
-    tests('should terminate with incorrect credentials') do
-      raises(Excon::Errors::Unauthorized) { Fog::Rackspace::Identity.new :rackspace_api_key => 'bad_key' }
-    end
-  end
-
-end

data/tests/rackspace/load_balancer_tests.rb

@@ -1,135 +0,0 @@
-Shindo.tests('Fog::Rackspace::LoadBalancers', ['rackspace']) do
-
-  def assert_method(url, method)
-    @service.instance_variable_set "@rackspace_auth_url", url
-    returns(method) { @service.send :authentication_method }
-  end
-
-  tests('#authentication_method') do
-    @service = Fog::Rackspace::LoadBalancers.new
-
-    assert_method nil, :authenticate_v2
-
-    assert_method 'auth.api.rackspacecloud.com', :authenticate_v1 # chef's default auth endpoint
-
-    assert_method 'https://identity.api.rackspacecloud.com', :authenticate_v1
-    assert_method 'https://identity.api.rackspacecloud.com/v1', :authenticate_v1
-    assert_method 'https://identity.api.rackspacecloud.com/v1.1', :authenticate_v1
-    assert_method 'https://identity.api.rackspacecloud.com/v2.0', :authenticate_v2
-
-    assert_method 'https://lon.identity.api.rackspacecloud.com', :authenticate_v1
-    assert_method 'https://lon.identity.api.rackspacecloud.com/v1', :authenticate_v1
-    assert_method 'https://lon.identity.api.rackspacecloud.com/v1.1', :authenticate_v1
-    assert_method 'https://lon.identity.api.rackspacecloud.com/v2.0', :authenticate_v2
-  end
-
-  tests('legacy authentication') do
-    pending if Fog.mocking?
-
-    tests('variables populated').succeeds do
-      @service = Fog::Rackspace::LoadBalancers.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v1.0'
-      returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
-      returns(false, "path populated") { @service.instance_variable_get("@uri").path.nil? }
-      returns(true, "identity_service was not used") { @service.instance_variable_get("@identity_service").nil? }
-      @service.list_load_balancers
-    end
-
-    tests('custom endpoint') do
-      @service = Fog::Rackspace::LoadBalancers.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v1.0',
-        :rackspace_load_balancers_url => 'https://my-custom-endpoint.com'
-        returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
-        returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil }
-    end
-  end
-
-  tests('current authentation') do
-    pending if Fog.mocking?
-
-    tests('variables populated').succeeds do
-      @service = Fog::Rackspace::LoadBalancers.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :connection_options => { :ssl_verify_peer => true }
-      returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
-      returns(false, "path populated") { @service.instance_variable_get("@uri").host.nil? }
-      identity_service = @service.instance_variable_get("@identity_service")
-      returns(false, "identity service was used") { identity_service.nil? }
-      returns(true, "connection_options are passed") { identity_service.instance_variable_get("@connection_options").key?(:ssl_verify_peer) }
-      @service.list_load_balancers
-    end
-    tests('dfw region').succeeds do
-      @service = Fog::Rackspace::LoadBalancers.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_region => :dfw
-      returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
-      returns(true) { (@service.instance_variable_get("@uri").host =~ /dfw/) != nil }
-      @service.list_load_balancers
-    end
-    tests('ord region').succeeds do
-      @service = Fog::Rackspace::LoadBalancers.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0', :rackspace_region => :ord
-      returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
-      returns(true) { (@service.instance_variable_get("@uri").host =~ /ord/) != nil }
-      @service.list_load_balancers
-    end
-    tests('custom endpoint') do
-      @service = Fog::Rackspace::LoadBalancers.new :rackspace_auth_url => 'https://identity.api.rackspacecloud.com/v2.0',
-        :rackspace_load_balancers_url => 'https://my-custom-endpoint.com'
-      returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
-      returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil }
-    end
-  end
-
-  tests('default auth') do
-    pending if Fog.mocking?
-
-    tests('no params').succeeds do
-      @service = Fog::Rackspace::LoadBalancers.new :rackspace_region => nil
-      returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
-      returns(true) { (@service.instance_variable_get("@uri").host =~ /dfw/) != nil }
-      @service.list_load_balancers
-    end
-    tests('specify old contstant style service endoint').succeeds do
-      @service = Fog::Rackspace::LoadBalancers.new :rackspace_lb_endpoint => Fog::Rackspace::LoadBalancers::ORD_ENDPOINT
-      returns(true) { (@service.instance_variable_get("@uri").to_s =~ /#{Fog::Rackspace::LoadBalancers::ORD_ENDPOINT}/ ) != nil }
-      @service.list_load_balancers
-    end
-    tests('specify region').succeeds do
-      @service = Fog::Rackspace::LoadBalancers.new :rackspace_region => :ord
-      returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
-      returns(true) { (@service.instance_variable_get("@uri").host =~ /ord/ ) != nil }
-      @service.list_load_balancers
-    end
-    tests('custom endpoint') do
-      @service = Fog::Rackspace::LoadBalancers.new :rackspace_load_balancers_url => 'https://my-custom-endpoint.com'
-      returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
-      returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil }
-    end
-  end
-
-  tests('reauthentication') do
-    pending if Fog.mocking?
-
-    tests('should reauth with valid credentials') do
-      @service = Fog::Rackspace::LoadBalancers.new
-      returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
-      @service.instance_variable_set("@auth_token", "bad-token")
-      returns(200) { @service.list_load_balancers.status }    end
-    tests('should terminate with incorrect credentials') do
-      raises(Excon::Errors::Unauthorized) { Fog::Rackspace::LoadBalancers.new:rackspace_api_key => 'bad_key' }
-    end
-  end
-
-  pending if Fog.mocking?
-
-  @service = Fog::Rackspace::LoadBalancers.new
-
-  tests('#algorithms').succeeds do
-    data = @service.algorithms
-    returns(true) { data.is_a? Array }
-    returns(true) { data.first.is_a? String }
-  end
-
-  tests('#protocols').succeeds do
-    data = @service.protocols
-    returns(true) { data.is_a? Array }
-  end
-
-  tests('#usage').succeeds do
-    @service.usage
-  end
-end

data/tests/rackspace/models/auto_scale/group_builder_tests.rb

@@ -1,145 +0,0 @@
-require 'fog/rackspace/models/auto_scale/group_builder'
-require 'fog/rackspace/models/auto_scale/group'
-require 'fog/rackspace/models/compute_v2/flavor'
-require 'fog/rackspace/models/load_balancers/load_balancer'
-
-Shindo.tests('Fog::Rackspace::AutoScale | group builder', ['rackspace', 'rackspace_autoscale']) do
-  builder = Fog::Rackspace::AutoScale::GroupBuilder
-
-  tests('#get_id') do
-    tests('widget_id').returns(5) do
-      builder.send(:get_id, 'widget', {:widget_id => 5, :noise => 3})
-    end
-    tests('widget').returns(5) do
-      Fog::Rackspace::AutoScale::GroupBuilder.send(:get_id, 'widget', {:widget => 5, :noise => 3})
-    end
-    tests('Flavor object').returns(2) do
-      flavor = Fog::Compute::RackspaceV2::Flavor.new(:id => 2)
-      builder.send(:get_id, 'flavor', {:flavor => flavor, :noise => 3})
-    end
-  end
-
-  tests('networks_to_hash').returns([{"uuid" => '00000000-0000-0000-0000-000000000000'}]) do
-    builder.send(:networks_to_hash, ['00000000-0000-0000-0000-000000000000'])
-  end
-
-  tests('#build_server_template').returns(LAUNCH_CONFIG_OPTIONS["args"]["server"]) do
-    attributes = {
-      :server_name => "autoscale_server",
-      :image => "0d589460-f177-4b0f-81c1-8ab8903ac7d8",
-      :flavor => "2",
-      :disk_config => "AUTO",
-      :server_metadata => {
-        "build_config" => "core",
-        "meta_key_1" => "meta_value_1",
-        "meta_key_2" => "meta_value_2"
-      },
-      :networks => ["11111111-1111-1111-1111-111111111111", "00000000-0000-0000-0000-000000000000"],
-      :personality => [
-        {
-          "path" => "/root/.csivh",
-          "contents" => "VGhpcyBpcyBhIHRlc3QgZmlsZS4="
-        }
-      ]
-    }
-    builder.send(:build_server_template, attributes)
-  end
-
-  tests('#load_balancer_to_hash') do
-    lb_test_hash = {
-      "port" =>  80,
-      "loadBalancerId" => 1234
-    }
-    tests('hash').raises(ArgumentError, "Expected LoadBalancer") do
-      builder.send(:load_balancer_to_hash, lb_test_hash)
-    end
-    tests('LoadBalancer').returns(lb_test_hash) do
-      lb = Fog::Rackspace::LoadBalancers::LoadBalancer.new :port => 80, :id => 1234
-      builder.send(:load_balancer_to_hash, lb)
-    end
-  end
-
-  tests('build_load_balancers') do
-    lb_test_hash = {
-      "port" =>  80,
-      "loadBalancerId" => 1234
-    }
-    tests('nil').returns(nil) do
-      builder.send(:build_load_balancers, {})
-    end
-    tests('hash').returns([lb_test_hash]) do
-      builder.send(:build_load_balancers, :load_balancers => [lb_test_hash])
-    end
-    tests('LoadBalancer').returns([lb_test_hash]) do
-      lb = Fog::Rackspace::LoadBalancers::LoadBalancer.new :port => 80, :id => 1234
-      builder.send(:build_load_balancers, :load_balancers => [lb])
-    end
-    tests('multiple lbs').returns([lb_test_hash, lb_test_hash]) do
-      lb = Fog::Rackspace::LoadBalancers::LoadBalancer.new :port => 80, :id => 1234
-      builder.send(:build_load_balancers, :load_balancers => [lb, lb])
-    end
-  end
-
-  tests('build_server_launch_config') do
-    tests('no launch_config_type').returns(nil) do
-      builder.build_server_launch_config({:pancakes => true})
-    end
-    tests('wrong launch_config_type').returns(nil) do
-      builder.build_server_launch_config({:launch_config_type => :something_else})
-    end
-    tests('valid launch config').returns(LAUNCH_CONFIG_OPTIONS["args"]) do
-      attributes = {
-        :server_name => "autoscale_server",
-        :image => "0d589460-f177-4b0f-81c1-8ab8903ac7d8",
-        :flavor => "2",
-        :disk_config => "AUTO",
-        :server_metadata => {
-          "build_config" => "core",
-          "meta_key_1" => "meta_value_1",
-          "meta_key_2" => "meta_value_2"
-        },
-        :networks => ["11111111-1111-1111-1111-111111111111", "00000000-0000-0000-0000-000000000000"],
-        :personality => [
-          {
-            "path" => "/root/.csivh",
-            "contents" => "VGhpcyBpcyBhIHRlc3QgZmlsZS4="
-          }
-        ],
-        :launch_config_type => :launch_server,
-        :load_balancers => { "port" => 8080, "loadBalancerId" => 9099}
-      }
-
-      builder.build_server_launch_config(attributes).args
-    end
-  end
-
-  tests('#build_group_config') do
-    attributes = {
-      :max_entities => 3,
-      :min_entities => 0,
-      :cooldown => 360,
-      :name => "testscalinggroup198547",
-      :metadata => {
-        "gc_meta_key_2" => "gc_meta_value_2",
-        "gc_meta_key_1" => "gc_meta_value_1"
-      }
-    }
-
-    config = builder.build_group_config(attributes)
-    returns(3) { config.max_entities }
-    returns(0) { config.min_entities }
-    returns(360) { config.cooldown }
-    returns("testscalinggroup198547") { config.name }
-    returns(attributes[:metadata]) { config.metadata }
-  end
-
-  tests('build') do
-    pending if Fog.mocking?
-    service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord
-
-    group = builder.build(service, :launch_config_type => :launch_server, :server_name => 'test', :cooldown => 500)
-    returns(500) { group.group_config.cooldown }
-    returns('test') { group.launch_config.args["server"]["name"]}
-  end
-
-end

data/tests/rackspace/models/auto_scale/group_tests.rb

@@ -1,35 +0,0 @@
-Shindo.tests('Fog::Rackspace::AutoScale | group', ['rackspace', 'rackspace_autoscale']) do
-
-	service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord
-
-	options = {
-		:name => "fog_#{Time.now.to_i.to_s}",
-		:policies => POLICIES_OPTIONS,
-		:launch_config => LAUNCH_CONFIG_OPTIONS,
-		:group_config => GROUP_CONFIG_OPTIONS
-	}
-
-	model_tests(service.groups, options, false) do
-    pending if Fog.mocking?
-		tests('#policies').succeeds do
-			@instance.policies
-		end
-
-		tests('#launch_config').succeeds do
-      @instance.launch_config
-	  end
-
-	  tests('#group_config').succeeds do
-      @instance.group_config
-    end
-
-    tests('#state').succeeds do
-      @instance.state
-    end
-
-    tests('deactive scaling group').succeeds do
-      deactive_auto_scale_group(@instance)
-    end
-	end
-
-end