fog-aws 0.0.5

data/tests/requests/compute/instance_tests.rb

@@ -0,0 +1,297 @@
+Shindo.tests('Fog::Compute[:aws] | instance requests', ['aws']) do
+
+  @instance_format = {
+    'architecture'        => String,
+    'amiLaunchIndex'      => Integer,
+    'associatePublicIP'   => Fog::Nullable::Boolean,
+    'attachmentId'        => Fog::Nullable::String,
+    'blockDeviceMapping'  => [Fog::Nullable::Hash],
+    'networkInterfaces'   => [Fog::Nullable::Hash],
+    'clientToken'         => Fog::Nullable::String,
+    'dnsName'             => NilClass,
+    'ebsOptimized'        => Fog::Boolean,
+    'imageId'             => String,
+    'instanceId'          => String,
+    'instanceState'       => {'code' => Integer, 'name' => String},
+    'instanceType'        => String,
+    'kernelId'            => Fog::Nullable::String,
+    'keyName'             => Fog::Nullable::String,
+    'launchTime'          => Time,
+    'monitoring'          => {'state' => Fog::Boolean},
+    'networkInterfaceId'  => Fog::Nullable::String,
+    'placement'           => {
+      'availabilityZone' => String,
+      'groupName'        => Fog::Nullable::String,
+      'tenancy'          => String
+    },
+    'platform'            => Fog::Nullable::String,
+    'privateDnsName'      => NilClass,
+    'productCodes'        => Array,
+    'reason'              => Fog::Nullable::String,
+    'rootDeviceName'      => Fog::Nullable::String,
+    'rootDeviceType'      => String,
+    'sourceDestCheck'     => Fog::Nullable::Boolean,
+    'subnetId'            => Fog::Nullable::String,
+    'vpcId'               => Fog::Nullable::String
+  }
+
+  @run_instances_format = {
+    'groupSet'        => [String],
+    'instancesSet'    => [@instance_format],
+    'ownerId'         => Fog::Nullable::String,
+    'requestId'       => String,
+    'reservationId'   => String
+  }
+
+  @describe_instances_format = {
+    'reservationSet'  => [{
+      'groupSet'      => [String],
+      'groupIds'      => [String],
+      'instancesSet'  => [@instance_format.merge(
+        'architecture'       => String,
+        'dnsName'            => Fog::Nullable::String,
+        'hypervisor'         => String,
+        'iamInstanceProfile' => Hash,
+        'ipAddress'          => Fog::Nullable::String,
+        'networkInterfaces'  => Array,
+        'ownerId'            => String,
+        'privateDnsName'     => Fog::Nullable::String,
+        'privateIpAddress'   => Fog::Nullable::String,
+        'stateReason'        => Hash,
+        'tagSet'             => Hash,
+        'virtualizationType' => String
+      )],
+      'ownerId'       => Fog::Nullable::String,
+      'reservationId' => String
+    }],
+    'requestId'       => String
+  }
+
+  @get_console_output_format = {
+    'instanceId'  => String,
+    'output'      => Fog::Nullable::String,
+    'requestId'   => String,
+    'timestamp'   => Time
+  }
+
+  @get_password_data_format = {
+    'instanceId'   => String,
+    'passwordData' => Fog::Nullable::String,
+    'requestId'    => String,
+    'timestamp'    => Time
+  }
+
+  @terminate_instances_format = {
+    'instancesSet'  => [{
+      'currentState' => {'code' => Integer, 'name' => String},
+      'instanceId'    => String,
+      'previousState' => {'code' => Integer, 'name' => String},
+    }],
+    'requestId'     => String
+  }
+
+  @describe_reserved_instances_offerings_format = {
+    'reservedInstancesOfferingsSet' => [{
+      'reservedInstancesOfferingId'     => String,
+      'instanceType'                    => String,
+      'availabilityZone'                => String,
+      'duration'                        => Integer,
+      'fixedPrice'                      => Float,
+      'offeringType'                    => String,
+      'usagePrice'                      => Float,
+      'productDescription'              => String,
+      'instanceTenancy'                 => String,
+      'currencyCode'                    => String
+    }],
+    'requestId'                     => String
+  }
+
+  @purchase_reserved_instances_offering_format = {
+    'reservedInstancesId' => String,
+    'requestId' => String
+  }
+
+  @describe_reserved_instances_format = {
+    'reservedInstancesSet' => [{
+      'reservedInstancesId' => String,
+      'instanceType'        => String,
+      'availabilityZone'    => String,
+      'start'               => Time,
+      'end'                 => Time,
+      'duration'            => Integer,
+      'fixedPrice'          => Float,
+      'usagePrice'          => Float,
+      'instanceCount'       => Integer,
+      'offeringType'        => String,
+      'productDescription'  => String,
+      'state'               => String,
+      'tagSet'              => [{
+        'key'                   => String,
+        'value'                 => String
+      }],
+      'instanceTenancy'     => String,
+      'currencyCode'        => String
+    }],
+    'requestId'     => String
+  }
+
+  @describe_instance_status_format = {
+    'requestId'         => String,
+    'instanceStatusSet' => [{
+      'instanceId'       => String,
+      'availabilityZone' => String,
+      'instanceState' => {
+        'code' => Integer,
+        'name' => String
+      },
+      'systemStatus'     => {
+        'status'  => String,
+        'details' => [{
+          'name'    => String,
+          'status'  => String
+        }]
+      },
+      'instanceStatus'   => {
+        'status'  => String,
+        'details' => [{
+          'name'    => String,
+          'status'  => String
+        }]
+      },
+      'eventsSet'        => [Fog::Nullable::Hash],
+    }]
+  }
+  tests('success') do
+
+    @instance_id = nil
+    @ami = if ENV['FASTER_TEST_PLEASE']
+      'ami-79c0ae10' # ubuntu 12.04 daily build 20120728
+    else
+      # Use a MS Windows AMI to test #get_password_data
+      'ami-71b50018' # Amazon Public Images - Windows_Server-2008-SP2-English-64Bit-Base-2012.07.11
+    end
+
+    # Create a keypair for decrypting the password
+    key_name = 'fog-test-key'
+    key = Fog::Compute[:aws].key_pairs.create(:name => key_name)
+
+    tests("#run_instances").formats(@run_instances_format) do
+      data = Fog::Compute[:aws].run_instances(@ami, 1, 1, 'InstanceType' => 't1.micro', 'KeyName' => key_name, 'BlockDeviceMapping' => [{"DeviceName" => "/dev/sdp1", "VirtualName" => nil, "Ebs.VolumeSize" => 15}]).body
+      @instance_id = data['instancesSet'].first['instanceId']
+      data
+    end
+
+    server = Fog::Compute[:aws].servers.get(@instance_id)
+    while server.nil? do
+      # It may take a moment to get the server after launching it
+      sleep 0.1
+      server = Fog::Compute[:aws].servers.get(@instance_id)
+    end
+    server.wait_for { ready? }
+
+    tests("#describe_instances").formats(@describe_instances_format) do
+      Fog::Compute[:aws].describe_instances('instance-state-name' => 'running').body
+    end
+
+    # Launch another instance to test filters
+    another_server = Fog::Compute[:aws].servers.create
+
+    tests("#describe_instances('instance-id' => '#{@instance_id}'").formats(@describe_instances_format) do
+      body = Fog::Compute[:aws].describe_instances('instance-id' => "#{@instance_id}").body
+      tests("returns 1 instance").returns(1) { body['reservationSet'].size }
+      body
+    end
+
+    # Test network interface attachment
+    tests('#describe_instances networkInterfaces') do
+      vpc = Fog::Compute[:aws].vpcs.create('cidr_block' => '10.0.10.0/16')
+      subnet = Fog::Compute[:aws].subnets.create('vpc_id' => vpc.id, 'cidr_block' => '10.0.10.0/16')
+      data = Fog::Compute[:aws].create_network_interface(subnet.subnet_id).body
+      @network_interface_id = data['networkInterface']['networkInterfaceId']
+      Fog::Compute[:aws].attach_network_interface(@network_interface_id, @instance_id, '1')
+      body = Fog::Compute[:aws].describe_instances('instance-id' => "#{@instance_id}").body
+      tests("returns 1 attachment").returns(1) { body['reservationSet'].first['instancesSet'].first['networkInterfaces'].size }
+      subnet.destroy
+      vpc.destroy
+    end
+
+    another_server.destroy
+
+    tests("#get_console_output('#{@instance_id}')").formats(@get_console_output_format) do
+      Fog::Compute[:aws].get_console_output(@instance_id).body
+    end
+
+    tests("#get_password_data('#{@instance_id}')").formats(@get_password_data_format) do
+      result = Fog::Compute[:aws].get_password_data(@instance_id).body
+
+      tests("key can decrypt passwordData").returns(true) do
+
+        pending if Fog.mocking?
+
+        password_data = result['passwordData']
+        Fog.wait_for do
+          password_data ||= Fog::Compute[:aws].get_password_data(@instance_id).body['passwordData']
+        end
+
+        decoded_password = Base64.decode64(password_data)
+        pkey = OpenSSL::PKey::RSA.new(key.private_key)
+        String === pkey.private_decrypt(decoded_password)
+      end
+      result
+    end unless ENV['FASTER_TEST_PLEASE']
+
+    key.destroy
+
+    tests("#reboot_instances('#{@instance_id}')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].reboot_instances(@instance_id).body
+    end
+
+    tests("#terminate_instances('#{@instance_id}')").formats(@terminate_instances_format) do
+      Fog::Compute[:aws].terminate_instances(@instance_id).body
+    end
+
+    tests("#describe_reserved_instances_offerings").formats(@describe_reserved_instances_offerings_format) do
+      @reserved_instances = Fog::Compute[:aws].describe_reserved_instances_offerings.body
+      @reserved_instances
+    end
+
+    tests('#describe_instance_status').formats(@describe_instance_status_format) do
+      Fog::Compute[:aws].describe_instance_status.body
+    end
+
+    if Fog.mocking?
+      @reserved_instance_offering_id = @reserved_instances["reservedInstancesOfferingsSet"].first["reservedInstancesOfferingId"]
+      tests("#purchase_reserved_instances_offering('#{@reserved_instance_offering_id}')").formats(@purchase_reserved_instances_offering_format) do
+        Fog::Compute[:aws].purchase_reserved_instances_offering(@reserved_instance_offering_id, 1).body
+      end
+
+      tests("#describe_reserved_instances").formats(@describe_reserved_instances_format) do
+        Fog::Compute[:aws].describe_reserved_instances.body
+      end
+    end
+  end
+
+  tests('failure') do
+
+    tests("#run_instances(nil, 1, 1, {'SubnetId'=>'subnet-00000000'}").raises(::Fog::Compute::AWS::Error) do
+      Fog::Compute[:aws].run_instances(nil, 1, 1, {'SubnetId' => 'subnet-000000'})
+    end
+    tests("#get_console_output('i-00000000')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].get_console_output('i-00000000')
+    end
+
+    tests("#get_password_data('i-00000000')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].get_password_data('i-00000000')
+    end
+
+    tests("#reboot_instances('i-00000000')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].reboot_instances('i-00000000')
+    end
+
+    tests("#terminate_instances('i-00000000')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].terminate_instances('i-00000000')
+    end
+
+  end
+
+end

data/tests/requests/compute/internet_gateway_tests.rb

@@ -0,0 +1,49 @@
+Shindo.tests('Fog::Compute[:aws] | internet_gateway requests', ['aws']) do
+
+  @internet_gateways_format = {
+    'internetGatewaySet' => [{
+      'internetGatewayId'        => String,
+      'attachmentSet'            => Hash,
+      'tagSet'                   => Fog::Nullable::Hash,
+    }],
+    'requestId' => String
+  }
+
+  tests('success') do
+    Fog::Compute::AWS::Mock.reset if Fog.mocking?
+    @vpc=Fog::Compute[:aws].vpcs.create('cidr_block' => '10.0.10.0/24')
+    @vpc_id = @vpc.id
+    @subnet=Fog::Compute[:aws].subnets.create('vpc_id' => @vpc_id, 'cidr_block' => '10.0.10.0/24')
+    @subnet_id = @subnet.subnet_id
+    @igw_id = nil
+
+    tests('#create_internet_gateway').formats(@internet_gateways_format) do
+      data = Fog::Compute[:aws].create_internet_gateway().body
+      @igw_id = data['internetGatewaySet'].first['internetGatewayId']
+      data
+    end
+
+    tests('#describe_internet_gateways').formats(@internet_gateways_format) do
+      Fog::Compute[:aws].describe_internet_gateways.body
+    end
+
+    tests('#describe_internet_gateways with tags').formats(@internet_gateways_format) do
+      Fog::Compute[:aws].create_tags @igw_id, {"environment" => "production"}
+      Fog::Compute[:aws].describe_internet_gateways.body
+    end
+
+    tests("#attach_internet_gateway('#{@igw_id}, #{@vpc_id}')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].attach_internet_gateway(@igw_id, @vpc_id).body
+    end
+
+    tests("#detach_internet_gateway('#{@igw_id}, #{@vpc_id}')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].detach_internet_gateway(@igw_id, @vpc_id).body
+    end
+
+    tests("#delete_internet_gateway('#{@igw_id}')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].delete_internet_gateway(@igw_id).body
+    end
+    @subnet.destroy
+    @vpc.destroy
+  end
+end

data/tests/requests/compute/key_pair_tests.rb

@@ -0,0 +1,67 @@
+Shindo.tests('Fog::Compute[:aws] | key pair requests', ['aws']) do
+
+  tests('success') do
+
+    @keypair_format = {
+      'keyFingerprint'  => String,
+      'keyName'         => String,
+      'requestId'       => String
+    }
+
+    @keypairs_format = {
+      'keySet' => [{
+        'keyFingerprint' => String,
+        'keyName' => String
+      }],
+      'requestId' => String
+    }
+
+    @key_pair_name = 'fog_create_key_pair'
+    @public_key_material = 'ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEA1SL+kgze8tvSFW6Tyj3RyZc9iFVQDiCKzjgwn2tS7hyWxaiDhjfY2mBYSZwFdKN+ZdsXDJL4CPutUg4DKoQneVgIC1zuXrlpPbaT0Btu2aFd4qNfJ85PBrOtw2GrWZ1kcIgzZ1mMbQt6i1vhsySD2FEj+5kGHouNxQpI5dFR5K+nGgcTLFGnzb/MPRBk136GVnuuYfJ2I4va/chstThoP8UwnoapRHcBpwTIfbmmL91BsRVqjXZEUT73nxpxFeXXidYwhHio+5dXwE0aM/783B/3cPG6FVoxrBvjoNpQpAcEyjtRh9lpwHZtSEW47WNzpIW3PhbQ8j4MryznqF1Rhw=='
+
+    tests("#create_key_pair('#{@key_pair_name}')").formats(@keypair_format.merge({'keyMaterial' => String})) do
+      body = Fog::Compute[:aws].create_key_pair(@key_pair_name).body
+      tests("key material").returns(OpenSSL::PKey::RSA, "is a valid private RSA key") do
+        OpenSSL::PKey::RSA.new(body['keyMaterial']).class
+      end
+      body
+    end
+
+    tests('#describe_key_pairs').formats(@keypairs_format) do
+      Fog::Compute[:aws].describe_key_pairs.body
+    end
+
+    tests("#describe_key_pairs('key-name' => '#{@key_pair_name}')").formats(@keypairs_format) do
+      Fog::Compute[:aws].describe_key_pairs('key-name' => @key_pair_name).body
+    end
+
+    tests("#delete_key_pair('#{@key_pair_name}')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].delete_key_pair(@key_pair_name).body
+    end
+
+    tests("#import_key_pair('fog_import_key_pair', '#{@public_key_material}')").formats(@keypair_format) do
+      Fog::Compute[:aws].import_key_pair('fog_import_key_pair', @public_key_material).body
+    end
+
+    tests("#delete_key_pair('fog_import_key_pair)").succeeds do
+      Fog::Compute[:aws].delete_key_pair('fog_import_key_pair')
+    end
+
+    tests("#delete_key_pair('not_a_key_name')").succeeds do
+      Fog::Compute[:aws].delete_key_pair('not_a_key_name')
+    end
+
+  end
+  tests('failure') do
+
+    @key_pair = Fog::Compute[:aws].key_pairs.create(:name => 'fog_key_pair')
+
+    tests("duplicate #create_key_pair('#{@key_pair.name}')").raises(Fog::Compute::AWS::Error) do
+      Fog::Compute[:aws].create_key_pair(@key_pair.name)
+    end
+
+    @key_pair.destroy
+
+  end
+
+end

data/tests/requests/compute/network_acl_tests.rb

@@ -0,0 +1,112 @@
+Shindo.tests('Fog::Compute[:aws] | network acl requests', ['aws']) do
+
+  @network_acl_format = {
+    'networkAclId'   => String,
+    'vpcId'          => String,
+    'default'        => Fog::Boolean,
+    'entrySet'       => [{
+      'ruleNumber'   => Integer,
+      'protocol'     => Integer,
+      'ruleAction'   => String,
+      'egress'       => Fog::Boolean,
+      'cidrBlock'    => String,
+      'icmpTypeCode' => {
+        'code'       => Fog::Nullable::Integer,
+        'type'       => Fog::Nullable::Integer
+      },
+      'portRange' => {
+        'from'       => Fog::Nullable::Integer,
+        'to'         => Fog::Nullable::Integer
+      }
+    }],
+    'associationSet' => Array,
+    'tagSet'         => Hash
+  }
+
+  @network_acls_format = {
+    'requestId'     => String,
+    'networkAclSet' => [ @network_acl_format ]
+  }
+
+  @network_acl_replace_association = {
+    'requestId'        => String,
+    'newAssociationId' => String
+  }
+
+  tests('success') do
+    Fog::Compute::AWS::Mock.reset if Fog.mocking?
+
+    @vpc         = Fog::Compute[:aws].vpcs.create('cidr_block' => '10.0.10.0/24')
+    @subnet      = Fog::Compute[:aws].subnets.create('vpc_id' => @vpc.id, 'cidr_block' => '10.0.10.16/28')
+    @network_acl = nil
+
+    # Describe network interfaces
+    tests('#describe_network_acls').formats(@network_acls_format) do
+      Fog::Compute[:aws].describe_network_acls.body
+    end
+
+    tests('#create_network_acl').formats(@network_acl_format) do
+      data = Fog::Compute[:aws].create_network_acl(@vpc.id).body
+
+      @network_acl = data['networkAcl']
+      data['networkAcl']
+    end
+
+    tests("#create_network_acl_entry").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].create_network_acl_entry(@network_acl['networkAclId'], 100, 6, 'allow', '0.0.0.0/8', false, 'PortRange.From' => 22, 'PortRange.To' => 22).body
+    end
+
+    tests("#replace_network_acl_entry").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].replace_network_acl_entry(@network_acl['networkAclId'], 100, 6, 'deny', '0.0.0.0/8', false, 'PortRange.From' => 22, 'PortRange.To' => 22).body
+    end
+
+    tests("#delete_network_acl_entry").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].delete_network_acl_entry(@network_acl['networkAclId'], 100, false).body
+    end
+
+    default_acl = Fog::Compute[:aws].describe_network_acls('vpc-id' => @vpc.id, 'default' => true).body['networkAclSet'].first
+    @assoc_id   = default_acl['associationSet'].first['networkAclAssociationId']
+
+    tests("#replace_network_acl_association").formats(@network_acl_replace_association) do
+      data = Fog::Compute[:aws].replace_network_acl_association(@assoc_id, @network_acl['networkAclId']).body
+      @assoc_id = data['newAssociationId']
+      data
+    end
+
+    tests("#replace_network_acl_association").formats(@network_acl_replace_association) do
+      Fog::Compute[:aws].replace_network_acl_association(@assoc_id, default_acl['networkAclId']).body
+    end
+
+    # Create another network acl to test tag filters
+    test_tags = {'foo' => 'bar'}
+    @another_acl = Fog::Compute[:aws].network_acls.create :vpc_id => @vpc.id, :tags => test_tags
+    tests("#describe_network_acls('tag-key' => 'foo')").formats(@network_acls_format) do
+      body = Fog::Compute[:aws].describe_network_acls('tag-key' => 'foo').body
+      tests("returns 1 acl").returns(1) { body['networkAclSet'].size }
+      body
+    end
+
+    tests("#describe_network_acls('tag-value' => 'bar')").formats(@network_acls_format) do
+      body = Fog::Compute[:aws].describe_network_acls('tag-value' => 'bar').body
+      tests("returns 1 acl").returns(1) { body['networkAclSet'].size }
+      body
+    end
+
+    tests("#describe_network_acls('tag:foo' => 'bar')").formats(@network_acls_format) do
+      body = Fog::Compute[:aws].describe_network_acls('tag:foo' => 'bar').body
+      tests("returns 1 acl").returns(1) { body['networkAclSet'].size }
+      body
+    end
+
+    tests('#delete_network_acl').formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].delete_network_acl(@network_acl['networkAclId']).body
+    end
+
+    # Clean up
+    Fog::Compute[:aws].delete_tags(@another_acl.identity, test_tags)
+    @another_acl.destroy
+    @subnet.destroy
+    @vpc.destroy
+    Fog::Compute::AWS::Mock.reset if Fog.mocking?
+  end
+end