fog-aws 0.0.5

data/tests/models/rds/security_groups_tests.rb

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

data/tests/models/rds/server_tests.rb

@@ -0,0 +1,110 @@
+Shindo.tests("AWS::RDS | server", ['aws', 'rds']) do
+  # Disabled due to https://github.com/fog/fog/1546
+  pending
+
+  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))
+
+    @instance.wait_for(20*60) { ready? }
+
+    test('#read_replica_identifiers is []') do
+      returns([]) { @instance.read_replica_identifiers }
+    end
+
+    tests('#snapshots') do
+      snapshot = nil
+
+      tests('#create').succeeds do
+        snapshot = @instance.snapshots.create(:id => 'fog-test-snapshot')
+      end
+
+      snapshot.wait_for { ready?}
+
+      @instance.wait_for { ready? }
+
+      returns(true) { @instance.snapshots.map{|s| s.id}.include?(snapshot.id) }
+      snapshot.destroy
+    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.5', :description => 'fog-test')
+
+      orig_security_groups = @instance.db_security_groups.map{|h| h['DBSecurityGroupName']}
+      security_group = Fog::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.wait_for { ready? }
+
+      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.wait_for { state == 'rebooting' }
+      @instance.wait_for { ready? }
+
+      # Restore back to original state using symbols
+      restore_options = {
+       :parameter_group_name => orig_parameter_group,
+       :security_group_names => orig_security_groups
+      }
+      @instance.modify(true, restore_options)
+
+      @instance.reboot
+      @instance.wait_for { state == 'rebooting' }
+      @instance.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.wait_for { state == 'rebooting' }
+    @instance.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 = Fog::AWS[:rds].snapshots.get(final_snapshot_id)
+        !@final_snapshot.nil?
+      end
+
+      @final_snapshot.wait_for { ready? }
+      @final_snapshot.destroy
+    end
+
+  end
+end

data/tests/models/rds/servers_tests.rb

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

data/tests/models/rds/snapshot_tests.rb

@@ -0,0 +1,12 @@
+Shindo.tests("AWS::RDS | snapshot", ['aws', 'rds']) do
+
+  @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) do
+    @instance.wait_for { ready? }
+  end
+
+  @server.destroy
+end

data/tests/models/rds/snapshots_tests.rb

@@ -0,0 +1,12 @@
+Shindo.tests("AWS::RDS | snapshots", ['aws', 'rds']) do
+
+  @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) do
+    @instance.wait_for { ready? }
+  end
+
+  @server.destroy
+end

data/tests/models/rds/tagging_tests.rb

@@ -0,0 +1,20 @@
+Shindo.tests("AWS::RDS | tagging", ['aws', 'rds']) do
+
+  @server = Fog::AWS[:rds].servers.create(rds_default_server_params)
+  Formatador.display_line "Creating RDS instance #{@server.id}"
+  Formatador.display_line "Waiting for instance #{@server.id} to be ready"
+  @server.wait_for { ready? }
+
+  tags1 = {'key1' => 'val1'}
+  tags2 = {'key2' => 'val2'}
+
+  tests "add and remove tags from a running RDS model" do
+    returns({})                 { @server.tags }
+    returns(tags1)              { @server.add_tags tags1 }
+    returns(tags1.merge tags2)  { @server.add_tags tags2 }
+    returns(tags2)              { @server.remove_tags tags1.keys  }
+    returns(tags2)              { @server.tags }
+  end
+
+  @server.destroy
+end

data/tests/models/sns/topic_tests.rb

@@ -0,0 +1,15 @@
+Shindo.tests("AWS::SNS | topic", ['aws', 'sns']) do
+  params = {:id => 'fog'}
+
+  model_tests(Fog::AWS[:sns].topics, params) do
+    @instance.wait_for { ready? }
+
+    tests("#display_name").returns('fog') { @instance.display_name }
+
+    tests("#update_topic_attribute") do
+      @instance.update_topic_attribute("DisplayName", "new-fog")
+
+      tests("#display_name").returns('new-fog') { @instance.display_name }
+    end
+  end
+end

data/tests/models/sns/topics_tests.rb

@@ -0,0 +1,6 @@
+Shindo.tests("AWS::SNS | topics", ['aws', 'sns']) do
+  pending unless Fog.mocking?
+  params = {:id => 'arn:aws:sns:us-east-1:12345678910:fog'}
+
+  collection_tests(Fog::AWS[:sns].topics, params)
+end

data/tests/models/storage/directory_tests.rb

@@ -0,0 +1,87 @@
+Shindo.tests("Storage[:aws] | directory", ["aws"]) do
+
+  directory_attributes = {
+    :key => uniq_id('fogdirectorytests')
+  }
+
+  model_tests(Fog::Storage[:aws].directories, directory_attributes, Fog.mocking?) do
+    tests("#public_url").returns(nil) do
+      @instance.public_url
+    end
+
+    @instance.acl = 'public-read'
+    @instance.save
+
+    tests("#public_url").returns(true) do
+      if @instance.public_url =~ %r[\Ahttps://fogdirectorytests-[\da-f]+\.s3\.amazonaws\.com/\z]
+        true
+      else
+        @instance.public_url
+      end
+    end
+  end
+
+  directory_attributes = {
+    :key => uniq_id('different-region'),
+    :location => 'eu-west-1',
+  }
+
+  model_tests(Fog::Storage[:aws].directories, directory_attributes, Fog.mocking?) do
+    tests("#location").returns('eu-west-1') do
+      @instance.location
+    end
+
+    tests("#location").returns('eu-west-1') do
+      Fog::Storage[:aws].directories.get(@instance.identity).location
+    end
+  end
+
+  directory_attributes = {
+    :key => uniq_id('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.service.get_bucket_versioning(@instance.key).body['VersioningConfiguration']['Status']
+      end
+
+      tests("#versioning=(false)").succeeds do
+        (@instance.versioning = false).equal? false
+      end
+
+      tests("#versioning=(false) sets versioning to 'Suspended'").returns('Suspended') do
+        @instance.versioning = false
+        @instance.service.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.service.put_bucket_versioning(@instance.key, 'Enabled')
+        @instance.versioning?
+      end
+
+      tests("#versioning? false if suspended").returns(false) do
+        @instance.service.put_bucket_versioning(@instance.key, 'Suspended')
+        @instance.versioning?
+      end
+    end
+
+  end
+
+end

data/tests/models/storage/file_tests.rb

@@ -0,0 +1,92 @@
+Shindo.tests("Storage[:aws] | file", ["aws"]) do
+
+  require 'tempfile'
+
+  file_attributes = {
+    :key => 'fog_file_tests',
+    :body => lorem_file,
+    :public => true
+  }
+
+  directory_attributes = {
+    :key => uniq_id("fogfilestests")
+  }
+
+  @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
+        # JRuby 1.7.5+ issue causes a SystemStackError: stack level too deep
+        # https://github.com/jruby/jruby/issues/1265
+        pending if RUBY_PLATFORM == "java" and JRUBY_VERSION =~ /1\.7\.[5-8]/
+
+        @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
+
+    acl = Fog::Storage[:aws].get_object_acl(@directory.key, @instance.key).body["AccessControlList"]
+
+    tests("#acl").returns(acl) do
+      @instance.acl
+    end
+
+    tests("#public?").returns(acl.any? {|grant| grant['Grantee']['URI'] == 'http://acs.amazonaws.com/groups/global/AllUsers' && grant['Permission'] == 'READ'}) do
+      @instance.public?
+    end
+
+  end
+
+  @directory.versions.each(&:destroy)
+  @directory.destroy
+
+end

data/tests/models/storage/files_tests.rb

@@ -0,0 +1,58 @@
+Shindo.tests("Storage[:aws] | files", ["aws"]) do
+
+  file_attributes = {
+      :key => 'fog_file_tests',
+      :body => lorem_file,
+      :public => true
+  }
+
+  directory_attributes = {
+      :key => uniq_id('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.service.put_object(@directory.key, @instance.key, 'version 2 content').headers['x-amz-version-id']
+    v3 = @directory.service.delete_object(@directory.key, @instance.key).headers['x-amz-version-id']
+    v4 = @directory.service.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
+        pending # getting 405 Method Not Allowed
+        @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
+        pending # getting 405 Method Not Allowed
+        @directory.files.head(@instance.key, 'versionId' => v3)
+      end
+    end
+
+  end
+
+  @directory.versions.each(&:destroy)
+  @directory.destroy
+
+end

data/tests/models/storage/url_tests.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+Shindo.tests('AWS | url', ["aws"]) do
+
+
+  @storage = Fog::Storage.new(
+    :provider => 'AWS',
+    :aws_access_key_id => '123',
+    :aws_secret_access_key => 'abc',
+    :region => 'us-east-1'
+  )
+
+  @file = @storage.directories.new(:key => 'fognonbucket').files.new(:key => 'test.txt')
+
+  now = Fog::Time.now
+  if RUBY_VERSION > '1.8.7' # ruby 1.8.x doesn't provide hash ordering
+    tests('#url w/ response-cache-control').returns(
+      "https://fognonbucket.s3.amazonaws.com/test.txt?response-cache-control=No-cache&X-Amz-Expires=500&X-Amz-Date=#{now.to_iso8601_basic}&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=123/#{now.utc.strftime('%Y%m%d')}/us-east-1/s3/aws4_request&X-Amz-SignedHeaders=host&X-Amz-Signature="
+    ) do
+
+      @file.url(Time.now + 500, :query => { 'response-cache-control' => 'No-cache' }).gsub(/(X-Amz-Signature=)[0-9a-f]+\z/,'\\1')
+    end
+  end
+
+
+end