gandirb 1.1.1 → 2.0.0

data/lib/gandi/domain_modules/host.rb

@@ -1,29 +0,0 @@
-module Gandi
-  module DomainModules
-    module Host
-      #Returns the array of glue records for the specified domain.
-      def host_list(domain)
-        call('host_list', domain)
-      end
-      
-      #Retrieve an array of the IP addresses linked to this hostname.
-      def host_info(fqdn)
-        call('host_info', fqdn)
-      end
-      
-      #Create a glue record with the specified IP addresses.
-      #This implementation does not respect the original API specifications and allow for a single IP to be provided.
-      #An array of IPs can be provided but only the first IP is used (this is an API limitation).
-      #Return the operation attributed ID
-      def host_create(host, ip)
-        call('host_create', host, [ip].flatten)
-      end
-      
-      #Delete a host.
-      #Return the operation attributed ID
-      def host_delete(host)
-        call('host_delete', host)
-      end
-    end
-  end
-end

data/lib/gandi/domain_modules/mail.rb

@@ -1,80 +0,0 @@
-module Gandi
-  module DomainModules
-    module Mail
-
-      #Enables the Gandimail service for one domain
-      def domain_gandimail_activate(domain)
-        call('domain_gandimail_activate', domain)
-      end
-
-      #Disables the Gandimail service for one domain: mail servers won't accept mail sent to this domain anymore
-      #Does not delete forwards, aliases or mailboxes
-      def domain_gandimail_deactivate(domain)
-        call('domain_gandimail_deactivate', domain)
-      end
-
-      #Returns a structure associating each forward with its destinations
-      def domain_forward_list(domain)
-        call('domain_forward_list', domain)
-      end
-
-      #Setup a forward to redirect to one or more destinations. 
-      #Warning: it overwrites the forward (the source), so if you try to add one destination to a forward, you shall include the existing destinations
-      #TODO: keep existing forwards ?
-      def domain_forward_set(domain, source, destinations)
-        call('domain_forward_set', domain, source, destinations)
-      end
-
-      #Deletes a forward. This does the same thing as domain_forward_set(domain, [])
-      def domain_forward_delete(domain, source)
-        call('domain_forward_delete', domain, source)
-      end
-
-      #Return the list of mailboxes associated with a domain
-      def domain_mailbox_list(domain)
-        call('domain_mailbox_list', domain)
-      end
-
-      #Provides information about a mailbox
-      def domain_mailbox_info(domain, mailbox)
-        call('domain_mailbox_info', domain, mailbox)
-      end
-
-      #Creates a new mailbox
-      #Accepted options:
-      #  integer quota
-      #  boolean antivirus
-      #  boolean antispam
-      #  string fallback_email
-      def domain_mailbox_add(domain, mailbox, password, options = {})
-        call('domain_mailbox_add', domain, mailbox, password, options)
-      end
-
-      #Updates an existing mailbox
-      #Accepted options are the same as the ones for domain_mailbox_add, with password added
-      def domain_mailbox_update(domain, mailbox, options)
-        call('domain_mailbox_update', domain, mailbox, options)
-      end
-
-      #Deletes a mailbox
-      def domain_mailbox_delete(domain, mailbox)
-        call('domain_mailbox_delete', domain, mailbox)
-      end
-
-      #List the aliases of a mailbox
-      def domain_mailbox_alias_list(domain, mailbox)
-        call('domain_mailbox_alias_list', domain, mailbox)
-      end
-
-      #Affect aliases to a mailbox
-      def domain_mailbox_alias_set(domain, mailbox, aliases)
-        call('domain_mailbox_alias_set', domain, mailbox, aliases)
-      end
-
-      #Delete all messages from a mailbox
-      def domain_mailbox_purge(domain, mailbox)
-        call('domain_mailbox_purge', domain, mailbox)
-      end
-    end
-  end
-end

data/lib/gandi/domain_modules/name_servers.rb

@@ -1,28 +0,0 @@
-module Gandi
-  module DomainModules
-    module NameServers
-      #Retrieve an array of name servers for a domain
-      def domain_ns_list(domain)
-        call('domain_ns_list', domain)
-      end
-      
-      #Add the specified name servers to the name servers list of a domain
-      #Return the operation attributed ID 
-      def domain_ns_add(domain, ns_list)
-        call('domain_ns_add', domain, ns_list)
-      end
-      
-      #Remove the specified name servers from the name servers list of a domain
-      #Return the operation attributed ID
-      def domain_ns_del(domain, ns_list)
-        call('domain_ns_del', domain, ns_list)
-      end
-      
-      #Set a domain name servers list
-      #Return the operation attributed ID
-      def domain_ns_set(domain, ns_list)
-        call('domain_ns_set', domain, ns_list)
-      end
-    end
-  end
-end

data/lib/gandi/domain_modules/operations.rb

@@ -1,30 +0,0 @@
-module Gandi
-  module DomainModules
-    module Operations
-      #Retrieve an array of the last 300 operation IDs matching the optional criterias
-      def operation_list(filter = {})
-        unless filter.empty?
-          call('operation_list', filter)
-        else
-          call('operation_list')
-        end
-      end
-      
-      #Retrieve an operation details
-      def operation_details(opid)
-        call('operation_details', opid)
-      end
-      
-      #Relaunch an operation, modifying the given parameters
-      #TODO: check param
-      def operation_relaunch(opid, param)
-        call('operation_relaunch', opid, param)
-      end
-      
-      #Cancel an operation
-      def operation_cancel(opid)
-        call('operation_cancel', opid)
-      end
-    end
-  end
-end

data/lib/gandi/domain_modules/redirection.rb

@@ -1,25 +0,0 @@
-module Gandi
-  module DomainModules
-    module Redirection
-      DOMAIN_WEB_REDIR_REDIRECTION_TYPES = ['http302', 'http301', 'cloak']
-      
-      #Retrieve an array of web redirections for a domain
-      def domain_web_redir_list(domain)
-        call('domain_web_redir_list', domain)
-      end
-      
-      #Add a web redirection to a domain. All HTTP requests to http://fqdn/ will be redirected to 'destination_url' with a HTTP redirection 'type'
-      #Return the operation attributed ID
-      def domain_web_redir_add(fqdn, destination_url, type)
-        raise ArgumentError.new("Redirection type is invalid") unless DOMAIN_WEB_REDIR_REDIRECTION_TYPES.include?(type)
-        call('domain_web_redir_add', fqdn, destination_url, type)
-      end
-      
-      #Delete the web redirection of the fully qualified domain name fqdn
-      #Return the operation attributed ID
-      def domain_web_redir_del(fqdn)
-        call('domain_web_redir_del', fqdn)
-      end
-    end
-  end
-end

data/test/gandi/base_test.rb

@@ -1,188 +0,0 @@
-require 'test_helper'
-
-class BaseTest < ActiveSupport::TestCase
-  def setup
-    @login = 'XX000-Gandi'
-    @password = 'dummy'
-    @uri = Gandi::Domain::TEST_URL
-    
-    @session_id = "session id"
-  end
-  
-  context "an instance of Gandi::Base without an URL provided" do
-    should "raise an error when trying to initialize" do
-      assert_raise ArgumentError do
-        Gandi::Base.new @login, @password
-      end
-    end
-    
-    should "raise an error when trying to login directly" do
-      assert_raise ArgumentError do
-        Gandi::Base.login @login, @password
-      end
-    end
-  end
-  
-  context "an instance of Gandi::Base with an URL provided" do
-    setup do
-      @gandi_base = Gandi::Base.new @login, @password, @uri
-    end
-    
-    context "without logging in" do
-      should "raise a runtime error error when trying to call an arbitrary method" do
-        assert_raise RuntimeError do
-          @gandi_base.call "mymethod"
-        end
-      end
-      
-      should "raise a runtime error error when trying to call an account method" do
-        %w(account_balance account_currency).each do |method|
-          assert_raise RuntimeError do
-            @gandi_base.send(method)
-          end
-        end
-      end
-      
-      should "raise a runtime error error when trying to su or change password" do
-        assert_raise RuntimeError do
-          @gandi_base.su 'anotherhandle-Gandi'
-        end
-        
-        assert_raise RuntimeError do
-          @gandi_base.password 'mypassword'
-        end
-      end
-      
-      should "raise a runtime error error when trying to use raw_call" do
-        assert_raise RuntimeError do
-          @gandi_base.send :raw_call, "mymethod"
-        end
-      end
-      
-      should "have a handler set to nil" do
-        assert @gandi_base.handler.nil?
-      end
-      
-      should "have a session id set to nil" do
-        assert @gandi_base.session_id.nil?
-      end
-    end
-    
-    context "logging in" do
-      should "raise an error if the account does not exist" do
-        XMLRPC::Client.any_instance.expects(:call).raises(Gandi::DataError.new("DataError: account does not exist [login: #{@login}]"))
-        assert_raise Gandi::DataError do
-          @gandi_base.login
-        end
-      end
-      
-      should "raise an error if the password is wrong" do
-        XMLRPC::Client.any_instance.expects(:call).raises(Gandi::DataError.new("DataError: invalid value for password [incorrect password]"))
-        assert_raise Gandi::DataError do
-          @gandi_base.login
-        end
-      end
-      
-      context "with correct credentials" do
-        setup do
-          XMLRPC::Client.any_instance.expects(:call).with("login", @login, @password, false).returns(@session_id)
-        end
-        
-        should "return a session string when using correct credentials and store it"  do
-          session_id = @gandi_base.login
-          assert session_id.is_a? String
-          assert_equal session_id, @gandi_base.session_id
-        end
-      end
-    end
-  end
-  
-  context "An instance of Gandi::Base using login directly" do
-    setup do
-      XMLRPC::Client.any_instance.expects(:call).at_least_once.with("login", @login, @password, false).returns(@session_id)
-      @gandi_base = Gandi::Base.login @login, @password, @uri
-    end
-    
-    should "have a session id" do
-      assert_equal @session_id, @gandi_base.session_id
-    end
-    
-    should "have a handler" do
-      assert @gandi_base.handler
-    end
-    
-    should "get the account balance" do
-      @gandi_base.handler.expects(:call).with("account_balance", @session_id).returns(1000)
-      assert @gandi_base.account_balance.is_a? Numeric
-    end
-    
-    should "get the currency name" do
-      @gandi_base.handler.expects(:call).with("account_currency", @session_id).returns("EUR")
-      assert_match /\w{3}/, @gandi_base.account_currency
-    end
-    
-    should "change the session id when suing to another handle" do
-      @gandi_base.handler.expects(:call).with("su", @session_id, "NEWHANDLE-Gandi").returns("new session id")
-      
-      @gandi_base.su "NEWHANDLE-Gandi"
-      assert_equal "new session id", @gandi_base.session_id
-    end
-    
-    should "change the password" do
-      @gandi_base.handler.expects(:call).with("password", @session_id, "newpassword").returns(true)
-      
-      assert @gandi_base.password "newpassword"
-    end
-  end
-  
-  context "An instance of Gandi::Base expecting failures" do
-    setup do
-    end
-    
-    should "retry once when failing after a timeout" do
-      tries = states('tries').starts_as('none')
-      XMLRPC::Client.any_instance.expects(:call).with("login", @login, @password, false).returns('sid1').when(tries.is('none')).then(tries.is('first'))
-      XMLRPC::Client.any_instance.expects(:call).with("login", @login, @password, false).returns('sid2').when(tries.is('first')).then(tries.is('second'))
-      XMLRPC::Client.any_instance.expects(:call).with("account_balance", 'sid1').raises(EOFError).when(tries.is('first'))
-      XMLRPC::Client.any_instance.expects(:call).with("account_balance", 'sid2').returns(1000).when(tries.is('second'))
-      
-      @gandi_base = Gandi::Base.login @login, @password, @uri
-      assert_equal 1000, @gandi_base.account_balance
-    end
-    
-    should "fail after trying unsuccesfully two times" do
-      tries = states('tries').starts_as('none')
-      XMLRPC::Client.any_instance.expects(:call).with("login", @login, @password, false).returns('sid1').when(tries.is('none')).then(tries.is('first'))
-      XMLRPC::Client.any_instance.expects(:call).with("login", @login, @password, false).returns('sid2').when(tries.is('first')).then(tries.is('second'))
-      XMLRPC::Client.any_instance.expects(:call).with("account_balance", 'sid1').raises(EOFError).when(tries.is('first'))
-      XMLRPC::Client.any_instance.expects(:call).with("account_balance", 'sid2').raises(Errno::EPIPE).when(tries.is('second'))
-      
-      @gandi_base = Gandi::Base.login @login, @password, @uri
-      
-      assert_raise *Gandi::Base::TIMEOUT_EXCEPTIONS do
-        @gandi_base.account_balance
-      end
-    end
-    
-    should "fail when directly failing on login" do
-      XMLRPC::Client.any_instance.expects(:call).with("login", @login, @password, false).raises(EOFError)
-      
-      assert_raise *Gandi::Base::TIMEOUT_EXCEPTIONS do
-        @gandi_base = Gandi::Base.login @login, @password, @uri
-      end
-    end
-    
-    should "fail after trying to login when retrying" do
-      tries = states('tries').starts_as('none')
-      XMLRPC::Client.any_instance.expects(:call).with("login", @login, @password, false).returns('sid1').when(tries.is('none')).then(tries.is('first'))
-      XMLRPC::Client.any_instance.expects(:call).with("login", @login, @password, false).raises(EOFError).when(tries.is('first')).then(tries.is('second'))
-      XMLRPC::Client.any_instance.expects(:call).with("account_balance", 'sid1').raises(EOFError).when(tries.is('first'))
-      
-      @gandi_base = Gandi::Base.login @login, @password, @uri
-      
-      assert_raise *Gandi::Base::TIMEOUT_EXCEPTIONS do
-        @gandi_base.account_balance
-      end
-    end
-  end
-end

data/test/gandi/domain_test.rb

@@ -1,301 +0,0 @@
-require 'test_helper'
-
-class DomainTest < ActiveSupport::TestCase
-  def setup
-    @login = 'XX000-Gandi'
-    @password = 'dummy'
-    @uri = Gandi::Domain::TEST_URL
-    
-    @session_id = "session id"
-    @sample_domain_name = "mydomain.com"
-  end
-  
-  context "a new logged in Gandi::Domain instance" do
-    setup do
-      XMLRPC::Client.any_instance.expects(:call).at_least_once.with("login", @login, @password, false).returns(@session_id)
-      @gandi_domain = Gandi::Domain.login @login, @password, @uri
-    end
-    
-    should "get domain list" do
-      @gandi_domain.handler.expects(:call).with("domain_list", @session_id).returns(["mydomain.com"])
-      
-      assert @gandi_domain.domain_list.is_a? Array
-    end
-    
-    context "mocking domain_available calls" do
-      setup do
-        @gandi_domain.handler.expects(:call).with("domain_available", @session_id, ['testdomain.com']).returns({"testdomain.com" => false})
-      end
-      
-      should "return a hash when providing an array" do
-        assert_equal({"testdomain.com" => false}, @gandi_domain.domain_available(['testdomain.com']))
-      end
-      
-      should "return a boolean when providing a single domain" do
-        assert_equal false, @gandi_domain.domain_available('testdomain.com')
-      end
-    end
-    
-    context "with an existing domain" do
-      should "lock a domain" do
-        @gandi_domain.handler.expects(:call).with("domain_lock", @session_id, @sample_domain_name).returns(rand(9000))
-        
-        assert @gandi_domain.domain_lock(@sample_domain_name).is_a? Integer
-      end
-      
-      should "unlock a domain" do
-        @gandi_domain.handler.expects(:call).with("domain_unlock", @session_id, @sample_domain_name).returns(rand(9000))
-        
-        assert @gandi_domain.domain_unlock(@sample_domain_name).is_a? Integer
-      end
-      
-      #TODO: better test (use a hash similar to a real api call result)
-      should "get infos on a domain" do
-        @gandi_domain.handler.expects(:call).with("domain_info", @session_id, @sample_domain_name).returns({})
-        
-        assert @gandi_domain.domain_info(@sample_domain_name).is_a? Hash
-      end
-      
-      should "renew a domain for 8 years" do
-        @gandi_domain.handler.expects(:call).with("domain_renew", @session_id, @sample_domain_name, 8).returns(rand(9000))
-        
-        assert @gandi_domain.domain_renew(@sample_domain_name, 8).is_a? Integer
-      end
-      
-      should "not renew a domain for 11 years" do
-        assert_raise ArgumentError do
-          @gandi_domain.domain_renew(@sample_domain_name, 11)
-        end
-      end
-      
-      should "restore a domain" do
-        @gandi_domain.handler.expects(:call).with("domain_restore", @session_id, @sample_domain_name).returns(rand(9000))
-        
-        assert @gandi_domain.domain_restore(@sample_domain_name).is_a? Integer
-      end
-      
-      should "not delete a domain" do
-        assert_raise NoMethodError do
-          @gandi_domain.domain_del(@sample_domain_name)
-        end
-      end
-      
-      should "check if domain can be transferred" do
-        @gandi_domain.handler.expects(:call).with("domain_transfer_in_available", @session_id, @sample_domain_name).twice.returns(true)
-        
-        available = @gandi_domain.domain_transfer_in_available(@sample_domain_name)
-        assert_equal true, available
-        
-        assert_equal available, @gandi_domain.domain_transfer_in_available?(@sample_domain_name)
-      end
-      
-      should "transfer a domain in" do
-        owner_handle, admin_handle, tech_handle, billing_handle = 'owner_handle', "admin_handle", 'tech_handle', 'billing_handle'
-        nameservers = ['127.0.0.1']
-        @gandi_domain.handler.expects(:call).with("domain_transfer_in", @session_id, @sample_domain_name, owner_handle, admin_handle, tech_handle, billing_handle, nameservers).returns(rand(9000))
-        
-        assert @gandi_domain.domain_transfer_in(@sample_domain_name, owner_handle, admin_handle, tech_handle, billing_handle, nameservers).is_a? Integer
-      end
-      
-      should "not transfer a domain out" do
-        assert_raise NoMethodError do
-          @gandi_domain.domain_transfer_out(@sample_domain_name, true)
-        end
-      end
-      
-      should "not trade a domain" do
-        assert_raise NoMethodError do
-          @gandi_domain.domain_trade(@sample_domain_name, 'owner_handle', 'admin_handle', 'tech_handle', 'billing_handle')
-        end
-      end
-      
-      should "not change owner of a domain" do
-        assert_raise NoMethodError do
-          @gandi_domain.domain_change_owner(@sample_domain_name, 'new_owner')
-        end
-      end
-      
-      should "change contact for a domain" do
-        @gandi_domain.handler.expects(:call).with("domain_change_contact", @session_id, @sample_domain_name, 'admin', 'new-handle').returns(rand(9000))
-        
-        assert @gandi_domain.domain_change_contact(@sample_domain_name, 'admin', 'new-handle').is_a? Integer
-      end
-    end
-    
-    should "create a domain" do
-      domain, period, owner_handle, admin_handle, tech_handle, billing_handle = 'mynewdomain.com', 7, 'owner_handle', "admin_handle", 'tech_handle', 'billing_handle'
-      nameservers = ['127.0.0.1']
-      @gandi_domain.handler.expects(:call).with("domain_create", @session_id, domain, period, owner_handle, admin_handle, tech_handle, billing_handle, nameservers).returns(rand(9000))
-      
-      assert @gandi_domain.domain_create(domain, period, owner_handle, admin_handle, tech_handle, billing_handle, nameservers).is_a? Integer
-    end
-    
-    should "get domains list" do
-      tlds = ["info", "be", "eu", "name", "biz", "us", "org", "com", "net", "mobi", "ch", "li", "at", "asia", "de", "nu", "cz", "tw", "es", "lu", "pl", "pro", "me", "in"]
-      
-      @gandi_domain.handler.expects(:call).with("tld_list", @session_id).returns(tlds)
-      
-      assert_equal tlds, @gandi_domain.tld_list
-    end
-    
-    
-    should "list name servers for a domain" do
-      @gandi_domain.handler.expects(:call).with("domain_ns_list", @session_id, @sample_domain_name).returns([])
-      
-      assert @gandi_domain.domain_ns_list(@sample_domain_name).is_a? Array
-    end
-    
-    should "add name servers for a domain" do
-      @gandi_domain.handler.expects(:call).with("domain_ns_add", @session_id, @sample_domain_name, ['127.0.0.1']).returns(rand(9000))
-      
-      assert @gandi_domain.domain_ns_add(@sample_domain_name, ['127.0.0.1']).is_a? Integer
-    end
-    
-    should "remove name servers for a domain" do
-      @gandi_domain.handler.expects(:call).with("domain_ns_del", @session_id, @sample_domain_name, ['127.0.0.1']).returns(rand(9000))
-      
-      assert @gandi_domain.domain_ns_del(@sample_domain_name, ['127.0.0.1']).is_a? Integer
-    end
-    
-    should "set name servers for a domain" do
-      @gandi_domain.handler.expects(:call).with("domain_ns_set", @session_id, @sample_domain_name, ['127.0.0.1']).returns(rand(9000))
-      
-      assert @gandi_domain.domain_ns_set(@sample_domain_name, ['127.0.0.1']).is_a? Integer
-    end
-    
-    
-    should "list hosts for a domain" do
-      @gandi_domain.handler.expects(:call).with("host_list", @session_id, @sample_domain_name).returns([])
-      
-      assert @gandi_domain.host_list(@sample_domain_name).is_a? Array
-    end
-    
-    should "get IPs for a domain" do
-      ips = ['127.0.0.1']
-      @gandi_domain.handler.expects(:call).with("host_info", @session_id, @sample_domain_name).returns(ips)
-      
-      assert @gandi_domain.host_info(@sample_domain_name).is_a? Array
-    end
-    
-    should "create a glue record for a host when providing multiple IPs" do
-      ip_list  = ["1.2.3.4", "1.2.3.5"]
-      @gandi_domain.handler.expects(:call).with("host_create", @session_id, @sample_domain_name, ip_list).returns(rand(9000))
-      
-      assert @gandi_domain.host_create(@sample_domain_name, ip_list).is_a? Integer
-    end
-    
-    should "create a glue record for a host when providing an unique IP" do
-      ip  = "1.2.3.4"
-      @gandi_domain.handler.expects(:call).with("host_create", @session_id, @sample_domain_name, [ip]).returns(rand(9000))
-      
-      assert @gandi_domain.host_create(@sample_domain_name, ip).is_a? Integer
-    end
-    
-    should "delete a host" do
-      @gandi_domain.handler.expects(:call).with("host_delete", @session_id, @sample_domain_name).returns(rand(9000))
-      
-      assert @gandi_domain.host_delete(@sample_domain_name).is_a? Integer
-    end
-    
-    
-    should "list redirections for a domain" do
-      redirections = [{"type" => "http302", "from" => "w3.example.net", "to" => "http://www.example.net"}]
-      @gandi_domain.handler.expects(:call).with("domain_web_redir_list", @session_id, @sample_domain_name).returns(redirections)
-      
-      assert_equal redirections, @gandi_domain.domain_web_redir_list(@sample_domain_name)
-    end
-    
-    should "check redirection type when adding a redirection for a domain" do
-      destination_url = "http://www.example.net"
-      
-      calls = states('calls').starts_as('none')
-      @gandi_domain.handler.expects(:call).with("domain_web_redir_add", @session_id, @sample_domain_name, destination_url, 'http302').returns(rand(9000)).when(calls.is('none')).then(calls.is('first'))
-      @gandi_domain.handler.expects(:call).with("domain_web_redir_add", @session_id, @sample_domain_name, destination_url, 'http301').returns(rand(9000)).when(calls.is('first')).then(calls.is('second'))
-      @gandi_domain.handler.expects(:call).with("domain_web_redir_add", @session_id, @sample_domain_name, destination_url, 'cloak').returns(rand(9000)).when(calls.is('second'))
-      
-      Gandi::DomainModules::Redirection::DOMAIN_WEB_REDIR_REDIRECTION_TYPES.each do |type|
-        assert @gandi_domain.domain_web_redir_add(@sample_domain_name, destination_url, type).is_a? Integer
-      end
-      
-      assert_raise ArgumentError do
-        @gandi_domain.domain_web_redir_add(@sample_domain_name, destination_url, 'bad')
-      end
-    end
-    
-    should "delete the redirection on a fqdn" do
-      @gandi_domain.handler.expects(:call).with("domain_web_redir_del", @session_id, 'w3.example.net').returns(rand(9000))
-      
-      assert @gandi_domain.domain_web_redir_del('w3.example.net').is_a? Integer
-    end
-    
-    
-    should "create a contact" do
-      contact_class, firstname, lastname, address, zipcode, city, country, phone, email = 'individual', 'John', 'Doe', '24 Rue du Pont', '13000', 'Mars', 'France', '+33491909090', 'john@doe.com'
-      @gandi_domain.handler.expects(:call).with("contact_create", @session_id, contact_class, firstname, lastname, address, zipcode, city, country, phone, email).returns('XXXZZ-Gandi')
-      
-      assert_match /.+-Gandi/, @gandi_domain.contact_create(contact_class, firstname, lastname, address, zipcode, city, country, phone, email)
-    end
-    
-    should "update a contact" do
-      handle = 'XXXYY-Gandi'
-      params = {}
-      @gandi_domain.handler.expects(:call).with("contact_update", @session_id, handle, params).returns(rand(9000))
-        
-      assert @gandi_domain.contact_update(handle, params).is_a? Integer
-    end
-    
-    should "delete a contact" do
-      handle = 'XXXYY-Gandi'
-      @gandi_domain.handler.expects(:call).with("contact_del", @session_id, handle).returns(rand(9000))
-        
-      assert @gandi_domain.contact_del(handle).is_a? Integer
-    end
-    
-    should "retrieve infos on a contact" do
-      handle = 'XXXYY-Gandi'
-      infos = {}
-      @gandi_domain.handler.expects(:call).with("contact_info", @session_id, handle).returns(infos)
-        
-      assert @gandi_domain.contact_info(handle).is_a? Hash
-    end
-    
-    
-    should "list operations" do
-      operations = [5555, 5642, 6213]
-      @gandi_domain.handler.expects(:call).with("operation_list", @session_id).returns(operations)
-      
-      assert_equal operations, @gandi_domain.operation_list()
-    end
-    
-    should "list pending operations with a filter" do
-      operations = [5555]
-      filter = {'state' => 'PENDING'}
-      @gandi_domain.handler.expects(:call).with("operation_list", @session_id, filter).returns(operations)
-      
-      assert_equal operations, @gandi_domain.operation_list(filter)
-    end
-    
-    should "get operation details" do
-      opid = 5555
-      details = {}
-      @gandi_domain.handler.expects(:call).with("operation_details", @session_id, opid).returns(details)
-      
-      assert @gandi_domain.operation_details(opid).is_a? Hash
-    end
-    
-    should "relaunch an operation" do
-      opid = 5555
-      param = {'authcode' => 'xxxyyyzzz'}
-      @gandi_domain.handler.expects(:call).with("operation_relaunch", @session_id, opid, param).returns(true)
-      
-      assert @gandi_domain.operation_relaunch(opid, param)
-    end
-    
-    should "cancel an operation" do
-      opid = 5555
-      @gandi_domain.handler.expects(:call).with("operation_cancel", @session_id, opid).returns(true)
-      
-      assert @gandi_domain.operation_cancel(opid)
-    end
-  end
-end