Merge pull request #346 from ktheory/cleanup_rds_tests

[aws|rds] Refactor model tests

lib/fog/aws/models/rds/security_group.rb

@@ -65,8 +65,6 @@ module Fog
           merge_attributes(data)
         end
 
-
-
       end
     end
   end

lib/fog/aws/models/rds/server.rb

@@ -45,7 +45,7 @@ module Fog
           state == 'available'
         end
    
-        def destroy(snapshot_identifier)
+        def destroy(snapshot_identifier=nil)
           requires :id
           connection.delete_db_instance(id, snapshot_identifier, snapshot_identifier.nil?)
           true
@@ -102,4 +102,4 @@ module Fog
       end
     end
   end
-end
+end

tests/aws/models/rds/helper.rb

@@ -0,0 +1,5 @@
+def rds_default_server_params
+  { :id => uniq_id, :allocated_storage => 5, :engine => 'mysql',
+    :master_username => 'foguser', :password => 'fogpassword',
+    :backup_retention_period => 0 }
+end

tests/aws/models/rds/parameter_group_tests.rb

@@ -0,0 +1,24 @@
+Shindo.tests("AWS::RDS | parameter_group", ['aws', 'rds']) do
+
+  group_name = 'fog-test'
+  params = {:id => group_name, :family => 'mysql5.1', :description => group_name}
+
+  pending if Fog.mocking?
+  model_tests(AWS[:rds].parameter_groups, params, false) do
+    tests('#parameters') do
+      #search for a sample parameter
+      tests 'contains parameters' do
+        returns(true){ @instance.parameters.any? {|p| p.name == 'query_cache_size'}}
+      end
+    end
+
+    tests('#modify') do
+      @instance.modify([{:name => 'query_cache_size', :value => '6553600', :apply_method => 'immediate'}])
+
+      tests 'parameter has changed' do
+        returns('6553600'){@instance.parameters.detect {|p| p.name == 'query_cache_size'}.value}
+      end
+    end
+
+  end
+end

tests/aws/models/rds/parameter_groups_tests.rb

@@ -0,0 +1,8 @@
+Shindo.tests("AWS::RDS | parameter_groups", ['aws', 'rds']) do
+
+  group_name = 'fog-test'
+  params = {:id => group_name, :family => 'mysql5.1', :description => group_name}
+
+  pending if Fog.mocking?
+  collection_tests(AWS[:rds].parameter_groups, params, false)
+end

tests/aws/models/rds/security_group_tests.rb

@@ -0,0 +1,50 @@
+Shindo.tests("AWS::RDS | security_group", ['aws', 'rds']) do
+  group_name = 'fog-test'
+  params = {:id => group_name, :description => 'fog test'}
+
+  pending if Fog.mocking?
+  model_tests(AWS[:rds].security_groups, params, false) do
+
+    tests("#description").returns('fog test') { @instance.description }
+
+    tests("#authorize_ec2_security_group").succeeds do
+      @ec2_sec_group = AWS[:compute].security_groups.create(:name => 'fog-test', :description => 'fog test')
+
+      @instance.authorize_ec2_security_group(@ec2_sec_group.name)
+      returns('authorizing') do
+        @instance.ec2_security_groups.detect{|h| h['EC2SecurityGroupName'] == @ec2_sec_group.name}['Status']
+      end
+    end
+
+    @instance.wait_for { ready? }
+
+    tests("#revoke_ec2_security_group").succeeds do
+      @instance.revoke_ec2_security_group(@ec2_sec_group.name)
+
+      returns('revoking') do
+        @instance.ec2_security_groups.detect{|h| h['EC2SecurityGroupName'] == @ec2_sec_group.name}['Status']
+      end
+
+      @instance.wait_for { ready? }
+
+      returns(false) { @instance.ec2_security_groups.any?{|h| h['EC2SecurityGroupName'] == @ec2_sec_group.name} }
+      @ec2_sec_group.destroy
+    end
+
+    tests("#authorize_cidrip").succeeds do
+      @cidr = '127.0.0.1/32'
+      @instance.authorize_cidrip(@cidr)
+      returns('authorizing') { @instance.ip_ranges.detect{|h| h['CIDRIP'] == @cidr}['Status'] }
+    end
+
+    @instance.wait_for { ready? }
+    tests("#revoke_cidrip").succeeds do
+      @instance.revoke_cidrip(@cidr)
+      returns('revoking') { @instance.ip_ranges.detect{|h| h['CIDRIP'] == @cidr}['Status'] }
+      @instance.wait_for { ready? }
+      returns(false) { @instance.ip_ranges.any?{|h| h['CIDRIP'] == @cidr} }
+
+    end
+
+  end
+end

tests/aws/models/rds/security_groups_tests.rb

@@ -0,0 +1,6 @@
+Shindo.tests("AWS::RDS | security groups", ['aws', 'rds']) do
+  params = {:id => 'fog-test', :description => 'fog test'}
+
+  pending if Fog.mocking?
+  collection_tests(AWS[:rds].security_groups, params, false)
+end

tests/aws/models/rds/server_tests.rb

@@ -0,0 +1,104 @@
+Shindo.tests("AWS::RDS | server", ['aws', 'rds']) do
+
+  pending if Fog.mocking?
+
+  model_tests(AWS[:rds].servers, rds_default_server_params, false) do
+    # We'll need this later; create it early to avoid waiting
+    @instance_with_final_snapshot = AWS[:rds].servers.create(rds_default_server_params.merge(:id => uniq_id("fog-snapshot-test"), :backup_retention_period => 1))
+
+    @instance.wait_for { ready? }
+
+    tests('#snapshots') do
+      snapshot = nil
+
+      tests('#create').succeeds do
+        snapshot = @instance.snapshots.create(:id => 'fog-test-snapshot')
+      end
+
+      snapshot.wait_for {ready?}
+
+      @instance.reload
+      @instance.wait_for { ready? }
+
+      returns(true) { @instance.snapshots.map{|s| s.id}.include?(snapshot.id) }
+      snapshot.destroy
+    end
+
+    tests("#modify").succeeds do
+      orig_parameter_group = @instance.db_parameter_groups.first['DBParameterGroupName']
+      parameter_group = AWS[:rds].parameter_groups.create(:id => uniq_id, :family => 'mysql5.1', :description => 'fog-test')
+
+      orig_security_groups = @instance.db_security_groups.map{|h| h['DBSecurityGroupName']}
+      security_group = AWS[:rds].security_groups.create(:id => uniq_id, :description => 'fog-test')
+
+      modify_options = {
+        'DBParameterGroupName' => parameter_group.id,
+        'DBSecurityGroups' => orig_security_groups + [security_group.id]
+      }
+
+      @instance.modify(true, modify_options)
+      @instance.reload
+
+      returns(parameter_group.id, 'new parameter group') do
+        @instance.db_parameter_groups.first['DBParameterGroupName']
+      end
+
+      returns(true, "new security group") do
+        @instance.db_security_groups.any?{|hash| hash['DBSecurityGroupName'] == security_group.id}
+      end
+
+      @instance.reboot
+      @instance.reload.wait_for { state == 'rebooting' }
+      @instance.reload.wait_for { ready? }
+
+      # Restore back to original state
+      restore_options = {
+       'DBParameterGroupName' => orig_parameter_group,
+       'DBSecurityGroups' => orig_security_groups
+      }
+      @instance.modify(true, restore_options)
+
+      @instance.reboot
+      @instance.reload.wait_for { state == 'rebooting' }
+      @instance.reload.wait_for do
+        ready? &&
+          db_security_groups.all? {|hash| hash['Status'] == 'active'} &&
+          db_parameter_groups.all? {|hash| hash['ParameterApplyStatus'] == 'in-sync' }
+      end
+
+      parameter_group.destroy
+      security_group.destroy
+    end
+
+    tests("#reboot").succeeds do
+      @instance.reboot
+    end
+    @instance.reload.wait_for {state == 'rebooting'}
+    @instance.reload.wait_for { ready? }
+
+    tests('#create_read_replica').succeeds do
+      replica = @instance_with_final_snapshot.create_read_replica(uniq_id('fog-replica'))
+      @instance_with_final_snapshot.reload
+      returns([replica.id]) { @instance_with_final_snapshot.read_replica_identifiers }
+      returns(@instance_with_final_snapshot.id) { replica.read_replica_source }
+
+      replica.wait_for { ready? }
+      replica.destroy
+    end
+
+    test("Destroying with a final snapshot") do
+      final_snapshot_id = 'fog-test-snapshot'
+
+      @instance_with_final_snapshot.wait_for { ready? }
+      @instance_with_final_snapshot.destroy(final_snapshot_id)
+      returns(true, "Final snapshot created") do
+        @final_snapshot = AWS[:rds].snapshots.get(final_snapshot_id)
+        !@final_snapshot.nil?
+      end
+
+      @final_snapshot.wait_for { ready? }
+      @final_snapshot.destroy
+    end
+
+  end
+end

tests/aws/models/rds/servers_tests.rb

@@ -0,0 +1,8 @@
+Shindo.tests("AWS::RDS | servers", ['aws', 'rds']) do
+
+  pending if Fog.mocking?
+
+  collection_tests(AWS[:rds].servers, rds_default_server_params, false) do
+    @instance.wait_for { ready? }
+  end
+end

tests/aws/models/rds/snapshot_tests.rb

@@ -0,0 +1,15 @@
+Shindo.tests("AWS::RDS | snapshot", ['aws', 'rds']) do
+
+  pending if Fog.mocking?
+
+  @server = AWS[:rds].servers.create(rds_default_server_params)
+  @server.wait_for { ready? }
+
+  params = {:id => uniq_id, :instance_id => @server.id}
+  model_tests(AWS[:rds].snapshots, params, false) do
+    @instance.wait_for { ready? }
+  end
+
+  @server.destroy
+end
+

tests/aws/models/rds/snapshots_tests.rb

@@ -0,0 +1,15 @@
+Shindo.tests("AWS::RDS | snapshots", ['aws', 'rds']) do
+
+  pending if Fog.mocking?
+
+  @server = AWS[:rds].servers.create(rds_default_server_params)
+  @server.wait_for { ready? }
+
+  params = {:id => uniq_id, :instance_id => @server.id}
+  collection_tests(AWS[:rds].snapshots, params, false) do
+    @instance.wait_for { ready? }
+  end
+
+  @server.destroy
+end
+

tests/aws/requests/rds/model_tests.rb

@@ -1,98 +0,0 @@
-Shindo.tests('AWS::RDS | models', ['aws', 'rds']) do
-  @db_instance_id='fog-test'
-  @db_replica_id='fog-replica'
-
-  tests('success') do
-    pending if Fog.mocking?
-    
-    tests('parametergroups') do
-      group = nil
-
-      tests('create') do
-        group = AWS[:rds].parameter_groups.create :id => 'testgroup', :family => 'mysql5.1', :description => 'test'
-      end
-
-      tests('#parameters') do
-        parameters = group.parameters
-        #search for a sample parameter
-        tests 'contains parameter' do
-          returns(true){ !!parameters.detect {|p| p.name == 'query_cache_size'}}
-        end
-      end
-      
-      tests('modify') do
-        group.modify([{:name => 'query_cache_size', :value => '6553600', :apply_method => 'immediate'}])
-
-        tests 'parameter has changed' do
-          returns('6553600'){group.parameters.detect {|p| p.name == 'query_cache_size'}.value}
-        end
-      end
-      
-      tests('destroy').succeeds do
-        group.destroy
-      end
-
-      returns(nil){AWS[:rds].parameter_groups.detect {|g| g.id == 'testgroup'}}      
-    end
-    
-    tests('servers') do
-      server = nil
-      tests('create').succeeds do
-        server = AWS[:rds].servers.create( :id => @db_instance_id, :allocated_storage => 5, :engine => 'mysql',
-                                                        :master_username => 'foguser', :password => 'fogpassword',
-                                                        :backup_retention_period => 0)
-      end
-    
-      server.wait_for {ready?}
-    
-      tests('snapshots') do
-        snapshot = nil
-      
-        tests('create').succeeds do
-          snapshot = server.snapshots.create(:id => 'testsnapshot')
-        end
-      
-        returns(@db_instance_id){snapshot.instance_id}
-        server.reload
-        server.wait_for {ready?}
-        snapshot.wait_for {ready?}
-        tests('all') do
-          returns(['testsnapshot']){server.snapshots.collect {|s| s.id}}
-        end
-      
-        tests('destroy').succeeds do
-          snapshot.destroy
-        end
-      
-        returns([]) {server.snapshots}
-      end
-    
-      group = AWS[:rds].parameter_groups.create :id => 'some-group', :family => 'mysql5.1', :description => 'test'
-      tests('modify') do
-        server.modify(true, 'DBParameterGroupName' => 'some-group')
-        server.reload
-        returns('some-group'){server.db_parameter_groups.first['DBParameterGroupName']}
-      end
-      
-      tests('reboot').succeeds do
-        server.reboot
-      end
-      server.wait_for {state == 'rebooting'}
-      server.wait_for {state == 'available'}
-        
-      tests('destroy').succeeds do
-        server.destroy('finalsnapshot')      
-      end
-      
-      Fog.wait_for do
-        AWS[:rds].servers.length == 0
-      end
-      
-      group.destroy
-
-      tests("final snapshot was created") do
-        AWS[:rds].snapshots.get('finalsnapshot').destroy
-      end
-    end
-  end
-end

tests/helpers/collection_helper.rb

@@ -38,7 +38,7 @@ def collection_tests(collection, params = {}, mocks_implemented = true)
   tests('failure') do
 
     if !Fog.mocking? || mocks_implemented
-      @identity = @identity.to_s.gsub(/\w/, '0')
+      @identity = @identity.to_s.gsub(/\w/, 'a')
     end
 
     tests("#get('#{@identity}')").returns(nil) do

tests/helpers/model_helper.rb

@@ -24,3 +24,15 @@ def model_tests(collection, params = {}, mocks_implemented = true)
   end
 
 end
+
+# Generates a unique identifier with a random differentiator.
+# Useful when rapidly re-running tests, so we don't have to wait
+# serveral minutes for deleted objects to disappear from the API
+# E.g. 'fog-test-1234'
+def uniq_id(base_name = 'fog-test')
+  # random_differentiator
+  suffix = rand(65536).to_s(16).rjust(4, '0')
+  [base_name, suffix] * '-'
+end
+
+