gandirb 1.1.1 → 2.0.0

data/spec/gandi/contact_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+require 'gandi'
+
+describe Gandi::Contact do
+  before do
+    @connection_mock = double()
+    ::Gandi.connection = @connection_mock
+  end
+  
+  context "a blank instance" do
+    its(:handle) { should be_nil }
+    its(:id) { should be_nil }
+    its(:to_s) { should == '' }
+    it { should_not be_persisted }
+  end
+  
+  context "a new instance provided with contact infos" do
+    before { @contact_information_attributes = contact_information_attributes_hash('id' => 'new id', 'type' => 0) }
+    subject { Gandi::Contact.new(nil, @contact_information_attributes) }
+    
+    its(:handle) { should be_nil }
+    its(:id) { should == 'new id' }
+    its(:to_s) { should == '' }
+    it { should_not be_persisted }
+    
+    it "should map its attributes" do
+      [:orgname, :given, :family, :streetaddr, :city, :state, :zip, :country, :phone, :fax, :mobile, 
+      :tva_number, :siren, :marque, :lang, :newsletter, :obfuscated, :whois_obfuscated, :resell, :shippingaddress, 
+      :extra_parameters].each do |contact_attribute|
+        [subject.send(contact_attribute), subject[contact_attribute.to_s],subject.to_hash[contact_attribute.to_s]].each do |value|
+          value.should == @contact_information_attributes[contact_attribute.to_s]
+        end
+      end
+    end
+    
+    it "can modify its writable attributes" do
+      subject.city = "City 1"
+      subject.city.should == "City 1"
+      subject['city'] = "City 2"
+      subject.city.should == "City 2"
+    end
+    
+    it "cannot modify its id" do
+      lambda { subject['id'] = 'other id' }.should raise_error(Gandi::DataError)
+    end
+    
+    it "should map its type to the corresponding string" do
+      subject.type.should == 'person'
+      subject.type = 'company'
+      subject['type'].should == 1
+      subject.type.should == 'company'
+    end
+    
+    it "cannot associate domains" do
+      subject.can_associate_domain({:domain => 'any.tld'}).should be_false
+    end
+    
+    it "cannot get contact informations" do
+      lambda { subject.info }.should raise_error(Gandi::DataError)
+    end
+    
+    it "cannot be updated" do
+      lambda { subject.update({}) }.should raise_error(Gandi::DataError)
+    end
+  end
+  
+  context "an instance provided with its handle" do
+    before do
+      @handle = 'AA0-GANDI'
+      @attributes = contact_information_attributes_hash('id' => 'contact id', 'handle' => @handle)
+      @connection_mock.should_receive(:call).with('contact.info', @handle).and_return(@attributes)
+    end
+    subject { Gandi::Contact.new(@handle) }
+    
+    its(:handle) { should == @handle }
+    its(:id) { should == 'contact id' }
+    its(:to_s) { should == @handle }
+    it { should be_persisted }
+    
+    it "should map its attributes" do
+      [:orgname, :given, :family, :streetaddr, :city, :state, :zip, :country, :phone, :fax, :mobile, 
+      :tva_number, :siren, :marque, :lang, :newsletter, :obfuscated, :whois_obfuscated, :resell, :shippingaddress, 
+      :extra_parameters].each do |contact_attribute|
+        [subject.send(contact_attribute), subject[contact_attribute.to_s],subject.to_hash[contact_attribute.to_s]].each do |value|
+          value.should == @attributes[contact_attribute.to_s]
+        end
+      end
+    end
+    
+    it "can test successful domain association" do
+      domain_hash = {:domain => 'mydomain.com'}
+      @connection_mock.should_receive(:call).with('contact.can_associate_domain', @handle, domain_hash).and_return(true)
+      subject.can_associate_domain(domain_hash).should be_true
+      subject.should respond_to(:can_associate_domain?)
+    end
+    
+    pending "can test failing domain association"
+    
+    it "can fetch its contact informations" do
+      @connection_mock.should_receive(:call).with('contact.info', @handle).and_return(@attributes)
+      subject.info['city'].should == @attributes['city']
+    end
+    
+    it "cannot modify its id" do
+      lambda { subject['id'] = 'other id' }.should raise_error(Gandi::DataError)
+    end
+    
+    it "cannot modify its handle" do
+      lambda { subject['handle'] = 'NH0-GANDI' }.should raise_error(Gandi::DataError)
+    end
+    
+    it "can be updated" do
+      @updated_attributes = contact_information_attributes_hash('city' => "Marseille")
+      @connection_mock.should_receive(:call).with('contact.update', @handle, @updated_attributes).and_return(@updated_attributes)
+      subject.update(@updated_attributes)
+      subject.city.should == @updated_attributes['city']
+    end
+  end
+  
+  describe ".create" do
+    it "should return a contact object" do
+      attributes = contact_information_attributes_hash('id' => 'new id')
+      @connection_mock.should_receive(:call).with('contact.create', attributes).and_return(attributes.merge('handle' => 'AA9-GANDI'))
+      Gandi::Contact.create(attributes).handle.should == 'AA9-GANDI'
+    end
+  end
+  
+  describe ".info" do
+    it "should return a contact hash" do
+      attributes = contact_information_attributes_hash
+      @connection_mock.should_receive(:call).with('contact.info').and_return(attributes)
+      Gandi::Contact.info.should == attributes
+    end
+  end
+  
+  describe ".can_associate" do
+    it "should return a boolean when the domain can be associated" do
+      domain_hash = {:domain => 'mydomain.com'}
+      handle = 'AA0-GANDI'
+      @connection_mock.should_receive(:call).with('contact.can_associate', handle, domain_hash).and_return(true)
+      Gandi::Contact.can_associate(handle, domain_hash).should be_true
+    end
+    
+    pending "should return an error hash when the domain cannot be associated"
+  end
+  
+  describe ".list" do
+    let(:mocked_contacts_array) { [contact_information_attributes_hash('handle' => 'HA1-GANDI'), contact_information_attributes_hash('handle' => 'HA2-GANDI')] }
+    
+    it "returns an array of contacts" do
+      @connection_mock.should_receive(:call).with('contact.list', {}).and_return(mocked_contacts_array)
+      contacts = Gandi::Contact.list
+      contacts.length.should == 2
+      contacts.last.handle.should == 'HA2-GANDI'
+    end
+    
+    it "can return an array of contact hashes" do
+      @connection_mock.should_receive(:call).with('contact.list', {}).and_return(mocked_contacts_array)
+      contacts = Gandi::Contact.list({}, false)
+      contacts.length.should == 2
+      contacts.last['handle'].should == 'HA2-GANDI'
+    end
+  end
+  
+  describe ".update" do
+    it "returns a contact object" do
+      handle = 'JD0-GANDI'
+      attributes = contact_information_attributes_hash
+      @connection_mock.should_receive(:call).with('contact.update', handle, attributes).and_return(attributes.merge('handle' => handle))
+      Gandi::Contact.update(handle, attributes).handle.should == handle
+    end
+  end
+end

data/spec/gandi/domain/forward_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+require 'gandi'
+
+describe Gandi::Domain::Forward do
+  before do
+    @connection_mock = double()
+    ::Gandi.connection = @connection_mock
+  end
+  
+  describe '.list' do
+    let(:fqdn) { 'domain1.tld' }
+    let(:domain) { mock_domain(fqdn) }
+    let(:domain_forwards_list) { [domain_forward_attributes('john.doe'), domain_forward_attributes('jane.doe'), domain_forward_attributes('tom.doe')] }
+    
+    before do
+      @connection_mock.should_receive(:call).with('domain.forward.list', fqdn, {}).and_return(domain_forwards_list)
+    end
+    
+    it "returns an array of Forward objects" do
+      list = Gandi::Domain::Forward.list(domain)
+      list.length.should == domain_forwards_list.length
+      list.first.should be_a(Gandi::Domain::Forward)
+      list.first.source.should == domain_forwards_list.first['source']
+    end
+  end
+  
+  describe '.count' do
+    let(:fqdn) { 'domain1.tld' }
+    let(:domain) { mock_domain(fqdn) }
+    
+    before do
+      @connection_mock.should_receive(:call).with('domain.forward.count', fqdn, {}).and_return(42)
+    end
+    
+    it "returns an integer" do
+      Gandi::Domain::Forward.count(domain).should == 42
+    end
+  end
+  
+  describe '.create' do
+    let(:fqdn) { 'domain1.tld' }
+    let(:domain) { mock_domain(fqdn) }
+    let(:source) { 'john.doe' }
+    let(:forward_create_params) { {'password' => 'securedp4ssword'} }
+    
+    before do
+      @connection_mock.should_receive(:call).with('domain.forward.create', fqdn, source, forward_create_params).and_return(forward_create_params)
+    end
+    
+    it "returns a Forward object" do
+      forward = Gandi::Domain::Forward.create(domain, source, forward_create_params)
+      forward.should be_a(Gandi::Domain::Forward)
+      forward.source.should == source
+    end
+  end
+  
+  it "can be instanciated with its attributes" do
+    fqdn = 'domain1.tld'
+    domain = mock_domain(fqdn)
+    source = 'john.doe'
+    forward_attributes = domain_forward_attributes(source)
+    
+    forward = Gandi::Domain::Forward.new(domain, source, forward_attributes)
+    forward.to_hash.should == forward_attributes
+    forward.source.should == source
+    forward.domain.should == domain
+  end
+  
+  context "an instance" do
+    let(:fqdn) { 'domain1.tld' }
+    let(:domain) { mock_domain(fqdn) }
+    let(:source) { 'john.doe' }
+    let(:forward_attributes) { domain_forward_attributes(source) }
+    
+    before do
+      @connection_mock.should_receive(:call).with('domain.forward.list', fqdn, {'source' => source}).and_return([forward_attributes])
+    end
+    subject { Gandi::Domain::Forward.new(domain, source) }
+    
+    its(:source) { should == source }
+    its(:domain) { should == domain }
+    
+    it "can read its attributes" do
+      subject.to_hash.should == forward_attributes
+      subject['destinations'].should == forward_attributes['destinations']
+    end
+    
+    it "can be deleted" do
+      @connection_mock.should_receive(:call).with('domain.forward.delete', fqdn, source).and_return(true)
+      
+      subject.delete.should be_true
+    end
+    
+    it "can be updated" do
+      new_attrs = forward_attributes.merge('destinations' => ['jean.dupond@domain1.tld'])
+      @connection_mock.should_receive(:call).with('domain.forward.update', fqdn, source, new_attrs).and_return(new_attrs)
+      
+      same_subject = subject.update(new_attrs)
+      same_subject.should == subject
+      subject.destinations.should == new_attrs['destinations']
+    end
+  end
+end

data/spec/gandi/domain/host_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+require 'gandi'
+
+describe Gandi::Domain::Host do
+  before do
+    @connection_mock = double()
+    ::Gandi.connection = @connection_mock
+  end
+  
+  describe '.list' do
+    let(:fqdn) { 'domain1.tld' }
+    let(:domain_host_list) { [{"ips"=>["1.2.3.4"], "name"=>"dns1.domain1.tld"}, {"ips"=>["6.7.8.9"], "name"=>"dns2.domain1.tld"}] }
+    
+    before do
+      @connection_mock.should_receive(:call).with('domain.host.list', fqdn, {}).and_return(domain_host_list)
+    end
+    
+    it "returns an array of Host objects" do
+      list = Gandi::Domain::Host.list(fqdn)
+      list.length.should == domain_host_list.length
+      list.first.should be_a(Gandi::Domain::Host)
+      list.first.hostname.should == domain_host_list.first['name']
+    end
+  end
+  
+  describe '.count' do
+    let(:fqdn) { 'domain1.tld' }
+    
+    before do
+      @connection_mock.should_receive(:call).with('domain.host.count', fqdn, {}).and_return(42)
+    end
+    
+    it "returns an integer" do
+      Gandi::Domain::Host.count(fqdn).should == 42
+    end
+  end
+  
+  describe '.create' do
+    let(:host_ips) { ["1.2.3.4"] }
+    let(:hostname) { 'dns1.domain1.tld' }
+    
+    before do
+      @connection_mock.should_receive(:call).with('domain.host.create', hostname, host_ips).and_return(operation_information_attributes_hash('id' => 42))
+    end
+    
+    it "returns an operation object" do
+      host_operation = Gandi::Domain::Host.create(hostname, host_ips)
+      host_operation.should be_a(Gandi::Operation)
+      host_operation.id.should == 42
+    end
+  end
+  
+  it "can be instanciated with its attributes" do
+    hostname = 'domain1.tld'
+    host_attributes = domain_host_attributes_hash('name' => hostname)
+    
+    host = Gandi::Domain::Host.new(hostname, host_attributes)
+    host.to_hash.should == host_attributes
+    host.hostname.should == hostname
+  end
+  
+  context "an instance" do
+    let(:hostname) { 'domain1.tld' }
+    let(:host_attributes) { domain_host_attributes_hash('name' => hostname) }
+    
+    before do
+      @connection_mock.should_receive(:call).with('domain.host.info', hostname).and_return(host_attributes)
+    end
+    subject { Gandi::Domain::Host.new(hostname) }
+    
+    its(:hostname) { should == hostname }
+    its(:ips) { should == host_attributes['ips'] }
+    
+    pending '#domain'
+    
+    it "can fetch its informations" do
+      @connection_mock.should_receive(:call).with('domain.host.info', hostname).and_return(host_attributes)
+      subject.info['ips'].should == host_attributes['ips']
+    end
+    
+    it "can read its attributes" do
+      subject.to_hash.should == host_attributes
+      subject['ips'].should == host_attributes['ips']
+    end
+    
+    it "can be deleted" do
+      @connection_mock.should_receive(:call).with('domain.host.delete', hostname).and_return(operation_information_attributes_hash('id' => 42))
+      
+      host_deletion = subject.delete
+      host_deletion.should be_a(Gandi::Operation)
+      host_deletion.id.should == 42
+    end
+    
+    it "can be updated" do
+      new_ips = ['5.6.7.8']
+      @connection_mock.should_receive(:call).with('domain.host.update', hostname, new_ips).and_return(operation_information_attributes_hash('id' => 42))
+      
+      host_update = subject.update(new_ips)
+      host_update.should be_a(Gandi::Operation)
+      host_update.id.should == 42
+    end
+  end
+end

data/spec/gandi/domain/mailbox_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+require 'gandi'
+
+describe Gandi::Domain::Mailbox do
+  before do
+    @connection_mock = double()
+    ::Gandi.connection = @connection_mock
+  end
+  
+  describe '.list' do
+    let(:fqdn) { 'domain1.tld' }
+    let(:domain) { mock_domain(fqdn) }
+    let(:domain_mailboxes_list) { [domain_mailbox_attributes('login' => 'john.doe'), domain_mailbox_attributes('login' => 'jane.doe'), domain_mailbox_attributes('login' => 'tom.doe')] }
+    
+    before do
+      @connection_mock.should_receive(:call).with('domain.mailbox.list', fqdn, {}).and_return(domain_mailboxes_list)
+    end
+    
+    it "returns an array of Mailbox objects by default" do
+      domain_mailboxes_list.each do |mailbox_hash|
+        @connection_mock.should_receive(:call).with('domain.mailbox.info', fqdn, mailbox_hash['login']).and_return(mailbox_hash)
+      end
+      
+      list = Gandi::Domain::Mailbox.list(domain)
+      list.length.should == domain_mailboxes_list.length
+      list.first.should be_a(Gandi::Domain::Mailbox)
+      list.first.login.should == domain_mailboxes_list.first['login']
+    end
+    
+    it "returns an array of hashes if map_mailboxes is false" do
+      list = Gandi::Domain::Mailbox.list(domain, {}, false)
+      list.should == domain_mailboxes_list
+    end
+  end
+  
+  describe '.count' do
+    let(:fqdn) { 'domain1.tld' }
+    let(:domain) { mock_domain(fqdn) }
+    
+    before do
+      @connection_mock.should_receive(:call).with('domain.mailbox.count', fqdn, {}).and_return(42)
+    end
+    
+    it "returns an integer" do
+      Gandi::Domain::Mailbox.count(domain).should == 42
+    end
+  end
+  
+  describe '.create' do
+    let(:fqdn) { 'domain1.tld' }
+    let(:domain) { mock_domain(fqdn) }
+    let(:login) { 'john.doe' }
+    let(:mailbox_create_params) { {'password' => 'securedp4ssword'} }
+    
+    before do
+      @connection_mock.should_receive(:call).with('domain.mailbox.create', fqdn, login, mailbox_create_params).and_return(mailbox_create_params)
+    end
+    
+    it "returns a Mailbox object" do
+      mailbox = Gandi::Domain::Mailbox.create(domain, login, mailbox_create_params)
+      mailbox.should be_a(Gandi::Domain::Mailbox)
+      mailbox.login.should == login
+    end
+  end
+  
+  it "can be instanciated with its attributes" do
+    fqdn = 'domain1.tld'
+    domain = mock_domain(fqdn)
+    login = 'john.doe'
+    mailbox_attributes = domain_mailbox_attributes('login' => login)
+    
+    mailbox = Gandi::Domain::Mailbox.new(domain, login, mailbox_attributes)
+    mailbox.to_hash.should == mailbox_attributes
+    mailbox.login.should == login
+    mailbox.domain.should == domain
+  end
+  
+  context "an instance" do
+    let(:fqdn) { 'domain1.tld' }
+    let(:domain) { mock_domain(fqdn) }
+    let(:login) { 'john.doe' }
+    let(:mailbox_attributes) { domain_mailbox_attributes('name' => login) }
+    
+    before do
+      @connection_mock.should_receive(:call).with('domain.mailbox.info', fqdn, login).and_return(mailbox_attributes)
+    end
+    subject { Gandi::Domain::Mailbox.new(domain, login) }
+    
+    its(:login) { should == login }
+    its(:domain) { should == domain }
+    
+    it "can fetch its informations" do
+      @connection_mock.should_receive(:call).with('domain.mailbox.info', fqdn, login).and_return(mailbox_attributes)
+      subject.info['ips'].should == mailbox_attributes['ips']
+    end
+    
+    it "can read its attributes" do
+      subject.to_hash.should == mailbox_attributes
+      subject['login'].should == mailbox_attributes['login']
+    end
+    
+    it "can be deleted" do
+      @connection_mock.should_receive(:call).with('domain.mailbox.delete', fqdn, login).and_return(true)
+      
+      subject.delete.should be_true
+    end
+    
+    it "can be updated" do
+      new_attrs = mailbox_attributes.merge('password' => 'newpassword')
+      @connection_mock.should_receive(:call).with('domain.mailbox.update', fqdn, login, new_attrs).and_return(operation_information_attributes_hash('id' => 42))
+      
+      mailbox_update = subject.update(new_attrs)
+      mailbox_update.should be_a(Gandi::Operation)
+      mailbox_update.id.should == 42
+    end
+  end
+end

data/spec/gandi/domain/tld_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'gandi'
+
+describe Gandi::Domain::Tld do
+  before do
+    @connection_mock = double()
+    ::Gandi.connection = @connection_mock
+  end
+  
+  describe '.list' do
+    it "returns a hash" do
+      @connection_mock.should_receive(:call).with('domain.tld.list').and_return(domain_tld_list)
+      Gandi::Domain::Tld.list.should == domain_tld_list
+    end
+  end
+  
+  describe '.region' do
+    it "returns an array" do
+      @connection_mock.should_receive(:call).with('domain.tld.region').and_return(domain_tld_regions)
+      Gandi::Domain::Tld.region.should == domain_tld_regions
+    end
+  end
+end

data/spec/gandi/domain_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+require 'gandi'
+
+describe Gandi::Domain do
+  before do
+    @connection_mock = double()
+    ::Gandi.connection = @connection_mock
+  end
+  
+  describe '.list' do
+    let(:domain_list) { [domain_information_attributes_hash('fqdn' => 'domain1.com'), domain_information_attributes_hash('fqdn' => 'domain2.net')] }
+    
+    before do
+      @connection_mock.should_receive(:call).with('domain.list', {}).and_return(domain_list)
+      @connection_mock.should_receive(:call).with('domain.info', 'domain1.com').and_return(domain_information_attributes_hash('fqdn' => 'domain1.com'))
+      @connection_mock.should_receive(:call).with('domain.info', 'domain2.net').and_return(domain_information_attributes_hash('fqdn' => 'domain2.net'))
+    end
+    
+    it "returns an array of domain objects" do
+      list = Gandi::Domain.list
+      list.length.should == domain_list.length
+      list.first.should be_a(Gandi::Domain)
+      list.first.fqdn.should == domain_list.first['fqdn']
+    end
+  end
+  
+  describe '.count' do
+    before do
+      @connection_mock.should_receive(:call).with('domain.count', {}).and_return(42)
+    end
+    
+    it "returns an integer" do
+      Gandi::Domain.count.should == 42
+    end
+  end
+  
+  describe '.available' do
+    let(:fqdns) { ['domain1.com', 'domain2.net'] }
+    
+    it "returns a hash of fqdns" do
+      fqdns_available_call_result = {"domain1.com"=>"unavailable", "domain2.net"=>"available"}
+      @connection_mock.should_receive(:call).with('domain.available', fqdns).and_return(fqdns_available_call_result)
+      
+      Gandi::Domain.available(fqdns).should == fqdns_available_call_result
+    end
+    
+    pending "should wait then recall the method when getting pending results"
+  end
+  
+  describe '.create' do
+    let(:handle) { 'FLN123-GANDI' }
+    let(:domain_creation_params) { {'owner' => handle, 'admin' => handle, 'tech' => handle, 'bill' => handle, 'nameservers' => ['gandi.net'], 'duration' => 1} }
+    let(:fqdn) { 'domain1.com' }
+    
+    before do
+      @connection_mock.should_receive(:call).with('domain.create', fqdn, domain_creation_params).and_return(domain_creation_operation_hash('id' => 42))
+    end
+    
+    it "returns an operation object" do
+      domain_operation = Gandi::Domain.create(fqdn, domain_creation_params)
+      domain_operation.should be_a(Gandi::Operation)
+      domain_operation.id.should == 42
+    end
+  end
+  
+  describe '.transferin' do
+    let(:handle) { 'FLN123-GANDI' }
+    let(:transfer_params) { {'owner' => handle, 'admin' => handle, 'bill' => handle, 'tech' => handle} }
+    let(:fqdn) { 'domain1.com' }
+    
+    before do
+      @connection_mock.should_receive(:call).with('domain.transferin.proceed', fqdn, transfer_params).and_return(operation_information_attributes_hash('id' => 42))
+    end
+    
+    it "returns an operation object" do
+      domain_operation = Gandi::Domain.transferin(fqdn, transfer_params)
+      domain_operation.should be_a(Gandi::Operation)
+      domain_operation.id.should == 42
+    end
+  end
+  
+  context "an instance" do
+    let(:fqdn) { 'domain1.tld' }
+    let(:domain_attributes) { domain_information_attributes_hash('fqdn' => fqdn) }
+    
+    before do
+      @connection_mock.should_receive(:call).with('domain.info', fqdn).and_return(domain_attributes)
+    end
+    subject { Gandi::Domain.new(fqdn) }
+    
+    its(:fqdn) { should == fqdn }
+    
+    it "can fetch its informations" do
+      @connection_mock.should_receive(:call).with('domain.info', fqdn).and_return(domain_attributes)
+      subject.info['fqdn'].should == domain_attributes['fqdn']
+    end
+    
+    it "can read its attributes" do
+      subject.to_hash.should == domain_attributes
+      subject['tld'].should == domain_attributes['tld']
+    end
+    
+    it "can be renewed" do
+      renewal_spec = domain_renew_spec
+      @connection_mock.should_receive(:call).with('domain.renew', fqdn, renewal_spec).and_return(domain_renewal_operation_hash('id' => 42))
+      
+      domain_renewal_operation = subject.renew(renewal_spec)
+      domain_renewal_operation.should be_a(Gandi::Operation)
+      domain_renewal_operation.id.should == 42
+    end
+    
+    pending "has attributes writers and readers"
+    
+    it "has contacts" do
+      @connection_mock.should_receive(:call).exactly(5).times.with('contact.info', 'FLN123-GANDI').and_return(contact_information_attributes_hash('handle' => 'FLN123-GANDI'))
+      
+      contacts = subject.contacts
+      contacts['owner'].should be_a(Gandi::Contact)
+      contacts['owner'].handle.should == 'FLN123-GANDI'
+    end
+    
+    it "can set its contacts" do
+      contacts_update_hash = {
+        "admin"=>"FLN123-GANDI", 
+        "bill"=>"FLN123-GANDI", 
+        "tech"=>"FLN123-GANDI"
+      }
+      @connection_mock.should_receive(:call).with('domain.contacts.set', fqdn, contacts_update_hash).and_return(operation_information_attributes_hash('id' => 42))
+      
+      contacts_change = subject.contacts = contacts_update_hash
+      #contacts_change.should be_a(Gandi::Operation)
+      #contacts_change.id.should == 42
+      contacts_change.should == contacts_update_hash
+    end
+    
+    pending "can set its contacts using a hash of contacts objects"
+    
+    it 'can be locked' do
+      @connection_mock.should_receive(:call).with('domain.status.lock', fqdn).and_return(operation_information_attributes_hash('id' => 42))
+      
+      domain_lock_operation = subject.lock
+      domain_lock_operation.should be_a(Gandi::Operation)
+      domain_lock_operation.id.should == 42
+    end
+    
+    pending 'cannot be locked if already locked'
+    
+    it 'can be unlocked' do
+      @connection_mock.should_receive(:call).with('domain.status.unlock', fqdn).and_return(operation_information_attributes_hash('id' => 42))
+      
+      domain_lock_operation = subject.unlock
+      domain_lock_operation.should be_a(Gandi::Operation)
+      domain_lock_operation.id.should == 42
+    end
+    
+    pending 'cannot be unlocked if already unlocked'
+    
+    pending '#locked?'
+    
+    it "has nameservers" do
+      subject.nameservers.should == domain_attributes['nameservers']
+    end
+    
+    it "can set its nameservers" do
+      new_nameservers = ['a.dns.gandi-ote.net', 'b.dns.gandi-ote.net', 'c.dns.gandi-ote.net']
+      @connection_mock.should_receive(:call).with('domain.nameservers.set', fqdn, new_nameservers).and_return(operation_information_attributes_hash('id' => 42))
+      
+      namservers_change = subject.nameservers=(new_nameservers)
+      #namservers_change.should be_a(Gandi::Operation)
+      #namservers_change.id.should == 42
+      namservers_change.should == new_nameservers
+    end
+  end
+end