class TestSetRS(fakes.TestDNS):

    _data = fakes.FakeRecordset.create_one()
    _zone = fakes.FakeZone.create_one()

    columns = ('description', 'name', 'records', 'status', 'ttl', 'type')

    data = fakes.gen_data(_data, columns)

    def setUp(self):
        super(TestSetRS, self).setUp()

        self.cmd = recordset.SetRS(self.app, None)

        self.client.update_recordset = mock.Mock()
        self.client.find_zone = mock.Mock()
        self.client.get_recordset = mock.Mock()
        self.client.api_mock = self.client.update_recordset

    def test_create(self):
        arglist = [
            'zn',
            'rs',
            '--description',
            'descr',
            '--ttl',
            '500',
            '--record',
            'a=b',
            '--record',
            'c=d',
        ]

        verifylist = [
            ('zone', 'zn'),
            ('recordset', 'rs'),
            ('description', 'descr'),
            ('ttl', 500),
            ('record', ['a=b', 'c=d']),
        ]

        # Verify cm is triggereg with default parameters
        parsed_args = self.check_parser(self.cmd, arglist, verifylist)

        # Set the response
        self.client.find_zone.side_effect = [self._zone]
        self.client.api_mock.side_effect = [self._data]
        self.client.get_recordset.side_effect = [self._data]

        # Trigger the action
        columns, data = self.cmd.take_action(parsed_args)

        self.client.api_mock.assert_called_once_with(recordset=self._data,
                                                     description='descr',
                                                     records=['a=b', 'c=d'],
                                                     ttl=500,
                                                     zone_id=self._zone.id)

        self.assertEqual(self.columns, columns)
        self.assertEqual(self.data, data)
class TestShowPTR(fakes.TestDNS):

    _data = fakes.FakeFloatingIP.create_one()

    columns = ('address', 'description', 'id', 'ptrdname', 'ttl')

    data = fakes.gen_data(_data, columns)

    def setUp(self):
        super(TestShowPTR, self).setUp()

        self.cmd = ptr.ShowPTR(self.app, None)

        self.client.get_ptr = mock.Mock()
        self.client.api_mock = self.client.get_floating_ip

    def test_default(self):
        arglist = ['fpid']

        verifylist = [('floatingip_id', 'fpid')]

        # Verify cm is triggereg with default parameters
        parsed_args = self.check_parser(self.cmd, arglist, verifylist)

        # Set the response
        self.client.api_mock.side_effect = [self._data]

        # Trigger the action
        columns, data = self.cmd.take_action(parsed_args)

        self.client.api_mock.assert_called_once_with('fpid')

        self.assertEqual(self.columns, columns)
        self.assertEqual(self.data, data)
Exemple #3
0
class TestSetZone(fakes.TestDNS):

    _data = fakes.FakeZone.create_one()

    columns = ('action', 'created_at', 'description', 'email', 'id', 'name',
               'pool_id', 'record_num', 'router', 'serial', 'status', 'ttl',
               'updated_at', 'zone_type')

    data = fakes.gen_data(_data, columns)

    def setUp(self):
        super(TestSetZone, self).setUp()

        self.cmd = zone.SetZone(self.app, None)

        self.client.update_zone = mock.Mock()
        self.client.find_zone = mock.Mock()
        self.client.api_mock = self.client.update_zone

    def test_update(self):
        arglist = [
            'zn',
            '--email',
            'eml',
            '--description',
            'descr',
            '--ttl',
            '500',
        ]

        verifylist = [
            ('zone', 'zn'),
            ('email', 'eml'),
            ('description', 'descr'),
            ('ttl', 500),
        ]

        # Verify cm is triggereg with default parameters
        parsed_args = self.check_parser(self.cmd, arglist, verifylist)

        # Set the response
        self.client.api_mock.side_effect = [self._data]
        self.client.find_zone.side_effect = [self._data]

        # Trigger the action
        columns, data = self.cmd.take_action(parsed_args)

        self.client.find_zone.assert_called_once_with('zn',
                                                      ignore_missing=False)

        self.client.api_mock.assert_called_once_with(zone=self._data,
                                                     description='descr',
                                                     email='eml',
                                                     ttl=500)

        self.assertEqual(self.columns, columns)
        self.assertEqual(self.data, data)
Exemple #4
0
class TestListZone(fakes.TestDNS):

    objects = fakes.FakeZone.create_multiple(3)

    columns = ('id', 'name', 'zone_type', 'serial', 'status', 'action')

    data = []

    for s in objects:
        data.append(fakes.gen_data(s, columns))

    def setUp(self):
        super(TestListZone, self).setUp()

        self.cmd = zone.ListZone(self.app, None)

        self.client.zones = mock.Mock()
        self.client.api_mock = self.client.zones

    def test_default(self):
        arglist = []

        verifylist = []

        # Verify cm is triggereg with default parameters
        parsed_args = self.check_parser(self.cmd, arglist, verifylist)

        # Set the response
        self.client.api_mock.side_effect = [self.objects]

        # Trigger the action
        columns, data = self.cmd.take_action(parsed_args)

        self.client.api_mock.assert_called_once_with()

        self.assertEqual(self.columns, columns)
        self.assertEqual(self.data, list(data))

    def test_default_query(self):
        arglist = ['--type', 'private']

        verifylist = [('type', 'private')]

        # Verify cm is triggereg with default parameters
        parsed_args = self.check_parser(self.cmd, arglist, verifylist)

        # Set the response
        self.client.api_mock.side_effect = [self.objects]

        # Trigger the action
        columns, data = self.cmd.take_action(parsed_args)

        self.client.api_mock.assert_called_once_with(type='private')

        self.assertEqual(self.columns, columns)
        self.assertEqual(self.data, list(data))
class TestListRS(fakes.TestDNS):

    objects = fakes.FakeRecordset.create_multiple(3)
    _zone = fakes.FakeZone.create_one()

    columns = ('id', 'name', 'type', 'status', 'description', 'records')

    data = []

    for s in objects:
        data.append(fakes.gen_data(s, columns))

    def setUp(self):
        super(TestListRS, self).setUp()

        self.cmd = recordset.ListRS(self.app, None)

        self.client.recordsets = mock.Mock()
        self.client.find_zone = mock.Mock()
        self.client.api_mock = self.client.recordsets

    def test_default_zone(self):
        arglist = ['zn']

        verifylist = [('zone', 'zn')]

        # Verify cm is triggereg with default parameters
        parsed_args = self.check_parser(self.cmd, arglist, verifylist)

        # Set the response
        self.client.api_mock.side_effect = [self.objects]
        self.client.find_zone.side_effect = [self._zone]

        # Trigger the action
        columns, data = self.cmd.take_action(parsed_args)

        self.client.find_zone.assert_called_once_with(
            'zn',
            ignore_missing=False,
        )
        self.client.api_mock.assert_called_once_with(zone=self._zone)

        self.assertEqual(self.columns, columns)
        self.assertEqual(self.data, list(data))
Exemple #6
0
class TestListNameserver(fakes.TestDNS):

    objects = fakes.FakeNameserver.create_multiple(3)
    _zone = fakes.FakeZone.create_one()

    columns = ('address', 'hostname', 'priority')

    data = []

    for s in objects:
        data.append(fakes.gen_data(s, columns))

    def setUp(self):
        super(TestListNameserver, self).setUp()

        self.cmd = zone.ListNameserver(self.app, None)

        self.client.nameservers = mock.Mock()
        self.client.find_zone = mock.Mock()
        self.client.api_mock = self.client.nameservers

    def test_default(self):
        arglist = ['zn']

        verifylist = [('zone', 'zn')]

        # Verify cm is triggereg with default parameters
        parsed_args = self.check_parser(self.cmd, arglist, verifylist)

        # Set the response
        self.client.api_mock.side_effect = [self.objects]
        self.client.find_zone.side_effect = [self._zone]

        # Trigger the action
        columns, data = self.cmd.take_action(parsed_args)

        self.client.find_zone.assert_called_once_with('zn',
                                                      ignore_missing=False)

        self.client.api_mock.assert_called_once_with(zone=self._zone)

        self.assertEqual(self.columns, columns)
        self.assertEqual(self.data, list(data))
class TestShowRS(fakes.TestDNS):

    _data = fakes.FakeRecordset.create_one()
    _zone = fakes.FakeZone.create_one()

    columns = ('description', 'name', 'records', 'status', 'ttl', 'type')

    data = fakes.gen_data(_data, columns)

    def setUp(self):
        super(TestShowRS, self).setUp()

        self.cmd = recordset.ShowRS(self.app, None)

        self.client.find_zone = mock.Mock()
        self.client.get_recordset = mock.Mock()
        self.client.api_mock = self.client.get_recordset

    def test_default(self):
        arglist = ['zone', 'rs']

        verifylist = [('zone', 'zone'), ('recordset', 'rs')]

        # Verify cm is triggereg with default parameters
        parsed_args = self.check_parser(self.cmd, arglist, verifylist)

        # Set the response
        self.client.find_zone.side_effect = [self._zone]
        self.client.api_mock.side_effect = [self._data]

        # Trigger the action
        columns, data = self.cmd.take_action(parsed_args)

        self.client.api_mock.assert_called_once_with(zone=self._zone,
                                                     recordset='rs')

        self.assertEqual(self.columns, columns)
        self.assertEqual(self.data, data)
class TestListPTR(fakes.TestDNS):

    objects = fakes.FakeFloatingIP.create_multiple(3)

    columns = ('id', 'ptrdname', 'address', 'status', 'description', 'ttl')

    data = []

    for s in objects:
        data.append(fakes.gen_data(s, columns))

    def setUp(self):
        super(TestListPTR, self).setUp()

        self.cmd = ptr.ListPTR(self.app, None)

        self.client.ptrs = mock.Mock()
        self.client.api_mock = self.client.floating_ips

    def test_default(self):
        arglist = []

        verifylist = []

        # Verify cm is triggereg with default parameters
        parsed_args = self.check_parser(self.cmd, arglist, verifylist)

        # Set the response
        self.client.api_mock.side_effect = [self.objects]

        # Trigger the action
        columns, data = self.cmd.take_action(parsed_args)

        self.client.api_mock.assert_called_once_with()

        self.assertEqual(self.columns, columns)
        self.assertEqual(self.data, list(data))
Exemple #9
0
class TestCreateZone(fakes.TestDNS):

    _data = fakes.FakeZone.create_one()

    columns = ('action', 'created_at', 'description', 'email', 'id', 'name',
               'pool_id', 'record_num', 'router', 'serial', 'status', 'ttl',
               'updated_at', 'zone_type')

    data = fakes.gen_data(_data, columns)

    def setUp(self):
        super(TestCreateZone, self).setUp()

        self.cmd = zone.CreateZone(self.app, None)

        self.client.create_zone = mock.Mock()
        self.client.api_mock = self.client.create_zone

    def test_create(self):
        arglist = [
            'zn',
            '--email',
            'eml',
            '--description',
            'descr',
            '--type',
            'public',
            '--ttl',
            '500',
            '--router_id',
            'rid',
            '--router_region',
            'regio',
        ]

        verifylist = [
            ('name', 'zn'),
            ('email', 'eml'),
            ('description', 'descr'),
            ('type', 'public'),
            ('ttl', 500),
            ('router_id', 'rid'),
            ('router_region', 'regio'),
        ]

        # Verify cm is triggereg with default parameters
        parsed_args = self.check_parser(self.cmd, arglist, verifylist)

        # Set the response
        self.client.api_mock.side_effect = [self._data]

        # Trigger the action
        columns, data = self.cmd.take_action(parsed_args)

        self.client.api_mock.assert_called_once_with(description='descr',
                                                     email='eml',
                                                     name='zn',
                                                     ttl=500,
                                                     zone_type='public')

        self.assertEqual(self.columns, columns)
        self.assertEqual(self.data, data)

    def test_create_private(self):
        arglist = [
            'zn',
            '--email',
            'eml',
            '--description',
            'descr',
            '--type',
            'private',
            '--ttl',
            '500',
            '--router_id',
            'rid',
            '--router_region',
            'regio',
        ]

        verifylist = [
            ('name', 'zn'),
            ('email', 'eml'),
            ('description', 'descr'),
            ('type', 'private'),
            ('ttl', 500),
            ('router_id', 'rid'),
            ('router_region', 'regio'),
        ]

        # Verify cm is triggereg with default parameters
        parsed_args = self.check_parser(self.cmd, arglist, verifylist)

        # Set the response
        self.client.api_mock.side_effect = [self._data]

        # Trigger the action
        columns, data = self.cmd.take_action(parsed_args)

        self.client.api_mock.assert_called_once_with(description='descr',
                                                     email='eml',
                                                     name='zn',
                                                     ttl=500,
                                                     zone_type='private',
                                                     router={
                                                         'router_id': 'rid',
                                                         'router_region':
                                                         'regio'
                                                     })

        self.assertEqual(self.columns, columns)
        self.assertEqual(self.data, data)

    def test_create_private_raise_no_rid(self):
        arglist = [
            'zn',
            '--email',
            'eml',
            '--description',
            'descr',
            '--type',
            'private',
            '--ttl',
            '500',
            '--router_region',
            'regio',
        ]

        verifylist = [
            ('name', 'zn'),
            ('email', 'eml'),
            ('description', 'descr'),
            ('type', 'private'),
            ('ttl', 500),
            ('router_region', 'regio'),
        ]

        # Verify cm is triggereg with default parameters
        parsed_args = self.check_parser(self.cmd, arglist, verifylist)

        # Set the response
        self.client.api_mock.side_effect = [self._data]

        # Trigger the action
        self.assertRaises(argparse.ArgumentTypeError, self.cmd.take_action,
                          parsed_args)

        self.client.api_mock.assert_not_called()