fog-maestrodev 1.8.0.20130114204828 → 1.14.0.20130806165225

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

@@ -105,6 +105,19 @@ class AWS
 
       })
 
+      DB_LOG_FILE = {
+        'LastWritten' => Time,
+        'Size' => Integer,
+        'LogFileName' => String
+      }
+
+      DESCRIBE_DB_LOG_FILES = BASIC.merge({
+        'DescribeDBLogFilesResult' => {
+          'Marker' => Fog::Nullable::String,
+          'DBLogFiles' => [DB_LOG_FILE]
+        }
+      })
+
       SNAPSHOT={
         'AllocatedStorage' => Integer,
         'AvailabilityZone' => String,
@@ -137,6 +150,7 @@ class AWS
             'DBSecurityGroupName' => String
           }],
         'DBSubnetGroupName' => Fog::Nullable::String,
+        'PubliclyAccessible' => Fog::Boolean,
         'Endpoint' => {
           'Address' => Fog::Nullable::String,
           'Port' => Fog::Nullable::Integer

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

@@ -1,4 +1,7 @@
 Shindo.tests('AWS::RDS | instance requests', ['aws', 'rds']) do
+  # Disabled due to https://github.com/fog/fog/1546
+  pending
+
   # random_differentiator
   # Useful when rapidly re-running tests, so we don't have to wait
   # serveral minutes for deleted servers to disappear
@@ -42,8 +45,8 @@ Shindo.tests('AWS::RDS | instance requests', ['aws', 'rds']) do
       body
     end
 
-    server.reload.wait_for { state == 'modifying' }
-    server.reload.wait_for { state == 'available' }
+    server.wait_for { state == 'modifying' }
+    server.wait_for { state == 'available' }
 
     tests 'new storage' do
       returns(new_storage){ server.allocated_storage}
@@ -55,8 +58,8 @@ Shindo.tests('AWS::RDS | instance requests', ['aws', 'rds']) do
       end
     end
 
-    server.reload.wait_for { state == 'rebooting' }
-    server.reload.wait_for { state == 'available'}
+    server.wait_for { state == 'rebooting' }
+    server.wait_for { state == 'available'}
 
     tests("#create_db_snapshot").formats(AWS::RDS::Formats::CREATE_DB_SNAPSHOT) do
       body = Fog::AWS[:rds].create_db_snapshot(@db_instance_id, @db_snapshot_id).body
@@ -68,7 +71,7 @@ Shindo.tests('AWS::RDS | instance requests', ['aws', 'rds']) do
       body = Fog::AWS[:rds].describe_db_snapshots.body
     end
 
-    server.reload.wait_for { state == 'available' }
+    server.wait_for { state == 'available' }
 
     tests( "#create read replica").formats(AWS::RDS::Formats::CREATE_READ_REPLICA) do
       Fog::AWS[:rds].create_db_instance_read_replica(@db_replica_id, @db_instance_id).body

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

@@ -0,0 +1,19 @@
+Shindo.tests('AWS::RDS | log file requests', %w[aws rds]) do
+  tests('success') do
+    pending if Fog.mocking?
+
+    suffix = rand(65536).to_s(16)
+    @db_instance_id = "fog-test-#{suffix}"
+
+    tests('#describe_db_log_files').formats(AWS::RDS::Formats::DESCRIBE_DB_LOG_FILES) do
+      result = Fog::AWS[:rds].describe_db_log_files(@db_instance_id).body['DescribeDBLogFilesResult']
+      returns(true) { result['DBLogFiles'].size > 0 }
+      result
+    end
+
+  end
+
+  tests('failures') do
+    raises(Fog::AWS::RDS::NotFound) {Fog::AWS[:rds].describe_db_log_files('doesntexist')}
+  end
+end

data/tests/aws/requests/ses/verified_domain_identity_tests.rb

@@ -0,0 +1,16 @@
+Shindo.tests('AWS::SES | verified domain identity requests', ['aws', 'ses']) do
+
+  tests('success') do
+
+    tests("#verify_domain_identity('example.com')").formats(AWS::SES::Formats::BASIC) do
+      pending if Fog.mocking?
+      Fog::AWS[:ses].verify_domain_identity('example.com').body
+    end
+
+  end
+
+  tests('failure') do
+
+  end
+
+end

data/tests/aws/requests/storage/bucket_tests.rb

@@ -22,7 +22,16 @@ Shindo.tests('Fog::Storage[:aws] | bucket requests', ["aws"]) do
         'StorageClass' => String
       }]
     }
-
+    @bucket_lifecycle_format = {
+      'Rules' => [{
+         'ID'         => String, 
+         'Prefix'     => Fog::Nullable::String,
+         'Enabled'    => Fog::Boolean, 
+         'Expiration' => Fog::Nullable::Hash,
+         'Transition' => Fog::Nullable::Hash
+       }]
+    }
+      
     @service_format = {
       'Buckets' => [{
         'CreationDate'  => Time,
@@ -221,11 +230,22 @@ Shindo.tests('Fog::Storage[:aws] | bucket requests', ["aws"]) do
       tests('create').succeeds do
         Fog::Storage[:aws].put_bucket_lifecycle(@aws_bucket_name, lifecycle)
       end
-      tests('read').returns(lifecycle) do
+      tests('read').formats(@bucket_lifecycle_format) do
         Fog::Storage[:aws].get_bucket_lifecycle(@aws_bucket_name).body
       end
       lifecycle = { 'Rules' => 5.upto(6).map { |i| {'ID' => "rule\##{i}", 'Prefix' => i.to_s, 'Enabled' => true, 'Days' => i} } }
-      tests('update').returns(lifecycle) do
+      lifecycle_return = { 'Rules' => 5.upto(6).map { |i| {'ID' => "rule\##{i}", 'Prefix' => i.to_s, 'Enabled' => true, 'Expiration' => {'Days' => i}} } }
+      tests('update').returns(lifecycle_return) do
+        Fog::Storage[:aws].put_bucket_lifecycle(@aws_bucket_name, lifecycle)
+        Fog::Storage[:aws].get_bucket_lifecycle(@aws_bucket_name).body
+      end
+      lifecycle = {'Rules' => [{'ID' => 'test rule', 'Prefix' => '/prefix', 'Enabled' => true, 'Expiration' => {'Days' => 42}, 'Transition' => {'Days' => 6, 'StorageClass'=>'GLACIER'}}]}
+      tests('transition').returns(lifecycle) do
+        Fog::Storage[:aws].put_bucket_lifecycle(@aws_bucket_name, lifecycle)
+        Fog::Storage[:aws].get_bucket_lifecycle(@aws_bucket_name).body
+      end
+      lifecycle = {'Rules' => [{'ID' => 'test rule', 'Prefix' => '/prefix', 'Enabled' => true, 'Expiration' => {'Date' => '2012-12-31T00:00:00.000Z'}}]}
+      tests('date').returns(lifecycle) do
         Fog::Storage[:aws].put_bucket_lifecycle(@aws_bucket_name, lifecycle)
         Fog::Storage[:aws].get_bucket_lifecycle(@aws_bucket_name).body
       end

data/tests/aws/requests/storage/multipart_upload_tests.rb

@@ -1,6 +1,6 @@
 Shindo.tests('Fog::Storage[:aws] | multipart upload requests', ["aws"]) do
 
-  @directory = Fog::Storage[:aws].directories.create(:key => 'fogmultipartuploadtests')
+  @directory = Fog::Storage[:aws].directories.create(:key => uniq_id('fogmultipartuploadtests'))
 
   tests('success') do
 

data/tests/aws/requests/storage/object_tests.rb

@@ -46,6 +46,10 @@ Shindo.tests('AWS::Storage | object requests', ['aws']) do
       Fog::Storage[:aws].head_object(@directory.identity, 'fog_object')
     end
 
+    tests("#post_object_restore('#{@directory.identity}', 'fog_object')").succeeds do
+      Fog::Storage[:aws].post_object_restore(@directory.identity, 'fog_object')
+    end
+
     tests("#put_object_acl('#{@directory.identity}', 'fog_object', 'private')").succeeds do
       Fog::Storage[:aws].put_object_acl(@directory.identity, 'fog_object', 'private')
     end
@@ -111,14 +115,16 @@ Shindo.tests('AWS::Storage | object requests', ['aws']) do
 
   end
 
+  fognonbucket = uniq_id('fognonbucket')
+
   tests('failure') do
 
-    tests("#put_object('fognonbucket', 'fog_non_object', lorem_file)").raises(Excon::Errors::NotFound) do
-      Fog::Storage[:aws].put_object('fognonbucket', 'fog_non_object', lorem_file)
+    tests("#put_object('#{fognonbucket}', 'fog_non_object', lorem_file)").raises(Excon::Errors::NotFound) do
+      Fog::Storage[:aws].put_object(fognonbucket, 'fog_non_object', lorem_file)
     end
 
-    tests("#copy_object('fognonbucket', 'fog_object', '#{@directory.identity}', 'fog_other_object')").raises(Excon::Errors::NotFound) do
-      Fog::Storage[:aws].copy_object('fognonbucket', 'fog_object', @directory.identity, 'fog_other_object')
+    tests("#copy_object('#{fognonbucket}', 'fog_object', '#{@directory.identity}', 'fog_other_object')").raises(Excon::Errors::NotFound) do
+      Fog::Storage[:aws].copy_object(fognonbucket, 'fog_object', @directory.identity, 'fog_other_object')
     end
 
     tests("#copy_object('#{@directory.identity}', 'fog_non_object', '#{@directory.identity}', 'fog_other_object')").raises(Excon::Errors::NotFound) do
@@ -126,38 +132,41 @@ Shindo.tests('AWS::Storage | object requests', ['aws']) do
     end
 
     tests("#copy_object('#{@directory.identity}', 'fog_object', 'fognonbucket', 'fog_other_object')").raises(Excon::Errors::NotFound) do
-      Fog::Storage[:aws].copy_object(@directory.identity, 'fog_object', 'fognonbucket', 'fog_other_object')
+      Fog::Storage[:aws].copy_object(@directory.identity, 'fog_object', fognonbucket, 'fog_other_object')
     end
 
-    tests("#get_object('fognonbucket', 'fog_non_object')").raises(Excon::Errors::NotFound) do
-      Fog::Storage[:aws].get_object('fognonbucket', 'fog_non_object')
+    tests("#get_object('#{fognonbucket}', 'fog_non_object')").raises(Excon::Errors::NotFound) do
+      Fog::Storage[:aws].get_object(fognonbucket, 'fog_non_object')
     end
 
     tests("#get_object('#{@directory.identity}', 'fog_non_object')").raises(Excon::Errors::NotFound) do
       Fog::Storage[:aws].get_object(@directory.identity, 'fog_non_object')
     end
 
-    tests("#head_object('fognonbucket', 'fog_non_object')").raises(Excon::Errors::NotFound) do
-      Fog::Storage[:aws].head_object('fognonbucket', 'fog_non_object')
+    tests("#head_object(fognonbucket, 'fog_non_object')").raises(Excon::Errors::NotFound) do
+      Fog::Storage[:aws].head_object(fognonbucket, 'fog_non_object')
     end
 
     tests("#head_object('#{@directory.identity}', 'fog_non_object')").raises(Excon::Errors::NotFound) do
       Fog::Storage[:aws].head_object(@directory.identity, 'fog_non_object')
     end
 
-    tests("#delete_object('fognonbucket', 'fog_non_object')").raises(Excon::Errors::NotFound) do
-      Fog::Storage[:aws].delete_object('fognonbucket', 'fog_non_object')
+    tests("#delete_object('#{fognonbucket}', 'fog_non_object')").raises(Excon::Errors::NotFound) do
+      Fog::Storage[:aws].delete_object(fognonbucket, 'fog_non_object')
     end
 
-    tests("#delete_multiple_objects('fognonbucket', ['fog_non_object'])").raises(Excon::Errors::NotFound) do
+    tests("#delete_multiple_objects('#{fognonbucket}', ['fog_non_object'])").raises(Excon::Errors::NotFound) do
       pending if Fog.mocking?
-      Fog::Storage[:aws].delete_multiple_objects('fognonbucket', ['fog_non_object'])
+      Fog::Storage[:aws].delete_multiple_objects(fognonbucket, ['fog_non_object'])
     end
 
     tests("#put_object_acl('#{@directory.identity}', 'fog_object', 'invalid')").raises(Excon::Errors::BadRequest) do
       Fog::Storage[:aws].put_object_acl('#{@directory.identity}', 'fog_object', 'invalid')
     end
 
+    tests("#post_object_restore('#{@directory.identity}', 'fog_non_object')").raises(Excon::Errors::NotFound) do
+      Fog::Storage[:aws].post_object_restore(@directory.identity, 'fog_non_object')
+    end
   end
 
   @directory.destroy

data/tests/aws/requests/sts/assume_role_tests.rb

@@ -0,0 +1,19 @@
+Shindo.tests('AWS::STS | assume role', ['aws']) do
+
+	@policy = {"Statement" => [{"Effect" => "Allow", "Action" => "*", "Resource" => "*"}]}
+
+	@response_format = {
+		'SessionToken' => String,
+		'SecretAccessKey' => String,
+		'Expiration' => String,
+		'AccessKeyId' => String,
+		'Arn' => String,
+		'RequestId' => String
+	}
+	
+	tests("#assume_role('rolename', 'assumed_role_session', 'external_id', #{@policy.inspect}, 900)").formats(@response_format) do
+		pending if Fog.mocking?
+		Fog::AWS[:sts].assume_role("rolename","assumed_role_session","external_id", @policy, 900).body
+	end
+
+end

data/tests/bluebox/requests/blb/helper.rb

@@ -0,0 +1,64 @@
+class Bluebox
+  module BLB
+    module Formats
+      LB_APPLICATION = {
+        'id' => String,
+        'ip_v4' => String,
+        'ip_v6' => String,
+        'name'  => String,
+        'lb_services' => Array,
+        'source_ip_v4' => Fog::Nullable::String,
+      }
+
+      LB_APPLICATIONS = [LB_APPLICATION]
+
+      LB_SERVICE = {
+        'name' => String,
+        'port' => Integer,
+        'private' => Fog::Boolean,
+        'status_username' => String,
+        'status_password' => String,
+        'status_url' => String,
+        'service_type' => String,
+        'created' => String,
+        'lb_backends' => Array,
+        'pem_file_uploaded?' => Fog::Nullable::Boolean,
+      }
+
+      LB_SERVICES = [LB_SERVICE]
+
+      LB_BACKEND = {
+        'id' => String,
+        'backend_name' => String,
+        'lb_machines' => Array,
+        'acl_name' => String,
+        'acl_name' => String,
+        'monitoring_url_hostname' => String,
+        'monitoring_url' => String,
+        'monitoring_url_hostname' => String,
+        'check_interval' => Integer,
+        'rise' => Fog::Nullable::Integer,
+        'order' => Fog::Nullable::Integer,
+        'fall' => Fog::Nullable::Integer,
+      }
+
+      LB_BACKENDS = [LB_BACKEND]
+
+      LB_MACHINE = {
+        'port' => Integer,
+        'id' => String,
+        'ip' => String,
+        'maxconn' => Integer,
+        'hostname' => String,
+        'created' => String,
+      }
+
+      ADD_MACHINE_TO_LB = [
+        { 'text' => String },
+        { 'status' => String },
+      ]
+
+      REMOVE_MACHINE_FROM_BACKEND = 'Record Removed.'
+    end
+  end
+end

data/tests/bluebox/requests/blb/lb_tests.rb

@@ -0,0 +1,75 @@
+require 'securerandom'
+
+Shindo.tests('Bluebox::BLB | lb_tests', ['bluebox']) do
+  pending if Fog.mocking?
+  
+  tests('success') do
+    @flavor_id    = compute_providers[:bluebox][:server_attributes][:flavor_id]
+    @image_id     = compute_providers[:bluebox][:server_attributes][:image_id]
+    @location_id  = compute_providers[:bluebox][:server_attributes][:location_id]
+    @password     = SecureRandom.base64(18)
+
+    tests("get_lb_applications").formats(Bluebox::BLB::Formats::LB_APPLICATIONS) do
+      @lb_applications = Fog::Bluebox[:blb].get_lb_applications.body
+    end
+
+    tests("get_lb_application").formats(Bluebox::BLB::Formats::LB_APPLICATION) do
+      Fog::Bluebox[:blb].get_lb_application(@lb_applications.first['id']).body
+    end
+
+    tests("get_lb_services").formats(Bluebox::BLB::Formats::LB_SERVICES) do
+      @lb_services = Fog::Bluebox[:blb].get_lb_services(@lb_applications.first['id']).body
+    end
+
+    tests("get_lb_service").formats(Bluebox::BLB::Formats::LB_SERVICE) do
+      Fog::Bluebox[:blb].get_lb_service(@lb_applications.first['id'], @lb_services.first['id']).body
+    end
+
+    tests("get_lb_backends").formats(Bluebox::BLB::Formats::LB_BACKENDS) do
+      @lb_backends = Fog::Bluebox[:blb].get_lb_backends(@lb_services.first['id']).body
+    end
+
+    tests("get_lb_backend").formats(Bluebox::BLB::Formats::LB_BACKEND) do
+      Fog::Bluebox[:blb].get_lb_backend(@lb_services.first['id'], @lb_backends.first['id']).body
+    end
+
+    # create block
+    data = Fog::Compute[:bluebox].create_block(@flavor_id, @image_id, @location_id, {'password' => @password}).body
+    @block_id = data['id']
+    Fog::Compute[:bluebox].servers.get(@block_id).wait_for { ready? }
+
+    tests("add_machine_to_lb_application").formats(Bluebox::BLB::Formats::ADD_MACHINE_TO_LB) do
+      Fog::Bluebox[:blb].add_machine_to_lb_application(@lb_applications.first['id'], @block_id).body
+    end
+
+    @default_backend = @lb_backends.select { |x| x['backend_name'] == 'default' }.first
+    @id_in_backend = @default_backend['lb_machines'].last['id']
+    @machine_opts = { 'port' => 4361, 'backup' => true };
+    tests("update_lb_backend_machine(#{@lb_backends.first['id']}, #{@id_in_backend}, #{@machine_opts})").formats(Bluebox::BLB::Formats::LB_MACHINE) do
+      Fog::Bluebox[:blb].update_lb_backend_machine(@lb_backends.first['id'], @id_in_backend, @machine_opts).body
+    end
+
+    tests("remove_machine_from_lb_backend(#{@default_backend['id']}, #{@id_in_backend})").formats(Bluebox::BLB::Formats::REMOVE_MACHINE_FROM_BACKEND) do
+      Fog::Bluebox[:blb].remove_machine_from_lb_backend(@default_backend['id'], @id_in_backend).body
+    end
+
+    tests("add_machine_to_lb_backend(#{@default_backend['id']}, #{@block_id})").formats(Bluebox::BLB::Formats::ADD_MACHINE_TO_LB) do
+      Fog::Bluebox[:blb].add_machine_to_lb_backend(@default_backend['id'], @block_id).body
+    end
+
+    Fog::Compute[:bluebox].destroy_block(@block_id).body
+
+  end
+
+  tests('failure') do
+    tests('get_lb_application').raises(Fog::Compute::Bluebox::NotFound) do
+      Fog::Bluebox[:blb].get_lb_application('00000000-0000-0000-0000-000000000000')
+    end
+    tests('get_lb_service').raises(Fog::Compute::Bluebox::NotFound) do
+      Fog::Bluebox[:blb].get_lb_service('00000000-0000-0000-0000-000000000000','00000000-0000-0000-0000-000000000000')
+    end
+    tests('get_lb_backend').raises(Fog::Compute::Bluebox::NotFound) do
+      Fog::Bluebox[:blb].get_lb_backend('00000000-0000-0000-0000-000000000000','00000000-0000-0000-0000-000000000000')
+    end
+  end
+end

data/tests/brightbox/compute/image_selector_tests.rb

@@ -0,0 +1,103 @@
+Shindo.tests("Fog::Brightbox::Compute::ImageSelector.new", ["brightbox"]) do
+
+  sample_images = [
+    {
+      "id" => "img-00000",
+      "name" => "Ubuntu Lucid 10.04 LTS",
+      "official" => true,
+      "arch" => "i686",
+      "created_at" => "2013-04-30T12:34:56"
+    },
+    {
+      "id" => "img-11111",
+      "name" => "ubuntu-precise-12.04-amd64-server",
+      "official" => false,
+      "arch" => "i686",
+      "created_at" => "2013-05-01T12:34:56"
+    },
+    {
+      "id" => "img-22222",
+      "name" => "ubuntu-quantal-12.10-i386-server",
+      "official" => true,
+      "arch" => "i686",
+      "created_at" => "2013-05-01T12:34:56"
+    },
+    {
+      "id" => "img-33333",
+      "name" => "ubuntu-raring-13.04-amd64-server",
+      "official" => true,
+      "arch" => "amd64",
+      "created_at" => "2013-05-01T12:34:56"
+    },
+    {
+      "id" => "img-44444",
+      "name" => "Fedora 17 server",
+      "official" => true,
+      "arch" => "i686",
+      "created_at" => "2013-05-01T12:34:56"
+    },
+    {
+      "id" => "img-ubuntu",
+      "name" => "ubuntu-raring-13.04-i386-server",
+      "official" => true,
+      "arch" => "i686",
+      "created_at" => "2013-05-01T12:34:56"
+    },
+  ]
+
+  @image_selector = Fog::Brightbox::Compute::ImageSelector.new(sample_images)
+
+  test("#respond_to?(:latest_ubuntu)") do
+    @image_selector.respond_to?(:latest_ubuntu)
+  end
+
+  tests("when there are sample of images") do
+    tests("#latest_ubuntu").returns("img-ubuntu") do
+      @image_selector.latest_ubuntu
+    end
+  end
+
+  tests("when only old format names are present") do
+    tests("#latest_ubuntu").returns("img-ubuntu") do
+      sample_images = [
+        {
+          "id" => "img-11111",
+          "name" => "Ubuntu Lucid 10.04 LTS server",
+          "official" => true,
+          "arch" => "i686",
+          "created_at" => "2013-05-01T12:34:56"
+        },
+        {
+          "id" => "img-22222",
+          "name" => "Ubuntu Quantal 12.10 server",
+          "official" => false,
+          "arch" => "x86_64",
+          "created_at" => "2013-05-01T12:34:56"
+        },
+        {
+          "id" => "img-ubuntu",
+          "name" => "Ubuntu Quantal 12.10 server",
+          "official" => true,
+          "arch" => "i686",
+          "created_at" => "2013-05-01T12:34:56"
+        },
+        {
+          "id" => "img-33333",
+          "name" => "Blank disk image",
+          "official" => true,
+          "arch" => "i686",
+          "created_at" => "2013-05-01T12:34:56"
+        }
+      ]
+      @image_selector = Fog::Brightbox::Compute::ImageSelector.new(sample_images)
+      @image_selector.latest_ubuntu
+
+    end
+  end
+
+  tests("when ") do
+    tests("#latest_ubuntu").returns(nil) do
+      Fog::Brightbox::Compute::ImageSelector.new([]).latest_ubuntu
+    end
+  end
+end