def test_print_group_transport(self):
source = TransportGroup(name='source')
destination = TransportGroup(name='destination')
transport = TransportLayer(source=source, destination=destination)
ace = Ace(transport=transport)
expected = 'permit tcp/udp 0.0.0.0/0 source 0.0.0.0/0 destination'
assert_equals(ace.print_group(), expected)
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_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_name_setter(self):
group = TransportGroup()
for value in (
'test01',
'test02',
):
group.name = value
assert_equals(group.name, value)
def _build_transport_group(value):
if value is None:
value = TransportGroup()
elif isinstance(value, basestring):
value = TransportGroup.from_string(value)
if not isinstance(value, TransportGroup):
message = 'Invalid type {}'
message = message.format(type(value).__name__)
raise TypeError(message)
return value
def test_address_is_default(self):
group = TransportGroup()
assert_true(group.address_is_default)
group.add('1 3')
assert_false(group.address_is_default)
group.add('4 5')
assert_false(group.address_is_default)
group.remove('1 3')
assert_false(group.address_is_default)
group.remove('4 5')
assert_true(group.address_is_default)
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_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_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_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_address_is_default(self):
group = TransportGroup()
assert_true(group.address_is_default)
group.add('1 3')
assert_false(group.address_is_default)
group.add('4 5')
assert_false(group.address_is_default)
group.remove('1 3')
assert_false(group.address_is_default)
group.remove('4 5')
assert_true(group.address_is_default)
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_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_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 _build_transport_group(value):
if value is None:
value = TransportGroup()
elif isinstance(value, basestring):
value = TransportGroup.from_string(value)
if not isinstance(value, TransportGroup):
message = 'Invalid type {}'
message = message.format(type(value).__name__)
raise TypeError(message)
return value
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_src_dst_setter(self):
layer = TransportLayer()
for side in ('source', 'destination'):
setattr(layer, side, '2-5')
side_attr = getattr(layer, side)
assert_is_instance(side_attr, TransportGroup)
assert_in(2, side_attr)
assert_in(5, side_attr)
assert_not_in(6, side_attr)
assert_not_in(1, side_attr)
setattr(layer, side, TransportGroup())
assert_is_instance(side_attr, TransportGroup)
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 build(cls, text):
if isinstance(text, TransportLayer):
return text
elif text is None:
return TransportLayer()
original_text = text
cls._validate_text(text)
text = cls._clean_text(text)
protocol_cls, text = TransportAddressBuilder._extract_protocol(text)
text = cls._normalize(text, original_text)
source, destination = text.split()
source_group = TransportGroup()
source_group.add(protocol_cls.from_string(source))
destination_group = TransportGroup()
destination_group.add(protocol_cls.from_string(destination))
return TransportLayer(source=source_group, destination=destination_group)
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_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_address_from_string_invalid(self):
group = TransportGroup()
assert_raises(TypeError, group.address_builder, True)
def test_initialization_defaults(self):
layer = TransportLayer()
assert_equals(layer.source, TransportGroup())
assert_equals(layer.destination, TransportGroup())
assert_is_instance(layer.source, TransportGroup)
assert_is_instance(layer.destination, TransportGroup)
def test_name_setter_invalid(self):
group = TransportGroup()
for value in self.invalid_name_types:
assert_raises(TypeError, setattr, group, 'name', value)
def test_repr(self):
layer = TransportGroup()
layer.add('1-2')
assert_equals(layer.__repr__(), "<TransportGroup TCP/UDP 1-2>")
layer.add('3-4')
assert_equals(layer.__repr__(),
"<TransportGroup ['TCP/UDP 1-2', 'TCP/UDP 3-4']>")
layer.add('5-6')
text = "<TransportGroup ['TCP/UDP 1-2', 'TCP/UDP 3-4', 'TCP/UDP 5-6']>"
assert_equals(layer.__repr__(), text)
layer.add('7-8')
text = "<TransportGroup ['TCP/UDP 1-2', 'TCP/UDP 3-4', 'TCP/UDP 5-6', ...]>"
assert_equals(layer.__repr__(), text)
def test_addresses_getter(self):
group = TransportGroup()
assert_equals(group.addresses, [TransportAddress()])
def test_addresses_getitem(self):
group = TransportGroup()
assert_equals(group.addresses[0], TransportAddress())
def setup(self):
# self.invalid_name_values = (0, 65536)
self.invalid_name_types = (True, False, 1)
self.group = TransportGroup()
def test_initialization(self):
assert_equals(TransportGroup('name').name, 'name')
def test_initialization_defaults(self):
group = TransportGroup()
assert_equals(group.name, TransportGroup._default_name)
def test_name_setter(self):
group = TransportGroup()
for value in ('test01', 'test02', ):
group.name = value
assert_equals(group.name, value)
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_single_port(self):
group = TransportGroup()
assert_in(2, group)
group.add('1-2')
assert_in(1, group)
assert_not_in(3, 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_repr(self):
layer = TransportGroup()
layer.add('1-2')
assert_equals(layer.__repr__(), "<TransportGroup TCP/UDP 1-2>")
layer.add('3-4')
assert_equals(layer.__repr__(), "<TransportGroup ['TCP/UDP 1-2', 'TCP/UDP 3-4']>")
layer.add('5-6')
text = "<TransportGroup ['TCP/UDP 1-2', 'TCP/UDP 3-4', 'TCP/UDP 5-6']>"
assert_equals(layer.__repr__(), text)
layer.add('7-8')
text = "<TransportGroup ['TCP/UDP 1-2', 'TCP/UDP 3-4', 'TCP/UDP 5-6', ...]>"
assert_equals(layer.__repr__(), text)
def test_contains_single_port(self):
group = TransportGroup()
assert_in(2, group)
group.add('1-2')
assert_in(1, group)
assert_not_in(3, group)
