fog 1.1.2 → 1.2.0

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

@@ -0,0 +1,56 @@
+Shindo.tests("Storage[:aws] | files", [:aws]) do
+
+  file_attributes = {
+      :key => 'fog_file_tests',
+      :body => lorem_file,
+      :public => true
+  }
+
+  directory_attributes = {
+      :key => 'fogfilestests'
+  }
+
+  @directory = Fog::Storage[:aws].directories.create(directory_attributes)
+  @directory.versioning = true
+
+  model_tests(@directory.files, file_attributes, Fog.mocking?) do
+
+    v1 = @instance.version
+    v2 = @directory.connection.put_object(@directory.key, @instance.key, 'version 2 content').headers['x-amz-version-id']
+    v3 = @directory.connection.delete_object(@directory.key, @instance.key).headers['x-amz-version-id']
+    v4 = @directory.connection.put_object(@directory.key, @instance.key, 'version 3 content').headers['x-amz-version-id']
+
+    tests("#get") do
+      tests("#get without version fetches the latest version").returns(v4) do
+        @directory.files.get(@instance.key).version
+      end
+
+      tests("#get with version fetches that exact version").returns(v2) do
+        @directory.files.get(@instance.key, 'versionId' => v2).version
+      end
+
+      tests("#get with a deleted version returns nil").returns(nil) do
+        @directory.files.get(@instance.key, 'versionId' => v3)
+      end
+    end
+
+    tests("#head") do
+      tests("#head without version fetches the latest version").returns(v4) do
+        @directory.files.head(@instance.key).version
+      end
+
+      tests("#head with version fetches that exact version").returns(v2) do
+        @directory.files.head(@instance.key, 'versionId' => v2).version
+      end
+
+      tests("#head with a deleted version returns nil").returns(nil) do
+        @directory.files.head(@instance.key, 'versionId' => v3)
+      end
+    end
+
+  end
+
+  @directory.versions.each(&:destroy)
+  @directory.destroy
+
+end

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

@@ -0,0 +1,52 @@
+Shindo.tests("Storage[:aws] | version", [:aws]) do
+
+  file_attributes = {
+      :key => 'fog_file_tests',
+      :body => lorem_file,
+      :public => true
+  }
+
+  directory_attributes = {
+      :key => 'fogfilestests'
+  }
+
+  @directory = Fog::Storage[:aws].directories.create(directory_attributes)
+  @directory.versioning = true
+
+  model_tests(@directory.files, file_attributes, Fog.mocking?) do
+
+    @version_instance = @instance.versions.first
+    @directory.connection.put_object(@directory.key, @instance.key, 'second version content')
+
+    tests("#file") do
+      tests("#file should return the object associated with the version").returns(@version_instance.version) do
+        @version_instance.file.version
+      end
+    end
+
+    tests("#delete_marker") do
+      tests("#delete_marker should be false if the version isn't a DeleteMarker'").returns(false) do
+        @version_instance.delete_marker
+      end
+
+      tests("#delete_marker should be true if the version is a DeleteMarker'").returns(true) do
+        @instance.destroy
+
+        @instance.versions.all.first.delete_marker
+      end
+    end
+
+    tests("#destroy") do
+      tests("#destroy removes the specific version").returns(false) do
+        @version_instance.destroy
+
+        @instance.versions.all.collect(&:version).include?(@version_instance.version)
+      end
+    end
+
+  end
+
+  @directory.versions.each(&:destroy)
+  @directory.destroy
+
+end

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

@@ -0,0 +1,56 @@
+Shindo.tests("Storage[:aws] | versions", [:aws]) do
+
+  file_attributes = {
+      :key => 'fog_file_tests',
+      :body => lorem_file,
+      :public => true
+  }
+
+  directory_attributes = {
+      :key => 'fogfilestests'
+  }
+
+  model_tests(Fog::Storage[:aws].directories, directory_attributes, Fog.mocking?) do
+    @instance.versioning = true
+
+    versions = []
+    versions << @instance.connection.put_object(@instance.key, 'one', 'abcde').headers['x-amz-version-id']
+
+    puts versions.first
+
+    versions << @instance.connection.put_object(@instance.key, 'one', '32423').headers['x-amz-version-id']
+    versions << @instance.connection.delete_object(@instance.key, 'one').headers['x-amz-version-id']
+    versions.reverse!
+
+    puts versions.first
+
+    versions << @instance.connection.put_object(@instance.key, 'two', 'aoeu').headers['x-amz-version-id']
+
+    tests('#versions') do
+      tests('#versions.size includes versions (including DeleteMarkers) for all keys').returns(4) do
+        @instance.versions.all.size
+      end
+
+      tests('#versions returns the correct versions').returns(versions) do
+        @instance.versions.all.collect(&:version)
+      end
+    end
+
+    tests("#all") do
+      tests("#all for a directory returns all versions, regardless of key").returns(versions) do
+        @instance.versions.all.collect(&:version)
+      end
+
+      tests("#all for file returns only versions for that file").returns(1) do
+        @instance.files.get('two').versions.all.collect(&:version).size
+      end
+
+      tests("#all for file returns only versions for that file").returns(versions.last) do
+        @instance.files.get('two').versions.all.collect(&:version).first
+      end
+    end
+
+    @instance.versions.each(&:destroy)
+  end
+
+end

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

@@ -13,13 +13,13 @@ class AWS
       ACTIVITY = {
         'ActivityId' => String,
         'AutoScalingGroupName' => String,
-        'Cause' => String,
+        'Cause' => Fog::Nullable::String,
         'Description' => String,
         'EndTime' => Time,
         'Progress' => Integer,
         'StartTime' => Time,
         'StatusCode' => String,
-        'StatusMessage' => String
+        'StatusMessage' => Fog::Nullable::String
       }
 
       ALARM = {

data/tests/aws/requests/beanstalk/application_tests.rb

@@ -0,0 +1,140 @@
+Shindo.tests('AWS::ElasticBeanstalk | application_tests', ['aws', 'beanstalk']) do
+
+  def unique_name(prefix)
+    #get time (with 1/100th of sec accuracy)
+    #want unique domain name and if provider is fast, this can be called more than once per second
+    time = Time.now.to_i.to_s
+    prefix + time
+  end
+
+  unless Fog.mocking?
+    @beanstalk = Fog::AWS[:beanstalk]
+  end
+
+  @test_description = "A unique description."
+
+  @test_app_name = unique_name("fog-test-app-")
+
+  tests('success') do
+    pending if Fog.mocking?
+
+    @describe_applications_format = {
+        'DescribeApplicationsResult' => {
+            'Applications' => [
+                'ApplicationName' => String,
+                'ConfigurationTemplates' => [String],
+                'Description' => Fog::Nullable::String,
+                'DateCreated' => Time,
+                'DateUpdated' => Time,
+                'Versions' => [String]
+            ]},
+        'ResponseMetadata' => {'RequestId'=> String},
+    }
+
+    tests("#describe_applications format").formats(@describe_applications_format) do
+      result = @beanstalk.describe_applications.body
+    end
+
+    test("#create_application") {
+      response = @beanstalk.create_application({
+                                                   'ApplicationName' => @test_app_name,
+                                                   'Description' => @test_description
+                                               })
+
+      result = false
+      if response.status == 200
+
+        app_info = response.body['CreateApplicationResult']['Application']
+        if app_info
+          if app_info['ApplicationName'] == @test_app_name &&
+              app_info['Description'] == @test_description &&
+              app_info['ConfigurationTemplates'].empty? &&
+              app_info['Versions'].empty?
+            result = true
+          end
+        end
+      end
+
+      result
+    }
+
+    test("#describe_applications all") {
+      response = @beanstalk.describe_applications
+
+      result = false
+      if response.status == 200
+        apps = response.body['DescribeApplicationsResult']['Applications']
+        apps.each { |app_info|
+          if app_info
+            if app_info['ApplicationName'] == @test_app_name &&
+                app_info['Description'] == @test_description &&
+                app_info['ConfigurationTemplates'].empty? &&
+                app_info['Versions'].empty?
+              result = true
+            end
+          end
+        }
+      end
+
+      result
+    }
+
+    test("#create_application filter") {
+      # Test for a specific app
+      response = @beanstalk.describe_applications([@test_app_name])
+
+      result = false
+      if response.status == 200
+        apps = response.body['DescribeApplicationsResult']['Applications']
+        if apps && apps.length == 1
+          app_info = apps.first
+          if app_info['ApplicationName'] == @test_app_name &&
+              app_info['Description'] == @test_description &&
+              app_info['ConfigurationTemplates'].empty? &&
+              app_info['Versions'].empty?
+            result = true
+          end
+        end
+      end
+
+      result
+    }
+
+    test("#update_application description") {
+
+      @test_description = "A completely new description."
+
+      response = @beanstalk.update_application({
+                                                   'ApplicationName' => @test_app_name,
+                                                   'Description' => @test_description
+                                               })
+
+      result = false
+      if response.status == 200
+        app_info = response.body['UpdateApplicationResult']['Application']
+        if app_info
+          if app_info['ApplicationName'] == @test_app_name &&
+              app_info['Description'] == @test_description &&
+              app_info['ConfigurationTemplates'].empty? &&
+              app_info['Versions'].empty?
+            result = true
+          end
+        end
+      end
+
+      result
+    }
+
+    test("#delete_application") {
+      response = @beanstalk.delete_application(@test_app_name)
+
+      result = false
+      if response.status == 200
+          result = true
+      end
+
+      result
+    }
+
+  end
+end

data/tests/aws/requests/beanstalk/solution_stack_tests.rb

@@ -0,0 +1,22 @@
+Shindo.tests('AWS::ElasticBeanstalk | solution_stack_tests', ['aws', 'beanstalk']) do
+
+  tests('success') do
+    pending if Fog.mocking?
+
+    @solution_stack_result_format = {
+        'ListAvailableSolutionStacksResult' => {
+            'SolutionStackDetails' => [
+               'SolutionStackName' => String,
+              'PermittedFileTypes' => [String]
+            ],
+            'SolutionStacks' => [String]
+        },
+        'ResponseMetadata' => {'RequestId'=> String},
+    }
+    tests("#list_available_solution_stacks").formats(@solution_stack_result_format) do
+      Fog::AWS[:beanstalk].list_available_solution_stacks.body
+
+    end
+
+  end
+end

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

@@ -2,12 +2,14 @@ Shindo.tests('Fog::Compute[:aws] | address requests', ['aws']) do
 
   @addresses_format = {
     'addressesSet' => [{
-      'instanceId'  => NilClass,
-      'publicIp'    => String
+      'allocationId'  => Fog::Nullable::String,
+      'associationId' => Fog::Nullable::String,
+      'domain'        => String,
+      'instanceId'    => Fog::Nullable::String,
+      'publicIp'      => String
     }],
     'requestId' => String
   }
-
   @server = Fog::Compute[:aws].servers.create
   @server.wait_for { ready? }
   @ip_address = @server.public_ip_address
@@ -16,7 +18,7 @@ Shindo.tests('Fog::Compute[:aws] | address requests', ['aws']) do
 
     @public_ip = nil
 
-    tests('#allocate_address').formats({'publicIp' => String, 'requestId' => String}) do
+    tests('#allocate_address').formats({'domain' => String, 'publicIp' => String, 'requestId' => String}) do
       data = Fog::Compute[:aws].allocate_address.body
       @public_ip = data['publicIp']
       data
@@ -33,7 +35,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

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

@@ -131,12 +131,26 @@ Shindo.tests('Fog::Compute[:aws] | instance requests', ['aws']) do
                                 'code' => Integer,
                                 'name' => String
                               },
-                              'eventsSet' => [{
+                              'systemStatus' => {
+                                'status' => String,
+                                'details' => [{
+                                  'name' => String,
+                                  'status' => String
+                                }]
+                              },
+                              'instanceStatus' => {
+                                'status' => String,
+                                'details' => [{
+                                  'name' => String,
+                                  'status' => String
+                                }]
+                              },
+                              'event' => {
                                                 'code' => String,
                                                 'description' => String,
                                                 'notBefore' => Time,
                                                 'notAfter' => Time
-                                              }]
+                                              }
                             }]
 
   }

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

@@ -7,14 +7,15 @@ Shindo.tests('Fog::Compute[:aws] | security group requests', ['aws']) do
       'groupId'           => Fog::Nullable::String,
       'groupName'         => String,
       'ipPermissions'     => [{
-        'fromPort'    => Integer,
-        'groups'      => [{ 'groupName' => String, 'userId' => String }],
+        'fromPort'    => Fog::Nullable::Integer,
+        'groups'      => [{ 'groupName' => Fog::Nullable::String, 'userId' => String }],
         'ipProtocol'  => String,
         'ipRanges'    => [],
-        'toPort'      => Integer,
+        'toPort'      => Fog::Nullable::Integer,
       }],
       'ipPermissionsEgress' => [],
-      'ownerId'           => String
+      'ownerId'           => String,
+      'vpcId'             => Fog::Nullable::String
     }]
   }
 
@@ -30,6 +31,7 @@ Shindo.tests('Fog::Compute[:aws] | security group requests', ['aws']) do
       Fog::Compute[:aws].create_security_group('fog_security_group_two', 'tests group').body
     end
 
+    group_id = Fog::Compute[:aws].describe_security_groups('group-name' => 'fog_security_group').body['securityGroupInfo'].first['groupId']
     to_be_revoked = []
     expected_permissions = []
 
@@ -62,6 +64,10 @@ Shindo.tests('Fog::Compute[:aws] | security group requests', ['aws']) do
       array_differences(expected_permissions, Fog::Compute[:aws].describe_security_groups('group-name' => 'fog_security_group').body['securityGroupInfo'].first['ipPermissions'])
     end
 
+    tests("#describe_security_groups('group-id' => '#{group_id}')").returns([]) do
+      array_differences(expected_permissions, Fog::Compute[:aws].describe_security_groups('group-id' => group_id).body['securityGroupInfo'].first['ipPermissions'])
+    end
+
     permission = { 'SourceSecurityGroupName' => 'fog_security_group_two', 'SourceSecurityGroupOwnerId' => @owner_id }
     tests("#authorize_security_group_ingress('fog_security_group', #{permission.inspect})").formats(AWS::Compute::Formats::BASIC) do
       Fog::Compute[:aws].authorize_security_group_ingress('fog_security_group', permission).body
@@ -255,6 +261,56 @@ Shindo.tests('Fog::Compute[:aws] | security group requests', ['aws']) do
       Fog::Compute[:aws].delete_security_group('fog_security_group_two').body
     end
 
+    vpc_id = Fog::Compute[:aws].create_vpc('10.255.254.64/28').body['vpcSet'].first['vpcId']
+
+    # Create security group in VPC
+    tests("#create_security_group('vpc_security_group', 'tests group')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].create_security_group('vpc_security_group', 'tests group', vpc_id).body
+    end
+
+    group_id = Fog::Compute[:aws].describe_security_groups('group-name' => 'vpc_security_group').body['securityGroupInfo'].first['groupId']
+    
+    # Access group with name in options array
+    permission = { 'IpProtocol' => '42', 'FromPort' => '22', 'ToPort' => '22', 'CidrIp' => '10.0.0.0/8' }
+    expected_permissions = [
+      {"groups"=>[],
+        "ipRanges"=>[{"cidrIp"=>"10.0.0.0/8"}],
+        "ipProtocol"=>"42",
+        "fromPort"=>22,
+        "toPort"=>22}
+    ]
+
+    options = permission.clone
+    options['GroupName'] = 'vpc_security_group'
+    tests("#authorize_security_group_ingress(#{options.inspect})").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].authorize_security_group_ingress(options).body
+    end
+
+    tests("#describe_security_groups('group-name' => 'vpc_security_group')").returns([]) do
+      array_differences(expected_permissions, Fog::Compute[:aws].describe_security_groups('group-name' => 'vpc_security_group').body['securityGroupInfo'].first['ipPermissions'])
+    end
+
+    tests("#revoke_security_group_ingress(#{options.inspect})").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].revoke_security_group_ingress(options).body
+    end
+
+    # Access group with id in options array
+    options = permission.clone
+    options['GroupId'] = group_id
+    tests("#authorize_security_group_ingress(#{options.inspect})").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].authorize_security_group_ingress(options).body
+    end
+
+    tests("#describe_security_groups('group-name' => 'vpc_security_group')").returns([]) do
+      array_differences(expected_permissions, Fog::Compute[:aws].describe_security_groups('group-name' => 'vpc_security_group').body['securityGroupInfo'].first['ipPermissions'])
+    end
+
+    tests("#revoke_security_group_ingress(#{options.inspect})").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].revoke_security_group_ingress(options).body
+    end
+
+    Fog::Compute[:aws].delete_vpc(vpc_id)
+
   end
   tests('failure') do
 
@@ -357,6 +413,23 @@ Shindo.tests('Fog::Compute[:aws] | security group requests', ['aws']) do
     tests("#delete_security_group('default')").raises(Fog::Compute::AWS::Error) do
       Fog::Compute[:aws].delete_security_group('default')
     end
+
+    broken_params = [
+                     [ 'fog_security_group', { 'GroupName' => 'fog_security_group'}],
+                     [ 'fog_security_group', { 'GroupId' => 'sg-11223344'}],
+                     [ { 'GroupName' => 'fog_security_group', 'GroupId' => 'sg-11223344'}, nil]
+                    ]
+
+    broken_params.each do |list_elem|
+      tests("#authorize_security_group_ingress(#{list_elem[0].inspect}, #{list_elem[1].inspect})").raises(Fog::Compute::AWS::Error) do
+        Fog::Compute[:aws].authorize_security_group_ingress(list_elem[0], list_elem[1])
+      end
+
+      tests("#revoke_security_group_ingress(#{list_elem[0].inspect}, #{list_elem[1].inspect})").raises(Fog::Compute::AWS::Error) do
+        Fog::Compute[:aws].revoke_security_group_ingress(list_elem[0], list_elem[1])
+      end
+    end
+
   end
 
 end