gandi_v5 0.6.0 → 0.7.0

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', 'fetch.yml'))
-      expect(GandiV5).to receive(:get).with('https://dns.api.gandi.net/api/v5/domains/example.com')
+      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,129 +139,254 @@ 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.yml'))
-      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
@@ -267,11 +394,63 @@ describe GandiV5::LiveDNS::Domain do
 
     before :each do
       body_fixture = File.expand_path(File.join('spec', 'fixtures', 'bodies', 'GandiV5_LiveDNS_Domain', 'fetch.yml'))
-      expect(GandiV5).to receive(:get).with('https://dns.api.gandi.net/api/v5/domains/example.com')
+      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