ktheory-fog 1.1.2

data/tests/aws/requests/compute/snapshot_tests.rb

@@ -0,0 +1,57 @@
+Shindo.tests('Fog::Compute[:aws] | snapshot requests', ['aws']) do
+
+  @snapshot_format = {
+    'description' => Fog::Nullable::String,
+    'ownerId'     => String,
+    'progress'    => String,
+    'snapshotId'  => String,
+    'startTime'   => Time,
+    'status'      => String,
+    'volumeId'    => String,
+    'volumeSize'  => Integer
+  }
+
+  @snapshots_format = {
+    'requestId'   => String,
+    'snapshotSet' => [@snapshot_format.merge('tagSet' => {})]
+  }
+
+  @volume = Fog::Compute[:aws].volumes.create(:availability_zone => 'us-east-1a', :size => 1)
+
+  tests('success') do
+
+    @snapshot_id = nil
+
+    tests("#create_snapshot(#{@volume.identity})").formats(@snapshot_format.merge('progress' => NilClass, 'requestId' => String)) do
+      data = Fog::Compute[:aws].create_snapshot(@volume.identity).body
+      @snapshot_id = data['snapshotId']
+      data
+    end
+
+    Fog.wait_for { Fog::Compute[:aws].snapshots.get(@snapshot_id) }
+    Fog::Compute[:aws].snapshots.get(@snapshot_id).wait_for { ready? }
+
+    tests("#describe_snapshots").formats(@snapshots_format) do
+      Fog::Compute[:aws].describe_snapshots.body
+    end
+
+    tests("#describe_snapshots('snapshot-id' => '#{@snapshot_id}')").formats(@snapshots_format) do
+      Fog::Compute[:aws].describe_snapshots('snapshot-id' => @snapshot_id).body
+    end
+
+    tests("#delete_snapshots(#{@snapshot_id})").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].delete_snapshot(@snapshot_id).body
+    end
+
+  end
+  tests('failure') do
+
+    tests("#delete_snapshot('snap-00000000')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].delete_snapshot('snap-00000000')
+    end
+
+  end
+
+  @volume.destroy
+
+end

data/tests/aws/requests/compute/spot_datafeed_subscription_tests.rb

@@ -0,0 +1,47 @@
+Shindo.tests('Fog::Compute[:aws] | spot datafeed subscription requests', ['aws']) do
+  @spot_datafeed_subscription_format = {
+    'spotDatafeedSubscription' => {
+      'bucket'  => String,
+      'ownerId' => String,
+      'prefix'  => String,
+      'state'   => String
+    },
+    'requestId' => String
+  }
+
+  @directory = Fog::Storage[:aws].directories.create(:key => 'fogspotdatafeedsubscriptiontests')
+
+  tests('success') do
+    pending if Fog.mocking?
+
+    tests("#create_spot_datafeed_subscription('fogspotdatafeedsubscriptiontests', 'fogspotdatafeedsubscription/')").formats(@spot_datafeed_subscription_format) do
+      Fog::Compute[:aws].create_spot_datafeed_subscription('fogspotdatafeedsubscriptiontests', 'fogspotdatafeedsubscription/').body
+    end
+
+    tests("duplicate #create_spot_datafeed_subscription('fogspotdatafeedsubscriptiontests', 'fogspotdatafeedsubscription/')").succeeds do
+      Fog::Compute[:aws].create_spot_datafeed_subscription('fogspotdatafeedsubscriptiontests', 'fogspotdatafeedsubscription/')
+    end
+
+    tests("#describe_spot_datafeed_subscription").formats(@spot_datafeed_subscription_format) do
+      Fog::Compute[:aws].describe_spot_datafeed_subscription.body
+    end
+
+    tests("#delete_spot_datafeed_subscription").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].delete_spot_datafeed_subscription.body
+    end
+
+    tests("duplicate #delete_spot_datafeed_subscription").succeeds do
+      Fog::Compute[:aws].delete_spot_datafeed_subscription
+    end
+  end
+
+  tests('failure') do
+    pending if Fog.mocking?
+
+    tests("#describe_spot_datafeed_subscription").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].describe_spot_datafeed_subscription
+    end
+  end
+
+  @directory.destroy
+end

data/tests/aws/requests/compute/spot_instance_tests.rb

@@ -0,0 +1,53 @@
+Shindo.tests('Fog::Compute[:aws] | spot instance requests', ['aws']) do
+
+  @spot_instance_requests_format = {
+    'spotInstanceRequestSet' => [{
+      'createTime'                => Time,
+      'instanceId'                => Fog::Nullable::String,
+      'launchedAvailabilityZone'  => Fog::Nullable::String,
+      'launchSpecification'       => {
+        'blockDeviceMapping'  => [],
+        'groupSet'            => [String],
+        'keyName'             => Fog::Nullable::String,
+        'imageId'             => String,
+        'instanceType'        => String,
+        'monitoring'          => Fog::Boolean
+      },
+      'productDescription'        => String,
+      'spotInstanceRequestId'     => String,
+      'spotPrice'                 => Float,
+      'state'                     => String,
+      'type'                      => String
+    }],
+    'requestId' => String
+  }
+
+  @cancel_spot_instance_request_format = {
+    'spotInstanceRequestSet' => [{
+      'spotInstanceRequestId' => String,
+      'state'                 => String
+    }],
+    'requestId' => String
+  }
+
+  tests('success') do
+
+    pending if Fog.mocking?
+
+    tests("#request_spot_instances('ami-3202f25b', 't1.micro', '0.001')").formats(@spot_instance_requests_format) do
+      data = Fog::Compute[:aws].request_spot_instances('ami-3202f25b', 't1.micro', '0.001').body
+      @spot_instance_request_id = data['spotInstanceRequestSet'].first['spotInstanceRequestId']
+      data
+    end
+
+    tests("#describe_spot_instance_requests").formats(@spot_instance_requests_format) do
+      Fog::Compute[:aws].describe_spot_instance_requests.body
+    end
+
+    tests("#cancel_spot_instance_requests('#{@spot_instance_request_id}')").formats(@cancel_spot_instance_request_format) do
+      Fog::Compute[:aws].cancel_spot_instance_requests(@spot_instance_request_id).body
+    end
+
+  end
+
+end

data/tests/aws/requests/compute/spot_price_history_tests.rb

@@ -0,0 +1,24 @@
+Shindo.tests('Fog::Compute[:aws] | spot price history requests', ['aws']) do
+
+  @spot_price_history_format = {
+    'spotPriceHistorySet'   => [{
+      'availabilityZone'    => String,
+      'instanceType'        => String,
+      'spotPrice'           => Float,
+      'productDescription'  => String,
+      'timestamp'           => Time
+    }],
+    'requestId' => String
+  }
+
+  tests('success') do
+
+    pending # Some history data doesn't have an availability zone
+
+    tests("#describe_spot_price_history").formats(@spot_price_history_format) do
+      Fog::Compute[:aws].describe_spot_price_history.body
+    end
+
+  end
+
+end

data/tests/aws/requests/compute/tag_tests.rb

@@ -0,0 +1,77 @@
+Shindo.tests('Fog::Compute[:aws] | tag requests', ['aws']) do
+  @tags_format = {
+    'tagSet'    => [{
+      'key'          => String,
+      'resourceId'   => String,
+      'resourceType' => String,
+      'value'        => Fog::Nullable::String
+    }],
+    'requestId' => String
+  }
+
+  @volume = Fog::Compute[:aws].volumes.create(:availability_zone => 'us-east-1a', :size => 1)
+  @volume.wait_for { ready? }
+
+  tests('success') do
+    if Fog.mocking?
+      @other_account = Fog::Compute::AWS.new(:aws_access_key_id => 'other', :aws_secret_access_key => 'account')
+      @image_id = Fog::Compute[:aws].register_image('image', 'image', '/dev/sda1').body['imageId']
+    end
+
+    tests("#create_tags('#{@volume.identity}', 'foo' => 'bar')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].create_tags(@volume.identity, 'foo' => 'bar').body
+    end
+
+    if Fog.mocking?
+      tests("#create_tags('#{@image_id}', 'foo' => 'baz')").formats(AWS::Compute::Formats::BASIC) do
+        Fog::Compute[:aws].create_tags(@image_id, 'foo' => 'baz').body
+      end
+    end
+
+    tests('#describe_tags').formats(@tags_format) do
+      Fog::Compute[:aws].describe_tags.body
+    end
+
+    expected_identities = Fog.mocking? ? [@volume.identity, @image_id] : [@volume.identity]
+    tests('#describe_tags').succeeds do
+      (expected_identities - Fog::Compute[:aws].describe_tags.body['tagSet'].map {|t| t['resourceId'] }).empty?
+    end
+
+    tests("#describe_tags('key' => 'foo', 'value' => 'bar')").returns([@volume.identity]) do
+      Fog::Compute[:aws].describe_tags('key' => 'foo', 'value' => 'bar').body['tagSet'].map {|t| t['resourceId'] }
+    end
+
+    if Fog.mocking?
+      tests("#describe_tags('key' => 'foo', 'value' => 'baz')").returns([@image_id]) do
+        Fog::Compute[:aws].describe_tags('key' => 'foo', 'value' => 'baz').body['tagSet'].map {|t| t['resourceId'] }
+      end
+
+      Fog::Compute[:aws].modify_image_attribute(@image_id, 'Add.UserId' => [@other_account.data[:owner_id]])
+
+      tests("other_account#describe_tags('key' => 'foo', 'value' => 'baz')").returns([]) do
+        @other_account.describe_tags('key' => 'foo', 'value' => 'baz').body['tagSet'].map {|t| t['resourceId'] }
+      end
+
+      tests("other_account#create_tags('#{@image_id}', 'foo' => 'quux')").formats(AWS::Compute::Formats::BASIC) do
+        @other_account.create_tags(@image_id, 'foo' => 'quux').body
+      end
+
+      tests("other_account#describe_tags('key' => 'foo', 'value' => 'quux')").returns([@image_id]) do
+        @other_account.describe_tags('key' => 'foo', 'value' => 'quux').body['tagSet'].map {|t| t['resourceId'] }
+      end
+    end
+
+    @volume.destroy
+
+    tests("#delete_tags('#{@volume.identity}', 'foo' => 'bar')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].delete_tags(@volume.identity, 'foo' => 'bar').body
+    end
+  end
+
+  tests('failure') do
+    tests("#create_tags('vol-00000000', 'baz' => 'qux')").raises(Fog::Service::NotFound) do
+      Fog::Compute[:aws].create_tags('vol-00000000', 'baz' => 'qux')
+    end
+
+  end
+end

data/tests/aws/requests/compute/volume_tests.rb

@@ -0,0 +1,122 @@
+Shindo.tests('Fog::Compute[:aws] | volume requests', ['aws']) do
+
+  @volume_format = {
+    'availabilityZone'  => String,
+    'createTime'        => Time,
+    'requestId'         => String,
+    'size'              => Integer,
+    'snapshotId'        => Fog::Nullable::String,
+    'status'            => String,
+    'volumeId'          => String
+  }
+
+  @volume_attachment_format = {
+    'attachTime'  => Time,
+    'device'      => String,
+    'instanceId'  => String,
+    'requestId'   => String,
+    'status'      => String,
+    'volumeId'    => String
+  }
+
+  @volumes_format = {
+    'volumeSet' => [{
+      'availabilityZone'  => String,
+      'attachmentSet'     => Array,
+      'createTime'        => Time,
+      'size'              => Integer,
+      'snapshotId'        => Fog::Nullable::String,
+      'status'            => String,
+      'tagSet'            => Hash,
+      'volumeId'          => String
+    }],
+    'requestId' => String
+  }
+
+  @server = Fog::Compute[:aws].servers.create
+  @server.wait_for { ready? }
+
+  tests('success') do
+
+    @volume_id = nil
+
+    tests('#create_volume').formats(@volume_format) do
+      data = Fog::Compute[:aws].create_volume(@server.availability_zone, 1).body
+      @volume_id = data['volumeId']
+      data
+    end
+
+    tests('#create_volume from snapshot').formats(@volume_format) do
+      volume = Fog::Compute[:aws].volumes.create(:availability_zone => 'us-east-1d', :size => 1)
+      snapshot = Fog::Compute[:aws].create_snapshot(volume.identity).body
+      data = Fog::Compute[:aws].create_volume(@server.availability_zone, nil, snapshot['snapshotId']).body
+      @volume_id = data['volumeId']
+      data
+    end
+
+    tests('#create_volume from snapshot with size').formats(@volume_format) do
+      volume = Fog::Compute[:aws].volumes.create(:availability_zone => 'us-east-1d', :size => 1)
+      snapshot = Fog::Compute[:aws].create_snapshot(volume.identity).body
+      data = Fog::Compute[:aws].create_volume(@server.availability_zone, 1, snapshot['snapshotId']).body
+      @volume_id = data['volumeId']
+      data
+    end
+
+    Fog::Compute[:aws].volumes.get(@volume_id).wait_for { ready? }
+
+    tests('#describe_volumes').formats(@volumes_format) do
+      Fog::Compute[:aws].describe_volumes.body
+    end
+
+    tests("#describe_volumes('volume-id' => #{@volume_id})").formats(@volumes_format) do
+      Fog::Compute[:aws].describe_volumes('volume-id' => @volume_id).body
+    end
+
+    tests("#attach_volume(#{@server.identity}, #{@volume_id}, '/dev/sdh')").formats(@volume_attachment_format) do
+      Fog::Compute[:aws].attach_volume(@server.identity, @volume_id, '/dev/sdh').body
+    end
+
+    Fog::Compute[:aws].volumes.get(@volume_id).wait_for { state == 'in-use' }
+
+    tests("#describe_volume('attachment.device' => '/dev/sdh')").formats(@volumes_format) do
+      Fog::Compute[:aws].describe_volumes('attachment.device' => '/dev/sdh').body
+    end
+
+    tests("#detach_volume('#{@volume_id}')").formats(@volume_attachment_format) do
+      Fog::Compute[:aws].detach_volume(@volume_id).body
+    end
+
+    Fog::Compute[:aws].volumes.get(@volume_id).wait_for { ready? }
+
+    tests("#delete_volume('#{@volume_id}')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].delete_volume(@volume_id).body
+    end
+
+  end
+  tests('failure') do
+
+    @volume = Fog::Compute[:aws].volumes.create(:availability_zone => @server.availability_zone, :size => 1)
+
+    tests("#attach_volume('i-00000000', '#{@volume.identity}', '/dev/sdh')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].attach_volume('i-00000000', @volume.identity, '/dev/sdh')
+    end
+
+    tests("#attach_volume('#{@server.identity}', 'vol-00000000', '/dev/sdh')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].attach_volume(@server.identity, 'vol-00000000', '/dev/sdh')
+    end
+
+    tests("#detach_volume('vol-00000000')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].detach_volume('vol-00000000')
+    end
+
+    tests("#delete_volume('vol-00000000')").raises(Fog::Compute::AWS::NotFound) do
+      Fog::Compute[:aws].delete_volume('vol-00000000')
+    end
+
+    @volume.destroy
+
+  end
+
+  @server.destroy
+
+end

data/tests/aws/requests/dns/dns_tests.rb

@@ -0,0 +1,289 @@
+Shindo.tests('Fog::DNS[:aws] | DNS requests', ['aws', 'dns']) do
+
+  @org_zone_count = 0
+  @zone_id = ''
+  @change_id = ''
+  @new_records = []
+  @domain_name = generate_unique_domain
+
+  @elb_connection = Fog::AWS::ELB.new
+  @r53_connection = Fog::DNS[:aws]
+
+  tests('success') do
+
+    test('get current zone count') do
+      pending if Fog.mocking?
+
+      @org_zone_count= 0
+      response = @r53_connection.list_hosted_zones
+      if response.status == 200
+        @hosted_zones = response.body['HostedZones']
+        @org_zone_count = @hosted_zones.count
+      end
+
+      response.status == 200
+    end
+
+    test('create simple zone') {
+      pending if Fog.mocking?
+
+      result = false
+
+      response = @r53_connection.create_hosted_zone(@domain_name)
+      if response.status == 201
+
+        zone        = response.body['HostedZone']
+        change_info = response.body['ChangeInfo']
+        ns_servers  = response.body['NameServers']
+
+        if (zone and change_info and ns_servers)
+
+          @zone_id = zone['Id']
+          caller_ref = zone['CallerReference']
+          @change_id = change_info['Id']
+          status = change_info['Status']
+          ns_srv_count = ns_servers.count
+
+          if (@zone_id.length > 0) and (caller_ref.length > 0) and (@change_id.length > 0) and
+             (status.length > 0) and (ns_srv_count > 0)
+            result = true
+          end
+        end
+      end
+
+      result
+    }
+
+    test("get status of change #{@change_id}") {
+      pending if Fog.mocking?
+
+      result = false
+      response = @r53_connection.get_change(@change_id)
+      if response.status == 200
+        status = response.body['Status']
+        if (status == 'PENDING') or (status == 'INSYNC')
+          result = true
+        end
+      end
+
+      result
+    }
+
+    test("get info on hosted zone #{@zone_id}") {
+      pending if Fog.mocking?
+
+      result = false
+
+      response = @r53_connection.get_hosted_zone(@zone_id)
+      if response.status == 200
+        zone = response.body['HostedZone']
+        zone_id = zone['Id']
+        name = zone['Name']
+        caller_ref = zone['CallerReference']
+        ns_servers = response.body['NameServers']
+
+        # AWS returns domain with a dot at end - so when compare, remove dot
+
+        if (zone_id == @zone_id) and (name.chop == @domain_name) and (caller_ref.length > 0) and
+           (ns_servers.count > 0)
+           result = true
+        end
+      end
+
+      result
+    }
+
+    test('list zones') do
+      pending if Fog.mocking?
+
+      result = false
+
+      response = @r53_connection.list_hosted_zones
+      if response.status == 200
+
+        zones= response.body['HostedZones']
+        if (zones.count > 0)
+          zone = zones[0]
+          zone_id = zone['Id']
+          zone_name= zone['Name']
+          caller_ref = zone['CallerReference']
+        end
+        max_items = response.body['MaxItems']
+
+        if (zone_id.length > 0) and (zone_name.length > 0) and (caller_ref.length > 0) and
+           (max_items > 0)
+          result = true
+        end
+      end
+
+      result
+    end
+
+    test("add a A resource record") {
+      pending if Fog.mocking?
+
+      # create an A resource record
+      host = 'www.' + @domain_name
+      ip_addrs = ['1.2.3.4']
+      resource_record = { :name => host, :type => 'A', :ttl => 3600, :resource_records => ip_addrs }
+      resource_record_set = resource_record.merge(:action => 'CREATE')
+
+      change_batch = []
+      change_batch << resource_record_set
+      options = { :comment => 'add A record to domain'}
+      response = @r53_connection.change_resource_record_sets(@zone_id, change_batch, options)
+      if response.status == 200
+        change_id = response.body['Id']
+        status = response.body['Status']
+        @new_records << resource_record
+      end
+
+      response.status == 200
+    }
+
+    test("add a CNAME resource record") {
+      pending if Fog.mocking?
+
+      # create a CNAME resource record
+      host = 'mail.' + @domain_name
+      value = ['www.' + @domain_name]
+      resource_record = { :name => host, :type => 'CNAME', :ttl => 3600, :resource_records => value }
+      resource_record_set = resource_record.merge(:action => 'CREATE')
+
+      change_batch = []
+      change_batch << resource_record_set
+      options = { :comment => 'add CNAME record to domain'}
+      response = @r53_connection.change_resource_record_sets( @zone_id, change_batch, options)
+      if response.status == 200
+        change_id = response.body['Id']
+        status = response.body['Status']
+        @new_records << resource_record
+      end
+
+      response.status == 200
+    }
+
+    test("add a MX resource record") {
+      pending if Fog.mocking?
+
+      # create a MX resource record
+      host = @domain_name
+      value = ['7 mail.' + @domain_name]
+      resource_record = { :name => host, :type => 'MX', :ttl => 3600, :resource_records => value }
+      resource_record_set = resource_record.merge( :action => 'CREATE')
+
+      change_batch = []
+      change_batch << resource_record_set
+      options = { :comment => 'add MX record to domain'}
+      response = @r53_connection.change_resource_record_sets( @zone_id, change_batch, options)
+      if response.status == 200
+        change_id = response.body['Id']
+        status = response.body['Status']
+        @new_records << resource_record
+      end
+
+      response.status == 200
+    }
+
+    test("add an ALIAS resource record") {
+      pending if Fog.mocking?
+
+      # create a load balancer
+      @elb_connection.create_load_balancer(["us-east-1a"], "fog", [{"Protocol" => "HTTP", "LoadBalancerPort" => "80", "InstancePort" => "80"}])
+
+      elb_response   = @elb_connection.describe_load_balancers("fog")
+      elb            = elb_response.body["DescribeLoadBalancersResult"]["LoadBalancerDescriptions"].first
+      hosted_zone_id = elb["CanonicalHostedZoneNameID"]
+      dns_name       = elb["DNSName"]
+
+      # create an ALIAS record
+      host = @domain_name
+      alias_target = {
+        :hosted_zone_id => hosted_zone_id,
+        :dns_name       => dns_name
+      }
+      resource_record = { :name => host, :type => 'A', :alias_target => alias_target }
+      resource_record_set = resource_record.merge(:action => 'CREATE')
+
+      change_batch = []
+      change_batch << resource_record_set
+      options = { :comment => 'add ALIAS record to domain'}
+
+      puts "Hosted Zone ID (ELB): #{hosted_zone_id}"
+      puts "DNS Name (ELB): #{dns_name}"
+      puts "Zone ID for Route 53: #{@zone_id}"
+
+      sleep 120
+      response = @r53_connection.change_resource_record_sets(@zone_id, change_batch, options)
+      if response.status == 200
+        change_id = response.body['Id']
+        status = response.body['Status']
+        @new_records << resource_record
+      end
+
+      response.status == 200
+    }
+
+    test("list resource records")  {
+      pending if Fog.mocking?
+
+      # get resource records for zone
+      response = @r53_connection.list_resource_record_sets( @zone_id)
+      if response.status == 200
+        record_sets= response.body['ResourceRecordSets']
+        num_records= record_sets.count
+      end
+
+      response.status == 200
+    }
+
+    test("delete #{@new_records.count} resource records") {
+      pending if Fog.mocking?
+
+      result = true
+
+      change_batch = []
+      @new_records.each { |record|
+        resource_record_set = record.merge( :action => 'DELETE')
+        change_batch << resource_record_set
+      }
+      options = { :comment => 'remove records from domain'}
+      response = @r53_connection.change_resource_record_sets(@zone_id, change_batch, options)
+      if response.status != 200
+        result = false
+        break
+      end
+
+      result
+    }
+
+    test("delete hosted zone #{@zone_id}") {
+      pending if Fog.mocking?
+
+      # cleanup the ELB as well
+      @elb_connection.delete_load_balancer("fog")
+
+      response = @r53_connection.delete_hosted_zone(@zone_id)
+
+      response.status == 200
+    }
+
+  end
+
+
+  tests('failure') do
+    tests('create hosted zone using invalid domain name').raises(Excon::Errors::BadRequest) do
+      pending if Fog.mocking?
+      response = @r53_connection.create_hosted_zone('invalid-domain')
+    end
+
+    tests('get hosted zone using invalid ID').raises(Excon::Errors::Forbidden) do
+      pending if Fog.mocking?
+      zone_id = 'dummy-id'
+      response = @r53_connection.get_hosted_zone(zone_id)
+    end
+
+  end
+
+
+end