fog-aws 1.4.1 → 3.27.0

data/tests/requests/data_pipeline/helper.rb

@@ -1,78 +0,0 @@
-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" => [
-          {
-            "fields" => [
-              {
-                '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,
-          }
-        ],
-        "parameterObjects" => Fog::Nullable::Array,
-        "parameterValues" => Fog::Nullable::Array,
-      }
-    end
-  end
-end

data/tests/requests/data_pipeline/pipeline_tests.rb

@@ -1,80 +0,0 @@
-Shindo.tests('AWS::DataPipeline | pipeline_tests', ['aws', 'data_pipeline']) do
-  @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, {}).body
-      @pipeline_id = result['pipelineId']
-      result
-    end
-
-    tests("#list_pipelines").formats(AWS::DataPipeline::Formats::LIST_PIPELINES) do
-      Fog::AWS[:data_pipeline].list_pipelines.body
-    end
-
-    tests("#describe_pipelines").formats(AWS::DataPipeline::Formats::DESCRIBE_PIPELINES) do
-      ids = [@pipeline_id]
-      Fog::AWS[:data_pipeline].describe_pipelines(ids).body
-    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).body
-    end
-
-    tests("#activate_pipeline") do
-      Fog::AWS[:data_pipeline].activate_pipeline(@pipeline_id)
-    end
-
-    tests("#deactivate_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).body
-    end
-
-    tests("#query_objects") do
-      tests("for COMPONENTs").formats(AWS::DataPipeline::Formats::QUERY_OBJECTS) do
-        Fog::AWS[:data_pipeline].query_objects(@pipeline_id, 'COMPONENT').body
-      end
-
-      tests("for INSTANCEs").formats(AWS::DataPipeline::Formats::QUERY_OBJECTS) do
-        Fog::AWS[:data_pipeline].query_objects(@pipeline_id, 'INSTANCE').body
-      end
-
-      tests("for ATTEMPTs").formats(AWS::DataPipeline::Formats::QUERY_OBJECTS) do
-        Fog::AWS[:data_pipeline].query_objects(@pipeline_id, 'ATTEMPT').body
-      end
-    end
-
-    tests('#describe_objects').formats(AWS::DataPipeline::Formats::DESCRIBE_OBJECTS) do
-      attempts = Fog::AWS[:data_pipeline].query_objects(@pipeline_id, 'ATTEMPT').body
-      object_ids = attempts['ids'][0..5]
-      Fog::AWS[:data_pipeline].describe_objects(@pipeline_id, object_ids).body
-    end
-
-    tests("#delete_pipeline").returns(true) do
-      Fog::AWS[:data_pipeline].delete_pipeline(@pipeline_id)
-    end
-
-  end
-end

data/tests/requests/dns/change_resource_record_sets_tests.rb

@@ -1,34 +0,0 @@
-Shindo.tests('Fog::DNS[:aws] | change_resource_record_sets', ['aws', 'dns']) do
-  tests('success') do
-    test('#elb_hosted_zone_mapping from DNS name') do
-      zone_id = Fog::DNS::AWS.hosted_zone_for_alias_target('arbitrary-sub-domain.eu-west-1.elb.amazonaws.com')
-      zone_id == Fog::DNS::AWS.elb_hosted_zone_mapping['eu-west-1']
-    end
-  end
-
-  tests("#change_resource_record_sets_data formats geolocation properly") do
-    change_batch = [{
-        :action=>"CREATE",
-        :name=>"ark.m.example.net.",
-        :resource_records=>["1.1.1.1"],
-        :ttl=>"300",
-        :type=>"A",
-        :set_identifier=>"ark",
-        :geo_location=>{"CountryCode"=>"US", "SubdivisionCode"=>"AR"},
-        }]
-
-    version = '2013-04-01'
-    result = Fog::DNS::AWS.change_resource_record_sets_data('zone_id123', change_batch, version)
-    doc = Nokogiri::XML(result)
-
-    returns("https://route53.amazonaws.com/doc/#{version}/") { doc.namespaces['xmlns'] }
-    returns(%w[US AR]) {
-      [
-        doc.css("GeoLocation CountryCode").text,
-        doc.css("GeoLocation SubdivisionCode").text
-      ]
-    }
-
-    result
-  end
-end

data/tests/requests/dns/dns_tests.rb

@@ -1,244 +0,0 @@
-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)
-
-      Fog.wait_for { @r53_connection.get_change(response.body["Id"]).body["Status"] != "PENDING" }
-
-      @new_records << resource_record
-
-      @r53_connection.get_change(response.body["Id"]).body["Status"] == "INSYNC"
-    }
-
-    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)
-
-      Fog.wait_for { @r53_connection.get_change(response.body["Id"]).body["Status"] != "PENDING" }
-
-      @new_records << resource_record
-
-      @r53_connection.get_change(response.body["Id"]).body["Status"] == "INSYNC"
-    }
-
-    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)
-
-      Fog.wait_for { @r53_connection.get_change(response.body["Id"]).body["Status"] != "PENDING" }
-
-      @new_records << resource_record
-
-      @r53_connection.get_change(response.body["Id"]).body["Status"] == "INSYNC"
-    }
-
-    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}"
-
-      response = @r53_connection.change_resource_record_sets(@zone_id, change_batch, options)
-
-      Fog.wait_for { @r53_connection.get_change(response.body["Id"]).body["Status"] != "PENDING" }
-
-      @new_records << resource_record
-
-      @r53_connection.get_change(response.body["Id"]).body["Status"] == "INSYNC"
-    }
-
-
-    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") {
-      change_batch = @new_records.map { |record| record.merge(:action => 'DELETE') }
-      options      = { :comment => 'remove records from domain'}
-
-      response = @r53_connection.change_resource_record_sets(@zone_id, change_batch, options)
-
-      Fog.wait_for { @r53_connection.get_change(response.body["Id"]).body["Status"] != "PENDING" }
-
-      @r53_connection.get_change(response.body["Id"]).body["Status"] == "INSYNC"
-    }
-
-    test("delete hosted zone #{@zone_id}") {
-      # cleanup the ELB as well
-      @elb_connection.delete_load_balancer("fog")
-
-      @r53_connection.delete_hosted_zone(@zone_id).status == 200
-    }
-
-  end
-
-  tests('failure') do
-    tests('create hosted zone using invalid domain name').raises(Excon::Errors::BadRequest) do
-      pending if Fog.mocking?
-      @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'
-      @r53_connection.get_hosted_zone(zone_id)
-    end
-
-  end
-
-end

data/tests/requests/dns/health_check_tests.rb

@@ -1,159 +0,0 @@
-Shindo.tests('Fog::DNS[:aws] | DNS requests', ['aws', 'dns']) do
-
-  pending if Fog.mocking?
-
-  @r53_connection = Fog::DNS[:aws]
-
-  tests('success') do
-
-    tests('create a health check') do
-      after do
-        @r53_connection.delete_health_check(@response.body['HealthCheck']['Id'])
-      end
-
-      test('create an IP TCP based health check') do
-        @response = @r53_connection.create_health_check('8.8.8.8', '53', 'TCP')
-        @response.status == 201 &&
-          @response.body['HealthCheck']['HealthCheckConfig']['IPAddress'] == '8.8.8.8' &&
-          @response.body['HealthCheck']['HealthCheckConfig']['Port'] == '53'
-      end
-
-      test('create a FQDN HTTP based health check') do
-        @options = {
-          :fqdn => "www.amazon.com",
-          :resource_path => "/gp/cart/view.html/ref=nav_cart"
-        }
-        @response = @r53_connection.create_health_check(nil, '80', 'HTTP', @options)
-        @response.status == 201 &&
-          @response.body['HealthCheck']['HealthCheckConfig']['IPAddress'].nil? &&
-          @response.body['HealthCheck']['HealthCheckConfig']['Port'] == '80' &&
-          @response.body['HealthCheck']['HealthCheckConfig']['FullyQualifiedDomainName'] == 'www.amazon.com'
-      end
-    end
-
-    tests('get a health check') do
-      @options = {
-        :fqdn => "www.amazon.com",
-        :resource_path => "/gp/cart/view.html/ref=nav_cart",
-        :search_string => "Amazon",
-        :request_interval => 10,
-        :failure_threshold => "7"
-      }
-      create_response = @r53_connection.create_health_check('8.8.8.8', '443', 'HTTPS_STR_MATCH', @options)
-      @health_check_id = create_response.body['HealthCheck']['Id']
-      @response = @r53_connection.get_health_check(@health_check_id)
-
-      sleep 2
-      @r53_connection.delete_health_check(@health_check_id)
-
-      test('id') do
-        @response.body['HealthCheck']['Id'] == @health_check_id
-      end
-
-      {
-        'IPAddress' => '8.8.8.8',
-        'Port' => '443',
-        'Type' => 'HTTPS_STR_MATCH',
-        'FullyQualifiedDomainName' => @options[:fqdn],
-        'ResourcePath' => @options[:resource_path],
-        'RequestInterval' => @options[:request_interval],
-        'FailureThreshold' => @options[:failure_threshold]
-      }.each do |key, value|
-        test("and check property #{key}") do
-          @response.body['HealthCheck']['HealthCheckConfig'][key] == value
-        end
-      end
-    end
-
-    tests('delete a health check') do
-      before do
-        response = @r53_connection.create_health_check('8.8.8.8', '53', 'TCP')
-        @health_check_id = response.body['HealthCheck']['Id']
-      end
-
-      test('setup as IP TCP') do
-        response = @r53_connection.delete_health_check(@health_check_id)
-        response.status == 200
-      end
-    end
-
-    tests('listing health checks') do
-      test('succeeds') do
-        response = @r53_connection.list_health_checks
-        response.status == 200
-      end
-
-      before do
-        response_1 = @r53_connection.create_health_check('8.8.8.8', '53', 'TCP')
-        @health_check_1_id = response_1.body['HealthCheck']['Id']
-        options = {
-          :fqdn => "www.amazon.com",
-          :resource_path => "/gp/cart/view.html/ref=nav_cart"
-        }
-        response_2 = @r53_connection.create_health_check(nil, '80', 'HTTP', options)
-        @health_check_2_id = response_2.body['HealthCheck']['Id']
-        @health_check_ids = [@health_check_1_id, @health_check_2_id]
-      end
-
-      after do
-        @health_check_ids.each { |id| @r53_connection.delete_health_check id }
-      end
-
-      test('contains 2 new health checks') do
-        sleep 2
-        response = @r53_connection.list_health_checks
-        health_checks_by_id = response.body['HealthChecks'].map do |health_check|
-          health_check['Id']
-        end.to_a
-        @health_check_ids.all? { |id| health_checks_by_id.include?(id) }
-      end
-
-      test('contains properties') do
-        sleep 2
-        response = @r53_connection.list_health_checks
-        list_response_2 = response.body['HealthChecks'].find { |health_check| health_check['Id'] == @health_check_2_id }
-
-        list_response_2['HealthCheckConfig']['Type'] == 'HTTP' &&
-          list_response_2['HealthCheckConfig']['FullyQualifiedDomainName'] == 'www.amazon.com' &&
-          list_response_2['HealthCheckConfig']['IPAddress'].nil?
-      end
-    end
-
-    tests('assign a health check to a DNS record') do
-      after do
-        @r53_connection.change_resource_record_sets(@zone_id, [@resource_record.merge(:action => 'DELETE')])
-        @r53_connection.delete_hosted_zone(@zone_id)
-        @r53_connection.delete_health_check @health_check_id
-      end
-
-      health_check_response = @r53_connection.create_health_check('8.8.8.8', '53', 'TCP')
-      raise "Health check was not created" unless health_check_response.status == 201
-      @health_check_id = health_check_response.body['HealthCheck']['Id']
-
-      @domain_name = generate_unique_domain
-      zone_response = @r53_connection.create_hosted_zone(@domain_name)
-      raise "Zone was not created for #{@domain_name}" unless zone_response.status == 201
-      @zone_id = zone_response.body['HostedZone']['Id']
-
-      @resource_record = {
-        :name => "www.#{@domain_name}.",
-        :type => 'A',
-        :ttl => 3600,
-        :resource_records => ['8.8.4.4'],
-        :health_check_id => @health_check_id,
-        :set_identifier => SecureRandom.hex(8),
-        :weight => 50
-      }
-      resource_record_set = [@resource_record.merge(:action => 'CREATE')]
-      record_response = @r53_connection.change_resource_record_sets @zone_id, resource_record_set
-      raise "A record was not created" unless record_response.status == 200
-
-      test('succeeds') do
-        new_record = @r53_connection.list_resource_record_sets(@zone_id).body['ResourceRecordSets'].find do |record|
-          record['Name'] == @resource_record[:name]
-        end
-        new_record['HealthCheckId'] == @health_check_id
-      end
-    end
-  end
-end

data/tests/requests/dns/helper.rb

@@ -1,21 +0,0 @@
-class AWS
-  module DNS
-    module Formats
-      RESOURCE_RECORD_SET = {
-        "ResourceRecords" => Array,
-        "Name" => String,
-        "Type" => String,
-        "AliasTarget"=> Fog::Nullable::Hash,
-        "TTL" => Fog::Nullable::String
-      }
-
-      LIST_RESOURCE_RECORD_SETS = {
-        "ResourceRecordSets" => [RESOURCE_RECORD_SET],
-        "IsTruncated" => Fog::Boolean,
-        "MaxItems" => Integer,
-        "NextRecordName" => Fog::Nullable::String,
-        "NextRecordType" => Fog::Nullable::String
-      }
-    end
-  end
-end