tecnh-fog 0.2.23.vpc

data/spec/vcloud/terremark/ecloud/requests/login_spec.rb

@@ -0,0 +1,10 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper')
+
+if Fog.mocking?
+  describe Fog::Vcloud, :type => :mock_tmrk_ecloud_request do
+    subject { @vcloud }
+
+    it_should_behave_like "all login requests"
+  end
+else
+end

data/spec/vcloud/vcloud_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+if Fog.mocking?
+  describe Fog::Vcloud, :type => :mock_vcloud_request do
+    subject { Fog::Vcloud.new(:username => "foo", :password => "bar", :versions_uri => "https://fakey.com/api/versions") }
+
+    it { should be_an_instance_of Fog::Vcloud::Mock }
+
+    it { should respond_to :default_organization_uri }
+
+    it { should respond_to :supported_versions }
+
+    it { should have_at_least(1).supported_versions }
+
+    its(:default_organization_uri) { should == @mock_organization[:info][:href] }
+
+  end
+end

data/tests/aws/helper.rb

@@ -0,0 +1,41 @@
+module AWS
+
+  class << self
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        credentials = Fog.credentials.reject do |k, v|
+          ![:aws_access_key_id, :aws_secret_access_key].include?(k)
+        end
+        hash[key] = case key
+        when :ec2
+          Fog::AWS::EC2.new(credentials)
+        when :eu_s3
+          Fog::AWS::S3.new(credentials.merge!(:host => 's3-external-3.amazonaws.com'))
+        when :sdb
+          Fog::AWS::SimpleDB.new(credentials)
+        when :s3
+          Fog::AWS::S3.new(credentials)
+        end
+      end
+      @@connections[service]
+    end
+  end
+
+  module EC2
+
+    module Formats
+
+      BASIC = {
+        'requestId' => String,
+        'return'    => ::Fog::Boolean
+      }
+
+    end
+
+  end
+
+end
+
+unless defined?(GENTOO_AMI)
+  GENTOO_AMI = 'ami-5ee70037'
+end

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

@@ -0,0 +1,8 @@
+Shindo.tests('AWS::S3 | directory models', ['aws']) do
+
+  @collection = AWS[:s3].directories
+  @model = @collection.new(:key => Time.now.to_f.to_s)
+
+  tests_models
+
+end

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

@@ -0,0 +1,80 @@
+Shindo.tests('AWS::EC2 | address requests', ['aws']) do
+
+  @addresses_format = {
+    'addressesSet' => [{
+      'instanceId'  => NilClass,
+      'publicIp'    => String
+    }],
+    'requestId' => String
+  }
+
+  @server = AWS[:ec2].servers.create(:image_id => GENTOO_AMI)
+  @server.wait_for { ready? }
+  @ip_address = @server.ip_address
+
+  tests('success') do
+
+    @public_ip = nil
+
+    tests('#allocate_address').formats({'publicIp' => String, 'requestId' => String}) do
+      data = AWS[:ec2].allocate_address.body
+      @public_ip = data['publicIp']
+      data
+    end
+
+    tests('#describe_addresses').formats(@addresses_format) do
+      AWS[:ec2].describe_addresses.body
+    end
+
+    tests("#describe_addresses('#{@public_Ip}')").formats(@addresses_format) do
+      AWS[:ec2].describe_addresses(@public_ip).body
+    end
+
+    tests("#associate_addresses('#{@server.identity}', '#{@public_Ip}')").formats(AWS::EC2::Formats::BASIC) do
+      AWS[:ec2].associate_address(@server.identity, @public_ip).body
+    end
+
+    tests("#dissassociate_address('#{@public_ip}')").formats(AWS::EC2::Formats::BASIC) do
+      AWS[:ec2].disassociate_address(@public_ip).body
+    end
+
+    tests("#release_address('#{@public_ip}')").formats(AWS::EC2::Formats::BASIC) do
+      AWS[:ec2].release_address(@public_ip).body
+    end
+
+  end
+  tests ('failure') do
+
+    @address = AWS[:ec2].addresses.create
+
+    tests("#describe_addresses('127.0.0.1')").raises(Fog::AWS::EC2::NotFound) do
+      AWS[:ec2].describe_addresses('127.0.0.1')
+    end
+
+    tests("#associate_addresses('i-00000000', '#{@address.identity}')").raises(Fog::AWS::EC2::NotFound) do
+      AWS[:ec2].associate_address('i-00000000', @address.identity)
+    end
+
+    tests("#associate_addresses('#{@server.identity}', '127.0.0.1')").raises(Fog::AWS::EC2::Error) do
+      AWS[:ec2].associate_address(@server.identity, '127.0.0.1')
+    end
+
+    tests("#associate_addresses('i-00000000', '127.0.0.1')").raises(Fog::AWS::EC2::NotFound) do
+      AWS[:ec2].associate_address('i-00000000', '127.0.0.1')
+    end
+
+    tests("#disassociate_addresses('127.0.0.1') raises BadRequest error").raises(Fog::AWS::EC2::Error) do
+      AWS[:ec2].disassociate_address('127.0.0.1')
+    end
+
+    tests("#release_address('127.0.0.1')").raises(Fog::AWS::EC2::Error) do
+      AWS[:ec2].release_address('127.0.0.1')
+    end
+
+    @address.destroy
+
+  end
+
+  @server.destroy
+
+end

data/tests/aws/requests/ec2/availability_zone_tests.rb

@@ -0,0 +1,32 @@
+Shindo.tests('AWS::EC2 | availability zone requests', ['aws']) do
+
+  @availability_zones_format = {
+    'availabilityZoneInfo'  => [{
+      'regionName'  => String,
+      'zoneName'    => String,
+      'zoneState'   => String
+    }],
+    'requestId'             => String
+  }
+
+  tests('success') do
+
+    tests('#describe_availability_zones').formats(@availability_zones_format) do
+      AWS[:ec2].describe_availability_zones.body
+    end
+
+    tests("#describe_availability_zones('us-east-1a')").formats(@availability_zones_format) do
+      AWS[:ec2].describe_availability_zones('us-east-1a').body
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("#describe_availability_zones('us-east-1e')").raises(Fog::AWS::EC2::Error) do
+      AWS[:ec2].describe_availability_zones('us-east-1e')
+    end
+
+  end
+
+end

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

@@ -0,0 +1,122 @@
+Shindo.tests('AWS::EC2 | instance requests', ['aws']) do
+
+  @instance_format = {
+    # 'architecture'    => String,
+    'amiLaunchIndex'      => Integer,
+    'blockDeviceMapping'  => [],
+    'dnsName'             => NilClass,
+    'imageId'             => String,
+    'instanceId'          => String,
+    'instanceState'       => {'code' => Integer, 'name' => String},
+    'instanceType'        => String,
+    # 'ipAddress'           => String,
+    'kernelId'            => String,
+    # 'keyName'             => String,
+    'launchTime'          => Time,
+    'monitoring'          => {'state' => Fog::Boolean},
+    'placement'           => {'availabilityZone' => String},
+    'privateDnsName'      => NilClass,
+    # 'privateIpAddress'    => String,
+    'productCodes'        => [],
+    'ramdiskId'           => String,
+    'reason'              => NilClass,
+    # 'rootDeviceName'      => String,
+    'rootDeviceType'      => String
+  }
+
+  @run_instances_format = {
+    'groupSet'        => [String],
+    'instancesSet'    => [@instance_format],
+    'ownerId'         => String,
+    'requestId'       => String,
+    'reservationId'   => String
+  }
+
+  @describe_instances_format = {
+    'reservationSet'  => [{
+      'groupSet'      => [String],
+      'instancesSet'  => [@instance_format.merge(
+        'architecture'      => String,
+        'dnsName'           => String,
+        'ipAddress'         => String,
+        'privateDnsName'    => String,
+        'privateIpAddress'  => String
+      )],
+      'ownerId'       => String,
+      'reservationId' => String
+    }],
+    'requestId'       => String
+  }
+
+  @get_console_output_format = {
+    'instanceId'  => String,
+    'output'      => NilClass,
+    'requestId'   => String,
+    'timestamp'   => Time
+  }
+
+  @terminate_instances_format = {
+    'instancesSet'  => [{
+      'currentState' => {'code' => Integer, 'name' => String},
+      'instanceId'    => String,
+      'previousState' => {'code' => Integer, 'name' => String},
+    }],
+    'requestId'     => String
+  }
+
+  tests('success') do
+
+    @instance_id = nil
+
+    tests("#run_instances('#{GENTOO_AMI}', 1, 1)").formats(@run_instances_format) do
+      data = AWS[:ec2].run_instances(GENTOO_AMI, 1, 1).body
+      @instance_id = data['instancesSet'].first['instanceId']
+      data
+    end
+
+    AWS[:ec2].servers.get(@instance_id).wait_for { ready? }
+
+    # The format changes depending on state of instance, so this would be brittle
+    # tests("#describe_instances").formats(@describe_instances_format) do
+    #   AWS[:ec2].describe_instances.body
+    # end
+
+    tests("#describe_instances('#{@instance_id}')").formats(@describe_instances_format) do
+      AWS[:ec2].describe_instances(@instance_id).body
+    end
+
+    tests("#get_console_output('#{@instance_id}')").formats(@get_console_output_format) do
+      AWS[:ec2].get_console_output(@instance_id).body
+    end
+
+    tests("#reboot_instances('#{@instance_id}')").formats(AWS::EC2::Formats::BASIC) do
+      AWS[:ec2].reboot_instances(@instance_id).body
+    end
+
+    tests("#terminate_instances('#{@instance_id}')").formats(@terminate_instances_format) do
+      AWS[:ec2].terminate_instances(@instance_id).body
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("#describe_instances('i-00000000')").raises(Fog::AWS::EC2::NotFound) do
+      AWS[:ec2].describe_instances('i-00000000')
+    end
+
+    tests("#get_console_output('i-00000000')").raises(Fog::AWS::EC2::NotFound) do
+      AWS[:ec2].get_console_output('i-00000000')
+    end
+
+    tests("#reboot_instances('i-00000000')").raises(Fog::AWS::EC2::NotFound) do
+      AWS[:ec2].reboot_instances('i-00000000')
+    end
+
+    tests("#terminate_instances('i-00000000')").raises(Fog::AWS::EC2::NotFound) do
+      AWS[:ec2].terminate_instances('i-00000000')
+    end
+
+  end
+
+end

data/tests/aws/requests/ec2/key_pair_tests.rb

@@ -0,0 +1,59 @@
+Shindo.tests('AWS::EC2 | key pair requests', ['aws']) do
+
+  tests('success') do
+
+    @keypair_format = {
+      'keyFingerprint'  => String,
+      'keyMaterial'     => String,
+      'keyName'         => String,
+      'requestId'       => String
+    }
+
+    @keypairs_format = {
+      'keySet' => [{
+        'keyFingerprint' => String,
+        'keyName' => String
+      }],
+      'requestId' => String
+    }
+
+    @key_pair_name = 'fog_key_pair'
+
+    tests("#create_key_pair('#{@key_pair_name}')").formats(@keypair_format) do
+      AWS[:ec2].create_key_pair(@key_pair_name).body
+    end
+
+    tests('#describe_key_pairs').formats(@keypairs_format) do
+      AWS[:ec2].describe_key_pairs.body
+    end
+
+    tests("#describe_key_pairs(#{@key_pair_name})").formats(@keypairs_format) do
+      AWS[:ec2].describe_key_pairs(@key_pair_name).body
+    end
+
+    tests("#delete_key_pair('#{@key_pair_name}')").formats(AWS::EC2::Formats::BASIC) do
+      AWS[:ec2].delete_key_pair(@key_pair_name).body
+    end
+
+    tests("#delete_key_pair('not_a_key_name')").succeeds do
+      AWS[:ec2].delete_key_pair('not_a_key_name')
+    end
+
+  end
+  tests('failure') do
+
+    @key_pair = AWS[:ec2].key_pairs.create(:name => 'fog_key_pair')
+
+    tests("duplicate #create_key_pair('#{@key_pair.name}')").raises(Fog::AWS::EC2::Error) do
+      AWS[:ec2].create_key_pair(@key_pair.name)
+    end
+
+    tests("#describe_key_pair('not_a_key_name')").raises(Fog::AWS::EC2::NotFound) do
+      AWS[:ec2].describe_key_pairs('not_a_key_name').body
+    end
+
+    @key_pair.destroy
+
+  end
+
+end

data/tests/aws/requests/ec2/region_tests.rb

@@ -0,0 +1,30 @@
+Shindo.tests('AWS::EC2 | region requests', ['aws']) do
+
+  @regions_format = {
+    'regionInfo'  => [{
+      'regionEndpoint'  => String,
+      'regionName'      => String
+    }],
+    'requestId'   => String
+  }
+
+  tests('success') do
+
+    tests("#describe_regions").formats(@regions_format) do
+      AWS[:ec2].describe_regions.body
+    end
+
+    tests("#describe_regions('us-east-1')").formats(@regions_format) do
+      AWS[:ec2].describe_regions('us-east-1').body
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("#describe_regions('us-east-2')").raises(Fog::AWS::EC2::Error) do
+      AWS[:ec2].describe_regions('us-east-2')
+    end
+  end
+
+end

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

@@ -0,0 +1,128 @@
+Shindo.tests('AWS::EC2 | security group requests', ['aws']) do
+
+  @security_groups_format = {
+    'requestId'           => String,
+    'securityGroupInfo' => [{
+      'groupDescription'  => String,
+      'groupName'         => String,
+      'ipPermissions'     => [{
+        'fromPort'    => Integer,
+        'groups'      => [{ 'groupName' => String, 'userId' => String }],
+        'ipProtocol'  => String,
+        'ipRanges'    => [],
+        'toPort'      => Integer,
+      }],
+      'ownerId'           => String
+    }]
+  }
+
+  @owner_id = AWS[:ec2].describe_security_groups('default').body['securityGroupInfo'].first['ownerId']
+
+  tests('success') do
+
+    tests("#create_security_group('fog_security_group', 'tests group')").formats(AWS::EC2::Formats::BASIC) do
+      AWS[:ec2].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::EC2::Formats::BASIC) do
+      AWS[:ec2].authorize_security_group_ingress({
+        'FromPort' => 80,
+        'GroupName' => 'fog_security_group',
+        'IpProtocol' => 'tcp',
+        'ToPort' => 80,
+      }).body
+    end
+
+    tests("#authorize_security_group_ingress({'GroupName' => 'fog_security_group', 'SourceSecurityGroupName' => 'fog_security_group', 'SourceSecurityGroupOwnerId' => '#{@owner_id}'})").formats(AWS::EC2::Formats::BASIC) do
+      AWS[:ec2].authorize_security_group_ingress({
+        'GroupName'                   => 'fog_security_group',
+        'SourceSecurityGroupName'     => 'fog_security_group',
+        'SourceSecurityGroupOwnerId'  => @owner_id
+      }).body
+    end
+
+    tests("#describe_security_groups").formats(@security_groups_format) do
+      AWS[:ec2].describe_security_groups.body
+    end
+
+    tests("#describe_security_groups('fog_security_group')").formats(@security_groups_format) do
+      AWS[:ec2].describe_security_groups('fog_security_group').body
+    end
+
+    tests("#revoke_security_group_ingress({'FromPort' => 80, 'GroupName' => 'fog_security_group', 'IpProtocol' => 'tcp', 'toPort' => 80})").formats(AWS::EC2::Formats::BASIC) do
+      AWS[:ec2].revoke_security_group_ingress({
+        'FromPort' => 80,
+        'GroupName' => 'fog_security_group',
+        'IpProtocol' => 'tcp',
+        'ToPort' => 80,
+      }).body
+    end
+
+    tests("#revoke_security_group_ingress({'GroupName' => 'fog_security_group', 'SourceSecurityGroupName' => 'fog_security_group', 'SourceSecurityGroupOwnerId' => '#{@owner_id}'})").formats(AWS::EC2::Formats::BASIC) do
+      AWS[:ec2].revoke_security_group_ingress({
+        'GroupName'                   => 'fog_security_group',
+        'SourceSecurityGroupName'     => 'fog_security_group',
+        'SourceSecurityGroupOwnerId'  => @owner_id
+      }).body
+    end
+
+    tests("#delete_security_group('fog_security_group')").formats(AWS::EC2::Formats::BASIC) do
+      AWS[:ec2].delete_security_group('fog_security_group').body
+    end
+
+  end
+  tests('failure') do
+
+    @security_group = AWS[:ec2].security_groups.create(:description => 'tests group', :name => 'fog_security_group')
+
+    tests("duplicate #create_security_group(#{@security_group.name}, #{@security_group.description})").raises(Fog::AWS::EC2::Error) do
+      AWS[:ec2].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::EC2::NotFound) do
+      AWS[:ec2].authorize_security_group_ingress({
+        'FromPort' => 80,
+        'GroupName' => 'not_a_group_name',
+        '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::EC2::NotFound) do
+      AWS[:ec2].authorize_security_group_ingress({
+        'GroupName'                   => 'not_a_group_name',
+        'SourceSecurityGroupName'     => 'not_a_group_name',
+        'SourceSecurityGroupOwnerId'  => @owner_id
+      })
+    end
+
+    tests("#describe_security_group('not_a_group_name)").raises(Fog::AWS::EC2::NotFound) do
+      AWS[:ec2].describe_security_groups('not_a_group_name')
+    end
+
+    tests("#revoke_security_group_ingress({'FromPort' => 80, 'GroupName' => 'not_a_group_name', 'IpProtocol' => 'tcp', 'toPort' => 80})").raises(Fog::AWS::EC2::NotFound) do
+      AWS[:ec2].revoke_security_group_ingress({
+        'FromPort' => 80,
+        'GroupName' => 'not_a_group_name',
+        '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::EC2::NotFound) do
+      AWS[:ec2].revoke_security_group_ingress({
+        'GroupName'                   => 'not_a_group_name',
+        'SourceSecurityGroupName'     => 'not_a_group_name',
+        'SourceSecurityGroupOwnerId'  => @owner_id
+      })
+    end
+
+    tests("#delete_security_group('not_a_group_name')").raises(Fog::AWS::EC2::NotFound) do
+      AWS[:ec2].delete_security_group('not_a_group_name')
+    end
+
+    @security_group.destroy
+
+  end
+
+end