1
|
|
|
"""Link tests.""" |
2
|
|
|
import logging |
3
|
|
|
import time |
4
|
|
|
import unittest |
5
|
|
|
from unittest.mock import Mock |
6
|
|
|
|
7
|
|
|
from kytos.core.interface import Interface |
8
|
|
|
from kytos.core.link import Link |
9
|
|
|
from kytos.core.switch import Switch |
10
|
|
|
|
11
|
|
|
logging.basicConfig(level=logging.CRITICAL) |
12
|
|
|
|
13
|
|
|
|
14
|
|
|
class TestLink(unittest.TestCase): |
15
|
|
|
"""Test Links.""" |
16
|
|
|
|
17
|
|
|
def setUp(self): |
18
|
|
|
"""Create interface objects.""" |
19
|
|
|
self.iface1, self.iface2 = self._get_v0x04_ifaces() |
20
|
|
|
|
21
|
|
|
@staticmethod |
22
|
|
|
def _get_v0x04_ifaces(*args, **kwargs): |
23
|
|
|
"""Create a pair of v0x04 interfaces with optional extra arguments.""" |
24
|
|
|
switch1 = Switch('dpid1') |
25
|
|
|
switch1.connection = Mock() |
26
|
|
|
switch1.connection.protocol.version = 0x04 |
27
|
|
|
iface1 = Interface('interface1', 41, switch1, *args, **kwargs) |
28
|
|
|
|
29
|
|
|
switch2 = Switch('dpid2') |
30
|
|
|
switch2.connection = Mock() |
31
|
|
|
switch2.connection.protocol.version = 0x04 |
32
|
|
|
iface2 = Interface('interface2', 42, switch2, *args, **kwargs) |
33
|
|
|
|
34
|
|
|
return iface1, iface2 |
35
|
|
|
|
36
|
|
|
def test_init(self): |
37
|
|
|
"""Test normal Link initialization.""" |
38
|
|
|
link = Link(self.iface1, self.iface2) |
39
|
|
|
self.assertIsInstance(link, Link) |
40
|
|
|
self.assertIs(link.is_active(), True) |
41
|
|
|
self.assertIs(link.is_enabled(), False) |
42
|
|
|
|
43
|
|
|
def test_init_with_null_endpoints(self): |
44
|
|
|
"""Test initialization with None as endpoints.""" |
45
|
|
|
with self.assertRaises(ValueError): |
46
|
|
|
Link(None, None) |
47
|
|
|
|
48
|
|
|
def test_link_id(self): |
49
|
|
|
"""Test equality of links with the same values in different order.""" |
50
|
|
|
link1 = Link(self.iface1, self.iface2) |
51
|
|
|
link2 = Link(self.iface2, self.iface1) |
52
|
|
|
self.assertEqual(link1.id, link2.id) |
53
|
|
|
|
54
|
|
|
def test_get_next_available_tag(self): |
55
|
|
|
"""Test get next available tags returns different tags""" |
56
|
|
|
link = Link(self.iface1, self.iface2) |
57
|
|
|
tag = link.get_next_available_tag() |
58
|
|
|
next_tag = link.get_next_available_tag() |
59
|
|
|
|
60
|
|
|
self.assertNotEqual(tag, next_tag) |
61
|
|
|
|
62
|
|
|
def test_get_tag_multiple_calls(self): |
63
|
|
|
"""Test get next available tags returns different tags""" |
64
|
|
|
link = Link(self.iface1, self.iface2) |
65
|
|
|
tag = link.get_next_available_tag() |
66
|
|
|
next_tag = link.get_next_available_tag() |
67
|
|
|
self.assertNotEqual(next_tag.value, tag.value) |
68
|
|
|
|
69
|
|
|
def test_next_tag_with_use_tags(self): |
70
|
|
|
"""Test get next availabe tags returns different tags""" |
71
|
|
|
link = Link(self.iface1, self.iface2) |
72
|
|
|
tag = link.get_next_available_tag() |
73
|
|
|
is_available = link.is_tag_available(tag) |
74
|
|
|
self.assertFalse(is_available) |
75
|
|
|
link.use_tag(tag) |
76
|
|
|
|
77
|
|
|
def test_tag_life_cicle(self): |
78
|
|
|
"""Test get next available tags returns different tags""" |
79
|
|
|
link = Link(self.iface1, self.iface2) |
80
|
|
|
tag = link.get_next_available_tag() |
81
|
|
|
|
82
|
|
|
is_available = link.is_tag_available(tag) |
83
|
|
|
self.assertFalse(is_available) |
84
|
|
|
|
85
|
|
|
link.make_tag_available(tag) |
86
|
|
|
is_available = link.is_tag_available(tag) |
87
|
|
|
self.assertTrue(is_available) |
88
|
|
|
|
89
|
|
|
def test_concurrent_get_next_tag(self): |
90
|
|
|
"""Test get next available tags in concurrent execution""" |
91
|
|
|
# pylint: disable=import-outside-toplevel |
92
|
|
|
from tests.helper import test_concurrently |
93
|
|
|
_link = Link(self.iface1, self.iface2) |
94
|
|
|
|
95
|
|
|
_i = [] |
96
|
|
|
_initial_size = len(_link.endpoint_a.available_tags) |
97
|
|
|
|
98
|
|
|
@test_concurrently(20) |
99
|
|
|
def test_get_next_available_tag(): |
100
|
|
|
"""Assert that get_next_available_tag() returns different tags.""" |
101
|
|
|
_i.append(1) |
102
|
|
|
_i_len = len(_i) |
103
|
|
|
tag = _link.get_next_available_tag() |
104
|
|
|
time.sleep(0.0001) |
105
|
|
|
_link.use_tag(tag) |
106
|
|
|
|
107
|
|
|
next_tag = _link.get_next_available_tag() |
108
|
|
|
_link.use_tag(next_tag) |
109
|
|
|
|
110
|
|
|
self.assertNotEqual(tag, next_tag) |
111
|
|
|
|
112
|
|
|
test_get_next_available_tag() |
113
|
|
|
|
114
|
|
|
# sleep not needed because test_concurrently waits for all threads |
115
|
|
|
# to finish before returning. |
116
|
|
|
# time.sleep(0.1) |
117
|
|
|
|
118
|
|
|
# Check if after the 20th iteration we have 40 tags |
119
|
|
|
# It happens because we get 2 tags for every iteration |
120
|
|
|
self.assertEqual(_initial_size, |
121
|
|
|
len(_link.endpoint_a.available_tags) + 40) |
122
|
|
|
|