def test_contains_transport_layer(self):
layer_narrow = TransportAddress(low=2, high=5)
layer_wide = TransportAddress()
assert_true(layer_narrow in layer_wide)
assert_false(layer_narrow not in layer_wide)
assert_false(layer_wide in layer_narrow)
assert_true(layer_wide not in layer_narrow)
def test_inequality(self):
layer_a = TransportAddress()
layer_b = TransportAddress(high=2)
assert_not_equals(layer_a, layer_b)
layer_a.low = 2
layer_b.high = 65535
assert_not_equals(layer_a, layer_b)
def test_contains_single_port(self):
layer_a = TransportAddress()
assert_in(2, layer_a)
assert_false(2 not in layer_a)
layer_b = TransportAddress(low=2, high=5)
assert_not_in(1, layer_b)
assert_true(1 not in layer_b)
def test_setter_invalid(self):
for attr in ('low', 'high'):
for value in self.invalid_port_values:
assert_raises(ValueError, setattr, TransportAddress(), attr,
value)
for value in self.invalid_port_types:
assert_raises(TypeError, setattr, TransportAddress(), attr,
value)
def test_initialization(self):
group = TransportGroup()
group.add(TransportAddress(low=1, high=2))
layer = TransportLayer(source='1-2', destination='2-3')
assert_equals(layer.source, group)
group = TransportGroup()
group.add(TransportAddress(low=2, high=3))
assert_equals(layer.destination, group)
def test_inequality(self):
group_a = TransportGroup()
group_b = TransportGroup()
address01 = TransportAddress(1, 3)
address02 = TransportAddress(3, 5)
assert_equals(group_a, group_b)
group_a.add(address01)
assert_not_equals(group_a, group_b)
group_b.add(address01)
assert_equals(group_a, group_b)
group_b.add(address02)
assert_not_equals(group_a, group_b)
def test_equality(self):
group_a = TransportGroup()
group_b = TransportGroup()
addresses = list()
addresses.append(TransportAddress(1, 3))
addresses.append(TransportAddress(3, 5))
addresses.append(TransportAddress(25, 27))
assert_equals(group_a, group_b)
for address in addresses:
group_a.add(address)
group_b.add(address)
assert_equals(group_a, group_b)
def test_has(self):
group = TransportGroup()
addresses = list()
addresses.append(TransportAddress(1, 3))
addresses.append(TransportAddress(3, 5))
addresses.append(TransportAddress(25, 27))
for index, address in enumerate(addresses):
for added in addresses[:index]:
assert_true(group.has(added))
for not_added in addresses[index:]:
assert_false(group.has(not_added))
group.add(address)
def test_remove(self):
group = TransportGroup()
address01 = TransportAddress(1, 3)
address02 = TransportAddress(3, 5)
group.add(address01)
assert_false(group.remove(address02))
group.add(address02)
assert_true(group.remove(address01))
assert_true(group.remove(address02))
assert_false(group.remove(address01))
assert_false(group.has(address01))
assert_false(group.has(address02))
def test_repr(self):
layer = TransportAddress()
assert_equals(layer.__repr__(), '<TransportAddress 1-65535>')
layer.low = 3
assert_equals(layer.__repr__(), '<TransportAddress 3-65535>')
layer.high = 3
assert_equals(layer.__repr__(), '<TransportAddress 3>')
layer.high = 5
assert_equals(layer.__repr__(), '<TransportAddress 3-5>')
def test_str(self):
layer = TransportAddress()
assert_equals(layer.__str__(), 'TCP/UDP 1-65535')
layer.low = 3
assert_equals(layer.__str__(), 'TCP/UDP 3-65535')
layer.high = 3
assert_equals(layer.__str__(), 'TCP/UDP 3')
layer.high = 5
assert_equals(layer.__str__(), 'TCP/UDP 3-5')
def test_add(self):
group = TransportGroup()
address01 = TransportAddress(1, 3)
address02 = TransportAddress(3, 5)
address03 = TransportAddress(25, 27)
assert_true(group.add(address01))
assert_false(group.add(address01))
assert_false(group.add('1 3'))
assert_true(group.add(address02))
assert_false(group.add(address02))
assert_false(group.add('3 - 5'))
assert_false(group.add(address01))
assert_true(group.add('25-27'))
assert_false(group.add(address03))
def test_contains_transport_layer(self):
group = TransportGroup()
address = TransportAddress(low=1, high=2)
assert_in(address, group)
group.add('1-2')
assert_in(address, group)
assert_not_in('3-4', group)
def test_str(self):
layer = TransportAddress()
assert_equals(layer.__str__(), 'TCP/UDP 1-65535')
layer.low = 3
assert_equals(layer.__str__(), 'TCP/UDP 3-65535')
layer.high = 3
assert_equals(layer.__str__(), 'TCP/UDP 3')
layer.high = 5
assert_equals(layer.__str__(), 'TCP/UDP 3-5')
def test_repr(self):
layer = TransportAddress()
assert_equals(layer.__repr__(), '<TransportAddress 1-65535>')
layer.low = 3
assert_equals(layer.__repr__(), '<TransportAddress 3-65535>')
layer.high = 3
assert_equals(layer.__repr__(), '<TransportAddress 3>')
layer.high = 5
assert_equals(layer.__repr__(), '<TransportAddress 3-5>')
def test_initialization(self):
assert_equals(TransportAddress(1).low, 1)
assert_equals(TransportAddress(1).high, 1)
assert_equals(TransportAddress(high=1).low, 1)
assert_equals(TransportAddress(high=1).high, 1)
assert_equals(TransportAddress(low=1, high=2).low, 1)
assert_equals(TransportAddress(low=1, high=2).high, 2)
assert_equals(TransportAddress(low='1', high='2').low, 1)
def test_inequality(self):
layer_a = TransportAddress()
layer_b = TransportAddress(high=2)
assert_not_equals(layer_a, layer_b)
layer_a.low = 2
layer_b.high = 65535
assert_not_equals(layer_a, layer_b)
class TransportGroup(AddressGroup):
_address_name = 'Transport'
_default_address = TransportAddress()
_address_type = (TransportAddress, TcpAddress, UdpAddress)
def __init__(self, name=None):
self.name = name
self._addresses = list()
@staticmethod
def address_builder(address):
return TransportAddressBuilder.build(address)
@staticmethod
def from_string(value):
transport_address = TransportAddress.from_string(value)
transport_group = TransportGroup()
transport_group.add(transport_address)
return transport_group
@staticmethod
def _is_member(key, member):
return key in member
def test_from_string(self):
from_string = TransportGroup.from_string
group = from_string(1)
assert_is_instance(group, TransportGroup)
address = TransportAddress.from_string(1)
assert_in(address, group)
def test_contains_invalid(self):
layer = TransportAddress()
for value in self.invalid_port_values:
assert_raises(ValueError, layer.__contains__, value)
for value in self.invalid_port_types:
assert_raises(TypeError, layer.__contains__, value)
def from_string(value):
transport_address = TransportAddress.from_string(value)
transport_group = TransportGroup()
transport_group.add(transport_address)
return transport_group
def test_add_mixed_ports(self):
group = TransportGroup()
group.add(TransportAddress.from_string('1-3'))
group.add(TcpAddress.from_string('1-3'))
group.add(UdpAddress.from_string('1-3'))
assert_equals(len(group), 3)
def test_initialization_defaults(self):
layer = TransportAddress()
assert_equals(layer.low, 1)
assert_equals(layer.high, 65535)
def test_addresses_getitem(self):
group = TransportGroup()
assert_equals(group.addresses[0], TransportAddress())
def test_setter(self):
layer = TransportAddress()
layer.low = 1
assert_equals(layer.low, 1)
layer.high = 1
assert_equals(layer.high, 1)
def test_from_string(self):
from_string = TransportGroup.from_string
group = from_string(1)
assert_is_instance(group, TransportGroup)
address = TransportAddress.from_string(1)
assert_in(address, group)
def test_addresses_getter(self):
group = TransportGroup()
assert_equals(group.addresses, [TransportAddress()])
def test_equality(self):
layer_a = TransportAddress()
layer_b = TransportAddress()
assert_equals(layer_a, layer_b)
def test_contains_transport_string(self):
layer = TransportAddress.from_string('1-2')
assert_in('1-2', layer)
assert_not_in('2-3', layer)
def test_setter(self):
layer = TransportAddress()
layer.low = 1
assert_equals(layer.low, 1)
layer.high = 1
assert_equals(layer.high, 1)
def test_add_mixed_ports(self):
group = TransportGroup()
group.add(TransportAddress.from_string('1-3'))
group.add(TcpAddress.from_string('1-3'))
group.add(UdpAddress.from_string('1-3'))
assert_equals(len(group), 3)
def test_contains_transport_string(self):
layer = TransportAddress.from_string('1-2')
assert_in('1-2', layer)
assert_not_in('2-3', layer)
