fog 1.3.1 → 1.4.0

data/spec/spec_helper.rb

@@ -1,4 +1,4 @@
-require 'spec'
+require 'rspec'
 require 'open-uri'
 require 'fog'
 require 'fog/bin'

data/tests/aws/credentials_tests.rb

@@ -0,0 +1,57 @@
+Shindo.tests('AWS | credentials', ['aws']) do
+  old_mock_value = Excon.defaults[:mock]
+  Excon.stubs.clear
+
+  begin
+    Excon.defaults[:mock] = true
+    default_credentials = Fog::Compute::AWS.fetch_credentials({})
+    Excon.stub({:method => :get, :path => "/latest/meta-data/iam/security-credentials/"}, {:status => 200, :body => 'arole'})
+
+    expires_at = Time.at(Time.now.to_i + 500)
+    credentials = {
+      'AccessKeyId' => 'dummykey',
+      'SecretAccessKey' => 'dummysecret',
+      'Token' => 'dummytoken',
+      'Expiration' => expires_at.xmlschema
+    }
+
+    Excon.stub({:method => :get, :path => "/latest/meta-data/iam/security-credentials/arole"}, {:status => 200, :body => Fog::JSON.encode(credentials)})
+
+
+    tests("#fetch_credentials") do
+      returns({:aws_access_key_id => 'dummykey', 
+                :aws_secret_access_key => 'dummysecret', 
+                :aws_session_token => 'dummytoken', 
+                :aws_credentials_expire_at => expires_at}) { Fog::Compute::AWS.fetch_credentials(:use_iam_profile => true) }
+    end
+
+    compute = Fog::Compute::AWS.new(:use_iam_profile => true)
+
+    tests("#refresh_credentials_if_expired") do
+      returns(nil){compute.refresh_credentials_if_expired}
+    end
+
+    credentials['AccessKeyId'] = 'newkey'
+    credentials['SecretAccessKey'] = 'newsecret'
+    credentials['Expiration'] = (expires_at + 10).xmlschema
+
+    Excon.stub({:method => :get, :path => "/latest/meta-data/iam/security-credentials/arole"}, {:status => 200, :body => Fog::JSON.encode(credentials)})
+
+    Fog::Time.now = expires_at + 1
+    tests("#refresh_credentials_if_expired") do
+      returns(true){compute.refresh_credentials_if_expired}
+      returns("newkey"){ compute.instance_variable_get(:@aws_access_key_id)}
+    end
+    Fog::Time.now = Time.now
+
+
+    tests("#fetch_credentials when the url 404s") do
+      Excon.stub({:method => :get, :path => "/latest/meta-data/iam/security-credentials/"}, {:status => 404, :body => 'not bound'})
+      returns(default_credentials) {Fog::Compute::AWS.fetch_credentials(:use_iam_profile => true)}
+    end
+
+  ensure
+    Excon.stubs.clear
+    Excon.defaults[:mock] = old_mock_value
+  end
+end

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

@@ -9,6 +9,13 @@ Shindo.tests("Fog::Compute[:aws] | address", ['aws']) do
       @instance.server = @server
     end
 
+    tests('#server') do
+      test(' == @server') do
+        @server.reload
+        @instance.server.public_ip_address == @instance.public_ip
+      end
+    end
+    
     @server.destroy
 
   end

data/tests/aws/models/compute/dhcp_option_tests.rb

@@ -0,0 +1,4 @@
+Shindo.tests("Fog::Compute[:aws] | dhcp_options", ['aws']) do
+  model_tests(Fog::Compute[:aws].dhcp_options, {'dhcp_configuration_set' => {'domain-name' => 'example.com', 'domain-name-servers' => '10.10.10.10'}}, true)
+end
+

data/tests/aws/models/compute/dhcp_options_tests.rb

@@ -0,0 +1,4 @@
+Shindo.tests("Fog::Compute[:aws] | dhcp_options", ['aws']) do
+  collection_tests(Fog::Compute[:aws].dhcp_options, {'dhcp_configuration_set' => {'domain-name' => 'example.com', 'domain-name-servers' => '10.10.10.10'}}, true)
+end
+

data/tests/aws/models/compute/internet_gateway_tests.rb

@@ -0,0 +1,3 @@
+Shindo.tests("Fog::Compute[:aws] | internet_gateway", ['aws']) do
+  model_tests(Fog::Compute[:aws].internet_gateways , {}, true)
+end

data/tests/aws/models/compute/internet_gateways_tests.rb

@@ -0,0 +1,4 @@
+Shindo.tests("Fog::Compute[:aws] | internet_gateways", ['aws']) do
+  collection_tests(Fog::Compute[:aws].internet_gateways, {}, true)
+end
+

data/tests/aws/models/compute/network_interfaces_test.rb

@@ -0,0 +1,12 @@
+Shindo.tests("Fog::Compute[:aws] | network_interfaces", ['aws']) do
+  @vpc       = Fog::Compute[:aws].vpcs.create('cidr_block' => '10.0.10.0/24')
+  @subnet    = Fog::Compute[:aws].subnets.create('vpc_id' => @vpc.id, 'cidr_block' => '10.0.10.16/28')
+  @subnet_id = @subnet.subnet_id
+
+  collection_tests(Fog::Compute[:aws].network_interfaces,
+                   {:description => 'nic_desc', :name => 'nic_name', :subnet_id => @subnet_id},
+                   true)
+  
+  @subnet.destroy
+  @vpc.destroy
+end

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

@@ -31,6 +31,20 @@ Shindo.tests("Fog::Compute[:aws] | security_group", ['aws']) do
       @group.ip_permissions.empty?
     end
 
+    test("authorize port range access by another security group") do
+      @other_group.reload
+      @group.authorize_port_range(5000..6000, {:group => "#{@other_group.owner_id}:#{@other_group.group_id}"})
+      @group.reload
+      @group.ip_permissions.size == 1
+    end
+
+    test("revoke port range access by another security group") do
+      @other_group.reload
+      @group.revoke_port_range(5000..6000, {:group => "#{@other_group.owner_id}:#{@other_group.group_id}"})
+      @group.reload
+      @group.ip_permissions.empty?
+    end
+
     @other_group.destroy
     @group.destroy
   end

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

@@ -3,7 +3,7 @@ Shindo.tests("Fog::Compute[:aws] | volume", ['aws']) do
   @server = Fog::Compute[:aws].servers.create
   @server.wait_for { ready? }
 
-  model_tests(Fog::Compute[:aws].volumes, {:availability_zone => @server.availability_zone, :size => 1, :device => '/dev/sdz1'}, true) do
+  model_tests(Fog::Compute[:aws].volumes, {:availability_zone => @server.availability_zone, :size => 1, :device => '/dev/sdz1', :tags => {"key" => "value"}}, true) do
 
     @instance.wait_for { ready? }
 
@@ -32,6 +32,10 @@ Shindo.tests("Fog::Compute[:aws] | volume", ['aws']) do
 
     @instance.wait_for { ready? }
 
+    tests('@instance.reload.tags').returns({'key' => 'value'}) do
+      @instance.reload.tags
+    end
+
   end
 
   @server.destroy

data/tests/aws/models/elb/model_tests.rb

@@ -2,6 +2,16 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
   require 'fog'
   @availability_zones = Fog::Compute[:aws].describe_availability_zones('state' => 'available').body['availabilityZoneInfo'].collect{ |az| az['zoneName'] }
   @key_name = 'fog-test-model'
+  @vpc=Fog::Compute[:aws].vpcs.create('cidr_block' => '10.0.10.0/24')
+  @vpc_id = @vpc.id
+  @subnet = Fog::Compute[:aws].subnets.create({:vpc_id => @vpc_id, :cidr_block => '10.0.10.0/24'})
+  @subnet_id = @subnet.subnet_id
+  @scheme = 'internal'
+  @igw=Fog::Compute[:aws].internet_gateways.create
+  @igw_id = @igw.id
+  @igw.attach(@vpc_id)
+
+
 
   tests('success') do
     tests('load_balancers') do
@@ -46,6 +56,23 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
           tests("params").returns(Fog::AWS[:elb].listeners.new.to_params) { elb.listeners.first.to_params }
         end
       end
+      tests('with vpc') do
+        elb2 = Fog::AWS[:elb].load_balancers.create(:id => "#{elb_id}-2", :subnet_ids => [@subnet_id])
+        tests("subnet ids are correct").returns(@subnet_id) { elb2.subnet_ids.first }
+        elb2.destroy
+      end
+      tests('with vpc internal') do
+        elb2 = Fog::AWS[:elb].load_balancers.create(:id => "#{elb_id}-2", :subnet_ids => [@subnet_id], :scheme => 'internal')
+        tests("scheme is internal").returns(@scheme) { elb2.scheme }
+        elb2.destroy
+      end
+      if !Fog.mocking?
+        @igw.detach(@vpc_id)
+        @igw.destroy
+        @subnet.destroy
+        sleep 5
+        @vpc.destroy
+     end
 
       tests('with availability zones') do
         azs = @availability_zones[1..-1]
@@ -94,9 +121,16 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
       tests("contains elb").returns(true) { elb_ids.include? elb_id }
     end
 
+    if Fog.mocking?
+      tests('all marker support') do
+        extra_elb_ids = (1..1000).map {|n| Fog::AWS[:elb].load_balancers.create(:id => "#{elb_id}-extra-#{n}").id }
+        tests('returns all elbs').returns(true) { (extra_elb_ids - Fog::AWS[:elb].load_balancers.all.map {|e| e.id }).empty? }
+      end
+    end
+
     tests('get') do
-      elb_get = Fog::AWS[:elb].load_balancers.get(elb_id)
-      tests('ids match').returns(elb_id) { elb_get.id }
+      tests('ids match').returns(elb_id) { Fog::AWS[:elb].load_balancers.get(elb_id).id }
+      tests('nil id').returns(nil) { Fog::AWS[:elb].load_balancers.get(nil) }
     end
 
     tests('creating a duplicate elb') do

data/tests/aws/models/iam/access_keys_tests.rb

@@ -0,0 +1,53 @@
+Shindo.tests("Fog::Compute[:iam] | access_keys", ['aws','iam']) do
+
+  Fog.mock!
+  iam = Fog::AWS[:iam]
+  
+  @username = 'fake_user'
+  @user = iam.users.create(:id => @username)
+
+  
+  tests('#all', 'there are no access keys for a new user').succeeds do
+    @user.access_keys.empty?
+  end
+  
+  
+  tests('#create','an access key').succeeds do
+    access_key = @user.access_keys.create
+    access_key.id =~ /[A-Z0-9]{20}/
+    access_key.secret_access_key =~ /[\S]{40}/
+    access_key.status == "Active"
+    access_key.username == @username
+    @access_key_id = access_key.id
+  end
+  
+  @user.access_keys.create
+  
+  tests('#all','there are two access keys').succeeds do
+    @user.access_keys.size == 2
+  end
+  
+  tests('#get') do
+    tests('a valid access key id').succeeds do
+      access_key = @user.access_keys.get(@access_key_id)
+      access_key.id == @access_key_id
+      access_key.secret_access_key == nil
+      access_key.status == "Active"
+      access_key.username == @username
+    end
+    
+    tests('an invalid access key').succeeds do
+      @user.access_keys.get('non-existing') == nil
+    end
+  end
+  
+  tests('#destroy', 'decrease by one the number of access keys').succeeds do
+    size = @user.access_keys.size
+    @user.access_keys.get(@access_key_id).destroy
+    @user.access_keys.size == ( size - 1 )
+  end
+  
+  # clean up
+  @user.destroy
+  
+end

data/tests/aws/models/iam/policies_tests.rb

@@ -0,0 +1,56 @@
+Shindo.tests("Fog::Compute[:iam] | policies", ['aws','iam']) do
+
+  Fog.mock!
+  iam = Fog::AWS[:iam]
+  
+  @username = 'fake_user'
+  @user = iam.users.create(:id => @username)
+  @policy_document = {"Statement"=>[{"Action"=>["sqs:*"], "Effect"=>"Allow", "Resource"=>"*"}]}
+  @policy_name = 'fake-sqs-policy'
+  
+  tests('#all', 'there is no policies').succeeds do
+    @user.policies.empty?
+  end
+  
+  tests('#create') do 
+    tests('a valid policy').succeeds do
+      policy = @user.policies.create(id: @policy_name, document: @policy_document)
+      policy.id == @policy_name
+      policy.username == @username
+      policy.document == @policy_document
+    end
+    
+    # The mocking doesn't validate the document policy
+    #tests('an invalid valid policy').succeeds do
+    #  raises(Fog::AWS::IAM::Error) { @user.policies.create(id: 'non-valid-document', document: 'invalid json blob') }
+    #end
+  end
+  
+  @user.policies.create(id: 'another-policy', document: {})
+  
+  tests('#all','there are two policies').succeeds do
+    @user.policies.size == 2
+  end
+  
+  tests('#get') do
+    tests('a valid policy').succeeds do
+      policy = @user.policies.get(@policy_name)
+      policy.id == @polic_name
+      policy.username == @username
+      policy.document == @policy_document   
+    end
+    
+    tests('an invalid policy').succeeds do
+      @user.policies.get('non-existing') == nil
+    end
+  end
+  
+  tests('#destroy').succeeds do
+    @user.policies.get(@policy_name).destroy
+  end
+  
+  # clean up
+  @user.destroy
+
+  
+end

data/tests/aws/models/iam/users_tests.rb

@@ -0,0 +1,54 @@
+Shindo.tests("Fog::Compute[:iam] | users", ['aws','iam']) do
+
+  Fog.mock!
+  @iam = Fog::AWS[:iam]
+  @user_one_name = 'fake_user_one'
+  @user_two_name = 'fake_user_two'
+  
+  tests('#create').succeeds do
+    @user_one = @iam.users.create(:id => @user_one_name)
+    @user_one.id == @user_one_name
+  end
+  
+  tests('#all','there is only one user').succeeds do
+    @iam.users.size == 1
+  end
+  
+  tests('#all','the only user should match').succeeds do
+    @iam.users.first.id == @user_one_name
+  end
+  
+  tests('#create','a second user').succeeds do
+    @user_two = @iam.users.create(:id => @user_two_name)
+    @user_two.id == @user_two_name
+  end  
+
+  tests('#all','there are two users').succeeds do
+    @iam.users.size == 2
+  end
+
+  tests('#get','an existing user').succeeds do
+    @iam.users.get(@user_one_name).id == @user_one_name
+  end
+
+  tests('#get',"returns nil if the user doesn't exists").succeeds do
+    @iam.users.get('non-exists') == nil
+  end
+  
+  tests('#policies','it has no policies').succeeds do
+    @iam.users.get(@user_one_name).policies.empty?
+  end
+  
+  tests('#access_keys','it has no keys').succeeds do
+    @iam.users.get(@user_one_name).access_keys.empty?
+  end
+  
+  tests('#destroy','an existing user').succeeds do
+    @iam.users.get(@user_one_name).destroy
+  end
+  
+  tests('#destroy','clean up remaining user').succeeds do
+    @iam.users.get(@user_two_name).destroy
+  end
+  
+end

data/tests/aws/models/storage/url_tests.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+Shindo.tests('AWS | url') do
+
+  @expires = DateTime.parse('2013-01-01T00:00:00Z').to_time.utc.to_i
+
+  @storage = Fog::Storage.new(
+    provider: 'AWS',
+    aws_access_key_id: '123',
+    aws_secret_access_key: 'abc',
+    region: 'us-east-1'
+  )
+  
+  @file = @storage.directories.new(key: 'fognonbucket').files.new(key: 'test.txt')
+
+  tests('#url w/ response-cache-control').returns(
+    'https://fognonbucket.s3.amazonaws.com/test.txt?response-cache-control=No-cache&AWSAccessKeyId=123&Signature=tajHIhKHAdFYsigmzybCpaq8N0Q%3D&Expires=1356998400'
+  ) do
+    @file.url(@expires, query: { 'response-cache-control' => 'No-cache' })
+  end
+
+end

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

@@ -0,0 +1,40 @@
+Shindo.tests('Fog::Compute[:aws] | dhcp_options requests', ['aws']) do
+
+  @dhcp_options_format = {
+    'dhcpOptionsSet' => [{
+      'dhcpOptionsId'            => String,
+      'dhcpConfigurationSet'     => Hash,
+      'tagSet'                   => Fog::Nullable::Hash,
+    }],
+    'requestId' => String
+  }
+
+  tests('success') do
+    @vpc=Fog::Compute[:aws].vpcs.create('cidr_block' => '10.0.10.0/24')
+    @vpc_id = @vpc.id
+
+
+    tests('#create_dhcp_options').formats(@dhcp_options_format) do
+      data = Fog::Compute[:aws].create_dhcp_options({'domain-name' => 'example.com', 'domain-name-servers' => '10.10.10.10'}).body
+      @dopt_id = data['dhcpOptionsSet'].first['dhcpOptionsId']
+      data
+    end
+
+    tests('#describe_dhcp_options').formats(@dhcp_options_format) do
+      Fog::Compute[:aws].describe_dhcp_options.body
+    end
+
+    tests("#associate_dhcp_options('#{@dopt_id}, #{@vpc_id}')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].associate_dhcp_options(@dopt_id, @vpc_id).body
+    end
+
+    tests("#associate_default_dhcp_options('default', #{@vpc_id}')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].associate_dhcp_options('default', @vpc_id).body
+    end
+
+    tests("#delete_dhcp_options('#{@dopt_id}')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].delete_dhcp_options(@dopt_id).body
+    end
+    @vpc.destroy
+  end
+end