fog 1.1.2 → 1.2.0

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

@@ -0,0 +1,61 @@
+Shindo.tests("Fog::AWS[:beanstalk] | versions", ['aws', 'beanstalk']) do
+
+  pending if Fog.mocking?
+
+  @beanstalk = Fog::AWS[:beanstalk]
+
+  @application_name = uniq_id('fog-test-app')
+  @version_name = uniq_id('fog-test-version')
+
+  @version_description = 'A nice description'
+
+  @application = @beanstalk.applications.create({:name => @application_name})
+
+  params = {
+      :application_name => @application_name,
+      :label => @version_name,
+      :description => @version_description
+  }
+
+  collection = @beanstalk.versions
+
+  tests('success') do
+
+    tests("#new(#{params.inspect})").succeeds do
+      pending if Fog.mocking?
+      collection.new(params)
+    end
+
+    tests("#create(#{params.inspect})").succeeds do
+      pending if Fog.mocking?
+      @instance = collection.create(params)
+    end
+
+    tests("#all").succeeds do
+      pending if Fog.mocking?
+      collection.all
+    end
+
+    tests("#get(#{@application_name}, #{@version_name})").succeeds do
+      pending if Fog.mocking?
+      collection.get(@application_name, @version_name)
+    end
+
+    if !Fog.mocking?
+      @instance.destroy
+    end
+  end
+
+  tests('failure') do
+
+    tests("#get(#{@application_name}, #{@version_name})").returns(nil) do
+      pending if Fog.mocking?
+      collection.get(@application_name, @version_name)
+    end
+
+  end
+
+
+  # delete application
+  @application.destroy
+end

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

@@ -0,0 +1,5 @@
+Shindo.tests("Fog::Compute[:aws] | subnet", ['aws']) do
+  @vpc=Fog::Compute[:aws].vpcs.create('cidr_block' => '10.0.10.0/24')
+  model_tests(Fog::Compute[:aws].subnets, {:vpc_id => @vpc.id, :cidr_block => '10.0.10.0/28'}, true)
+  @vpc.destroy
+end

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

@@ -0,0 +1,6 @@
+Shindo.tests("Fog::Compute[:aws] | subnets", ['aws']) do
+  @vpc=Fog::Compute[:aws].vpcs.create('cidr_block' => '10.0.10.0/28')
+  collection_tests(Fog::Compute[:aws].subnets, { :vpc_id => @vpc.id, :cidr_block => '10.0.10.0/28'}, true)
+  @vpc.destroy
+end
+

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

@@ -0,0 +1,4 @@
+Shindo.tests("Fog::Compute[:aws] | vpc", ['aws']) do
+
+  model_tests(Fog::Compute[:aws].vpcs, {:cidr_block => '10.0.10.0/28'}, true)
+end

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

@@ -0,0 +1,6 @@
+Shindo.tests("Fog::Compute[:aws] | vpcs", ['aws']) do
+
+  collection_tests(Fog::Compute[:aws].vpcs, {:cidr_block => '10.0.10.0/28'}, true)
+
+end
+

data/tests/aws/models/dns/record_tests.rb

@@ -0,0 +1,23 @@
+Shindo.tests("Fog::Dns[:aws] | record", ['aws', 'dns']) do
+
+  pending if Fog.mocking?
+  tests("zones#create").succeeds do
+    @zone = Fog::DNS[:aws].zones.create(:domain => generate_unique_domain)
+  end
+
+  params = { :name => @zone.domain, :type => 'A', :ttl => 3600, :value => ['1.2.3.4'] }
+
+  model_tests(@zone.records, params, false) do
+    tests("#modify") do
+      new_value = ['5.5.5.5']
+      returns(true) { @instance.modify(:value => new_value) }
+      returns(new_value) { @instance.value }
+    end
+  end
+
+  tests("zones#destroy").succeeds do
+    @zone.destroy
+  end
+
+end
+

data/tests/aws/models/dns/records_tests.rb

@@ -0,0 +1,23 @@
+Shindo.tests("Fog::DNS[:aws] | records", ['aws', 'dns']) do
+
+  pending if Fog.mocking?
+  tests("zones#create").succeeds do
+    @zone = Fog::DNS[:aws].zones.create(:domain => generate_unique_domain)
+  end
+
+  param_groups = [
+    # A record
+    { :name => @zone.domain, :type => 'A', :ttl => 3600, :value => ['1.2.3.4'] },
+    # CNAME record
+    { :name => "www.#{@zone.domain}", :type => "CNAME", :ttl => 300, :value => @zone.domain}
+  ]
+
+  param_groups.each do |params|
+    collection_tests(@zone.records, params, false)
+  end
+
+  tests("zones#destroy").succeeds do
+    @zone.destroy
+  end
+end
+

data/tests/aws/models/dns/zone_tests.rb

@@ -0,0 +1,4 @@
+Shindo.tests("Fog::DNS[:aws] | zone", ['aws', 'dns']) do
+  params = {:domain => generate_unique_domain }
+  model_tests(Fog::DNS[:aws].zones, params, false)
+end

data/tests/aws/models/dns/zones_tests.rb

@@ -0,0 +1,4 @@
+Shindo.tests("Fog::DNS[:aws] | zones", ['aws', 'dns']) do
+  params = {:domain => generate_unique_domain }
+  collection_tests(Fog::DNS[:aws].zones, params, false)
+end

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

@@ -1,4 +1,5 @@
 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'
 
@@ -13,15 +14,17 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
       tests("default attributes") do
         listener = Fog::AWS[:elb].listeners.new
         tests('instance_port is 80').returns(80) { listener.instance_port }
+        tests('instance_protocol is HTTP').returns('HTTP') { listener.instance_protocol }
         tests('lb_port is 80').returns(80) { listener.lb_port }
         tests('protocol is HTTP').returns('HTTP') { listener.protocol }
         tests('policy_names is empty').returns([]) { listener.policy_names }
       end
 
       tests("specifying attributes") do
-        attributes = {:instance_port => 2000, :lb_port => 2001, :protocol => 'SSL', :policy_names => ['fake'] }
+        attributes = {:instance_port => 2000, :instance_protocol => 'SSL', :lb_port => 2001, :protocol => 'SSL', :policy_names => ['fake'] }
         listener = Fog::AWS[:elb].listeners.new(attributes)
         tests('instance_port is 2000').returns(2000) { listener.instance_port }
+        tests('instance_protocol is SSL').returns('SSL') { listener.instance_protocol }
         tests('lb_port is 2001').returns(2001) { listener.lb_port }
         tests('protocol is SSL').returns('SSL') { listener.protocol }
         tests('policy_names is [ fake ]').returns(['fake']) { listener.policy_names }
@@ -62,7 +65,7 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
             'PolicyNames' => []
           }, {
             'Listener' => {
-              'LoadBalancerPort' => 443, 'InstancePort' => 443, 'Protocol' => 'HTTPS',
+              'LoadBalancerPort' => 443, 'InstancePort' => 443, 'Protocol' => 'HTTPS', 'InstanceProtocol' => 'HTTPS',
               'SSLCertificateId' => @certificate['Arn']
             },
             'PolicyNames' => []
@@ -73,13 +76,14 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
         tests('lb_port is 2030').returns(2030) { elb3.listeners.first.lb_port }
         tests('protocol is HTTP').returns('HTTP') { elb3.listeners.first.protocol }
         tests('protocol is HTTPS').returns('HTTPS') { elb3.listeners.last.protocol }
+        tests('instance_protocol is HTTPS').returns('HTTPS') { elb3.listeners.last.instance_protocol }
         elb3.destroy
       end
 
       tests('with invalid Server Cert ARN').raises(Fog::AWS::IAM::NotFound) do
         listeners = [{
           'Listener' => {
-          'LoadBalancerPort' => 443, 'InstancePort' => 80, 'Protocol' => 'HTTPS', "SSLCertificateId" => "fakecert"}
+          'LoadBalancerPort' => 443, 'InstancePort' => 80, 'Protocol' => 'HTTPS', 'InstanceProtocol' => 'HTTPS', "SSLCertificateId" => "fakecert"}
         }]
         Fog::AWS[:elb].load_balancers.create(:id => "#{elb_id}-4", "ListenerDescriptions" => listeners, :availability_zones => @availability_zones)
       end
@@ -178,7 +182,7 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
         returns(1) { elb.listeners.size }
 
         listener = elb.listeners.first
-        returns([80,80,'HTTP', []]) { [listener.instance_port, listener.lb_port, listener.protocol, listener.policy_names] }
+        returns([80,80,'HTTP','HTTP', []]) { [listener.instance_port, listener.lb_port, listener.protocol, listener.instance_protocol, listener.policy_names] }
       end
 
       tests('#get') do
@@ -186,8 +190,8 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
       end
 
       tests('create') do
-        new_listener = { 'InstancePort' => 443, 'LoadBalancerPort' => 443, 'Protocol' => 'TCP'}
-        elb.listeners.create(:instance_port => 443, :lb_port => 443, :protocol => 'TCP')
+        new_listener = { 'InstancePort' => 443, 'LoadBalancerPort' => 443, 'Protocol' => 'TCP', 'InstanceProtocol' => 'TCP'}
+        elb.listeners.create(:instance_port => 443, :lb_port => 443, :protocol => 'TCP', :instance_protocol => 'TCP')
         returns(2) { elb.listeners.size }
         returns(443) { elb.listeners.get(443).lb_port }
       end
@@ -245,7 +249,7 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
     end
 
     tests('setting a new ssl certificate id') do
-      elb.listeners.create(:instance_port => 443, :lb_port => 443, :protocol => 'HTTPS', :ssl_id => @certificate['Arn'])
+      elb.listeners.create(:instance_port => 443, :lb_port => 443, :protocol => 'HTTPS', :instance_protocol => 'HTTPS', :ssl_id => @certificate['Arn'])
       elb.set_listener_ssl_certificate(443, @certificate['Arn'])
     end
 

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

@@ -2,8 +2,7 @@ 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(Fog::AWS[:rds].security_groups, params, false) do
+  model_tests(Fog::AWS[:rds].security_groups, params) do
 
     tests("#description").returns('fog test') { @instance.description }
 
@@ -19,6 +18,8 @@ Shindo.tests("AWS::RDS | security_group", ['aws', 'rds']) do
     @instance.wait_for { ready? }
 
     tests("#revoke_ec2_security_group").succeeds do
+      pending if Fog.mocking?
+
       @instance.revoke_ec2_security_group(@ec2_sec_group.name)
 
       returns('revoking') do
@@ -37,8 +38,10 @@ Shindo.tests("AWS::RDS | security_group", ['aws', 'rds']) do
       returns('authorizing') { @instance.ip_ranges.detect{|h| h['CIDRIP'] == @cidr}['Status'] }
     end
 
-    @instance.wait_for { ready? }
     tests("#revoke_cidrip").succeeds do
+      pending if Fog.mocking?
+
+      @instance.wait_for { ready? }
       @instance.revoke_cidrip(@cidr)
       returns('revoking') { @instance.ip_ranges.detect{|h| h['CIDRIP'] == @cidr}['Status'] }
       @instance.wait_for { ready? }

data/tests/aws/models/rds/security_groups_tests.rb

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

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

@@ -1,8 +1,6 @@
 Shindo.tests("AWS::RDS | server", ['aws', 'rds']) do
 
-  pending if Fog.mocking?
-
-  model_tests(Fog::AWS[:rds].servers, rds_default_server_params, false) do
+  model_tests(Fog::AWS[:rds].servers, rds_default_server_params) do
     # We'll need this later; create it early to avoid waiting
     @instance_with_final_snapshot = Fog::AWS[:rds].servers.create(rds_default_server_params.merge(:id => uniq_id("fog-snapshot-test"), :backup_retention_period => 1))
 
@@ -25,6 +23,8 @@ Shindo.tests("AWS::RDS | server", ['aws', 'rds']) do
     end
 
     tests("#modify").succeeds do
+      pending if Fog.mocking?
+
       orig_parameter_group = @instance.db_parameter_groups.first['DBParameterGroupName']
       parameter_group = Fog::AWS[:rds].parameter_groups.create(:id => uniq_id, :family => 'mysql5.1', :description => 'fog-test')
 
@@ -77,6 +77,8 @@ Shindo.tests("AWS::RDS | server", ['aws', 'rds']) do
     @instance.reload.wait_for { ready? }
 
     tests('#create_read_replica').succeeds do
+      pending if Fog.mocking?
+
       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 }

data/tests/aws/models/rds/servers_tests.rb

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

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

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

data/tests/aws/models/rds/snapshots_tests.rb

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

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

@@ -0,0 +1,51 @@
+Shindo.tests("Storage[:aws] | directory", [:aws]) do
+
+  directory_attributes = {
+    :key => 'fogdirectorytests'
+  }
+
+  model_tests(Fog::Storage[:aws].directories, directory_attributes, Fog.mocking?) do
+
+    tests("#versioning=") do
+      tests("#versioning=(true)").succeeds do
+        @instance.versioning = true
+      end
+
+      tests("#versioning=(true) sets versioning to 'Enabled'").returns('Enabled') do
+        @instance.versioning = true
+        @instance.connection.get_bucket_versioning(@instance.key).body['VersioningConfiguration']['Status']
+      end
+
+      tests("#versioning=(false)").succeeds do
+        @instance.versioning = false
+      end
+
+      tests("#versioning=(false) sets versioning to 'Suspended'").returns('Suspended') do
+        @instance.versioning = false
+        @instance.connection.get_bucket_versioning(@instance.key).body['VersioningConfiguration']['Status']
+      end
+    end
+
+  end
+
+  model_tests(Fog::Storage[:aws].directories, directory_attributes, Fog.mocking?) do
+
+    tests("#versioning?") do
+      tests("#versioning? false if not enabled").returns(false) do
+        @instance.versioning?
+      end
+
+      tests("#versioning? true if enabled").returns(true) do
+        @instance.connection.put_bucket_versioning(@instance.key, 'Enabled')
+        @instance.versioning?
+      end
+
+      tests("#versioning? false if suspended").returns(false) do
+        @instance.connection.put_bucket_versioning(@instance.key, 'Suspended')
+        @instance.versioning?
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,80 @@
+Shindo.tests("Storage[:aws] | file", [:aws]) do
+
+  require 'tempfile'
+
+  file_attributes = {
+    :key => 'fog_file_tests',
+    :body => lorem_file,
+    :public => true
+  }
+
+  directory_attributes = {
+    # Add a random suffix to prevent collision
+    :key => "fogfilestests-#{rand(65536)}"
+  }
+
+  @directory = Fog::Storage[:aws].directories.create(directory_attributes)
+
+  model_tests(@directory.files, file_attributes, Fog.mocking?) do
+
+    tests("#version") do
+      tests("#version should be null if versioning isn't enabled").returns(nil) do
+        @instance.version
+      end
+    end
+
+  end
+
+  @directory.versioning = true
+
+  model_tests(@directory.files, file_attributes, Fog.mocking?) do
+
+    tests("#version") do
+      tests("#version should not be null if versioning is enabled").returns(false) do
+        @instance.version == nil
+      end
+    end
+
+
+    @directory.files.create(:key => @instance.key)
+    @instance.destroy
+
+    tests("#versions") do
+      tests('#versions.size includes versions (including DeleteMarkers) for all keys').returns(3) do
+        @instance.versions.size
+      end
+
+      tests('#versions are all for the correct key').returns(true) do
+        @instance.versions.all? { |v| v.key == @instance.key }
+      end
+    end
+
+    tests("#destroy") do
+      tests("#destroy a specific version should delete the version, not create a DeleteMarker").returns(2) do
+        @instance.destroy('versionId' => @instance.version)
+        @instance.versions.all.size
+      end
+    end
+
+    tests("multipart upload") do
+      pending if Fog.mocking?
+
+      # A 6MB file
+      @large_file = Tempfile.new("fog-test-aws-s3-multipart")
+      6.times { @large_file.write("x" * (1024**2)) }
+      @large_file.rewind
+
+      tests("#save(:multipart_chunk_size => 5242880)").succeeds do
+        @directory.files.create(:key => 'multipart-upload', :body => @large_file, :multipart_chunk_size => 5242880)
+      end
+
+      @large_file.close
+
+    end
+
+  end
+
+  @directory.versions.each(&:destroy)
+  @directory.destroy
+
+end