fog-aws 0.0.5

data/tests/requests/compute/vpc_tests.rb

@@ -0,0 +1,111 @@
+Shindo.tests('Fog::Compute[:aws] | vpc requests', ['aws']) do
+
+  @create_vpcs_format = {
+    'vpcSet' => [{
+      'vpcId'           => String,
+      'state'           => String,
+      'cidrBlock'       => String,
+      'dhcpOptionsId'   => String,
+      'tagSet'          => Hash
+    }],
+    'requestId' => String
+  }
+
+  @describe_vpcs_format = {
+    'vpcSet' => [{
+      'vpcId'           => String,
+      'state'           => String,
+      'cidrBlock'       => String,
+      'dhcpOptionsId'   => String,
+      'tagSet'          => Hash,
+      'instanceTenancy' => Fog::Nullable::String,
+    }],
+    'requestId' => String
+  }
+
+  tests('success') do
+
+    @vpc_id = nil
+
+    tests('#create_vpc').formats(@create_vpcs_format) do
+      data = Fog::Compute[:aws].create_vpc('10.255.254.0/28').body
+      @vpc_id = data['vpcSet'].first['vpcId']
+      data
+    end
+
+    tests('#describe_vpcs').formats(@describe_vpcs_format) do
+      Fog::Compute[:aws].describe_vpcs.body
+    end
+
+    [ 'enableDnsSupport', 'enableDnsHostnames'].each do |attrib|
+      tests("#describe_vpc_attribute('#{@vpc_id}', #{attrib})").returns(@vpc_id) do
+        Fog::Compute[:aws].describe_vpc_attribute(@vpc_id, attrib).body['vpcId']
+      end
+    end
+
+    tests("#modify_vpc_attribute('#{@vpc_id}', {'EnableDnsSupport.Value' => false})").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].modify_vpc_attribute(@vpc_id, {'EnableDnsSupport.Value' => false}).body
+    end
+    tests("#describe_vpc_attribute(#{@vpc_id}, 'enableDnsSupport')").returns(false) do
+      Fog::Compute[:aws].describe_vpc_attribute(@vpc_id, 'enableDnsSupport').body["enableDnsSupport"]
+    end
+    tests("#modify_vpc_attribute('#{@vpc_id}', {'EnableDnsSupport.Value' => true})").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].modify_vpc_attribute(@vpc_id, {'EnableDnsSupport.Value' => true}).body
+    end
+    tests("#describe_vpc_attribute(#{@vpc_id}, 'enableDnsSupport')").returns(true) do
+      Fog::Compute[:aws].describe_vpc_attribute(@vpc_id, 'enableDnsSupport').body["enableDnsSupport"]
+    end
+
+    tests("#modify_vpc_attribute('#{@vpc_id}', {'EnableDnsHostnames.Value' => true})").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].modify_vpc_attribute(@vpc_id, {'EnableDnsHostnames.Value' => true}).body
+    end
+    tests("#describe_vpc_attribute(#{@vpc_id}, 'enableDnsHostnames')").returns(true) do
+      Fog::Compute[:aws].describe_vpc_attribute(@vpc_id, 'enableDnsHostnames').body["enableDnsHostnames"]
+    end
+    tests("#modify_vpc_attribute('#{@vpc_id}', {'EnableDnsHostnames.Value' => false})").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].modify_vpc_attribute(@vpc_id, {'EnableDnsHostnames.Value' => false}).body
+    end
+    tests("#describe_vpc_attribute(#{@vpc_id}, 'enableDnsHostnames')").returns(false) do
+      Fog::Compute[:aws].describe_vpc_attribute(@vpc_id, 'enableDnsHostnames').body["enableDnsHostnames"]
+    end
+
+    tests("#modify_vpc_attribute('#{@vpc_id}')").raises(Fog::Compute::AWS::Error) do
+      Fog::Compute[:aws].modify_vpc_attribute(@vpc_id).body
+    end
+
+    tests("#modify_vpc_attribute('#{@vpc_id}', {'EnableDnsSupport.Value' => true, 'EnableDnsHostnames.Value' => true})").raises(Fog::Compute::AWS::Error) do
+      Fog::Compute[:aws].modify_vpc_attribute(@vpc_id, {'EnableDnsSupport.Value' => true, 'EnableDnsHostnames.Value' => true}).body
+    end
+
+    # Create another vpc to test tag filters
+    test_tags = {'foo' => 'bar'}
+    @another_vpc = Fog::Compute[:aws].vpcs.create :cidr_block => '1.2.3.4/24', :tags => test_tags
+
+    tests("#describe_vpcs('tag-key' => 'foo')").formats(@describe_vpcs_format)do
+      body = Fog::Compute[:aws].describe_vpcs('tag-key' => 'foo').body
+      tests("returns 1 vpc").returns(1) { body['vpcSet'].size }
+      body
+    end
+
+    tests("#describe_vpcs('tag-value' => 'bar')").formats(@describe_vpcs_format)do
+      body = Fog::Compute[:aws].describe_vpcs('tag-value' => 'bar').body
+      tests("returns 1 vpc").returns(1) { body['vpcSet'].size }
+      body
+    end
+
+    tests("#describe_vpcs('tag:foo' => 'bar')").formats(@describe_vpcs_format)do
+      body = Fog::Compute[:aws].describe_vpcs('tag:foo' => 'bar').body
+      tests("returns 1 vpc").returns(1) { body['vpcSet'].size }
+      body
+    end
+
+    tests("#delete_vpc('#{@vpc_id}')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].delete_vpc(@vpc_id).body
+    end
+
+    # Clean up
+    Fog::Compute[:aws].delete_tags(@another_vpc.id, test_tags)
+    @another_vpc.destroy
+    Fog::Compute::AWS::Mock.reset if Fog.mocking?
+  end
+end

data/tests/requests/data_pipeline/helper.rb

@@ -0,0 +1,72 @@
+class AWS
+  module DataPipeline
+    module Formats
+      BASIC = {
+        'pipelineId' => String,
+      }
+
+      FIELDS = [
+        {
+          "key" => String,
+          "refValue" => Fog::Nullable::String,
+          "stringValue" => Fog::Nullable::String,
+        }
+      ]
+
+      LIST_PIPELINES = {
+        "hasMoreResults" => Fog::Nullable::Boolean,
+        "marker" => Fog::Nullable::String,
+        "pipelineIdList" => [
+          {
+            "id" => String,
+            "name" => String,
+          }
+        ]
+      }
+
+      QUERY_OBJECTS = {
+        "hasMoreResults" => Fog::Nullable::Boolean,
+        "marker" => Fog::Nullable::String,
+        "ids" => Fog::Nullable::Array,
+      }
+
+      DESCRIBE_OBJECTS = {
+        "hasMoreResults" => Fog::Nullable::Boolean,
+        "marker" => Fog::Nullable::String,
+        "pipelineObjects" => [
+          {
+            'id' => String,
+            'name' => String,
+            'fields' => FIELDS,
+          }
+        ]
+      }
+
+      DESCRIBE_PIPELINES = {
+        "pipelineDescriptionList" => [
+          {
+            "description" => Fog::Nullable::String,
+            "name" => String,
+            "pipelineId" => String,
+            "fields" => FIELDS,
+          }
+        ]
+      }
+
+      PUT_PIPELINE_DEFINITION = {
+        "errored" => Fog::Boolean,
+        "validationErrors" => Fog::Nullable::Array,
+      }
+
+      GET_PIPELINE_DEFINITION = {
+        "pipelineObjects" => [
+          {
+            "id" => String,
+            "name" => String,
+            "fields" => FIELDS,
+          }
+        ]
+      }
+    end
+  end
+end

data/tests/requests/data_pipeline/pipeline_tests.rb

@@ -0,0 +1,78 @@
+Shindo.tests('AWS::DataPipeline | pipeline_tests', ['aws', 'data_pipeline']) do
+  pending if Fog.mocking?
+
+  @pipeline_id = nil
+
+  tests('success') do
+    tests("#create_pipeline").formats(AWS::DataPipeline::Formats::BASIC) do
+      unique_id = 'fog-test-pipeline-unique-id'
+      name = 'fog-test-pipeline-name'
+      description = 'Fog test pipeline'
+
+      result = Fog::AWS[:data_pipeline].create_pipeline(unique_id, name, description, {})
+      @pipeline_id = result['pipelineId']
+      result
+    end
+
+    tests("#list_pipelines").formats(AWS::DataPipeline::Formats::LIST_PIPELINES) do
+      Fog::AWS[:data_pipeline].list_pipelines()
+    end
+
+    tests("#describe_pipelines").formats(AWS::DataPipeline::Formats::DESCRIBE_PIPELINES) do
+      ids = [@pipeline_id]
+      Fog::AWS[:data_pipeline].describe_pipelines(ids)
+    end
+
+    tests("#put_pipeline_definition").formats(AWS::DataPipeline::Formats::PUT_PIPELINE_DEFINITION) do
+      objects = [
+        {
+          "id" => "Nightly",
+          "type" => "Schedule",
+          "startDateTime" => Time.now.strftime("%Y-%m-%dT%H:%M:%S"),
+          "period" => "24 hours",
+        },
+        {
+          "id" => "Default",
+          "role" => "role-dumps",
+          "resourceRole" => "role-dumps-inst",
+          "schedule" => { "ref" => "Nightly" },
+        },
+      ]
+
+      Fog::AWS[:data_pipeline].put_pipeline_definition(@pipeline_id, objects)
+    end
+
+    tests("#activate_pipeline") do
+      Fog::AWS[:data_pipeline].activate_pipeline(@pipeline_id)
+    end
+
+    tests("#get_pipeline_definition").formats(AWS::DataPipeline::Formats::GET_PIPELINE_DEFINITION) do
+      Fog::AWS[:data_pipeline].get_pipeline_definition(@pipeline_id)
+    end
+
+    tests("#query_objects") do
+      tests("for COMPONENTs").formats(AWS::DataPipeline::Formats::QUERY_OBJECTS) do
+        Fog::AWS[:data_pipeline].query_objects(@pipeline_id, 'COMPONENT')
+      end
+
+      tests("for INSTANCEs").formats(AWS::DataPipeline::Formats::QUERY_OBJECTS) do
+        Fog::AWS[:data_pipeline].query_objects(@pipeline_id, 'INSTANCE')
+      end
+
+      tests("for ATTEMPTs").formats(AWS::DataPipeline::Formats::QUERY_OBJECTS) do
+        Fog::AWS[:data_pipeline].query_objects(@pipeline_id, 'ATTEMPT')
+      end
+    end
+
+    tests('#describe_objects').formats(AWS::DataPipeline::Formats::DESCRIBE_OBJECTS) do
+      attempts = Fog::AWS[:data_pipeline].query_objects(@pipeline_id, 'ATTEMPT')
+      object_ids = attempts['ids'][0..5]
+      Fog::AWS[:data_pipeline].describe_objects(@pipeline_id, object_ids)
+    end
+
+    tests("#delete_pipeline").returns(true) do
+      Fog::AWS[:data_pipeline].delete_pipeline(@pipeline_id)
+    end
+
+  end
+end

data/tests/requests/dns/dns_tests.rb

@@ -0,0 +1,257 @@
+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
+      @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') {
+      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}") {
+      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}") {
+      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
+      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") {
+      # 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") {
+      # 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") {
+      # 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") {
+      # 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("LoadBalancerNames" => "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,
+        :evaluate_target_health => false
+      }
+      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 unless Fog.mocking?
+      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
+    }
+
+    tests("list resource records").formats(AWS::DNS::Formats::LIST_RESOURCE_RECORD_SETS)  {
+      # get resource records for zone
+      @r53_connection.list_resource_record_sets(@zone_id).body
+    }
+
+    test("delete #{@new_records.count} resource records") {
+      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}") {
+      # 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::NotFound) do
+      pending if Fog.mocking?
+      zone_id = 'dummy-id'
+      response = @r53_connection.get_hosted_zone(zone_id)
+    end
+
+  end
+
+end