def test_bad_type(self):
x = kea.Lease4()
with self.assertRaises(TypeError) as cm:
x.client_id = 'bogus'
self.assertEqual(
("'bogus' is not a valid string of hexadecimal digits", ),
cm.exception.args)
def test_getset(self):
x = kea.Lease4()
self.assertIsNone(x.hostname)
x.hostname = 'example.org'
self.assertEqual('example.org', x.hostname)
x.hostname = None
self.assertIsNone(x.hostname)
def test_getset(self):
x = kea.Lease4()
self.assertEqual(False, x.fqdn_fwd)
x.fqdn_fwd = True
self.assertEqual(True, x.fqdn_fwd)
x.fqdn_fwd = False
self.assertEqual(False, x.fqdn_fwd)
def test_lease4_ok(self):
h = kea.CalloutHandle(kea.CalloutManager())
x = kea.Lease4()
x.addr = '1.2.3.4'
self.assertEqual(1, x.use_count)
self.assertIsNone(h.setArgument('lease4', x))
self.assertEqual(2, x.use_count)
self.assertEqual('1.2.3.4', h.getArgument('lease4').addr)
def test_ok(self):
x = kea.Lease4()
self.assertIs(x, x.setContext('foo'))
self.assertIs(x, x.setContext(2))
self.assertIs(x, x.setContext(True))
self.assertIs(x, x.setContext([1, 'foo']))
self.assertIs(x, x.setContext({'foo': 'bar'}))
self.assertIs(x, x.setContext(None))
def test_bad_type(self):
x = kea.Lease4()
with self.assertRaises(TypeError) as cm:
x.addr = 'bogus'
self.assertEqual((
"Failed to convert string to address 'bogus': Invalid argument", ),
cm.exception.args)
with self.assertRaises(TypeError) as cm:
x.addr = 0
self.assertEqual(('The addr attribute value must be a str', ),
cm.exception.args)
def test_ok(self):
x = kea.Lease4()
self.assertIsNone(x.getContext())
x.setContext(None)
self.assertIsNone(x.getContext())
x.setContext('foo')
self.assertEqual('foo', x.getContext())
x.setContext(2)
self.assertEqual(2, x.getContext())
x.setContext(True)
self.assertEqual(True, x.getContext())
x.setContext([1, 'foo'])
self.assertEqual([1, 'foo'], x.getContext())
x.setContext({'foo': 'bar'})
self.assertEqual({'foo': 'bar'}, x.getContext())
def test_ok(self):
x = kea.Lease4()
x.hwaddr = '01:02:03:04:05:06'
self.assertEqual(
{
'cltt': 0,
'fqdn-fwd': False,
'fqdn-rev': False,
'hostname': '',
'hw-address': '01:02:03:04:05:06',
'ip-address': '0.0.0.0',
'state': 0,
'subnet-id': 0,
'valid-lft': 0
}, x.toElement())
x.cltt = 3600
x.fqdn_fwd = x.fqdn_rev = True
x.hostname = 'example.com'
x.addr = '192.168.0.1'
x.state = 3
x.subnet_id = 4
x.valid_lft = 1800
x.client_id = '02:03:04:05:06:07'
self.assertEqual(
{
'client-id': '02:03:04:05:06:07',
'cltt': 3600,
'fqdn-fwd': True,
'fqdn-rev': True,
'hostname': 'example.com',
'hw-address': '01:02:03:04:05:06',
'ip-address': '192.168.0.1',
'state': 3,
'subnet-id': 4,
'valid-lft': 1800
}, x.toElement())
def test_ok(self):
x = kea.Lease4()
self.assertEqual(1, x.use_count)
def test_bad_type(self):
x = kea.Lease4()
with self.assertRaises(TypeError) as cm:
x.fqdn_rev = 'bogus'
self.assertEqual(('The fqdn_rev attribute value must be a bool', ),
cm.exception.args)
def test_bad_type(self):
x = kea.Lease4()
with self.assertRaises(TypeError) as cm:
x.subnet_id = 'bogus'
self.assertEqual(('The subnet_id attribute value must be an int', ),
cm.exception.args)
def test_getset(self):
x = kea.Lease4()
self.assertEqual(0, x.subnet_id)
x.subnet_id = 5
self.assertEqual(5, x.subnet_id)
def test_getset(self):
x = kea.Lease4()
self.assertEqual(0, x.cltt)
x.cltt = 3600
self.assertEqual(3600, x.cltt)
def test_getset(self):
x = kea.Lease4()
self.assertEqual(0, x.valid_lft)
x.valid_lft = 3600
self.assertEqual(3600, x.valid_lft)
def test_getset(self):
x = kea.Lease4()
self.assertEqual('0.0.0.0', x.addr)
x.addr = '192.168.0.1'
self.assertEqual('192.168.0.1', x.addr)
def test_empty(self):
x = kea.Lease4()
with self.assertRaises(RuntimeError) as cm:
self.assertEqual({}, x.toElement())
self.assertIsInstance(cm.exception, RuntimeError)
self.assertEqual(("hwaddr must not be empty", ), cm.exception.args)
def parse_lease4(args):
lease = kea.Lease4()
if not isinstance(args, dict):
raise CommandError("parameters missing or is not a map")
lease.addr = get_string_arg(args, 'ip-address')
lease.hwaddr = get_string_arg(args, 'hw-address')
subnet_id = get_int_arg(args, 'subnet-id', 0)
cfg = kea.CfgMgr().getCurrentCfg()
if subnet_id:
subnet = cfg.getCfgSubnets4().getSubnet(subnet_id)
if not subnet:
raise CommandError(
'no IPv4 subnet with subnet-id=%d currently configured' %
subnet_id)
if not subnet.inRange(lease.addr):
raise CommandError(
'address %s does not belong to subnet %s, subnet-id=%s' %
(lease.addr, subnet.toText(), subnet_id))
else:
subnet = cfg.getCfgSubnets4().selectSubnet(lease.addr)
if not subnet:
raise CommandError(
'subnet-id not specified and failed to find a subnet for address %s'
% lease.addr)
subnet_id = subnet.getID()
lease.subnet_id = subnet_id
client_id = get_string_arg(args, 'client-id', None)
if client_id is not None:
lease.client_id = client_id
valid_lft = get_int_arg(args, 'valid-lft', None)
if valid_lft is None:
valid_lft = subnet.getValid()
lease.valid_lft = valid_lft
expire = get_int_arg(args, 'expire', None)
if expire is not None:
if expire <= 0:
raise CommandError(
'expiration time must be positive for address %s' % lease.addr)
if expire < valid_lft:
raise CommandError(
'expiration time must be greater than valid lifetime for address %s'
% lease.addr)
cltt = expire - valid_lft
else:
cltt = int(time.time())
lease.cltt = cltt
lease.fqdn_fwd = get_bool_arg(args, 'fqdn-fwd', False)
lease.fqdn_rev = get_bool_arg(args, 'fqdn-rev', False)
lease.hostname = get_string_arg(args, 'hostname', None)
if lease.hostname and (lease.fqdn_fwd or lease.fqdn_rev):
raise CommandError(
'no hostname specified and either forward or reverse'
' fqdn was set to true')
lease.state = get_int_arg(args, 'state', 0)
if lease.state < 0 or lease.state > kea.STATE_EXPIRED_RECLAIMED:
raise CommandError(
'invalid state %s: must be 0 (default), 1 (declined),'
' or 2 (expired-reclaimed)' % lease.state)
ctx = get_map_arg(args, 'user-context', {})
comment = get_string_arg(args, 'comment', None)
if comment is not None:
if 'comment' in ctx:
raise CommandError(
"duplicated comment entry '%s' in user context '%s'" %
(comment, ctx))
ctx['comment'] = comment
if ctx:
lease.setContext(ctx)
return lease
def test_bad_type(self):
x = kea.Lease4()
with self.assertRaises(TypeError) as cm:
x.hostname = 3
self.assertEqual(('The hostname attribute value must be a str', ),
cm.exception.args)
def test_badarg_count(self):
x = kea.Lease4()
self.assert_method_no_arguments(x.getContext)
def test_getset(self):
x = kea.Lease4()
self.assertIsNone(x.client_id)
x.client_id = '01:02:03:04:05:06'
self.assertEqual('01:02:03:04:05:06', x.client_id)
def test_badarg_count(self):
x = kea.Lease4()
self.assert_method_one_arg_no_keywords(x.setContext)
def test_getset(self):
x = kea.Lease4()
self.assertEqual(0, x.state)
x.state = 5
self.assertEqual(5, x.state)
def test_getset(self):
x = kea.Lease4()
self.assertIsNone(x.hwaddr)
x.hwaddr = '01:02:03:04:05:06'
self.assertEqual('01:02:03:04:05:06', x.hwaddr)
def test_badarg_count(self):
x = kea.Lease4()
self.assert_method_no_arguments(x.toElement)
def test_bad_type(self):
x = kea.Lease4()
with self.assertRaises(TypeError) as cm:
x.hwaddr = 'bogus'
self.assertEqual(("invalid format of the decoded string 'bogus'", ),
cm.exception.args)
