fog 0.6.0 → 0.7.0

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

@@ -0,0 +1,98 @@
+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

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

@@ -0,0 +1,68 @@
+Shindo.tests('AWS::RDS | parameter group requests', ['aws', 'rds']) do
+  tests('success') do
+    pending if Fog.mocking?
+
+    tests("#create_db_parameter_groups").formats(AWS::RDS::Formats::CREATE_DB_PARAMETER_GROUP) do
+      pending if Fog.mocking?
+      body = AWS[:rds].create_db_parameter_group('fog-group', 'MySQL5.1', 'Some description').body
+
+      returns( 'mysql5.1') { body['CreateDBParameterGroupResult']['DBParameterGroup']['DBParameterGroupFamily']}
+      returns( 'fog-group') { body['CreateDBParameterGroupResult']['DBParameterGroup']['DBParameterGroupName']}
+      returns( 'Some description') { body['CreateDBParameterGroupResult']['DBParameterGroup']['Description']}
+      
+      body
+    end
+    
+    AWS[:rds].create_db_parameter_group('other-fog-group', 'MySQL5.1', 'Some description')
+
+    tests("#describe_db_parameter_groups").formats(AWS::RDS::Formats::DESCRIBE_DB_PARAMETER_GROUP) do
+      pending if Fog.mocking?
+
+      body = AWS[:rds].describe_db_parameter_groups().body
+      
+      returns(3) {body['DescribeDBParameterGroupsResult']['DBParameterGroups'].length}      
+      body
+    end
+
+    tests("#describe_db_parameter_groups('fog-group)").formats(AWS::RDS::Formats::DESCRIBE_DB_PARAMETER_GROUP) do
+      pending if Fog.mocking?
+
+      body = AWS[:rds].describe_db_parameter_groups('fog-group').body
+      
+      returns(1) {body['DescribeDBParameterGroupsResult']['DBParameterGroups'].length}      
+      
+      group = body['DescribeDBParameterGroupsResult']['DBParameterGroups'].first
+      returns( 'mysql5.1') { group['DBParameterGroupFamily']}
+      returns( 'fog-group') { group['DBParameterGroupName']}
+      returns( 'Some description') { group['Description']}
+
+      body
+    end
+    
+    tests("delete_db_parameter_group").formats(AWS::RDS::Formats::BASIC) do
+      pending if Fog.mocking?
+      body = AWS[:rds].delete_db_parameter_group('fog-group').body
+      
+      raises(Fog::AWS::RDS::NotFound) {AWS[:rds].describe_db_parameter_groups('fog-group')}      
+
+      body
+    end
+
+    AWS[:rds].delete_db_parameter_group('other-fog-group')
+  end
+
+  tests("failures") do
+    pending if Fog.mocking?
+    raises(Fog::AWS::RDS::NotFound) {AWS[:rds].describe_db_parameter_groups('doesntexist')}      
+    raises(Fog::AWS::RDS::NotFound) {AWS[:rds].delete_db_parameter_group('doesntexist')}      
+
+    tests "creating second group with same id" do
+      AWS[:rds].create_db_parameter_group('fog-group', 'MySQL5.1', 'Some description')
+      raises(Fog::AWS::RDS::IdentifierTaken) {AWS[:rds].create_db_parameter_group('fog-group', 'MySQL5.1', 'Some description')}      
+    end
+    
+    AWS[:rds].delete_db_parameter_group('fog-group')
+  
+  end
+  
+end

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

@@ -0,0 +1,35 @@
+Shindo.tests('AWS::RDS | parameter requests', ['aws', 'rds']) do
+  tests('success') do
+    pending if Fog.mocking?
+    
+    AWS[:rds].create_db_parameter_group('fog-group', 'MySQL5.1', 'Some description')
+    
+    tests('#modify_db_parameter_group').formats(AWS::RDS::Formats::MODIFY_PARAMETER_GROUP) do
+      body = AWS[:rds].modify_db_parameter_group('fog-group',[
+        {'ParameterName' => 'query_cache_size',
+        'ParameterValue' => '12345',
+        'ApplyMethod' => 'immediate'} 
+      ]).body
+      
+      body
+    end
+    
+    tests('#describe_db_parameters').formats(AWS::RDS::Formats::DESCRIBE_DB_PARAMETERS) do
+      AWS[:rds].describe_db_parameters('fog-group', :max_records => 20).body
+    end
+
+
+    tests("#describe_db_parameters :source => 'user'")do
+      body = AWS[:rds].describe_db_parameters('fog-group', :source => 'user').body
+      returns(1){ body['DescribeDBParametersResult']['Parameters'].length}
+      
+      param = body['DescribeDBParametersResult']['Parameters'].first
+      returns('query_cache_size'){param['ParameterName']}
+      returns('12345'){param['ParameterValue']}
+      returns(true){param['IsModifiable']}
+      returns('query_cache_size'){param['ParameterName']}
+    end
+    AWS[:rds].delete_db_parameter_group('fog-group')
+    
+  end
+end

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

@@ -0,0 +1,47 @@
+Shindo.tests("AWS::Compute::Server | monitor", ['aws']) do
+
+  config = compute_providers[AWS]
+
+  if !Fog.mocking? || config[:mocked]
+    @instance = AWS[:compute].servers.new(config[:server_attributes])
+  end
+
+  tests('new instance') do
+
+    test('monitor') do
+      @instance.monitoring = true
+      @instance.attributes[:monitoring] == true
+    end
+
+    test('unmonitor') do
+      @instance.monitoring = false
+      @instance.attributes[:monitoring] == false
+    end
+
+  end
+
+  tests('existing instance') do
+
+    @instance.save
+
+    test('monitor') do
+      #what I'd really like to test is if connection.monitor_instances is being called
+      #this is a safeguard
+      @instance.identity != nil
+      @instance.monitoring = false
+      @instance.monitor = true
+      @instance.monitoring == true
+    end
+
+    test('unmonitor') do
+      #what I'd really like to test is if connection.monitor_instances is being called
+      #this is a safeguard
+      @instance.identity != nil
+      @instance.monitoring = true
+      @instance.monitor = false
+      @instance.monitoring == false
+    end
+
+  end
+
+end

data/tests/compute/models/server_tests.rb

@@ -4,29 +4,13 @@ for provider, config in compute_providers
 
     server_tests(provider[:compute], (config[:server_attributes] || {}), config[:mocked]) do
 
-      tests('responds_to(:bootstrap)') do
-        pending if Fog.mocking? && !config[:mocked]
-        @instance.responds_to(:bootstrap)
-      end
-
-      tests('responds_to(:private_ip_address)') do
-        pending if Fog.mocking? && !config[:mocked]
-        @instance.responds_to(:public_ip_address)
-      end
-
-      tests('responds_to(:public_ip_address)') do
-        pending if Fog.mocking? && !config[:mocked]
-        @instance.responds_to(:public_ip_address)
-      end
-
-      tests('responds_to(:scp)') do
-        pending if Fog.mocking? && !config[:mocked]
-        @instance.responds_to(:ssh)
-      end
-
-      tests('responds_to(:ssh)') do
-        pending if Fog.mocking? && !config[:mocked]
-        @instance.responds_to(:ssh)
+      if Fog.mocking? && !config[:mocked]
+        pending
+      else
+        responds_to(:boostrap)
+        responds_to(:public_ip_address)
+        responds_to(:scp)
+        responds_to(:ssh)
       end
 
     end

data/tests/compute/parsers/aws/monitor_unmonitor_instances_tests.rb

@@ -0,0 +1,49 @@
+require 'fog/compute/parsers/aws/monitor_unmonitor_instances'
+
+Shindo.tests('AWS::Compute::MonitorUnmonitorInstances | monitor/unmonitor parser') do
+
+  tests('success') do
+
+    tests('#parse') do
+
+      aws_result = <<-AWS
+        <UnmonitorInstancesResponse xmlns="http://ec2.amazonaws.com/doc/2010-11-15/">
+           <requestId>59dbff89-35bd-4eac-99ed-be587EXAMPLE</requestId>
+           <instancesSet>
+              <item>
+                 <instanceId>i-43a4412a</instanceId>
+                 <monitoring>
+                    <state>enabled</state>
+                 </monitoring>
+              </item>
+              <item>
+                 <instanceId>i-23a3397d</instanceId>
+                 <monitoring>
+                    <state>disabled</state>
+                 </monitoring>
+              </item>
+           </instancesSet>
+        </UnmonitorInstancesResponse>
+      AWS
+
+      parser = Fog::Parsers::AWS::Compute::MonitorUnmonitorInstances.new
+      body = Nokogiri::XML::SAX::PushParser.new(parser)
+      body << aws_result
+
+      test('requestId') { parser.response['requestId'] == '59dbff89-35bd-4eac-99ed-be587EXAMPLE' }
+
+      test('enabled') do
+        selected = parser.response['instancesSet'].select { |item| item['instanceId'] == 'i-43a4412a' }[0]
+        selected['monitoring'] == 'enabled'
+      end
+
+      test('disabled') do
+        selected = parser.response['instancesSet'].select { |item| item['instanceId'] == 'i-23a3397d' }[0]
+        selected['monitoring'] == 'disabled'
+      end
+      
+    end
+
+  end
+
+end

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

@@ -24,21 +24,25 @@ Shindo.tests('AWS::Compute | security group requests', ['aws']) do
       AWS[:compute].create_security_group('fog_security_group', 'tests group').body
     end
 
-    tests("#authorize_security_group_ingress({'FromPort' => 80, 'GroupName' => 'fog_security_group', 'IpProtocol' => 'tcp', 'toPort' => 80})").formats(AWS::Compute::Formats::BASIC) do
-      AWS[:compute].authorize_security_group_ingress({
-        'FromPort' => 80,
-        'GroupName' => 'fog_security_group',
-        'IpProtocol' => 'tcp',
-        'ToPort' => 80,
-      }).body
+    tests("#authorize_security_group_ingress('fog_security_group', {'FromPort' => 80, 'IpProtocol' => 'tcp', 'toPort' => 80})").formats(AWS::Compute::Formats::BASIC) do
+      AWS[:compute].authorize_security_group_ingress(
+        'fog_security_group',
+        {
+          'FromPort' => 80,
+          'IpProtocol' => 'tcp',
+          'ToPort' => 80,
+        }
+      ).body
     end
 
-    tests("#authorize_security_group_ingress({'GroupName' => 'fog_security_group', 'SourceSecurityGroupName' => 'fog_security_group', 'SourceSecurityGroupOwnerId' => '#{@owner_id}'})").formats(AWS::Compute::Formats::BASIC) do
-      AWS[:compute].authorize_security_group_ingress({
-        'GroupName'                   => 'fog_security_group',
-        'SourceSecurityGroupName'     => 'fog_security_group',
-        'SourceSecurityGroupOwnerId'  => @owner_id
-      }).body
+    tests("#authorize_security_group_ingress('fog_security_group', {'SourceSecurityGroupName' => 'fog_security_group', 'SourceSecurityGroupOwnerId' => '#{@owner_id}'})").formats(AWS::Compute::Formats::BASIC) do
+      AWS[:compute].authorize_security_group_ingress(
+        'fog_security_group',
+        {
+          'SourceSecurityGroupName'     => 'fog_security_group',
+          'SourceSecurityGroupOwnerId'  => @owner_id
+        }
+      ).body
     end
 
     tests("#describe_security_groups").formats(@security_groups_format) do
@@ -49,21 +53,26 @@ Shindo.tests('AWS::Compute | security group requests', ['aws']) do
       AWS[:compute].describe_security_groups('group-name' => 'fog_security_group').body
     end
 
-    tests("#revoke_security_group_ingress({'FromPort' => 80, 'GroupName' => 'fog_security_group', 'IpProtocol' => 'tcp', 'toPort' => 80})").formats(AWS::Compute::Formats::BASIC) do
-      AWS[:compute].revoke_security_group_ingress({
-        'FromPort' => 80,
-        'GroupName' => 'fog_security_group',
-        'IpProtocol' => 'tcp',
-        'ToPort' => 80,
-      }).body
+    tests("#revoke_security_group_ingress('fog_security_group', {'FromPort' => 80, 'IpProtocol' => 'tcp', 'toPort' => 80})").formats(AWS::Compute::Formats::BASIC) do
+      AWS[:compute].revoke_security_group_ingress(
+        'fog_security_group',
+        {
+          'FromPort' => 80,
+          'IpProtocol' => 'tcp',
+          'ToPort' => 80,
+        }
+      ).body
     end
 
-    tests("#revoke_security_group_ingress({'GroupName' => 'fog_security_group', 'SourceSecurityGroupName' => 'fog_security_group', 'SourceSecurityGroupOwnerId' => '#{@owner_id}'})").formats(AWS::Compute::Formats::BASIC) do
-      AWS[:compute].revoke_security_group_ingress({
-        'GroupName'                   => 'fog_security_group',
-        'SourceSecurityGroupName'     => 'fog_security_group',
-        'SourceSecurityGroupOwnerId'  => @owner_id
-      }).body
+    tests("#revoke_security_group_ingress('fog_security_group', {'SourceSecurityGroupName' => 'fog_security_group', 'SourceSecurityGroupOwnerId' => '#{@owner_id}'})").formats(AWS::Compute::Formats::BASIC) do
+      AWS[:compute].revoke_security_group_ingress(
+      'fog_security_group',
+        {
+          'GroupName'                   => 'fog_security_group',
+          'SourceSecurityGroupName'     => 'fog_security_group',
+          'SourceSecurityGroupOwnerId'  => @owner_id
+        }
+      ).body
     end
 
     tests("#delete_security_group('fog_security_group')").formats(AWS::Compute::Formats::BASIC) do
@@ -79,38 +88,46 @@ Shindo.tests('AWS::Compute | security group requests', ['aws']) do
       AWS[:compute].create_security_group(@security_group.name, @security_group.description)
     end
 
-    tests("#authorize_security_group_ingress({'FromPort' => 80, 'GroupName' => 'not_a_group_name', 'IpProtocol' => 'tcp', 'toPort' => 80})").raises(Fog::AWS::Compute::NotFound) do
-      AWS[:compute].authorize_security_group_ingress({
-        'FromPort' => 80,
-        'GroupName' => 'not_a_group_name',
-        'IpProtocol' => 'tcp',
-        'ToPort' => 80,
-      })
+    tests("#authorize_security_group_ingress('not_a_group_name', {'FromPort' => 80, 'IpProtocol' => 'tcp', 'toPort' => 80})").raises(Fog::AWS::Compute::NotFound) do
+      AWS[:compute].authorize_security_group_ingress(
+        'not_a_group_name',
+        {
+          'FromPort' => 80,
+          'IpProtocol' => 'tcp',
+          'ToPort' => 80,
+        }
+      )
     end
 
-    tests("#authorize_security_group_ingress({'GroupName' => 'not_a_group_name', 'SourceSecurityGroupName' => 'not_a_group_name', 'SourceSecurityGroupOwnerId' => '#{@owner_id}'})").raises(Fog::AWS::Compute::NotFound) do
-      AWS[:compute].authorize_security_group_ingress({
-        'GroupName'                   => 'not_a_group_name',
-        'SourceSecurityGroupName'     => 'not_a_group_name',
-        'SourceSecurityGroupOwnerId'  => @owner_id
-      })
+    tests("#authorize_security_group_ingress('not_a_group_name', {'SourceSecurityGroupName' => 'not_a_group_name', 'SourceSecurityGroupOwnerId' => '#{@owner_id}'})").raises(Fog::AWS::Compute::NotFound) do
+      AWS[:compute].authorize_security_group_ingress(
+        'not_a_group_name',
+        {
+          'SourceSecurityGroupName'     => 'not_a_group_name',
+          'SourceSecurityGroupOwnerId'  => @owner_id
+        }
+      )
     end
 
-    tests("#revoke_security_group_ingress({'FromPort' => 80, 'GroupName' => 'not_a_group_name', 'IpProtocol' => 'tcp', 'toPort' => 80})").raises(Fog::AWS::Compute::NotFound) do
-      AWS[:compute].revoke_security_group_ingress({
-        'FromPort' => 80,
-        'GroupName' => 'not_a_group_name',
-        'IpProtocol' => 'tcp',
-        'ToPort' => 80,
-      })
+    tests("#revoke_security_group_ingress('not_a_group_name', {'FromPort' => 80, 'IpProtocol' => 'tcp', 'toPort' => 80})").raises(Fog::AWS::Compute::NotFound) do
+      AWS[:compute].revoke_security_group_ingress(
+        'not_a_group_name',
+        {
+          'FromPort' => 80,
+          'IpProtocol' => 'tcp',
+          'ToPort' => 80,
+        }
+      )
     end
 
-    tests("#revoke_security_group_ingress({'GroupName' => 'not_a_group_name', 'SourceSecurityGroupName' => 'not_a_group_name', 'SourceSecurityGroupOwnerId' => '#{@owner_id}'})").raises(Fog::AWS::Compute::NotFound) do
-      AWS[:compute].revoke_security_group_ingress({
-        'GroupName'                   => 'not_a_group_name',
-        'SourceSecurityGroupName'     => 'not_a_group_name',
-        'SourceSecurityGroupOwnerId'  => @owner_id
-      })
+    tests("#revoke_security_group_ingress('not_a_group_name', {'SourceSecurityGroupName' => 'not_a_group_name', 'SourceSecurityGroupOwnerId' => '#{@owner_id}'})").raises(Fog::AWS::Compute::NotFound) do
+      AWS[:compute].revoke_security_group_ingress(
+        'not_a_group_name',
+        {
+          'SourceSecurityGroupName'     => 'not_a_group_name',
+          'SourceSecurityGroupOwnerId'  => @owner_id
+        }
+      )
     end
 
     tests("#delete_security_group('not_a_group_name')").raises(Fog::AWS::Compute::NotFound) do