fog 1.4.0 → 1.5.0

data/tests/aws/requests/compute/address_tests.rb

@@ -17,6 +17,8 @@ Shindo.tests('Fog::Compute[:aws] | address requests', ['aws']) do
   tests('success') do
 
     @public_ip = nil
+    @vpc_public_ip = nil
+    @vpc_allocation_id = nil
 
     tests('#allocate_address').formats({'domain' => String, 'publicIp' => String, 'requestId' => String}) do
       data = Fog::Compute[:aws].allocate_address.body
@@ -24,6 +26,13 @@ Shindo.tests('Fog::Compute[:aws] | address requests', ['aws']) do
       data
     end
 
+    tests("#allocate_address('vpc')").formats({'domain' => String, 'publicIp' => String, 'allocationId' => String, 'requestId' => String}) do
+      data = Fog::Compute[:aws].allocate_address('vpc').body
+      @vpc_public_ip = data['publicIp']
+      @vpc_allocation_id = data['allocationId']
+      data
+    end
+
     tests('#describe_addresses').formats(@addresses_format) do
       Fog::Compute[:aws].describe_addresses.body
     end
@@ -35,7 +44,7 @@ Shindo.tests('Fog::Compute[:aws] | address requests', ['aws']) do
     tests("#associate_addresses('#{@server.identity}', '#{@public_ip}')").formats(AWS::Compute::Formats::BASIC) do
       Fog::Compute[:aws].associate_address(@server.identity, @public_ip).body
     end
-    
+
     tests("#dissassociate_address('#{@public_ip}')").formats(AWS::Compute::Formats::BASIC) do
       Fog::Compute[:aws].disassociate_address(@public_ip).body
     end
@@ -44,10 +53,14 @@ Shindo.tests('Fog::Compute[:aws] | address requests', ['aws']) do
       Fog::Compute[:aws].release_address(@public_ip).body
     end
 
+    tests("#release_address('#{@vpc_allocation_id}')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].release_address(@vpc_allocation_id).body
+    end
   end
   tests('failure') do
 
     @address = Fog::Compute[:aws].addresses.create
+    @vpc_address = Fog::Compute[:aws].addresses.create(:domain => 'vpc')
 
     tests("#associate_addresses('i-00000000', '#{@address.identity}')").raises(Fog::Compute::AWS::NotFound) do
       Fog::Compute[:aws].associate_address('i-00000000', @address.identity)
@@ -69,7 +82,12 @@ Shindo.tests('Fog::Compute[:aws] | address requests', ['aws']) do
       Fog::Compute[:aws].release_address('127.0.0.1')
     end
 
+    tests("#release_address('#{@vpc_address.identity}')").raises(Fog::Compute::AWS::Error) do
+      Fog::Compute[:aws].release_address(@vpc_address.identity)
+    end
+
     @address.destroy
+    @vpc_address.destroy
 
   end
 

data/tests/aws/requests/elasticache/cache_cluster_tests.rb

@@ -1,7 +1,6 @@
 Shindo.tests('AWS::Elasticache | cache cluster requests', ['aws', 'elasticache']) do
 
   tests('success') do
-    pending if Fog.mocking?
 
     # Randomize the cluster ID so tests can be fequently re-run
     CLUSTER_ID = "fog-test-cluster-#{rand(999).to_s}" # 20 chars max!
@@ -98,11 +97,12 @@ Shindo.tests('AWS::Elasticache | cache cluster requests', ['aws', 'elasticache']
       body = AWS[:elasticache].modify_cache_cluster(c.id,
       {
         :num_nodes          => NUM_NODES - 1,
-        :nodes_to_remove    => node_id,
+        :nodes_to_remove    => [node_id],
         :apply_immediately  => true,
       }).body
-      c.reload
-      returns(NUM_NODES - 1) { c.pending_values['NumCacheNodes'] }
+      returns(node_id) {
+        body['CacheCluster']['PendingModifiedValues']['CacheNodeId']
+      }
       body['CacheCluster']
     end
 

data/tests/aws/requests/elb/helper.rb

@@ -14,11 +14,22 @@ class AWS
         "DNSName" => String,
         "HealthCheck" => {"HealthyThreshold" => Integer, "Timeout" => Integer, "UnhealthyThreshold" => Integer, "Interval" => Integer, "Target" => String},
         "Instances" => Array,
-        "ListenerDescriptions" => Array,
+        "ListenerDescriptions" => [{
+          'PolicyNames' => Array,
+          'Listener' => {
+            'InstancePort' => Integer,
+            'InstanceProtocol' => String,
+            'LoadBalancerPort' => Integer,
+            'Protocol' => String,
+            'SSLCertificateId' => Fog::Nullable::String
+          }
+        }],
         "LoadBalancerName" => String,
         "Policies" => {"LBCookieStickinessPolicies" => Array, "AppCookieStickinessPolicies" => Array},
+        "Scheme" => String,
+        "SecurityGroups" => [Fog::Nullable::String],
         "SourceSecurityGroup" => {"GroupName" => String, "OwnerAlias" => String},
-        "Scheme" => String
+        "Subnets" => [Fog::Nullable::String]
       }
 
       CREATE_LOAD_BALANCER = BASIC.merge({

data/tests/aws/requests/iam/access_key_tests.rb

@@ -48,8 +48,6 @@ Shindo.tests('AWS::IAM | access key requests', ['aws']) do
     test('failing conditions')
   end
 
-  unless Fog.mocking?
-    Fog::AWS[:iam].delete_user('fog_access_key_tests')
-  end
+  Fog::AWS[:iam].delete_user('fog_access_key_tests')
 
 end

data/tests/cloudstack/compute/models/security_group_rule_tests.rb

@@ -0,0 +1,29 @@
+def security_group_rule_tests(connection, params, direction, mocks_implemented = true)
+  @security_group = connection.security_groups.create(params[:security_group_attributes])
+
+  rule_params = params[:security_group_rule_attributes].merge(:security_group_id => @security_group.id, :direction => direction)
+
+  model_tests(connection.security_group_rules, rule_params, mocks_implemented) do
+
+    if Fog.mocking? && !mocks_implemented
+      pending
+    end
+
+  end
+  @security_group.destroy
+end
+
+provider, config = :cloudstack, compute_providers[:cloudstack]
+
+Shindo.tests("Fog::Compute[:#{provider}] | security_group_rules | ingress", [provider.to_s]) do
+
+  security_group_rule_tests(Fog::Compute[:cloudstack], config, "ingress", config[:mocked])
+
+end
+
+
+Shindo.tests("Fog::Compute[:#{provider}] | security_group_rules | egress", [provider.to_s]) do
+
+  security_group_rule_tests(Fog::Compute[:cloudstack], config, "egress", config[:mocked])
+
+end

data/tests/cloudstack/compute/models/security_group_tests.rb

@@ -0,0 +1,16 @@
+def security_group_tests(connection, params, mocks_implemented = true)
+  model_tests(connection.security_groups, params[:security_group_attributes], mocks_implemented) do
+    if Fog.mocking? && !mocks_implemented
+      pending
+    else
+      responds_to(:rules)
+    end
+  end
+end
+
+provider, config = :cloudstack, compute_providers[:cloudstack]
+Shindo.tests("Fog::Compute[:#{provider}] | security_groups", [provider.to_s]) do
+
+  security_group_tests(Fog::Compute[:cloudstack], config, config[:mocked])
+
+end

data/tests/cloudstack/compute/models/security_groups_tests.rb

@@ -0,0 +1,19 @@
+def security_group_tests(provider, params, mocks_implemented = true)
+	collection_tests(provider.security_groups, params, mocks_implemented) do
+
+		if Fog.mocking? && !mocks_implemented
+			pending
+		else
+			responds_to(:rules)
+		end
+
+	end
+end
+
+
+provider, config = :cloudstack, compute_providers[:cloudstack]
+Shindo.tests("Fog::Compute[:#{provider}] | security_group", [provider.to_s]) do
+
+	security_group_tests(Fog::Compute[provider], (config[:security_group_attributes] || {}), config[:mocked])
+
+end

data/tests/cloudstack/compute/models/server_tests.rb

@@ -0,0 +1,18 @@
+provider, config = :cloudstack, compute_providers[:cloudstack]
+
+Shindo.tests("Fog::Compute[:#{provider}] | servers + security_groups", [provider.to_s]) do
+  connection = Fog::Compute[provider]
+  @security_group = connection.security_groups.create(config[:security_group_attributes])
+  @server = connection.servers.create(config[:server_attributes].merge(:security_groups => [@security_group]))
+
+  tests('#security_group').succeeds do
+    @server.wait_for { ready? }
+    @server.security_groups.map(&:id) == [@security_group.id]
+  end
+
+  tests('#destroy').succeeds do
+    @server.destroy.wait_for { ready? }
+    @security_group.destroy
+  end
+
+end

data/tests/cloudstack/compute/models/volume_tests.rb

@@ -0,0 +1,34 @@
+def volume_tests(connection, params, mocks_implemented = true)
+  model_tests(connection.volumes, params[:volume_attributes], mocks_implemented) do
+    if !Fog.mocking? || mocks_implemented
+      @instance.wait_for { ready? }
+    end
+
+    @server = @instance.connection.servers.create(params[:server_attributes])
+    @server.wait_for { ready? }
+
+    tests('attach').succeeds do
+      @instance.attach(@server)
+    end
+
+    tests('detach').succeeds do
+      @instance.detach
+    end
+
+    @server.destroy
+  end
+end
+
+Shindo.tests("Fog::Compute[:cloudstack] | volume", :cloudstack) do
+
+  config = compute_providers[:cloudstack]
+
+  volume_tests(Fog::Compute[:cloudstack], config, config[:mocked]) do
+    if Fog.mocking? && !mocks_implemented
+      pending
+    else
+      responds_to(:ready?)
+      responds_to(:flavor)
+    end
+  end
+end

data/tests/cloudstack/compute/models/volumes_tests.rb

@@ -0,0 +1,17 @@
+def volumes_tests(connection, params = {}, mocks_implemented = true)
+
+  collection_tests(connection.volumes, params, mocks_implemented) do
+
+    if !Fog.mocking? || mocks_implemented
+      @instance.wait_for { ready? }
+    end
+
+  end
+
+end
+
+config = compute_providers[:cloudstack]
+
+Shindo.tests("Fog::Compute[:cloudstack] | volumes", ["cloudstack"]) do
+  volumes_tests(Fog::Compute[:cloudstack], config[:volume_attributes], config[:mocked])
+end

data/tests/compute/helper.rb

@@ -32,15 +32,22 @@ def compute_providers
         :cloudstack_host => 'http://host.foo'
       },
       :server_attributes => {}.tap do |hash|
-        [:zone_id, :network_ids, :image_id, :flavor_id].each do |k|
-          hash[k]= Fog.credentials[:cloudstack] && Fog.credentials[:cloudstack][k]
+        [:zone_id, :network_ids, :template_id, :service_offering_id].each do |k|
+          hash[k]= Fog.credentials["cloudstack_#{k}".to_sym]
         end
       end,
       :volume_attributes => {:name => "somevolume"}.tap do |hash|
         [:zone_id, :disk_offering_id].each do |k|
-          hash[k]= Fog.credentials[:cloudstack] && Fog.credentials[:cloudstack][k]
+          hash[k]= Fog.credentials["cloudstack_#{k}".to_sym]
         end
       end,
+      :security_group_attributes => {:name => "cloudstack.sg.#{Time.now.to_i}"},
+      :security_group_rule_attributes => {
+        :cidr => '0.0.0.0/0',
+        :start_port => 123,
+        :end_port => 456,
+        :protocol => 'tcp'
+      },
       :mocked => true
     },
     :glesys   => {

data/tests/core/current_machine_tests.rb

@@ -0,0 +1,32 @@
+Shindo.tests('Fog CurrentMachine', 'core') do
+
+  pending unless Fog.mock?
+
+  old_excon_defaults_mock = Excon.defaults[:mock]
+  Excon.defaults[:mock] = true
+
+  tests('ip_address') do
+
+    tests('should be thread safe') do
+      Excon.stub({:method => :get, :path => '/'}, {:body => ''})
+
+      (1..10).map {
+        Thread.new { Fog::CurrentMachine.ip_address }
+      }.each{ |t| t.join }
+    end
+
+    Fog::CurrentMachine.ip_address = nil
+    Excon.stubs.clear
+
+    tests('should remove trailing endline characters') do
+      Excon.stub({:method => :get,  :path => '/'}, {:body => "192.168.0.1\n"})
+      Fog::CurrentMachine.ip_address == '192.168.0.1'
+    end
+
+  end
+
+  Fog::CurrentMachine.ip_address = nil
+  Excon.stubs.clear
+  Excon.defaults[:mock] = old_excon_defaults_mock
+
+end

data/tests/helper.rb

@@ -12,7 +12,7 @@ def array_differences(array_a, array_b)
 end
 
 # check to see which credentials are available and add others to the skipped tags list
-all_providers = ['aws', 'bluebox', 'brightbox', 'cloudstack', 'dnsimple', 'dnsmadeeasy', 'dynect', 'ecloud', 'glesys', 'gogrid', 'google', 'hp', 'linode', 'local', 'ninefold', 'newservers', 'openstack', 'rackspace', 'stormondemand', 'voxel', 'xenserver', 'zerigo']
+all_providers = ['aws', 'bare_metal_cloud', 'bluebox', 'brightbox', 'cloudstack', 'dnsimple', 'dnsmadeeasy', 'dynect', 'ecloud', 'glesys', 'gogrid', 'google', 'hp', 'linode', 'local', 'ninefold', 'openstack', 'rackspace', 'stormondemand', 'voxel', 'xenserver', 'zerigo']
 available_providers = Fog.available_providers.map {|provider| provider.downcase}
 for provider in (all_providers - available_providers)
   Formatador.display_line("[yellow]Skipping tests for [bold]#{provider}[/] [yellow]due to lacking credentials (add some to '~/.fog' to run them)[/]")

data/tests/helpers/mock_helper.rb

@@ -16,6 +16,9 @@ if Fog.mock?
     :brightbox_client_id              => 'brightbox_client_id',
     :brightbox_secret                 => 'brightbox_secret',
     :cloudstack_host                  => 'http://cloudstack.example.org',
+    :cloudstack_service_offering_id     => '4437ac6c-9fe3-477a-57ec-60a5a45896a4',
+    :cloudstack_template_id           => '8a31cf9c-f248-0588-256e-9dbf58785216',
+    :cloudstack_zone_id               => 'c554c592-e09c-9df5-7688-4a32754a4305',
     :clodo_api_key                    => 'clodo_api_key',
     :clodo_username                   => 'clodo_username',
     :dnsimple_email                   => 'dnsimple_email',

data/tests/hp/requests/compute/address_tests.rb

@@ -30,11 +30,12 @@ Shindo.tests('Fog::Compute[:hp] | address requests', [:hp]) do
     @server.wait_for { ready? }
 
     tests("#associate_address('#{@server.id}', '#{@ip_address}')").succeeds do
-      Fog::Compute[:hp].associate_address(@server.id, @ip_address)
+      result = Fog::Compute[:hp].associate_address(@server.id, @ip_address)
       tests("#get_address").returns(@server.id, "associated to valid instance id") do
         pending if Fog.mocking?
         Fog::Compute[:hp].get_address(@address_id).body['floating_ip']['instance_id']
       end
+      result
     end
 
     tests("#disassociate_address('#{@server.id}', '#{@ip_address}')").succeeds do

data/tests/joyent/requests/compute/datasets_tests.rb

@@ -1,7 +1,10 @@
 Shindo.tests("Fog::Compute[:joyent] | dataset requests", ["joyent"]) do
   @dataset_format = {
     "description" => String,
-    "requirements" => {},
+    "requirements" => {
+      "max_memory" => Integer,
+      "min_memory" => Integer
+    },
     "name" => String,
     "version" => String,
     "os" => String,
@@ -22,7 +25,10 @@ Shindo.tests("Fog::Compute[:joyent] | dataset requests", ["joyent"]) do
         "type" => "smartmachine",
         "description" => "Zeus Simple Load Balancer 200 Mbps SmartMachine",
         "default" => false,
-        "requirements" => {},
+        "requirements" => {
+          "max_memory" => 32768,
+          "min_memory" => 4096
+        },
         "version" => "1.1.1",
         "created" => Time.parse("2011-09-15T07:39:13+00:00")
       },
@@ -34,7 +40,10 @@ Shindo.tests("Fog::Compute[:joyent] | dataset requests", ["joyent"]) do
         "type" => "smartmachine",
         "description" => "MySQL SmartMachine",
         "default" => false,
-        "requirements" => {},
+        "requirements" => {
+          "max_memory" => 32768,
+          "min_memory" => 4096
+        },
         "version" => "1.4.1",
         "created" => Time.parse("2011-09-15T05:01:34+00:00")
       }

data/tests/local/models/file_tests.rb

@@ -0,0 +1,43 @@
+Shindo.tests('Storage[:local] | file', [:local]) do
+
+  pending if Fog.mocking?
+
+  before do
+    @options = { :local_root => '~/.fog' }
+  end
+
+  tests('#public_url') do
+    tests('when connection has an endpoint').
+      returns('http://example.com/files/directory/file.txt') do
+        @options[:endpoint] = 'http://example.com/files'
+
+        connection = Fog::Storage::Local.new(@options)
+        directory = connection.directories.new(:key => 'directory')
+        file = directory.files.new(:key => 'file.txt')
+
+        file.public_url
+      end
+
+    tests('when connection has no endpoint').
+      returns(nil) do
+        @options[:endpoint] = nil
+
+        connection = Fog::Storage::Local.new(@options)
+        directory = connection.directories.new(:key => 'directory')
+        file = directory.files.new(:key => 'file.txt')
+
+        file.public_url
+      end
+
+    tests('when file path has escapable characters').
+      returns('http://example.com/files/my%20directory/my%20file.txt') do
+        @options[:endpoint] = 'http://example.com/files'
+
+        connection = Fog::Storage::Local.new(@options)
+        directory = connection.directories.new(:key => 'my directory')
+        file = directory.files.new(:key => 'my file.txt')
+
+        file.public_url
+      end
+  end
+end

data/tests/local/storage_tests.rb

@@ -0,0 +1,40 @@
+Shindo.tests('Local | storage') do
+
+  pending if Fog.mocking?
+
+  before do
+    @options = { :local_root => "~/.fog" }
+  end
+
+  tests('#endpoint') do
+    tests('when no endpoint is provided').
+      returns(nil) do
+        Fog::Storage::Local.new(@options).endpoint
+      end
+
+    tests('when no host is provided').
+      returns(nil) do
+        @options[:scheme] = 'http'
+        @options[:path] = '/files'
+        @options[:port] = 80
+
+        Fog::Storage::Local.new(@options).endpoint
+      end
+
+    tests('when endpoint is provided').
+      returns('http://example.com/files') do
+        @options[:endpoint] = 'http://example.com/files'
+
+        Fog::Storage::Local.new(@options).endpoint
+      end
+
+    tests('when at least host option is provided').
+      returns('http://example.com/files') do
+        @options[:scheme] = 'http'
+        @options[:host] = 'example.com'
+        @options[:path] = '/files'
+
+        Fog::Storage::Local.new(@options).endpoint
+      end
+  end
+end