fog 0.7.2 → 0.8.0

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

@@ -1,6 +1,47 @@
 class AWS
 
   module IAM
+    # A self-signed test keypair. Generated using the command:
+    # openssl req -new -newkey rsa:1024 -days 3650 -nodes -x509 -keyout server-private.key -out server-public.crt
+    # NB: Amazon returns an error on extraneous linebreaks
+    SERVER_CERT_PUBLIC_KEY = %{-----BEGIN CERTIFICATE-----
+MIIDQzCCAqygAwIBAgIJAJaZ8wH+19AtMA0GCSqGSIb3DQEBBQUAMHUxCzAJBgNV
+BAYTAlVTMREwDwYDVQQIEwhOZXcgWW9yazERMA8GA1UEBxMITmV3IFlvcmsxHzAd
+BgNVBAoTFkZvZyBUZXN0IFNuYWtlb2lsIENlcnQxHzAdBgNVBAsTFkZvZyBUZXN0
+IFNuYWtlb2lsIENlcnQwHhcNMTEwNTA3MTc0MDU5WhcNMjEwNTA0MTc0MDU5WjB1
+MQswCQYDVQQGEwJVUzERMA8GA1UECBMITmV3IFlvcmsxETAPBgNVBAcTCE5ldyBZ
+b3JrMR8wHQYDVQQKExZGb2cgVGVzdCBTbmFrZW9pbCBDZXJ0MR8wHQYDVQQLExZG
+b2cgVGVzdCBTbmFrZW9pbCBDZXJ0MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKB
+gQC0CR76sovjdmpWRmEaf8XaG+nGe7czhpdLKkau2b16VtSjkPctxPL5U4vaMxQU
+boLPr+9oL+9fSYN31VzDD4hyaeGoeI5fhnGeqk71kq5uHONBOQUMbZbBQ8PVd9Sd
+k+y9JJ6E5fC+GhLL5I+y2DK7syBzyymq1Wi6rPp1XXF7AQIDAQABo4HaMIHXMB0G
+A1UdDgQWBBRfqBkpU/jEV324748fq6GJM80iVTCBpwYDVR0jBIGfMIGcgBRfqBkp
+U/jEV324748fq6GJM80iVaF5pHcwdTELMAkGA1UEBhMCVVMxETAPBgNVBAgTCE5l
+dyBZb3JrMREwDwYDVQQHEwhOZXcgWW9yazEfMB0GA1UEChMWRm9nIFRlc3QgU25h
+a2VvaWwgQ2VydDEfMB0GA1UECxMWRm9nIFRlc3QgU25ha2VvaWwgQ2VydIIJAJaZ
+8wH+19AtMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQADgYEAUV6NDdLHKNhl
+ACtzLycIhlMTmDr0xBeIBx3lpgw2K0+4oefMS8Z17eeZPeNodxnz56juJm81BZwt
+DF3qnnPyArLFx0HLB7wQdm9xYVIqQuLO+V6GRuOd+uSX//aDLDZhwbERf35hoyto
+Jfk4gX/qwuRFNy0vjQeTzdvhB1igG/w=
+-----END CERTIFICATE-----
+}
+
+    SERVER_CERT_PRIVATE_KEY = %{-----BEGIN RSA PRIVATE KEY-----
+MIICXAIBAAKBgQC0CR76sovjdmpWRmEaf8XaG+nGe7czhpdLKkau2b16VtSjkPct
+xPL5U4vaMxQUboLPr+9oL+9fSYN31VzDD4hyaeGoeI5fhnGeqk71kq5uHONBOQUM
+bZbBQ8PVd9Sdk+y9JJ6E5fC+GhLL5I+y2DK7syBzyymq1Wi6rPp1XXF7AQIDAQAB
+AoGANjjRBbwkeXs+h4Fm2W5GDmx9ufOkt3X/tvmilCKr+F6SaDjO2RAKBaFt62ea
+0pR9/UMFnaFiPJaNa9fsuirBcwId+RizruEp+7FGziM9mC5kcE7WKZrXgGGnLtqg
+4x5twVLArgp0ji7TA18q/74uTrI4az8H5iTY4n29ORlLmmkCQQDsGMuLEgGHgN5Y
+1c9ax1DT/rUXKxnqsIrijRkgbiTncHAArFJ88c3yykWqGvYnSFwMS8DSWiPyPaAI
+nNNlb/fPAkEAwzZ4CfvJ+OlE++rTPH9jemC89dnxC7EFGuWJmwdadnev8EYguvve
+cdGdGttD7QsZKpcz5mDngOUghbVm8vBELwJAMHfOoVgq9DRicP5DuTEdyMeLSZxR
+j7p6aJPqypuR++k7NQgrTvcc/nDD6G3shpf2PZf3l7dllb9M8TewtixMRQJBAIdX
+c0AQtoYBTJePxiYyd8i32ypkkK83ar+sFoxKO9jYwD1IkZax2xZ0aoTdMindQPR7
+Yjs+QiLmOHcbPqX+GHcCQERsSn0RjzKmKirDntseMB59BB/cEN32+gMDVsZuCfb+
+fOy2ZavFl13afnhbh2/AjKeDhnb19x/uXjF7JCUtwpA=
+-----END RSA PRIVATE KEY-----
+}
 
     module Formats
 

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

@@ -27,7 +27,7 @@ Shindo.tests('AWS::IAM | user requests', ['aws']) do
       result
     end
 
-    tests("#modify_login_profile('fog_user')").formats(AWS::IAM::Formats::BASIC) do
+    tests("#update_login_profile('fog_user')").formats(AWS::IAM::Formats::BASIC) do
       pending if Fog.mocking?
       begin
         AWS[:iam].update_login_profile('fog_user', 'otherpassword').body

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

@@ -0,0 +1,36 @@
+Shindo.tests('AWS::IAM | server certificate requests', ['aws']) do
+
+  pending if Fog.mocking?
+
+  @key_name = 'fog-test'
+
+  @certificate_format = {
+  'Arn' => String,
+  'Path' => String,
+  'ServerCertificateId' => String,
+  'ServerCertificateName' => String,
+  'UploadDate' => Time
+}
+  @upload_format = {
+    'Certificate' => @certificate_format,
+    'RequestId' => String
+  }
+  tests('#upload_server_certificate').formats(@upload_format) do
+    public_key  = AWS::IAM::SERVER_CERT_PUBLIC_KEY
+    private_key = AWS::IAM::SERVER_CERT_PRIVATE_KEY
+    AWS[:iam].upload_server_certificate(public_key, private_key, @key_name).body
+  end
+
+  @list_format = { 'Certificates' => [@certificate_format] }
+  tests('#list_server_certificates').formats(@list_format) do
+    result = AWS[:iam].list_server_certificates.body
+    tests('includes key name') do
+      returns(true) { result['Certificates'].any?{|c| c['ServerCertificateName'] == @key_name} }
+    end
+    result
+  end
+
+  tests('#delete_server_certificate').formats(AWS::IAM::Formats::BASIC) do
+    AWS[:iam].delete_server_certificate(@key_name).body
+  end
+end

data/tests/aws/requests/rds/instance_tests.rb

@@ -1,131 +1,128 @@
 Shindo.tests('AWS::RDS | instance requests', ['aws', 'rds']) do
-  @db_instance_id='fog-test'
-  @db_replica_id='fog-replica'
-  
+  # random_differentiator
+  # Useful when rapidly re-running tests, so we don't have to wait
+  # serveral minutes for deleted servers to disappear
+  suffix = rand(65536).to_s(16)
+
+  @db_instance_id       = "fog-test-#{suffix}"
+  @db_replica_id        = "fog-replica-#{suffix}"
+  @db_snapshot_id       = "fog-snapshot"
+  @db_final_snapshot_id = "fog-final-snapshot"
+
   tests('success') do
     pending if Fog.mocking?
-    
+
     tests("#create_db_instance").formats(AWS::RDS::Formats::CREATE_DB_INSTANCE) do
       result = AWS[:rds].create_db_instance(@db_instance_id, 'AllocatedStorage' => 5,
-                                                'DBInstanceClass' => 'db.m1.small',
-                                                'Engine' => 'mysql',
-                                                'EngineVersion' => '5.1.50',
-                                                'MasterUsername' => 'foguser',
-                                                'BackupRetentionPeriod' => 1,
-                                                'MasterUserPassword' => 'fogpassword').body
-    
+                                            'DBInstanceClass' => 'db.m1.small',
+                                            'Engine' => 'mysql',
+                                            'EngineVersion' => '5.1.50',
+                                            'MasterUsername' => 'foguser',
+                                            'BackupRetentionPeriod' => 1,
+                                            'MasterUserPassword' => 'fogpassword').body
+
       instance = result['CreateDBInstanceResult']['DBInstance']
       returns('creating'){ instance['DBInstanceStatus']}
       result
     end
-       
+
     tests("#describe_db_instances").formats(AWS::RDS::Formats::DESCRIBE_DB_INSTANCES) do
       AWS[:rds].describe_db_instances.body
     end
-    
+
     server = AWS[:rds].servers.get(@db_instance_id)
     server.wait_for {ready?}
-    
-    
+
+    new_storage = 6
     tests("#modify_db_instance with immediate apply").formats(AWS::RDS::Formats::MODIFY_DB_INSTANCE) do
-      body = AWS[:rds].modify_db_instance( @db_instance_id, true, 'AllocatedStorage'=> 10).body
+      body = AWS[:rds].modify_db_instance(@db_instance_id, true, 'AllocatedStorage'=> new_storage).body
       tests 'pending storage' do
         instance = body['ModifyDBInstanceResult']['DBInstance']
-        returns(10){instance['PendingModifiedValues']['AllocatedStorage']}
+        returns(new_storage){instance['PendingModifiedValues']['AllocatedStorage']}
       end
-      body      
+      body
     end
-    server.wait_for { state == 'modifying'}
-    server.wait_for { state == 'available'}
-  
-    server.reload
+
+    server.reload.wait_for { state == 'modifying' }
+    server.reload.wait_for { state == 'available' }
+
     tests 'new storage' do
-      returns(10){ server.allocated_storage}
+      returns(new_storage){ server.allocated_storage}
     end
-    server.wait_for { state == 'available'}
 
     tests("reboot db instance") do
       tests("#reboot").formats(AWS::RDS::Formats::REBOOT_DB_INSTANCE) do
-        AWS[:rds].reboot_db_instance( @db_instance_id).body
+        AWS[:rds].reboot_db_instance(@db_instance_id).body
       end
-
-      server.wait_for { state == 'rebooting'}
-      server.wait_for { state == 'available'}
-      server.reload
     end
-    
-    
+
+    server.reload.wait_for { state == 'rebooting' }
+    server.reload.wait_for { state == 'available'}
+
     tests("#create_db_snapshot").formats(AWS::RDS::Formats::CREATE_DB_SNAPSHOT) do
-      body = AWS[:rds].create_db_snapshot(@db_instance_id, 'fog-snapshot').body
+      body = AWS[:rds].create_db_snapshot(@db_instance_id, @db_snapshot_id).body
       returns('creating'){ body['CreateDBSnapshotResult']['DBSnapshot']['Status']}
       body
     end
-    
+
     tests("#describe_db_snapshots").formats(AWS::RDS::Formats::DESCRIBE_DB_SNAPSHOTS) do
-      body = AWS[:rds].describe_db_snapshots().body
+      body = AWS[:rds].describe_db_snapshots.body
     end
-    
-    Fog.wait_for do
-      data = AWS[:rds].describe_db_snapshots(:snapshot_id => 'fog-snapshot')
-      status = data.body['DescribeDBSnapshotsResult']['DBSnapshots'].first['Status']
-      status =='available'
-    end
-    
+
+    server.reload.wait_for { state == 'available' }
+
     tests( "#create read replica").formats(AWS::RDS::Formats::CREATE_READ_REPLICA) do
       AWS[:rds].create_db_instance_read_replica(@db_replica_id, @db_instance_id).body
     end
-    
+
     replica = AWS[:rds].servers.get(@db_replica_id)
     replica.wait_for {ready?}
-    
+
     tests("replica source") do
       returns(@db_instance_id){replica.read_replica_source}
     end
     server.reload
-    
+
     tests("replica identifiers") do
       returns([@db_replica_id]){server.read_replica_identifiers}
     end
 
     tests("#delete_db_instance").formats(AWS::RDS::Formats::DELETE_DB_INSTANCE) do
-      server.wait_for { state == 'available'}
+      #server.wait_for { state == 'available'}
       AWS[:rds].delete_db_instance(@db_replica_id, nil, true)
-      body = AWS[:rds].delete_db_instance(@db_instance_id, 'fog-final-snapshot').body
-      Fog.wait_for do
-        AWS[:rds].servers.length == 0
-      end
-      
+      body = AWS[:rds].delete_db_instance(@db_instance_id, @db_final_snapshot_id).body
+
       tests "final snapshot" do
-        returns('available'){AWS[:rds].describe_db_snapshots(:snapshot_id => 'fog-final-snapshot').body['DescribeDBSnapshotsResult']['DBSnapshots'].first['Status']}
+        returns('creating'){AWS[:rds].describe_db_snapshots(:snapshot_id => @db_final_snapshot_id).body['DescribeDBSnapshotsResult']['DBSnapshots'].first['Status']}
       end
       body
     end
-    
-    
-    
+
     tests("#delete_db_snapshot").formats(AWS::RDS::Formats::DELETE_DB_SNAPSHOT) do
-      AWS[:rds].delete_db_snapshot('fog-snapshot').body
+      AWS[:rds].snapshots.get(@db_snapshot_id).wait_for { ready? }
+      AWS[:rds].delete_db_snapshot(@db_snapshot_id).body
+    end
+
+    tests("snapshot.destroy") do
+      snapshot = AWS[:rds].snapshots.get(@db_final_snapshot_id)
+      snapshot.wait_for { ready? }
+      snapshot.destroy
+      returns(nil) { AWS[:rds].snapshots.get(@db_final_snapshot_id) }
     end
-    
-    AWS[:rds].delete_db_snapshot('fog-final-snapshot')
-    
-    returns([]){ AWS[:rds].describe_db_snapshots.body['DescribeDBSnapshotsResult']['DBSnapshots']}
-        
+
   end
-  
+
   tests('failure') do
     pending if Fog.mocking?
-    
+
     tests "deleting nonexisting instance" do
-      raises(Fog::AWS::RDS::NotFound) {AWS[:rds].delete_db_instance('doesnexist', 'irrelevant')}      
+      raises(Fog::AWS::RDS::NotFound) {AWS[:rds].delete_db_instance('doesnexist', 'irrelevant')}
     end
     tests "deleting non existing snapshot" do
-      raises(Fog::AWS::RDS::NotFound) {AWS[:rds].delete_db_snapshot('doesntexist')}          
+      raises(Fog::AWS::RDS::NotFound) {AWS[:rds].delete_db_snapshot('doesntexist')}
     end
     tests "modifying non existing instance" do
       raises(Fog::AWS::RDS::NotFound) { AWS[:rds].modify_db_instance 'doesntexit', true, 'AllocatedStorage'=> 10}
     end
   end
 end
-  
-    

data/tests/aws/requests/simpledb/attributes_tests.rb

@@ -6,11 +6,11 @@ Shindo.tests('AWS::SimpleDB | attributes requests', ['aws']) do
 
   tests('success') do
 
-    tests("#batch_put_attributes('#{@domain_name}', { 'a' => { 'b' => 'c' }, 'x' => { 'y' => 'z' } }).body").formats(AWS::SimpleDB::Formats::BASIC) do
-      AWS[:sdb].batch_put_attributes(@domain_name, { 'a' => { 'b' => 'c' }, 'x' => { 'y' => 'z' } }).body
+    tests("#batch_put_attributes('#{@domain_name}', { 'a' => { 'b' => 'c', 'd' => 'e' }, 'x' => { 'y' => 'z' } }).body").formats(AWS::SimpleDB::Formats::BASIC) do
+      AWS[:sdb].batch_put_attributes(@domain_name, { 'a' => { 'b' => 'c', 'd' => 'e' }, 'x' => { 'y' => 'z' } }).body
     end
 
-    tests("#get_attributes('#{@domain_name}', 'a').body['Attributes']").returns({'b' => ['c']}) do
+    tests("#get_attributes('#{@domain_name}', 'a').body['Attributes']").returns({'b' => ['c'], 'd' => ['e']}) do
       attributes = {}
       Fog.wait_for {
         attributes = AWS[:sdb].get_attributes(@domain_name, 'a').body['Attributes']
@@ -23,7 +23,7 @@ Shindo.tests('AWS::SimpleDB | attributes requests', ['aws']) do
       AWS[:sdb].get_attributes(@domain_name, 'notanattribute')
     end
 
-    tests("#select('select * from #{@domain_name}').body['Items']").returns({ 'a' => { 'b' => ['c'] }, 'x' => { 'y' => ['z'] } }) do
+    tests("#select('select * from #{@domain_name}').body['Items']").returns({'a' => { 'b' => ['c'], 'd' => ['e']}, 'x' => { 'y' => ['z'] } }) do
       pending if Fog.mocking?
       AWS[:sdb].select("select * from #{@domain_name}").body['Items']
     end

data/tests/aws/signed_params_tests.rb

@@ -0,0 +1,3 @@
+Shindo.tests('AWS | signed_params', ['aws']) do
+  returns( Fog::AWS.escape( "'Stop!' said Fred_-~." ) ) { "%27Stop%21%27%20said%20Fred_-~." }
+end

data/tests/compute/helper.rb

@@ -8,14 +8,14 @@ def compute_providers
     },
     Bluebox   => {
       :server_attributes => {
-        :image_id => 'a00baa8f-b5d0-4815-8238-b471c4c4bf72', # Ubuntu 9.10 64bit
+        :image_id => '03807e08-a13d-44e4-b011-ebec7ef2c928', # Ubuntu 10.04 64bit
         :password => 'chunkybacon'
       },
       :mocked => false
     },
     Brightbox => {
       :server_attributes => {
-        :image_id => 'img-9vxqi' # image img-9vxqi = Ubuntu Maverick 10.10 server
+        :image_id => 'img-2ab98' # Ubuntu Lucid 10.04 server (i686)
       },
       :mocked => false
     },

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

@@ -1,8 +1,8 @@
 Shindo.tests("AWS::Compute | address", ['aws']) do
 
   model_tests(AWS[:compute].addresses, {}, true) do
-                 
-    @server = AWS[:compute].servers.create(:image_id => GENTOO_AMI)
+
+    @server = AWS[:compute].servers.create
     @server.wait_for { ready? }
 
     tests('#server=').succeeds do

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

@@ -2,4 +2,16 @@ Shindo.tests("AWS::Compute | security_group", ['aws']) do
 
   model_tests(AWS[:compute].security_groups, {:description => 'foggroupdescription', :name => 'foggroupname'}, true)
 
+  tests("a group with trailing whitespace") do
+    @group = AWS[:compute].security_groups.create(:name => "foggroup with spaces   ", :description => "   fog group desc   ")
+    test("name is correct") do
+      @group.name ==  "foggroup with spaces   "
+    end
+
+    test("description is correct") do
+      @group.description == "   fog group desc   "
+    end
+
+    @group.destroy
+  end
 end

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

@@ -4,7 +4,7 @@ Shindo.tests("AWS::Compute | monitor", ['aws']) do
     responds_to(association)
   end
 
-  @instance = AWS[:compute].servers.new(:image_id => 'ami-1a837773')
+  @instance = AWS[:compute].servers.new
 
   tests('new instance') do
 
@@ -24,6 +24,12 @@ Shindo.tests("AWS::Compute | monitor", ['aws']) do
 
     @instance.save
 
+    [:id, :availability_zone, :flavor_id, :kernel_id, :image_id, :state].each do |attr|
+      test("instance##{attr} should not contain whitespace") do
+        nil == @instance.send(attr).match(/\s/)
+      end
+    end
+
     test('#monitor = true') do
       @instance.monitor = true
       @instance.monitoring == true
@@ -36,4 +42,5 @@ Shindo.tests("AWS::Compute | monitor", ['aws']) do
 
   end
 
+  @instance.destroy
 end

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

@@ -4,7 +4,7 @@ Shindo.tests("AWS::Compute | snapshot", ['aws']) do
   @volume.wait_for { ready? }
 
   model_tests(AWS[:compute].snapshots, {:volume_id => @volume.identity}, true)
-                    
+
   @volume.destroy
 
-end
+end

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

@@ -1,12 +1,12 @@
 Shindo.tests("AWS::Compute | volume", ['aws']) do
 
-  @server = AWS[:compute].servers.create(:image_id => GENTOO_AMI)
+  @server = AWS[:compute].servers.create
   @server.wait_for { ready? }
 
   model_tests(AWS[:compute].volumes, {:availability_zone => @server.availability_zone, :size => 1, :device => '/dev/sdz1'}, true) do
 
     @instance.wait_for { ready? }
-                      
+
     tests('#server = @server').succeeds do
       @instance.server = @server
     end
@@ -23,4 +23,4 @@ Shindo.tests("AWS::Compute | volume", ['aws']) do
 
   @server.destroy
 
-end
+end

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

@@ -8,7 +8,7 @@ Shindo.tests('AWS::Compute | address requests', ['aws']) do
     'requestId' => String
   }
 
-  @server = AWS[:compute].servers.create(:image_id => GENTOO_AMI)
+  @server = AWS[:compute].servers.create
   @server.wait_for { ready? }
   @ip_address = @server.ip_address
 

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

@@ -53,7 +53,7 @@ Shindo.tests('AWS::Compute | instance requests', ['aws']) do
 
   @get_console_output_format = {
     'instanceId'  => String,
-    'output'      => NilClass,
+    'output'      => Fog::Nullable::String,
     'requestId'   => String,
     'timestamp'   => Time
   }