fog 0.3.31 → 0.3.32

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

@@ -69,6 +69,15 @@ if Fog.mocking?
           it_should_behave_like "all delete responses"
           it_should_behave_like "a failed vapp deletion"
         end
+
+        context "when the VM's IP has an rnat set" do
+          before do
+            @mock_vm.network_ip[:rnat] = "1.2.3.4"
+          end
+
+          it_should_behave_like "all delete responses"
+          it_should_behave_like "a failed vapp deletion"
+        end
       end
 
       context "with a vapp uri that doesn't exist" do

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

@@ -1,9 +1,9 @@
 require File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper')
 
 if Fog.mocking?
-  shared_examples_for "the expected internet service item" do
+  shared_examples_for "a basic internet service" do
     specify { service.should be_an_instance_of Hash }
-    specify { service.should have(11).attributes }
+    specify { service.should have(14).attributes }
     specify { service[:Name].should == mock_service.name }
     specify { service[:Id].should == mock_service.object_id.to_s }
     specify { service[:Href].should == mock_service.href }
@@ -21,6 +21,39 @@ if Fog.mocking?
     specify { service[:Description].should == mock_service.description }
     specify { service[:RedirectURL].should == (mock_service.redirect_url || "") }
     specify { service[:Monitor].should == "" }
+    specify { service[:IsBackupService].should == "false" }
+    specify { service[:BackupOf].should == "" }
+  end
+
+  shared_examples_for "an internet service without a backup internet service set" do
+    specify { service[:BackupService].should be_nil }
+  end
+
+  shared_examples_for "an internet service with a backup internet service set" do
+    specify { service[:BackupService].should be_an_instance_of Hash }
+    specify { service[:BackupService].should include :Href }
+    specify { service[:BackupService][:Href].should == @mock_backup_service.href }
+  end
+
+  shared_examples_for "a backup internet service" do
+    specify { service.should be_an_instance_of Hash }
+    specify { service.should have(14).attributes }
+    specify { service[:Name].should == mock_service.name }
+    specify { service[:Id].should == mock_service.object_id.to_s }
+    specify { service[:Href].should == mock_service.href }
+
+    specify { service[:PublicIpAddress].should be_nil }
+
+    specify { service[:Port].should == mock_service.port.to_s }
+    specify { service[:Protocol].should == mock_service.protocol }
+    specify { service[:Enabled].should == mock_service.enabled.to_s }
+    specify { service[:Timeout].should == mock_service.timeout.to_s }
+    specify { service[:Description].should == mock_service.description }
+    specify { service[:RedirectURL].should == (mock_service.redirect_url || "") }
+    specify { service[:Monitor].should be_nil }
+    specify { service[:IsBackupService].should == "true" }
+    specify { service[:BackupService].should be_nil }
+    specify { service[:BackupOf].should == "" }
   end
 
   describe "Fog::Vcloud, initialized w/ the TMRK Ecloud module", :type => :mock_tmrk_ecloud_request do
@@ -30,7 +63,11 @@ if Fog.mocking?
 
     describe "#get_internet_services" do
       context "with a valid VDC internet_services_uri" do
-        before { @services = @vcloud.get_internet_services(@mock_vdc_service_collection.href) }
+        before do
+          @mock_vdc.internet_service_collection.items[3][:backup_service] = @mock_backup_service
+          @services = @vcloud.get_internet_services(@mock_vdc_service_collection.href)
+        end
+
         subject { @services }
 
         it_should_behave_like "all responses"
@@ -41,20 +78,32 @@ if Fog.mocking?
 
           it { should have(3).items }
 
-          its(:xmlns) { should == "urn:tmrk:eCloudExtensions-2.3" }
-          its(:xmlns_i) { should == "http://www.w3.org/2001/XMLSchema-instance" }
-
           context "[:InternetService]" do
             subject { @services.body[:InternetService] }
 
-            it { should have(4).items }
+            it { should have(5).items }
 
-            [0,1,2,3].each do |idx|
+            [0,1,2].each do |idx|
               let(:service) { subject[idx] }
-              let(:mock_service) { @mock_vdc.public_ip_collection.items.map {|ip| ip.internet_service_collection.items }.flatten[idx] }
+              let(:mock_service) { @mock_vdc.internet_service_collection.items[idx] }
               let(:mock_ip) { mock_service._parent._parent }
 
-              it_should_behave_like "the expected internet service item"
+              it_should_behave_like "an internet service without a backup internet service set"
+            end
+
+            context "for a service with a backup internet service" do
+              let(:service) { subject[3] }
+              let(:mock_service) { @mock_vdc.internet_service_collection.items[3] }
+              let(:mock_ip) { mock_service._parent._parent }
+
+              it_should_behave_like "an internet service with a backup internet service set"
+            end
+
+            context "for a backup internet service" do
+              let(:service) { subject[4] }
+              let(:mock_service) { @mock_vdc.internet_service_collection.backup_internet_services.first }
+
+              it_should_behave_like "a backup internet service"
             end
           end
         end
@@ -74,9 +123,6 @@ if Fog.mocking?
 
           it { should have(3).items }
 
-          its(:xmlns) { should == "urn:tmrk:eCloudExtensions-2.3" }
-          its(:xmlns_i) { should == "http://www.w3.org/2001/XMLSchema-instance" }
-
           context "[:InternetService]" do
             subject { @services.body[:InternetService] }
 
@@ -87,7 +133,7 @@ if Fog.mocking?
               let(:mock_service) { @mock_service_collection.items[idx] }
               let(:mock_ip) { @mock_public_ip }
 
-              it_should_behave_like "the expected internet service item"
+              it_should_behave_like "an internet service without a backup internet service set"
             end
           end
         end

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

@@ -23,6 +23,8 @@ if Fog.mocking?
           its(:Name) { should == @mock_network_ip.name }
           its(:Href) { should == @mock_network_ip.href }
           its(:Id)   { should == @mock_network_ip.object_id.to_s }
+          its(:RnatAddress) { should == @mock_network_ip.rnat }
+          its(:Status) { should == @mock_network_ip.status }
 
         end
       end

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

@@ -30,16 +30,16 @@ if Fog.mocking?
 
           context "one we know is assigned" do
             let(:address) { @ips.body[:IpAddress][0] }
-            specify { address.should have(5).keys }
+            specify { address.should have(6).keys }
             specify { address[:Status].should == "Assigned" }
             specify { address[:Server].should == "Broom 1" }
             specify { address[:Name].should == "1.2.3.3" }
             specify { address[:RnatAddress].should == "99.1.2.3" }
           end
 
-          context "one we know is assigned" do
+          context "one we know is not assigned" do
             let(:address) { @ips.body[:IpAddress][100] }
-            specify { address.should have(4).keys }
+            specify { address.should have(5).keys }
             specify { address[:Status].should == "Available" }
             specify { address.has_key?(:Server).should be_false }
             specify { address[:Name].should == "1.2.3.103" }

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

@@ -2,21 +2,22 @@ Shindo.tests('AWS::Compute | image requests', ['aws']) do
 
   @images_format = {
     'imagesSet'    => [{
-      'architecture'    => String,
-      'blockDeviceMapping' =>[],
-      'imageId'         => String,
-      'imageLocation'   => String,
-      'imageOwnerId'    => String,
-      'imageState'      => String,
-      'imageType'       => String,
-      'isPublic'        => Fog::Boolean,
-      'kernelId'        => String,
-      'productCodes'    => [],
-      'ramdiskId'       => String,
-      'rootDeviceType'  => String,
-      'tagSet'          => {}
+      'architecture'        => String,
+      'blockDeviceMapping'  =>[],
+      'imageId'             => String,
+      'imageLocation'       => String,
+      'imageOwnerId'        => String,
+      'imageState'          => String,
+      'imageType'           => String,
+      'isPublic'            => Fog::Boolean,
+      'kernelId'            => String,
+      'productCodes'        => [],
+      'ramdiskId'           => String,
+      'rootDeviceType'      => String,
+      'tagSet'              => {},
+      'virtualizationType'  => String
     }],
-      'requestId'     => String,
+    'requestId'     => String,
   }
 
   tests('success') do

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

@@ -0,0 +1,276 @@
+Shindo.tests('AWS::DNS | DNS requests', ['aws', 'dns']) do
+
+  @org_zone_count = 0
+  @zone_id = ''
+  @change_id = ''
+  @new_records =[]
+ 
+  # NOTE: can't use generate_unique_domain() as we do in other DNS provider
+  #       test suites as AWS charges $1/mth for each domain, even if it exists 
+  #       on AWS for only the time that this test suite runs!!
+  #       http://aws.amazon.com/route53/pricing/
+  @test_domain = 'test-343246324434.com'
+  
+  tests( 'success') do
+
+    test('see if test domain already exists') do
+      pending if Fog.mocking?
+      
+      @zone_id = nil
+      
+      response = AWS[:dns].list_hosted_zones()
+      if response.status == 200
+        @hosted_zones = response.body['HostedZones']
+      end
+
+      #go through zones for this account
+      @hosted_zones.each { |zone|
+        domain = zone['Name']
+        if domain.chomp == @test_domain
+          @zone_id = zone['Id']
+        end
+      }
+      
+      @zone_id.nil?
+    end
+      
+    test('get current zone count') do
+      pending if Fog.mocking?
+
+      @org_zone_count= 0
+      response = AWS[:dns].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 = AWS[:dns].create_hosted_zone( @test_domain)
+      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 = AWS[:dns].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 = AWS[:dns].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 == @test_domain) 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 = AWS[:dns].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?
+
+      result = false
+      
+      # create an A resource record
+      host = 'www.' + @test_domain
+      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 = AWS[:dns].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?
+
+      result = false
+      
+      # create a CNAME resource record
+      host = 'mail.' + @test_domain
+      value = ['www.' + @test_domain]
+      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 = AWS[:dns].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?
+
+      result = false
+      
+      # create a MX resource record
+      host = @test_domain
+      value = ['7 mail.' + @test_domain]
+      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 = AWS[:dns].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 = AWS[:dns].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 = AWS[:dns].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?
+
+      response = AWS[:dns].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 = AWS[:dns].create_hosted_zone('invalid-domain')
+    end
+    
+    tests('get hosted zone using invalid ID').raises(Excon::Errors::BadRequest) do
+      pending if Fog.mocking?
+      zone_id = 'dummy-id'
+      response = AWS[:dns].get_hosted_zone(zone_id)
+    end
+  
+  end
+
+  
+end