gandi_v5 0.2.0 → 0.7.0

data/spec/units/gandi_v5/live_dns/{record_set_spec.rb → domain/record_spec.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-describe GandiV5::LiveDNS::RecordSet do
+describe GandiV5::LiveDNS::Domain::Record do
   subject do
     described_class.new type: 'A', ttl: 900, name: 'www', values: %w[192.168.0.1 192.168.0.2]
   end

data/spec/units/gandi_v5/live_dns/domain/snapshot_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+describe GandiV5::LiveDNS::Domain::Snapshot do
+  subject do
+    described_class.new(
+      created_at: Time.new(2016, 12, 16, 16, 51, 26, 0),
+      uuid: 'snapshot-uuid',
+      name: 'snapshot-name',
+      automatic: false,
+      records: [],
+      fqdn: 'example.com'
+    )
+  end
+
+  it '#update' do
+    url = 'https://api.gandi.net/v5/livedns/domains/example.com/snapshots/snapshot-uuid'
+    body = '{"name":"NEW NAME"}'
+    expect(GandiV5).to receive(:patch).with(url, body)
+                                      .and_return([nil, { 'message' => 'Confirmation message.' }])
+    expect(subject.update(name: 'NEW NAME')).to eq 'Confirmation message.'
+    expect(subject.name).to eq 'NEW NAME'
+  end
+
+  it '#delete' do
+    expect(GandiV5).to receive(:delete).with('https://api.gandi.net/v5/livedns/domains/example.com/snapshots/snapshot-uuid')
+                                       .and_return([nil, { 'message' => 'Confirmation message.' }])
+    expect(subject.delete).to eq 'Confirmation message.'
+  end
+
+  describe '#records' do
+    it 'Returns existing if present' do
+      expect(GandiV5).to_not receive(:get)
+      expect(subject.records).to eq []
+    end
+
+    it 'Fetches and saves if not present' do
+      subject = described_class.new fqdn: 'example.com', uuid: 'snapshot-uuid'
+      expect(GandiV5).to receive(:get).with('https://api.gandi.net/v5/livedns/domains/example.com/snapshots/snapshot-uuid')
+                                      .and_return([nil, { 'zone_data' => [{ 'rrset_name' => 'HELLO' }] }])
+      expect(subject.records.count).to eq 1
+      expect(subject.records.first.name).to eq 'HELLO'
+    end
+  end
+
+  describe '.list' do
+    let :body_fixture do
+      File.expand_path(File.join('spec', 'fixtures', 'bodies', 'GandiV5_LiveDNS_Domain_Snapshot', 'list.yml'))
+    end
+    let(:url) { 'https://api.gandi.net/v5/livedns/domains/example.com/snapshots' }
+
+    it 'With default parameters' do
+      expect(GandiV5).to receive(:paginated_get).with(url, (1..), 100, params: {})
+                                                .and_yield(YAML.load_file(body_fixture))
+      results = described_class.list('example.com')
+      result = results.first
+      expect(results.count).to eq 1
+      expect(result.name).to eq 'snapshot-name'
+      expect(result.created_at).to eq Time.new(2016, 12, 16, 16, 51, 26, 0)
+      expect(result.uuid).to eq 'snapshot-uuid'
+      expect(result.automatic).to be true
+      expect(result.fqdn).to eq 'example.com'
+    end
+
+    describe 'Passes optional query params' do
+      describe 'automatic' do
+        it 'true' do
+          expect(GandiV5).to receive(:paginated_get).with(url, (1..), 100, params: { automatic: true })
+          described_class.list('example.com', automatic: true)
+        end
+
+        it 'false' do
+          expect(GandiV5).to receive(:paginated_get).with(url, (1..), 100, params: { automatic: false })
+          described_class.list('example.com', automatic: false)
+        end
+      end
+    end
+  end
+
+  describe '.fetch' do
+    subject { described_class.fetch 'example.com', 'snapshot-uuid' }
+
+    before :each do
+      body_fixture = File.expand_path(
+        File.join('spec', 'fixtures', 'bodies', 'GandiV5_LiveDNS_Domain_Snapshot', 'fetch.yml')
+      )
+      expect(GandiV5).to receive(:get).with('https://api.gandi.net/v5/livedns/domains/example.com/snapshots/snapshot-uuid')
+                                      .and_return([nil, YAML.load_file(body_fixture)])
+    end
+
+    its('created_at') { should eq Time.new(2016, 12, 16, 16, 51, 26, 0) }
+    its('uuid') { should eq 'snapshot-uuid' }
+    its('name') { should eq 'snapshot-name' }
+    its('automatic') { should be true }
+    its('fqdn') { should eq 'example.com' }
+    its('records.count') { should eq 1 }
+    its('records.first.type') { should eq 'A' }
+    its('records.first.ttl') { should eq 10_800 }
+    its('records.first.name') { should eq 'www' }
+    its('records.first.values') { should match_array ['10.0.1.42'] }
+  end
+end

data/spec/units/gandi_v5/live_dns/domain/tsig_key_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+describe GandiV5::LiveDNS::Domain::TsigKey do
+  subject do
+    described_class.new(
+      uuid: 'key-uuid',
+      name: 'key-name',
+      secret: 'key-secret',
+      config_examples: { test: 'test config sample' }
+    )
+  end
+
+  describe '.create' do
+    it 'Without sharing_id' do
+      url = 'https://api.gandi.net/v5/livedns/axfr/tsig'
+      created = { 'href' => '', 'id' => 'created-key-uuid', 'key_name' => 'based on id' }
+      returns = double described_class
+
+      expect(GandiV5).to receive(:post).with(url).and_return([nil, created])
+      expect(described_class).to receive(:fetch).with('created-key-uuid')
+                                                .and_return(returns)
+      expect(described_class.create).to be returns
+    end
+
+    it 'With sharing_id' do
+      url = 'https://api.gandi.net/v5/livedns/axfr/tsig?sharing_id=sharing-id'
+      created = { 'href' => '', 'id' => 'created-key-uuid', 'key_name' => 'based on id' }
+      returns = double described_class
+
+      expect(GandiV5).to receive(:post).with(url).and_return([nil, created])
+      expect(described_class).to receive(:fetch).with('created-key-uuid')
+                                                .and_return(returns)
+      expect(described_class.create('sharing-id')).to be returns
+    end
+  end
+
+  it '.list' do
+    body_fixture = File.expand_path(
+      File.join('spec', 'fixtures', 'bodies', 'GandiV5_LiveDNS_Domain_TsigKey', 'list.yml')
+    )
+    url = 'https://api.gandi.net/v5/livedns/axfr/tsig'
+
+    expect(GandiV5).to receive(:get).with(url).and_return([nil, YAML.load_file(body_fixture)])
+    results = described_class.list
+    result = results.first
+    expect(results.count).to eq 1
+    expect(result.uuid).to eq 'key-uuid'
+    expect(result.name).to eq 'key-name'
+    expect(result.secret).to eq 'key-secret'
+  end
+
+  describe '.fetch' do
+    subject { described_class.fetch 'key-uuid' }
+
+    before :each do
+      body_fixture = File.expand_path(
+        File.join('spec', 'fixtures', 'bodies', 'GandiV5_LiveDNS_Domain_TsigKey', 'fetch.yml')
+      )
+      url = 'https://api.gandi.net/v5/livedns/axfr/tsig/key-uuid'
+      expect(GandiV5).to receive(:get).with(url)
+                                      .and_return([nil, YAML.load_file(body_fixture)])
+    end
+
+    its('uuid') { should eq 'key-uuid' }
+    its('name') { should eq 'key-name' }
+    its('secret') { should eq 'key-secret' }
+    its('config_examples') do
+      should eq(
+        {
+          bind: 'bind-sample',
+          knot: 'knot-sample',
+          nsd: 'nsd-sample',
+          powerdns: 'powerdns-sample'
+        }
+      )
+    end
+  end
+end

data/spec/units/gandi_v5/live_dns/domain_spec.rb

@@ -2,51 +2,53 @@
 
 describe GandiV5::LiveDNS::Domain do
   subject do
-    described_class.new fqdn: 'example.com', zone_uuid: 'zone-uuid'
+    described_class.new fqdn: 'example.com', automatic_snapshots: false
   end
 
   describe '#refresh' do
     before :each do
-      body_fixture = File.expand_path(File.join('spec', 'fixtures', 'bodies', 'GandiV5_LiveDNS_Domain', 'get.yaml'))
-      expect(GandiV5).to receive(:get).with('https://dns.api.gandi.net/api/v5/domains/example.com')
+      body_fixture = File.expand_path(File.join('spec', 'fixtures', 'bodies', 'GandiV5_LiveDNS_Domain', 'fetch.yml'))
+      expect(GandiV5).to receive(:get).with('https://api.gandi.net/v5/livedns/domains/example.com')
                                       .and_return([nil, YAML.load_file(body_fixture)])
       subject.refresh
     end
 
     its('fqdn') { should eq 'example.com' }
-    its('zone_uuid') { should eq 'zone-uuid' }
+    its('automatic_snapshots') { should be true }
+  end
+
+  it '#update' do
+    url = 'https://api.gandi.net/v5/livedns/domains/example.com'
+    body = '{"automatic_snapshots":true}'
+    expect(GandiV5).to receive(:patch).with(url, body)
+                                      .and_return([nil, { 'message' => 'Confirmation message.' }])
+    expect(subject.update(automatic_snapshots: true)).to eq 'Confirmation message.'
+    expect(subject.automatic_snapshots).to be true
   end
 
   describe '#fetch_records' do
+    let(:url) { 'https://api.gandi.net/v5/livedns/domains/example.com/records' }
     it 'All of them' do
-      expect(GandiV5).to receive(:get).with('https://dns.api.gandi.net/api/v5/domains/example.com/records')
-                                      .and_return([nil, []])
-
+      expect(GandiV5).to receive(:paginated_get).with(url, (1..), 100)
+                                                .and_yield([])
       expect(subject.fetch_records).to eq []
     end
 
     it 'All for a name' do
-      expect(GandiV5).to receive(:get).with('https://dns.api.gandi.net/api/v5/domains/example.com/records/name')
-                                      .and_return([nil, []])
-
+      expect(GandiV5).to receive(:paginated_get).with("#{url}/name", (1..), 100)
+                                                .and_yield([])
       expect(subject.fetch_records('name')).to eq []
     end
 
     it 'A type for a name' do
-      expect(GandiV5).to receive(:get).with('https://dns.api.gandi.net/api/v5/domains/example.com/records/name/TXT')
-                                      .and_return(
-                                        [
-                                          nil,
-                                          [
-                                            {
-                                              'rrset_type' => 'TXT',
-                                              'rrset_name' => 'name',
-                                              'rrset_ttl' => 600,
-                                              'rrset_values' => %w[a b]
-                                            }
-                                          ]
-                                        ]
-                                      )
+      record = {
+        'rrset_type' => 'TXT',
+        'rrset_name' => 'name',
+        'rrset_ttl' => 600,
+        'rrset_values' => %w[a b]
+      }
+      expect(GandiV5).to receive(:paginated_get).with("#{url}/name/TXT", (1..), 100)
+                                                .and_yield([record])
 
       records = subject.fetch_records('name', 'TXT')
       expect(records.count).to eq 1
@@ -63,19 +65,19 @@ describe GandiV5::LiveDNS::Domain do
 
   describe '#fetch_zone_lines' do
     it 'All of them' do
-      url = 'https://dns.api.gandi.net/api/v5/domains/example.com/records'
+      url = 'https://api.gandi.net/v5/livedns/domains/example.com/records'
       expect(GandiV5).to receive(:get).with(url, accept: 'text/plain').and_return([nil, 'returned'])
       expect(subject.fetch_zone_lines).to eq 'returned'
     end
 
     it 'All for a name' do
-      url = 'https://dns.api.gandi.net/api/v5/domains/example.com/records/name'
+      url = 'https://api.gandi.net/v5/livedns/domains/example.com/records/name'
       expect(GandiV5).to receive(:get).with(url, accept: 'text/plain').and_return([nil, 'returned'])
       expect(subject.fetch_zone_lines('name')).to eq 'returned'
     end
 
     it 'A type for a name' do
-      url = 'https://dns.api.gandi.net/api/v5/domains/example.com/records/name/TXT'
+      url = 'https://api.gandi.net/v5/livedns/domains/example.com/records/name/TXT'
       expect(GandiV5).to receive(:get).with(url, accept: 'text/plain').and_return([nil, 'returned'])
       expect(subject.fetch_zone_lines('name', 'TXT')).to eq 'returned'
     end
@@ -87,7 +89,7 @@ describe GandiV5::LiveDNS::Domain do
 
   describe '#add_record' do
     it 'Success' do
-      url = 'https://dns.api.gandi.net/api/v5/domains/example.com/records'
+      url = 'https://api.gandi.net/v5/livedns/domains/example.com/records'
       body = '{"rrset_name":"name","rrset_type":"TXT","rrset_ttl":900,"rrset_values":["a","b"]}'
       expect(GandiV5).to receive(:post).with(url, body).and_return([nil, { 'message' => 'Confirmation message.' }])
       expect(subject.add_record('name', 'TXT', 900, 'a', 'b')).to eq 'Confirmation message.'
@@ -114,19 +116,19 @@ describe GandiV5::LiveDNS::Domain do
 
   describe '#delete_records' do
     it 'All of them' do
-      url = 'https://dns.api.gandi.net/api/v5/domains/example.com/records'
+      url = 'https://api.gandi.net/v5/livedns/domains/example.com/records'
       expect(GandiV5).to receive(:delete).with(url).and_return([nil, nil])
       subject.delete_records
     end
 
     it 'All for a name' do
-      url = 'https://dns.api.gandi.net/api/v5/domains/example.com/records/name'
+      url = 'https://api.gandi.net/v5/livedns/domains/example.com/records/name'
       expect(GandiV5).to receive(:delete).with(url).and_return([nil, nil])
       subject.delete_records 'name'
     end
 
     it 'A type for a name' do
-      url = 'https://dns.api.gandi.net/api/v5/domains/example.com/records/name/TXT'
+      url = 'https://api.gandi.net/v5/livedns/domains/example.com/records/name/TXT'
       expect(GandiV5).to receive(:delete).with(url).and_return([nil, nil])
       subject.delete_records 'name', 'TXT'
     end
@@ -137,141 +139,318 @@ describe GandiV5::LiveDNS::Domain do
   end
 
   describe '#replace_records' do
-    it 'Given array of GandiV5::LiveDNS::RecordSet' do
-      records = [
-        { name: 'name', ttl: 600, type: 'TXT', values: ['a'] }
-      ]
-
-      url = 'https://dns.api.gandi.net/api/v5/domains/example.com/records'
-      body = '{"items":[{"rrset_name":"name","rrset_ttl":600,"rrset_type":"TXT","rrset_values":["a"]}]}'
+    it 'All of them' do
+      url = 'https://api.gandi.net/v5/livedns/domains/example.com/records'
+      body = '{"items":[{"rrset_name":"name","rrset_type":"TXT","rrset_values":["a"]}]}'
       expect(GandiV5).to receive(:put).with(url, body)
                                       .and_return([nil, { 'message' => 'Confirmation message.' }])
-      expect(subject.replace_records(records: records)).to eq 'Confirmation message.'
+      records = [{ name: 'name', type: 'TXT', values: ['a'] }]
+      expect(subject.replace_records(records)).to eq 'Confirmation message.'
     end
 
-    it 'Given string' do
-      records = [
-        '@ 86400 IN A 192.168.0.1',
-        '* 86400 IN A 192.168.0.1'
-      ].join("\n")
+    it 'All for a name' do
+      url = 'https://api.gandi.net/v5/livedns/domains/example.com/records/name'
+      body = '{"items":[{"rrset_type":"TXT","rrset_values":["a"]}]}'
+      expect(GandiV5).to receive(:put).with(url, body)
+                                      .and_return([nil, { 'message' => 'Confirmation message.' }])
+      records = [{ type: 'TXT', values: ['a'] }]
+      expect(subject.replace_records(records, name: 'name')).to eq 'Confirmation message.'
+    end
 
-      url = 'https://dns.api.gandi.net/api/v5/domains/example.com/records'
-      expect(GandiV5).to receive(:put).with(url, records, 'content-type': 'text/plain')
+    it 'All of a type for a name' do
+      url = 'https://api.gandi.net/v5/livedns/domains/example.com/records/name/TXT'
+      body = '{"rrset_values":["a"]}'
+      expect(GandiV5).to receive(:put).with(url, body)
                                       .and_return([nil, { 'message' => 'Confirmation message.' }])
-      expect(subject.replace_records(text: records)).to eq 'Confirmation message.'
+      expect(subject.replace_records(['a'], name: 'name', type: 'TXT')).to eq 'Confirmation message.'
     end
 
-    it 'Given both' do
-      expect { subject.replace_records text: '', records: [] }.to raise_error(
-        ArgumentError,
-        'you must pass ONE of records: or text:'
-      )
+    it 'Given type but no name' do
+      expect(GandiV5).to_not receive(:put)
+      expect { subject.replace_records(['a'], type: 'TXT') }.to raise_error ArgumentError, 'missing keyword: name'
+    end
+  end
+
+  it '#replace_zone_lines' do
+    records = [
+      '@ 86400 IN A 192.168.0.1',
+      '* 86400 IN A 192.168.0.1'
+    ].join("\n")
+
+    url = 'https://api.gandi.net/v5/livedns/domains/example.com/records'
+    expect(GandiV5).to receive(:put).with(url, records, 'content-type': 'text/plain')
+                                    .and_return([nil, { 'message' => 'Confirmation message.' }])
+    expect(subject.replace_zone_lines(records)).to eq 'Confirmation message.'
+  end
+
+  describe '#name_servers' do
+    let(:nameservers) { double Array }
+
+    it 'Already fetched' do
+      subject.instance_exec(nameservers) { |ns| @name_servers = ns }
+      expect(subject).to_not receive(:fetch_name_servers)
+      expect(subject.name_servers).to be nameservers
     end
 
-    it 'Given nothing' do
-      expect { subject.replace_records }.to raise_error ArgumentError, 'you must pass ONE of records: or text:'
+    it 'Not already fetched' do
+      expect(subject).to receive(:fetch_name_servers).and_return(nameservers)
+      expect(subject.name_servers).to be nameservers
     end
   end
 
-  describe '#replace_records_for' do
-    it 'Given no type or ttl' do
-      url = 'https://dns.api.gandi.net/api/v5/domains/example.com/records/name'
-      body = '{"items":[{"rrset_type":"TXT","rrset_values":["a"]}]}'
-      expect(GandiV5).to receive(:put).with(url, body)
-                                      .and_return([nil, { 'message' => 'Confirmation message.' }])
-      records = [{ type: 'TXT', values: ['a'] }]
-      expect(subject.replace_records_for('name', records)).to eq 'Confirmation message.'
+  it '#fetch_name_servers' do
+    body_fixture = File.expand_path(
+      File.join('spec', 'fixtures', 'bodies', 'GandiV5_LiveDNS_Domain', 'nameservers.yml')
+    )
+
+    expect(GandiV5).to receive(:get).with('https://api.gandi.net/v5/livedns/domains/example.com/nameservers')
+                                    .and_return([nil, YAML.load_file(body_fixture)])
+
+    expect(subject.fetch_name_servers).to match_array ['a.example.com', 'b.example.com']
+  end
+
+  describe '#dnssec_keys' do
+    let(:dnsseckeys) { double Array }
+
+    it 'Already fetched' do
+      subject.instance_exec(dnsseckeys) { |k| @dnssec_keys = k }
+      expect(subject).to_not receive(:fetch_dnssec_keys)
+      expect(subject.dnssec_keys).to be dnsseckeys
     end
 
-    it 'Given type and ttl' do
-      url = 'https://dns.api.gandi.net/api/v5/domains/example.com/records/name/TXT'
-      body = '{"rrset_values":["a"],"rrset_ttl":600}'
-      expect(GandiV5).to receive(:put).with(url, body)
-                                      .and_return([nil, { 'message' => 'Confirmation message.' }])
-      expect(subject.replace_records_for('name', ['a'], type: 'TXT', ttl: 600)).to eq 'Confirmation message.'
+    it 'Not already fetched' do
+      expect(subject).to receive(:fetch_dnssec_keys).and_return(dnsseckeys)
+      expect(subject.dnssec_keys).to be dnsseckeys
     end
+  end
 
-    it 'Given type but no ttl' do
-      url = 'https://dns.api.gandi.net/api/v5/domains/example.com/records/name/TXT'
-      body = '{"rrset_values":["a"],"rrset_ttl":null}'
-      expect(GandiV5).to receive(:put).with(url, body)
-                                      .and_return([nil, { 'message' => 'Confirmation message.' }])
-      expect(subject.replace_records_for('name', ['a'], type: 'TXT')).to eq 'Confirmation message.'
+  it '#fetch_dnssec_keys' do
+    keys = double Array
+    expect(GandiV5::LiveDNS::Domain::DnssecKey).to receive(:list).with('example.com')
+                                                                 .and_return(keys)
+
+    expect(subject.fetch_dnssec_keys).to be keys
+    expect(subject.instance_exec { @dnssec_keys }).to be keys
+  end
+
+  describe '#tsig_keys' do
+    let(:tsigkeys) { double Array }
+
+    it 'Already fetched' do
+      subject.instance_exec(tsigkeys) { |k| @tsig_keys = k }
+      expect(subject).to_not receive(:fetch_tsig_keys)
+      expect(subject.tsig_keys).to be tsigkeys
     end
 
-    it 'Given ttl but no type' do
-      expect(GandiV5).to_not receive(:put)
-      expect { subject.replace_records_for 'name', 'a', ttl: 600 }.to raise_error ArgumentError, 'missing keyword: type'
+    it 'Not already fetched' do
+      expect(subject).to receive(:fetch_tsig_keys).and_return(tsigkeys)
+      expect(subject.tsig_keys).to be tsigkeys
     end
   end
 
-  describe '#change_zone' do
-    it 'Given a uuid' do
-      url = 'https://dns.api.gandi.net/api/v5/domains/example.com'
-      body = '{"zone_uuid":"zone-uuid"}'
-      expect(GandiV5).to receive(:patch).with(url, body)
-                                        .and_return([nil, { 'message' => 'Confirmation message.' }])
-      expect(subject.change_zone('zone-uuid')).to eq 'Confirmation message.'
-      expect(subject.zone_uuid).to eq 'zone-uuid'
-    end
-
-    it 'Given something with a uuid method' do
-      url = 'https://dns.api.gandi.net/api/v5/domains/example.com'
-      body = '{"zone_uuid":"zone-uuid"}'
-      expect(GandiV5).to receive(:patch).with(url, body)
-                                        .and_return([nil, { 'message' => 'Confirmation message.' }])
-      zone = double GandiV5::LiveDNS::Zone, uuid: 'zone-uuid'
-      expect(subject.change_zone(zone)).to eq 'Confirmation message.'
-      expect(subject.zone_uuid).to eq 'zone-uuid'
+  it '#fetch_tsig_keys' do
+    body_fixture = File.expand_path(
+      File.join('spec', 'fixtures', 'bodies', 'GandiV5_LiveDNS_Domain', 'list_tsig.yml')
+    )
+    url = 'https://api.gandi.net/v5/livedns/domains/example.com/axfr/tsig'
+
+    expect(GandiV5).to receive(:get).with(url).and_return([nil, YAML.load_file(body_fixture)])
+    results = subject.fetch_tsig_keys
+    result = results.first
+    expect(results.count).to eq 1
+    expect(result.uuid).to eq 'key-uuid'
+    expect(result.name).to eq 'key-name'
+  end
+
+  describe '#add_tsig_key' do
+    let(:url) { 'https://api.gandi.net/v5/livedns/domains/example.com/axfr/tsig/key-uuid' }
+
+    it 'Passed a key' do
+      key = GandiV5::LiveDNS::Domain::TsigKey.new uuid: 'key-uuid'
+      expect(GandiV5).to receive(:put).with(url).and_return([nil, nil])
+      subject.add_tsig_key key
+    end
+
+    it 'Passed a string' do
+      expect(GandiV5).to receive(:put).with(url).and_return([nil, nil])
+      subject.add_tsig_key 'key-uuid'
+    end
+
+    it 'With sharing_id' do
+      expect(GandiV5).to receive(:put).with("#{url}?sharing_id=sharing-id").and_return([nil, nil])
+      subject.add_tsig_key 'key-uuid', sharing_id: 'sharing-id'
     end
   end
 
-  it '#fetch_zone' do
-    returns = double GandiV5::LiveDNS::Zone
-    expect(GandiV5::LiveDNS::Zone).to receive(:fetch).with('zone-uuid')
-                                                     .and_return(returns)
-    expect(subject.fetch_zone).to be returns
+  describe '#remove_tsig_key' do
+    let(:url) { 'https://api.gandi.net/v5/livedns/domains/example.com/axfr/tsig/key-uuid' }
+
+    it 'Passed a key' do
+      key = GandiV5::LiveDNS::Domain::TsigKey.new uuid: 'key-uuid'
+      expect(GandiV5).to receive(:delete).with(url).and_return([nil, nil])
+      subject.remove_tsig_key key
+    end
+
+    it 'Passed a string' do
+      expect(GandiV5).to receive(:delete).with(url).and_return([nil, nil])
+      subject.remove_tsig_key 'key-uuid'
+    end
+
+    it 'With sharing_id' do
+      expect(GandiV5).to receive(:delete).with("#{url}?sharing_id=sharing-id").and_return([nil, nil])
+      subject.remove_tsig_key 'key-uuid', sharing_id: 'sharing-id'
+    end
   end
 
-  describe '#zone' do
-    it 'Not previously fetched' do
-      returns = double GandiV5::LiveDNS::Zone
-      expect(subject).to receive(:fetch_zone).and_return(returns)
-      expect(subject.zone).to be returns
+  describe '#axfr_clients' do
+    let(:clients) { double Array }
+
+    it 'Already fetched' do
+      subject.instance_exec(clients) { |k| @axfr_clients = k }
+      expect(subject).to_not receive(:fetch_axfr_clients)
+      expect(subject.axfr_clients).to be clients
     end
 
-    it 'Previously fetched' do
-      returns = double GandiV5::LiveDNS::Zone
-      subject.instance_exec { @zone = returns }
-      expect(subject).to_not receive(:fetch_zone)
-      expect(subject.zone).to be returns
+    it 'Not already fetched' do
+      expect(subject).to receive(:fetch_axfr_clients).and_return(clients)
+      expect(subject.axfr_clients).to be clients
     end
   end
 
+  it '#fetch_axfr_clients' do
+    url = 'https://api.gandi.net/v5/livedns/domains/example.com/axfr/slaves'
+    expect(GandiV5).to receive(:get).with(url).and_return([nil, ['1.2.3.4']])
+    expect(subject.fetch_axfr_clients).to match_array ['1.2.3.4']
+  end
+
+  it '#add_axfr_client' do
+    url = 'https://api.gandi.net/v5/livedns/domains/example.com/axfr/slaves/1.2.3.4'
+    expect(GandiV5).to receive(:put).with(url).and_return([nil, nil])
+    subject.add_axfr_client '1.2.3.4'
+  end
+
+  it '#remove_axfr_client' do
+    url = 'https://api.gandi.net/v5/livedns/domains/example.com/axfr/slaves/1.2.3.4'
+    expect(GandiV5).to receive(:delete).with(url).and_return([nil, nil])
+    subject.remove_axfr_client '1.2.3.4'
+  end
+
   describe '.list' do
-    subject { described_class.list }
+    let(:body_fixture) do
+      File.expand_path(File.join('spec', 'fixtures', 'bodies', 'GandiV5_LiveDNS_Domain', 'list.yml'))
+    end
+    let(:url) { 'https://api.gandi.net/v5/livedns/domains' }
 
-    before :each do
-      body_fixture = File.expand_path(File.join('spec', 'fixtures', 'bodies', 'GandiV5_LiveDNS_Domain', 'list.yaml'))
-      expect(GandiV5).to receive(:get).with('https://dns.api.gandi.net/api/v5/domains')
+    it 'With default parameters' do
+      headers = { params: { page: 1, per_page: 100 } }
+      expect(GandiV5).to receive(:get).with(url, headers)
                                       .and_return([nil, YAML.load_file(body_fixture)])
+
+      subject = described_class.list
+      expect(subject.count).to eq 1
+      expect(subject.first).to eq 'example.com'
     end
 
-    its('count') { should eq 1 }
-    its('first.fqdn') { should eq 'example.com' }
-    its('first.zone_uuid') { should be nil }
+    it 'Keeps fetching until no more to get' do
+      headers1 = { params: { page: 1, per_page: 1 } }
+      headers2 = { params: { page: 2, per_page: 1 } }
+      expect(GandiV5).to receive(:get).with(url, headers1)
+                                      .ordered
+                                      .and_return([nil, YAML.load_file(body_fixture)])
+      expect(GandiV5).to receive(:get).with(url, headers2)
+                                      .ordered
+                                      .and_return([nil, []])
+
+      expect(described_class.list(per_page: 1).count).to eq 1
+    end
+
+    it 'Given a range as page number' do
+      headers = { params: { page: 1, per_page: 1 } }
+      expect(GandiV5).to receive(:get).with(url, headers)
+                                      .and_return([nil, YAML.load_file(body_fixture)])
+
+      described_class.list(page: (1..1), per_page: 1)
+    end
+
+    describe 'Passes optional query params' do
+      it 'per_page' do
+        headers = { params: { page: 1, per_page: 10 } }
+        expect(GandiV5).to receive(:get).with(url, headers)
+                                        .and_return([nil, []])
+        described_class.list(per_page: 10)
+      end
+
+      it 'sharing_id' do
+        headers = { params: { sharing_id: 'SHARING-UUID', page: 1, per_page: 100 } }
+        expect(GandiV5).to receive(:get).with(url, headers)
+                                        .and_return([nil, []])
+        described_class.list(sharing_id: 'SHARING-UUID')
+      end
+    end
   end
 
   describe '.fetch' do
     subject { described_class.fetch 'example.com' }
 
     before :each do
-      body_fixture = File.expand_path(File.join('spec', 'fixtures', 'bodies', 'GandiV5_LiveDNS_Domain', 'get.yaml'))
-      expect(GandiV5).to receive(:get).with('https://dns.api.gandi.net/api/v5/domains/example.com')
+      body_fixture = File.expand_path(File.join('spec', 'fixtures', 'bodies', 'GandiV5_LiveDNS_Domain', 'fetch.yml'))
+      expect(GandiV5).to receive(:get).with('https://api.gandi.net/v5/livedns/domains/example.com')
                                       .and_return([nil, YAML.load_file(body_fixture)])
     end
 
     its('fqdn') { should eq 'example.com' }
-    its('zone_uuid') { should eq 'zone-uuid' }
+    its('automatic_snapshots') { should be true }
+  end
+
+  describe '.create' do
+    let(:url) { 'https://api.gandi.net/v5/livedns/domains' }
+    let(:response) do
+      double RestClient::Response, headers: { location: 'https://api.gandi.net/v5/livedns/domains/example.com' }
+    end
+
+    it 'When passed only fqdn' do
+      returns = double described_class
+      body = '{"fqdn":"example.com","zone":{}}'
+      expect(GandiV5).to receive(:post).with(url, body).and_return([response, nil])
+      expect(described_class).to receive(:fetch).with('example.com').and_return(returns)
+      expect(described_class.create('example.com')).to be returns
+    end
+
+    it 'When passed soa_ttl' do
+      body = '{"fqdn":"example.com","zone":{"ttl":123}}'
+      expect(GandiV5).to receive(:post).with(url, body).and_return([response, nil])
+      expect(described_class).to receive(:fetch).with('example.com').and_return(nil)
+      described_class.create('example.com', soa_ttl: 123)
+    end
+
+    it 'When passed records' do
+      body = '{"fqdn":"example.com","zone":{"items":' \
+             '[{"rrset_type":"TXT","rrset_ttl":234,"rrset_name":"test","rrset_values":["value"]}]}}'
+      record = GandiV5::LiveDNS::Domain::Record.new name: 'test', type: 'TXT', ttl: 234, values: ['value']
+      expect(GandiV5).to receive(:post).with(url, body).and_return([response, nil])
+      expect(described_class).to receive(:fetch).with('example.com').and_return(nil)
+      described_class.create('example.com', [record])
+    end
+
+    it 'When passed sharing_id' do
+      body = '{"fqdn":"example.com","zone":{}}'
+      expect(GandiV5).to receive(:post).with("#{url}?sharing_id=organization_id", body).and_return([response, nil])
+      expect(described_class).to receive(:fetch).with('example.com').and_return(nil)
+      described_class.create('example.com', sharing_id: 'organization_id')
+    end
+  end
+
+  it '.record_types' do
+    list = double Array
+    expect(GandiV5).to receive(:get).with('https://api.gandi.net/v5/livedns/dns/rrtypes')
+                                    .and_return([nil, list])
+    expect(described_class.record_types).to be list
+  end
+
+  it '.generic_name_servers' do
+    list = double Array
+    expect(GandiV5).to receive(:get).with('https://api.gandi.net/v5/livedns/nameservers/example.com')
+                                    .and_return([nil, list])
+    expect(described_class.generic_name_servers('example.com')).to be list
   end
 end