fog 1.10.0 → 1.10.1

data/lib/fog/xenserver/requests/compute/destroy_vlan.rb

@@ -0,0 +1,32 @@
+module Fog
+  module Compute
+    class XenServer
+
+      class Real
+
+        # Destroy a VLAN 
+        #
+        # @see http://docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=VLAN
+        #
+        def destroy_vlan( ref )
+          @connection.request(
+            {
+              :parser => Fog::Parsers::XenServer::Base.new, 
+              :method => 'VLAN.destroy'
+            }, 
+            ref
+          )
+        end
+
+      end
+
+      class Mock
+
+        def destroy_vlan( ref )
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/zerigo/models/dns/records.rb

@@ -10,15 +10,23 @@ module Fog
         attribute :zone
 
         model Fog::DNS::Zerigo::Record
-
-        def all
+        
+        # List all domains
+        # @param [Hash] options Options to pass to the underlying API call 
+        # @option options [String] :fqdn search for the given fqdn
+        def all(options = {})
           requires :zone
-          parent = zone.collection.get(zone.identity)
-          if parent
-            merge_attributes(parent.records.attributes)
-            load(parent.records.map {|record| record.attributes})
+          if options[:fqdn]
+            hosts = service.find_hosts(options[:fqdn], zone.id).body['hosts']
+            load(hosts)
           else
-            nil
+            parent = zone.collection.get(zone.identity)
+            if parent
+              merge_attributes(parent.records.attributes)
+              load(parent.records.map {|record| record.attributes})
+            else
+              nil
+            end
           end
         end
 
@@ -34,11 +42,6 @@ module Fog
           super({ :zone => zone }.merge!(attributes))
         end
 
-        def find(fqdn)
-          hosts = service.find_hosts(fqdn, zone.id).body['hosts']
-          hosts.collect { |host| new(host) }
-        end
-
       end
 
     end

data/lib/tasks/changelog_task.rb

@@ -68,6 +68,7 @@ module Fog
               'nightshade427',
               'Patrick Debois',
               'Paul Thornthwaite',
+              'Rupak Ganguly',
               'Stepan G. Fedorov',
               'Wesley Beary'
             ].include?(committer)

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

@@ -49,6 +49,10 @@ Shindo.tests('Fog::Compute[:aws] | address requests', ['aws']) do
       Fog::Compute[:aws].disassociate_address(@public_ip).body
     end
 
+    tests("#associate_addresses('#{@server.id}', nil, nil, '#{@vpc_allocation_id}')").formats(AWS::Compute::Formats::BASIC) do
+      Fog::Compute[:aws].associate_address(@server.id, nil, nil, @vpc_allocation_id).body
+    end
+
     tests("#release_address('#{@public_ip}')").formats(AWS::Compute::Formats::BASIC) do
       Fog::Compute[:aws].release_address(@public_ip).body
     end

data/tests/aws/requests/iam/server_certificate_tests.rb

@@ -13,6 +13,9 @@ Shindo.tests('AWS::IAM | server certificate requests', ['aws']) do
     'Certificate' => @certificate_format,
     'RequestId' => String
   }
+  @update_format = {
+    'RequestId' => String
+  }
   @get_server_certificate_format = {
     'Certificate' => @certificate_format,
     'RequestId' => String
@@ -64,6 +67,35 @@ Shindo.tests('AWS::IAM | server certificate requests', ['aws']) do
     end
   end
 
+  tests('#update_server_certificate') do
+    public_key  = AWS::IAM::SERVER_CERT_PUBLIC_KEY
+    private_key = AWS::IAM::SERVER_CERT_PRIVATE_KEY
+    key_name    = "update-key"
+
+    Fog::AWS::IAM.new.upload_server_certificate(public_key, private_key, key_name)
+
+    tests('duplicate name').raises(Fog::AWS::IAM::EntityAlreadyExists) do
+      other_key_name = "other-key-name"
+      Fog::AWS::IAM.new.upload_server_certificate(public_key, private_key, other_key_name)
+
+      Fog::AWS::IAM.new.update_server_certificate(key_name, {'NewServerCertificateName' => other_key_name})
+    end
+
+    tests('unknown name').raises(Fog::AWS::IAM::NotFound) do
+      Fog::AWS::IAM.new.update_server_certificate("unknown-key-name", {'NewServerCertificateName' => "other-keyname"})
+    end
+
+    tests('format').formats(@update_format) do
+      Fog::AWS::IAM.new.update_server_certificate(key_name).body
+    end
+
+    tests('updates name') do
+      other_key_name = "successful-update-key-name"
+      Fog::AWS::IAM.new.update_server_certificate(key_name, {'NewServerCertificateName' => other_key_name})
+      returns(true) { Fog::AWS::IAM.new.get_server_certificate(other_key_name).body['Certificate']['ServerCertificateName'] == other_key_name }
+    end
+  end
+
   tests('#get_server_certificate').formats(@get_server_certificate_format) do
     tests('raises NotFound').raises(Fog::AWS::IAM::NotFound) do
       Fog::AWS::IAM.new.get_server_certificate("#{@key_name}fake")

data/tests/cloudstack/compute/models/snapshot_tests.rb

@@ -0,0 +1,34 @@
+def snapshot_tests(connection, params, mocks_implemented = true)
+  model_tests(connection.snapshots, params[:snapshot_attributes], mocks_implemented) do
+    if !Fog.mocking? || mocks_implemented
+      @instance.wait_for { ready? }
+    end
+
+    @volume = @instance.connection.volumes.create(params[:volumes_attributes])
+    @volume.wait_for { ready? }
+
+    tests('create').succeeds do
+      @instance.create :volume_id => @volume.id
+    end
+
+    tests('destroy').succeeds do
+      @instance.destroy
+    end
+
+    @volume.destroy
+  end
+end
+
+Shindo.tests("Fog::Compute[:cloudstack] | snapshot", "cloudstack") do
+
+  config = compute_providers[:cloudstack]
+
+  snapshot_tests(Fog::Compute[:cloudstack], config, config[:mocked]) do
+    if Fog.mocking? && !mocks_implemented
+      pending
+    else
+      responds_to(:ready?)
+      responds_to(:volume)
+    end
+  end
+end

data/tests/digitalocean/helper.rb

@@ -0,0 +1,44 @@
+
+# Shortcut for Fog::Compute[:digitalocean]
+def service
+  Fog::Compute[:digitalocean]
+end
+
+# Create a long lived server for the tests
+def fog_test_server
+  server = service.servers.find { |s| s.name == 'fog-test-server' }
+  unless server
+    image = service.images.find { |i| i.name == 'Ubuntu 12.04 x64 Server' }
+    region = service.regions.find { |r| r.name == 'New York 1' }
+    flavor = service.flavors.find { |r| r.name == '512MB' }
+    server = service.servers.create :name      => 'fog-test-server',
+                                    :image_id  => image.id,
+                                    :region_id => region.id,
+                                    :flavor_id => flavor.id
+    # Wait for the server to come up
+    begin
+      server.wait_for(120) { server.reload rescue nil; server.ready? }
+    rescue Fog::Errors::TimeoutError
+      # Server bootstrap took more than 120 secs!
+    end
+  end
+  server
+end
+
+# Destroy the long lived server
+def fog_test_server_destroy
+  server = service.servers.find { |s| s.name == 'fog-test-server' }
+  server.destroy if server
+end
+
+at_exit do
+  unless Fog.mocking? || Fog.credentials[:digitalocean_api_key].nil?
+    server = service.servers.find { |s| s.name == 'fog-test-server' }
+    if server
+      server.wait_for(120) do
+        reload rescue nil; ready?
+      end
+    end
+    fog_test_server_destroy
+  end
+end

data/tests/digitalocean/models/compute/flavor_tests.rb

@@ -0,0 +1,30 @@
+Shindo.tests("Fog::Compute[:digitalocean] | flavor model", ['digitalocean', 'compute']) do
+
+  service = Fog::Compute[:digitalocean]
+  flavor  = service.flavors.first
+  
+  tests('The flavor model should') do
+    tests('have the action') do
+      test('reload') { flavor.respond_to? 'reload' }
+    end
+    tests('have attributes') do
+      model_attribute_hash = flavor.attributes
+      attributes = [ 
+        :id,
+        :name,
+      ]
+      tests("The flavor model should respond to") do
+        attributes.each do |attribute|
+          test("#{attribute}") { flavor.respond_to? attribute }
+        end
+      end
+      tests("The attributes hash should have key") do
+        attributes.each do |attribute|
+          test("#{attribute}") { model_attribute_hash.has_key? attribute }
+        end
+      end
+    end
+  end
+
+end
+

data/tests/digitalocean/models/compute/image_tests.rb

@@ -0,0 +1,31 @@
+Shindo.tests("Fog::Compute[:digitalocean] | image model", ['digitalocean', 'compute']) do
+
+  service = Fog::Compute[:digitalocean]
+  image  = service.images.first
+  
+  tests('The image model should') do
+    tests('have the action') do
+      test('reload') { image.respond_to? 'reload' }
+    end
+    tests('have attributes') do
+      model_attribute_hash = image.attributes
+      attributes = [ 
+        :id,
+        :name,
+        :distribution
+      ]
+      tests("The image model should respond to") do
+        attributes.each do |attribute|
+          test("#{attribute}") { image.respond_to? attribute }
+        end
+      end
+      tests("The attributes hash should have key") do
+        attributes.each do |attribute|
+          test("#{attribute}") { model_attribute_hash.has_key? attribute }
+        end
+      end
+    end
+  end
+
+end
+

data/tests/digitalocean/models/compute/region_tests.rb

@@ -0,0 +1,30 @@
+Shindo.tests("Fog::Compute[:digitalocean] | region model", ['digitalocean', 'compute']) do
+
+  service = Fog::Compute[:digitalocean]
+  region  = service.regions.first
+  
+  tests('The region model should') do
+    tests('have the action') do
+      test('reload') { region.respond_to? 'reload' }
+    end
+    tests('have attributes') do
+      model_attribute_hash = region.attributes
+      attributes = [ 
+        :id,
+        :name,
+      ]
+      tests("The region model should respond to") do
+        attributes.each do |attribute|
+          test("#{attribute}") { region.respond_to? attribute }
+        end
+      end
+      tests("The attributes hash should have key") do
+        attributes.each do |attribute|
+          test("#{attribute}") { model_attribute_hash.has_key? attribute }
+        end
+      end
+    end
+  end
+
+end
+

data/tests/digitalocean/models/compute/server_tests.rb

@@ -0,0 +1,84 @@
+Shindo.tests("Fog::Compute[:digitalocean] | server model", ['digitalocean', 'compute']) do
+
+  server  = fog_test_server
+
+  tests('The server model should') do
+
+    tests('have the action') do
+      test('reload') { server.respond_to? 'reload' }
+      %w{ 
+        shutdown 
+        reboot
+        power_cycle
+        stop
+        start
+      }.each do |action|
+        test(action) { server.respond_to? action }
+      end
+    end
+    tests('have attributes') do
+      model_attribute_hash = server.attributes
+      attributes = [ 
+        :id,
+        :name,
+        :state,
+        :backups_active,
+        :ip_address,
+        :flavor_id,
+        :region_id,
+        :image_id
+      ]
+      tests("The server model should respond to") do
+        attributes.each do |attribute|
+          test("#{attribute}") { server.respond_to? attribute }
+        end
+      end
+    end
+    test('#reboot') do
+      pending if Fog.mocking?
+      server.reboot
+      server.wait_for { server.state == 'off' }
+      server.state == 'off'
+    end
+    test('#power_cycle') do
+      pending if Fog.mocking?
+      server.wait_for { server.ready? }
+      server.power_cycle
+      server.wait_for { server.state == 'off' }
+      server.state == 'off'
+    end
+    test('#stop') do
+      server.stop
+      server.wait_for { server.state == 'off' }
+      server.state == 'off'
+    end
+    test('#start') do
+      server.start
+      server.wait_for { ready? }
+      server.ready?
+    end
+    # DigitalOcean shutdown is unreliable
+    # so disable it in real mode for now
+    test('#shutdown') do
+      pending unless Fog.mocking?
+      server.start
+      server.wait_for { server.ready? }
+      server.shutdown
+      server.wait_for { server.state == 'off' }
+      server.state == 'off'
+    end
+    test('#update') do
+      begin
+        server.update
+      rescue NotImplementedError => e
+        true
+      end
+    end
+
+  end
+
+  # restore server state
+  server.start
+
+end
+

data/tests/digitalocean/models/compute/servers_tests.rb

@@ -0,0 +1,35 @@
+Shindo.tests('Fog::Compute[:digitalocean] | servers collection', ['digitalocean']) do
+
+  service =  Fog::Compute[:digitalocean]
+
+  tests('The servers collection') do
+    servers = service.servers.all
+
+    server = fog_test_server
+
+    test('should NOT be empty') do
+      servers.reload
+      !servers.empty? 
+    end
+
+    test('should be a kind of Fog::Compute::DigitalOcean::Servers') do 
+      servers.kind_of? Fog::Compute::DigitalOcean::Servers 
+    end
+
+    tests('should have Fog::Compute::DigitalOcean::Servers inside') do
+      servers.each do |s|
+        test { s.kind_of? Fog::Compute::DigitalOcean::Server }
+      end
+    end
+
+    tests('should be able to reload itself').succeeds { servers.reload }
+
+    tests('should be able to get a model') do
+      test('by instance id') do
+        servers.get(server.id).kind_of? Fog::Compute::DigitalOcean::Server
+      end
+    end
+
+  end
+
+end

data/tests/digitalocean/models/compute/ssh_key_tests.rb

@@ -0,0 +1,40 @@
+Shindo.tests("Fog::Compute[:digitalocean] | ssh_key model", ['digitalocean', 'compute']) do
+
+  service = Fog::Compute[:digitalocean]
+
+  tests('The ssh_key model should') do
+    
+    test('#save') do
+      @key = service.ssh_keys.create :name => 'fookey',
+                                     :ssh_pub_key => 'fookey'
+      @key.is_a? Fog::Compute::DigitalOcean::SshKey
+    end
+    tests('have the action') do
+      test('reload') { @key.respond_to? 'reload' }
+      %w{ 
+        save
+        destroy
+      }.each do |action|
+        test(action) { @key.respond_to? action }
+      end
+    end
+    tests('have attributes') do
+      attributes = [ 
+        :id,
+        :name,
+        :ssh_pub_key
+      ]
+      tests("The key model should respond to") do
+        attributes.each do |attribute|
+          test("#{attribute}") { @key.respond_to? attribute }
+        end
+      end
+    end
+    test('#destroy') do
+      @key.destroy
+    end
+
+  end
+
+end
+