Beispiel #1
0
class Servers(ApiTestCase):
    def test_flush(self):
        r = self.session.put(
            self.url(
                "/api/v1/servers/localhost/cache/flush?domain=example.org."))
        self.assert_success_json(r)
        data = r.json()
        self.assertIn('count', data)

    @unittest.skipIf(not is_recursor(), "Not applicable")
    def test_flush_count(self):
        sdig("ns1.example.com", 'A')
        r = self.session.put(
            self.url(
                "/api/v1/servers/localhost/cache/flush?domain=ns1.example.com."
            ))
        self.assert_success_json(r)
        data = r.json()
        self.assertIn('count', data)
        self.assertEqual(1, data['count'])

    @unittest.skipIf(not is_recursor(), "Not applicable")
    def test_flush_subtree(self):
        sdig("ns1.example.com", 'A')
        sdig("ns2.example.com", 'A')
        r = self.session.put(
            self.url(
                "/api/v1/servers/localhost/cache/flush?domain=example.com.&subtree=false"
            ))
        self.assert_success_json(r)
        data = r.json()
        self.assertIn('count', data)
        self.assertEqual(1, data['count'])
        r = self.session.put(
            self.url(
                "/api/v1/servers/localhost/cache/flush?domain=example.com.&subtree=true"
            ))
        self.assert_success_json(r)
        data = r.json()
        self.assertIn('count', data)
        self.assertEqual(2, data['count'])

    def test_flush_root(self):
        r = self.session.put(
            self.url("/api/v1/servers/localhost/cache/flush?domain=."))
        self.assert_success_json(r)
        data = r.json()
        self.assertIn('count', data)
        self.assertEqual(data['result'], 'Flushed cache.')

    def test_flush_no_domain(self):
        r = self.session.put(self.url("/api/v1/servers/localhost/cache/flush"))
        self.assertEqual(r.status_code, 422)

    def test_flush_unqualified(self):
        r = self.session.put(
            self.url("/api/v1/servers/localhost/cache/flush?domain=bar"))
        self.assertEqual(r.status_code, 422)
Beispiel #2
0
 def test_read_metrics(self):
     if is_recursor():
         res = self.session.get(self.url("/metrics"), auth=('whatever', self.webServerBasicAuthPassword), timeout=2.0)
         self.assertEqual(res.status_code, 200)
         # print(res.text)
         found = False
         for line in res.text.splitlines():
             if line[0] == "#":
                 continue
             if line.split(" ")[0] == "pdns_recursor_uptime":
                 found = True
         self.assertTrue(found,"pdns_recursor_uptime is missing")
Beispiel #3
0
 def test_list_zones(self):
     r = self.session.get(self.url("/servers/localhost/zones"))
     self.assert_success_json(r)
     domains = r.json()
     example_com = [domain for domain in domains if domain['name'] in ('example.com', 'example.com.')]
     self.assertEquals(len(example_com), 1)
     example_com = example_com[0]
     required_fields = ['id', 'url', 'name', 'kind']
     if is_auth():
         required_fields = required_fields + ['masters', 'last_check', 'notified_serial', 'serial', 'account']
     elif is_recursor():
         required_fields = required_fields + ['recursion_desired', 'servers']
     for field in required_fields:
         self.assertIn(field, example_com)
Beispiel #4
0
 def test_servers_localhost(self):
     r = self.session.get(self.url("/api/v1/servers/localhost"))
     self.assert_success_json(r)
     data = r.json()
     for k in ('id', 'type', 'version', 'daemon_type', 'url', 'zones_url', 'config_url'):
         self.assertIn(k, data)
     self.assertEquals(data['id'], 'localhost')
     self.assertEquals(data['type'], 'Server')
     # or 'recursor' for recursors
     if is_auth():
         daemon_type = 'authoritative'
     elif is_recursor():
         daemon_type = 'recursor'
     else:
         raise RuntimeError('Unknown daemon type')
     self.assertEquals(data['daemon_type'], daemon_type)
Beispiel #5
0
 def test_servers_localhost(self):
     r = self.session.get(self.url("/api/v1/servers/localhost"))
     self.assert_success_json(r)
     data = r.json()
     for k in ('id', 'type', 'version', 'daemon_type', 'url', 'zones_url', 'config_url'):
         self.assertIn(k, data)
     self.assertEqual(data['id'], 'localhost')
     self.assertEqual(data['type'], 'Server')
     # or 'recursor' for recursors
     if is_auth():
         daemon_type = 'authoritative'
     elif is_recursor():
         daemon_type = 'recursor'
     else:
         raise RuntimeError('Unknown daemon type')
     self.assertEqual(data['daemon_type'], daemon_type)
Beispiel #6
0
import json
import unittest
from test_helper import ApiTestCase, is_recursor


@unittest.skipIf(not is_recursor(), "Only applicable to recursors")
class RecursorConfig(ApiTestCase):
    def test_config_allow_from_get(self):
        r = self.session.get(
            self.url("/api/v1/servers/localhost/config/allow-from"))
        self.assert_success_json(r)

    def test_config_allow_from_replace(self):
        payload = {'value': ["127.0.0.1"]}
        r = self.session.put(
            self.url("/api/v1/servers/localhost/config/allow-from"),
            data=json.dumps(payload),
            headers={'content-type': 'application/json'})
        self.assert_success_json(r)
        data = r.json()
        self.assertIn("value", data)
        self.assertEqual(len(data["value"]), 1)
        self.assertEqual("127.0.0.1/32", data["value"][0])

    def test_config_allow_from_replace_error(self):
        """Test the error case, should return 422."""
        payload = {'value': ["abcdefgh"]}
        r = self.session.put(
            self.url("/api/v1/servers/localhost/config/allow-from"),
            data=json.dumps(payload),
            headers={'content-type': 'application/json'})
Beispiel #7
0
        self.assertEquals(len(r.json()),
                          1)  # FIXME test disarmed for now (should be 4)

    def test_search_rr_case_insensitive(self):
        name = 'search-rr-insenszone.name'
        self.create_zone(name=name)
        r = self.session.get(
            self.url("/servers/localhost/search-data?q=rr-insensZONE"))
        self.assert_success_json(r)
        print r.json()
        # should return zone, SOA, ns1, ns2
        self.assertEquals(len(r.json()),
                          1)  # FIXME test disarmed for now (should be 4)


@unittest.skipIf(not is_recursor(), "Not applicable")
class RecursorZones(ApiTestCase):
    def create_zone(self, name=None, kind=None, rd=False, servers=None):
        if name is None:
            name = unique_zone_name()
        if servers is None:
            servers = []
        payload = {
            'name': name,
            'kind': kind,
            'servers': servers,
            'recursion_desired': rd
        }
        r = self.session.post(self.url("/servers/localhost/zones"),
                              data=json.dumps(payload),
                              headers={'content-type': 'application/json'})
Beispiel #8
0
            'kind': 'Native',
            'soa_edit_api': '',
            'soa_edit': ''
        }
        r = self.session.put(
            self.url("/servers/localhost/zones/" + zone_id),
            data=json.dumps(payload),
            headers={'content-type': 'application/json'})
        self.assert_success_json(r)
        data = r.json()
        for k in payload.keys():
            self.assertIn(k, data)
            self.assertEquals(data[k], payload[k])


@unittest.skipIf(not is_recursor(), "Not applicable")
class RecursorZones(ApiTestCase):

    def create_zone(self, name=None, kind=None, rd=False, servers=None):
        if name is None:
            name = unique_zone_name()
        if servers is None:
            servers = []
        payload = {
            'name': name,
            'kind': kind,
            'servers': servers,
            'recursion_desired': rd
        }
        r = self.session.post(
            self.url("/servers/localhost/zones"),
Beispiel #9
0
import json
import unittest
from test_helper import ApiTestCase, is_recursor


@unittest.skipIf(not is_recursor(), "Only applicable to recursors")
class RecursorConfig(ApiTestCase):

    def test_config_allow_from_get(self):
        r = self.session.get(self.url("/api/v1/servers/localhost/config/allow-from"))
        self.assert_success_json(r)

    def test_config_allow_from_replace(self):
        payload = {'value': ["127.0.0.1"]}
        r = self.session.put(
            self.url("/api/v1/servers/localhost/config/allow-from"),
            data=json.dumps(payload),
            headers={'content-type': 'application/json'})
        self.assert_success_json(r)
        data = r.json()
        self.assertEquals("127.0.0.1/32", data["value"][0])

    def test_config_allow_from_replace_error(self):
        """Test the error case, should return 422."""
        payload = {'value': ["abcdefgh"]}
        r = self.session.put(
            self.url("/api/v1/servers/localhost/config/allow-from"),
            data=json.dumps(payload),
            headers={'content-type': 'application/json'})
        self.assertEquals(r.status_code, 422)
        data = r.json()
Beispiel #10
0
class Servers(ApiTestCase):
    def test_list_servers(self):
        r = self.session.get(self.url("/api/v1/servers"))
        self.assert_success_json(r)
        lst = r.json()
        self.assertEqual(len(lst), 1)  # only localhost allowed in there
        data = lst[0]
        for k in ('id', 'daemon_type', 'url'):
            self.assertIn(k, data)
        self.assertEqual(data['id'], 'localhost')

    def test_servers_localhost(self):
        r = self.session.get(self.url("/api/v1/servers/localhost"))
        self.assert_success_json(r)
        data = r.json()
        for k in ('id', 'type', 'version', 'daemon_type', 'url', 'zones_url',
                  'config_url'):
            self.assertIn(k, data)
        self.assertEqual(data['id'], 'localhost')
        self.assertEqual(data['type'], 'Server')
        # or 'recursor' for recursors
        if is_auth():
            daemon_type = 'authoritative'
        elif is_recursor():
            daemon_type = 'recursor'
        else:
            raise RuntimeError('Unknown daemon type')
        self.assertEqual(data['daemon_type'], daemon_type)

    def test_read_config(self):
        r = self.session.get(self.url("/api/v1/servers/localhost/config"))
        self.assert_success_json(r)
        data = dict([(r['name'], r['value']) for r in r.json()])
        self.assertIn('daemon', data)

    def test_read_statistics(self):
        r = self.session.get(self.url("/api/v1/servers/localhost/statistics"))
        self.assert_success_json(r)
        data = r.json()
        self.assertIn('uptime', [e['name'] for e in data])
        print(data)
        if is_auth():
            qtype_stats, respsize_stats, queries_stats, rcode_stats = None, None, None, None
            for elem in data:
                if elem['type'] == 'MapStatisticItem' and elem[
                        'name'] == 'response-by-qtype':
                    qtype_stats = elem['value']
                elif elem['type'] == 'MapStatisticItem' and elem[
                        'name'] == 'response-sizes':
                    respsize_stats = elem['value']
                elif elem['type'] == 'RingStatisticItem' and elem[
                        'name'] == 'queries':
                    queries_stats = elem['value']
                elif elem['type'] == 'MapStatisticItem' and elem[
                        'name'] == 'response-by-rcode':
                    rcode_stats = elem['value']
            self.assertIn('A', [e['name'] for e in qtype_stats])
            self.assertIn('80', [e['name'] for e in respsize_stats])
            self.assertIn('example.com/A', [e['name'] for e in queries_stats])
            self.assertIn('No Error', [e['name'] for e in rcode_stats])
        else:
            qtype_stats, respsize_stats, rcode_stats = None, None, None
            for elem in data:
                if elem['type'] == 'MapStatisticItem' and elem[
                        'name'] == 'response-by-qtype':
                    qtype_stats = elem['value']
                elif elem['type'] == 'MapStatisticItem' and elem[
                        'name'] == 'response-sizes':
                    respsize_stats = elem['value']
                elif elem['type'] == 'MapStatisticItem' and elem[
                        'name'] == 'response-by-rcode':
                    rcode_stats = elem['value']
            self.assertIn('A', [e['name'] for e in qtype_stats])
            self.assertIn('60', [e['name'] for e in respsize_stats])
            self.assertIn('80', [e['name'] for e in respsize_stats])
            self.assertIn('No Error', [e['name'] for e in rcode_stats])

    def test_read_one_statistic(self):
        r = self.session.get(
            self.url("/api/v1/servers/localhost/statistics?statistic=uptime"))
        self.assert_success_json(r)
        data = r.json()
        self.assertIn('uptime', [e['name'] for e in data])

    def test_read_one_non_existent_statistic(self):
        r = self.session.get(
            self.url(
                "/api/v1/servers/localhost/statistics?statistic=uptimeAAAA"))
        self.assertEqual(r.status_code, 422)
        self.assertIn("Unknown statistic name", r.json()['error'])

    def test_read_metrics(self):
        if is_recursor():
            res = self.session.get(self.url("/metrics"),
                                   auth=('whatever',
                                         self.webServerBasicAuthPassword),
                                   timeout=2.0)
            self.assertEqual(res.status_code, 200)
            # print(res.text)
            found = False
            for line in res.text.splitlines():
                if line[0] == "#":
                    continue
                if line.split(" ")[0] == "pdns_recursor_uptime":
                    found = True
            self.assertTrue(found, "pdns_recursor_uptime is missing")

    @unittest.skipIf(is_auth(), "Not applicable")
    def test_read_statistics_using_password(self):
        r = requests.get(self.url("/api/v1/servers/localhost/statistics"),
                         auth=('admin', self.server_web_password))
        self.assertEqual(r.status_code, requests.codes.ok)
        self.assert_success_json(r)

    @unittest.skipIf(is_recursor(), "Not applicable")
    @unittest.skipIf(is_auth_lmdb(), "No autoprimary management in LMDB yet")
    def test_autoprimaries(self):
        # verify that we have zero autoprimaries
        res = self.session.get(
            self.url("/api/v1/servers/localhost/autoprimaries"),
            auth=('whatever', self.webServerBasicAuthPassword),
            timeout=2.0)
        self.assertEqual(res.status_code, requests.codes.ok)
        self.assertEqual(res.json(), [])

        # add one
        payload = {'ip': '192.0.2.1', 'nameserver': 'ns.example.com'}

        res = self.session.post(
            self.url("/api/v1/servers/localhost/autoprimaries"),
            data=json.dumps(payload),
            headers={'content-type': 'application/json'})

        self.assertEqual(res.status_code, 201)

        # check that it's there
        res = self.session.get(
            self.url("/api/v1/servers/localhost/autoprimaries"),
            auth=('whatever', self.webServerBasicAuthPassword),
            timeout=2.0)
        self.assertEqual(res.status_code, requests.codes.ok)
        self.assertEqual(res.json(), [{
            'account': '',
            'ip': '192.0.2.1',
            'nameserver': 'ns.example.com'
        }])

        # add another one, this time with an account field
        payload = {
            'ip': '192.0.2.2',
            'nameserver': 'ns.example.org',
            'account': 'test'
        }

        res = self.session.post(
            self.url("/api/v1/servers/localhost/autoprimaries"),
            data=json.dumps(payload),
            headers={'content-type': 'application/json'})

        self.assertEqual(res.status_code, 201)

        # check that both are there
        res = self.session.get(
            self.url("/api/v1/servers/localhost/autoprimaries"),
            auth=('whatever', self.webServerBasicAuthPassword),
            timeout=2.0)
        self.assertEqual(res.status_code, requests.codes.ok)
        self.assertEqual(len(res.json()), 2)
        self.assertEqual(sorted(res.json(), key=operator.itemgetter('ip')),
                         [{
                             'account': '',
                             'ip': '192.0.2.1',
                             'nameserver': 'ns.example.com'
                         }, {
                             'account': 'test',
                             'ip': '192.0.2.2',
                             'nameserver': 'ns.example.org'
                         }])

        # remove one
        res = self.session.delete(self.url(
            "/api/v1/servers/localhost/autoprimaries/192.0.2.2/ns.example.org"
        ),
                                  headers={
                                      'content-type': 'application/json"'
                                  })

        self.assertEqual(res.status_code, 204)

        # check that we are back to just one
        res = self.session.get(
            self.url("/api/v1/servers/localhost/autoprimaries"),
            auth=('whatever', self.webServerBasicAuthPassword),
            timeout=2.0)
        self.assertEqual(res.status_code, requests.codes.ok)
        self.assertEqual(res.json(), [{
            'account': '',
            'ip': '192.0.2.1',
            'nameserver': 'ns.example.com'
        }])