def test_mac_addresses_are_comparable(self):
mac_addr1 = MacAddress('01:23:45:67:89:ab')
mac_addr2 = MacAddress('01:23:45:67:89:cc')
self.assertTrue(mac_addr1 < mac_addr2)
self.assertTrue(mac_addr2 > mac_addr1)
self.assertTrue(mac_addr1 <= mac_addr2)
self.assertTrue(mac_addr2 >= mac_addr1)
self.assertTrue(mac_addr1 != mac_addr2)
def test_mac_addresses_are_comparable():
mac_addr1 = MacAddress('01:23:45:67:89:ab')
mac_addr2 = MacAddress('01:23:45:67:89:cc')
assert mac_addr1 < mac_addr2
assert mac_addr2 > mac_addr1
assert mac_addr1 <= mac_addr2
assert mac_addr2 >= mac_addr1
assert mac_addr1 != mac_addr2
def is_mac_address(thing):
"""Checks if this is a mac address"""
try:
MacAddress(thing)
except ValueError:
return False
else:
return True
def parse(nbtscan_output, encoding=None):
"""Parse the results from a netbios scan"""
results = nbtscan_output.split('\n')
parsed_results = []
for result in results:
if result:
try:
args = [x.strip() for x in result.split(SPLITCHAR)]
netbiosresult = NetbiosResult(*args)
# Handle mac address with "-" separator (FreeBSD nbtscan).
netbiosresult = netbiosresult._replace(
mac=str(MacAddress(netbiosresult.mac)))
except (TypeError, ValueError):
_logger.error('Error parsing %s', result)
else:
parsed_results.append(netbiosresult)
return parsed_results
def _identify_netbox(self):
netbox = None
if self.record.ip:
netbox = self._netbox_from_ip(self.record.ip)
if not netbox and self.record.deviceid:
if looks_like_binary_garbage(self.record.deviceid):
if len(self.record.deviceid) == 6:
try:
mac = MacAddress.from_octets(self.record.deviceid)
except TypeError:
pass
else:
netbox = self._netbox_from_mac(str(mac))
else:
self._logger.debug(
"remote deviceid looks like garbage: %r", self.record.deviceid
)
else:
netbox = self._netbox_from_sysname(self.record.deviceid)
return netbox
def test_mac_address_to_string_without_delimiter_return_same_address(self):
param = 'e42f.4572.6e76'
mac_addr = MacAddress(param)
self.assertEqual(mac_addr.to_string(), 'e42f45726e76')
def test_mac_address_with_byte_string_prefix_should_return_same_address(self):
param = b'\xe4\x2f\x45\x72\x6e\x76'
mac_addr = MacAddress(MacAddress.from_octets(param))
self.assertEqual(unicode(mac_addr), u'e4:2f:45:72:6e:76')
def test_mac_address_return_same_address_value_without_dot():
param = 'e42f.4572.6e76'
mac_addr = MacAddress(param)
assert six.text_type(mac_addr) == u'e4:2f:45:72:6e:76'
def test_mac_address_with_byte_string_prefix_should_return_same_address():
param = b'\xe4\x2f\x45\x72\x6e\x76'
mac_addr = MacAddress(MacAddress.from_octets(param))
assert six.text_type(mac_addr) == u'e4:2f:45:72:6e:76'
def test_mac_address_with_byte_string_prefix_should_return_zero_padded_addr():
param = b'\xe4\x2f\x45\x72'
mac_addr = MacAddress.from_octets(param)
assert six.text_type(mac_addr) == u'00:00:e4:2f:45:72'
def test_mac_address_to_string_with_dot_delimiter_return_same_address(self):
param = 'e4:2f:45:72:6e:76'
mac_addr = MacAddress(param)
self.assertEqual(mac_addr.to_string('.'), 'e42f.4572.6e76')
def test_mac_address_to_string_with_dot_delimiter_return_same_address(
self):
param = 'e4:2f:45:72:6e:76'
mac_addr = MacAddress(param)
self.assertEqual(mac_addr.to_string('.'), 'e42f.4572.6e76')
def test_mac_address_too_long():
with pytest.raises(ValueError):
MacAddress("e4:2f:45:72:6e:76:01")
def test_mac_address_to_string_with_colon_delimiter_return_same_address(
self):
param = 'e4-2f-45-72-6e76'
mac_addr = MacAddress(param)
self.assertEqual(mac_addr.to_string(':'), 'e4:2f:45:72:6e:76')
def test_mac_address_to_string_with_dash_delimiter_return_same_address(
self):
param = 'e42f.4572.6e76'
mac_addr = MacAddress(param)
self.assertEqual(mac_addr.to_string('-'), 'e4-2f-45-72-6e-76')
def test_mac_address_to_string_without_delimiter_return_same_address(self):
param = 'e42f.4572.6e76'
mac_addr = MacAddress(param)
self.assertEqual(mac_addr.to_string(), 'e42f45726e76')
def test_mac_address_return_same_address_value_without_dot(self):
param = 'e42f.4572.6e76'
mac_addr = MacAddress(param)
self.assertEqual(six.text_type(mac_addr), u'e4:2f:45:72:6e:76')
def test_mac_address_to_string_with_colon_delimiter_return_same_address(self):
param = 'e4-2f-45-72-6e76'
mac_addr = MacAddress(param)
self.assertEqual(mac_addr.to_string(':'), 'e4:2f:45:72:6e:76')
def test_mac_address_should_compare_with_int():
mac = MacAddress('01:23:45:67:89:ab')
assert mac != 5
def test_mac_address_address_contains_illegal_value():
with pytest.raises(ValueError):
MacAddress("e4:2f:45:72:6e:o6")
def test_mac_address_should_compare_with_string():
mac = MacAddress('01:23:45:67:89:ab')
assert mac == '01:23:45:67:89:ab'
assert mac != 'blah'
def test_mac_address_return_same_address_value_with_colon():
param = u'e4:2f:45:72:6e:76'
mac_addr = MacAddress(param)
assert six.text_type(mac_addr) == param
def test_mac_address_too_short():
with pytest.raises(ValueError):
MacAddress("e4:2f")
def test_mac_address_to_string_with_dash_delimiter_return_same_address(self):
param = 'e42f.4572.6e76'
mac_addr = MacAddress(param)
self.assertEqual(mac_addr.to_string('-'), 'e4-2f-45-72-6e-76')
def test_mac_address_wrong_parameter_type_dict():
with pytest.raises(ValueError):
MacAddress({})
def test_mac_address_to_string_with_colon_delimiter_return_same_address():
param = 'e4-2f-45-72-6e76'
mac_addr = MacAddress(param)
assert mac_addr.to_string(':') == 'e4:2f:45:72:6e:76'
def test_mac_address_mac_addres_as_parameter_should_return_same_address():
param = 'e42f45726e76'
ma = MacAddress(param)
mac_addr = MacAddress(ma)
assert six.text_type(mac_addr) == u'e4:2f:45:72:6e:76'
def test_mac_address_to_string_with_dash_delimiter_return_same_address():
param = 'e42f.4572.6e76'
mac_addr = MacAddress(param)
assert mac_addr.to_string('-') == 'e4-2f-45-72-6e-76'
def test_mac_address_return_same_address_value_without_dash():
param = 'e4-2f-45-72-6e-76'
mac_addr = MacAddress(param)
assert six.text_type(mac_addr) == u'e4:2f:45:72:6e:76'
def test_mac_address_to_string_with_dot_delimiter_return_same_address():
param = 'e4:2f:45:72:6e:76'
mac_addr = MacAddress(param)
assert mac_addr.to_string('.') == 'e42f.4572.6e76'
def test_mac_address_return_same_address_value_when_byte_string():
param = b'\xe4\x2f\x45\x72\x6e\x76'
mac_addr = MacAddress(MacAddress.from_octets(param))
assert six.text_type(mac_addr) == u'e4:2f:45:72:6e:76'
def test_mac_address_param_as_int_should_return_same_in_hex():
param = 11111110000
mac_addr = MacAddress(param)
assert six.text_type(mac_addr) == u'00:02:96:46:15:70'
def test_mac_address_to_string_without_delimiter_return_same_address():
param = 'e42f.4572.6e76'
mac_addr = MacAddress(param)
assert mac_addr.to_string() == 'e42f45726e76'
def test_mac_addresses_are_equal():
mac_addr1 = MacAddress('01:23:45:67:89:ab')
mac_addr2 = MacAddress('01:23:45:67:89:ab')
assert mac_addr1 == mac_addr2
def test_mac_addresses_hash_not_the_same():
mac_addr1 = MacAddress('01:23:45:67:89:ab')
mac_addr2 = MacAddress('01:23:45:67:89:ac')
assert hash(mac_addr1) != hash(mac_addr2)
def test_mac_address_with_byte_string_prefix_should_return_zero_padded_addr(self):
param = b'\xe4\x2f\x45\x72'
mac_addr = MacAddress.from_octets(param)
self.assertEqual(unicode(mac_addr), u'00:00:e4:2f:45:72')
