Skip to content

Commit 4b3d8d0

Browse files
AttilaGombosERAttilaGombosER
committed
Refactor tests
1 parent 082aa58 commit 4b3d8d0

4 files changed

Lines changed: 95 additions & 95 deletions

File tree

‎tests/advertizerIntegrationTest.py‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -108,17 +108,17 @@ def test_sends_hello_when_schedules_advertisement_once(self):
108108
# Given
109109
context = Context()
110110
sender = RadioSender(context)
111-
_advertizer = DefaultAdvertizer(sender)
111+
advertizer = DefaultAdvertizer(sender)
112112
timer = ReusableTimer()
113113
messages = []
114114

115-
with ScheduledAdvertizer(_advertizer, timer) as advertizer, DishReceiver(context) as test_receiver:
115+
with ScheduledAdvertizer(advertizer, timer) as scheduled_advertizer, DishReceiver(context) as test_receiver:
116116
test_receiver.start(GROUP.hello())
117117
test_receiver.register(lambda message: messages.append(message))
118-
advertizer.start(GROUP)
118+
scheduled_advertizer.start(GROUP)
119119

120120
# When
121-
advertizer.schedule(self.SERVICE_INFO, interval=0.01, one_shot=True)
121+
scheduled_advertizer.schedule(self.SERVICE_INFO, interval=0.01, one_shot=True)
122122

123123
wait_for_assertion(0.1, lambda: self.assertEqual(1, len(messages)))
124124

@@ -129,17 +129,17 @@ def test_sends_hello_when_schedules_advertisement_periodically(self):
129129
# Given
130130
context = Context()
131131
sender = RadioSender(context)
132-
_advertizer = DefaultAdvertizer(sender)
132+
advertizer = DefaultAdvertizer(sender)
133133
timer = ReusableTimer()
134134
messages = []
135135

136-
with ScheduledAdvertizer(_advertizer, timer) as advertizer, DishReceiver(context) as test_receiver:
136+
with ScheduledAdvertizer(advertizer, timer) as scheduled_advertizer, DishReceiver(context) as test_receiver:
137137
test_receiver.start(GROUP.hello())
138138
test_receiver.register(lambda message: messages.append(message))
139-
advertizer.start(GROUP)
139+
scheduled_advertizer.start(GROUP)
140140

141141
# When
142-
advertizer.schedule(self.SERVICE_INFO, interval=0.01)
142+
scheduled_advertizer.schedule(self.SERVICE_INFO, interval=0.01)
143143

144144
# Then
145145
wait_for_assertion(0.1, lambda: self.assertEqual(5, len(messages)))

‎tests/discovererIntegrationTest.py‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -95,17 +95,17 @@ def test_sends_query_when_schedules_discovery_once(self):
9595
context = Context()
9696
sender = RadioSender(context)
9797
receiver = DishReceiver(context)
98-
_discoverer = DefaultDiscoverer(sender, receiver)
98+
discoverer = DefaultDiscoverer(sender, receiver)
9999
timer = ReusableTimer()
100100
messages = []
101101

102-
with ScheduledDiscoverer(_discoverer, timer) as discoverer, DishReceiver(context) as test_receiver:
102+
with ScheduledDiscoverer(discoverer, timer) as scheduled_discoverer, DishReceiver(context) as test_receiver:
103103
test_receiver.start(GROUP.query())
104104
test_receiver.register(lambda message: messages.append(message))
105-
discoverer.start(GROUP)
105+
scheduled_discoverer.start(GROUP)
106106

107107
# When
108-
discoverer.schedule(SERVICE_QUERY, interval=0.01, one_shot=True)
108+
scheduled_discoverer.schedule(SERVICE_QUERY, interval=0.01, one_shot=True)
109109

110110
wait_for_assertion(0.1, lambda: self.assertEqual(1, len(messages)))
111111

@@ -117,17 +117,17 @@ def test_sends_query_when_schedules_discovery_periodically(self):
117117
context = Context()
118118
sender = RadioSender(context)
119119
receiver = DishReceiver(context)
120-
_discoverer = DefaultDiscoverer(sender, receiver)
120+
discoverer = DefaultDiscoverer(sender, receiver)
121121
timer = ReusableTimer()
122122
messages = []
123123

124-
with ScheduledDiscoverer(_discoverer, timer) as discoverer, DishReceiver(context) as test_receiver:
124+
with ScheduledDiscoverer(discoverer, timer) as scheduled_discoverer, DishReceiver(context) as test_receiver:
125125
test_receiver.start(GROUP.query())
126126
test_receiver.register(lambda message: messages.append(message))
127-
discoverer.start(GROUP)
127+
scheduled_discoverer.start(GROUP)
128128

129129
# When
130-
discoverer.schedule(SERVICE_QUERY, interval=0.01)
130+
scheduled_discoverer.schedule(SERVICE_QUERY, interval=0.01)
131131

132132
# Then
133133
wait_for_assertion(0.1, lambda: self.assertEqual(5, len(messages)))

‎tests/scheduledAdvertizerTest.py‎

Lines changed: 32 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -22,94 +22,94 @@ def setUp(self):
2222

2323
def test_stops_timer_and_advertizer_on_exit(self):
2424
# Given
25-
_advertizer = MagicMock(spec=Advertizer)
25+
advertizer = MagicMock(spec=Advertizer)
2626
timer = MagicMock(spec=IReusableTimer)
2727

28-
with ScheduledAdvertizer(_advertizer, timer) as advertizer:
29-
advertizer.start(GROUP)
28+
with ScheduledAdvertizer(advertizer, timer) as scheduled_advertizer:
29+
scheduled_advertizer.start(GROUP)
3030

3131
# When
3232

3333
# Then
3434
timer.cancel.assert_called_once()
35-
_advertizer.stop.assert_called_once()
35+
advertizer.stop.assert_called_once()
3636

3737
def test_stops_timer_and_advertizer_when_stopped(self):
3838
# Given
39-
_advertizer = MagicMock(spec=Advertizer)
39+
advertizer = MagicMock(spec=Advertizer)
4040
timer = MagicMock(spec=IReusableTimer)
41-
advertizer = ScheduledAdvertizer(_advertizer, timer)
42-
advertizer.start(GROUP)
41+
scheduled_advertizer = ScheduledAdvertizer(advertizer, timer)
42+
scheduled_advertizer.start(GROUP)
4343

4444
# When
45-
advertizer.stop()
45+
scheduled_advertizer.stop()
4646

4747
# Then
4848
timer.cancel.assert_called_once()
49-
_advertizer.stop.assert_called_once()
49+
advertizer.stop.assert_called_once()
5050

5151
def test_starts_advertizer_when_started(self):
5252
# Given
53-
_advertizer = MagicMock(spec=Advertizer)
53+
advertizer = MagicMock(spec=Advertizer)
5454
timer = MagicMock(spec=IReusableTimer)
55-
advertizer = ScheduledAdvertizer(_advertizer, timer)
55+
scheduled_advertizer = ScheduledAdvertizer(advertizer, timer)
5656

5757
# When
58-
advertizer.start(GROUP, SERVICE_INFO)
58+
scheduled_advertizer.start(GROUP, SERVICE_INFO)
5959

6060
# Then
61-
_advertizer.start.assert_called_once_with(GROUP, SERVICE_INFO)
61+
advertizer.start.assert_called_once_with(GROUP, SERVICE_INFO)
6262

6363
def test_sends_service_info(self):
6464
# Given
65-
_advertizer = MagicMock(spec=Advertizer)
65+
advertizer = MagicMock(spec=Advertizer)
6666
timer = MagicMock(spec=IReusableTimer)
67-
advertizer = ScheduledAdvertizer(_advertizer, timer)
67+
scheduled_advertizer = ScheduledAdvertizer(advertizer, timer)
6868

6969
# When
70-
advertizer.advertise(SERVICE_INFO)
70+
scheduled_advertizer.advertise(SERVICE_INFO)
7171

7272
# Then
73-
_advertizer.advertise.assert_called_once_with(SERVICE_INFO)
73+
advertizer.advertise.assert_called_once_with(SERVICE_INFO)
7474

7575
def test_schedules_advertise_once(self):
7676
# Given
77-
_advertizer = MagicMock(spec=Advertizer)
77+
advertizer = MagicMock(spec=Advertizer)
7878
timer = MagicMock(spec=IReusableTimer)
79-
advertizer = ScheduledAdvertizer(_advertizer, timer)
80-
advertizer.start(GROUP)
79+
scheduled_advertizer = ScheduledAdvertizer(advertizer, timer)
80+
scheduled_advertizer.start(GROUP)
8181

8282
# When
83-
advertizer.schedule(SERVICE_INFO, 60, True)
83+
scheduled_advertizer.schedule(SERVICE_INFO, 60, True)
8484

8585
# Then
86-
timer.start.assert_called_once_with(60, advertizer._execute, [SERVICE_INFO])
86+
timer.start.assert_called_once_with(60, scheduled_advertizer._execute, [SERVICE_INFO])
8787

8888
def test_schedules_periodic_advertise(self):
8989
# Given
90-
_advertizer = MagicMock(spec=Advertizer)
90+
advertizer = MagicMock(spec=Advertizer)
9191
timer = MagicMock(spec=IReusableTimer)
92-
advertizer = ScheduledAdvertizer(_advertizer, timer)
93-
advertizer.start(GROUP)
92+
scheduled_advertizer = ScheduledAdvertizer(advertizer, timer)
93+
scheduled_advertizer.start(GROUP)
9494

9595
# When
96-
advertizer.schedule(SERVICE_INFO, 60, False)
96+
scheduled_advertizer.schedule(SERVICE_INFO, 60, False)
9797

9898
# Then
99-
timer.start.assert_called_once_with(60, advertizer._execute_and_restart, [SERVICE_INFO])
99+
timer.start.assert_called_once_with(60, scheduled_advertizer._execute_and_restart, [SERVICE_INFO])
100100

101101
def test_execute_and_restart_calls_advertise_and_restarts_timer(self):
102102
# Given
103-
_advertizer = MagicMock(spec=Advertizer)
103+
advertizer = MagicMock(spec=Advertizer)
104104
timer = MagicMock(spec=IReusableTimer)
105-
advertizer = ScheduledAdvertizer(_advertizer, timer)
106-
advertizer.start(GROUP)
105+
scheduled_advertizer = ScheduledAdvertizer(advertizer, timer)
106+
scheduled_advertizer.start(GROUP)
107107

108108
# When
109-
advertizer._execute_and_restart(SERVICE_INFO)
109+
scheduled_advertizer._execute_and_restart(SERVICE_INFO)
110110

111111
# Then
112-
_advertizer.advertise.assert_called_once_with(SERVICE_INFO)
112+
advertizer.advertise.assert_called_once_with(SERVICE_INFO)
113113
timer.restart.assert_called_once()
114114

115115

‎tests/scheduledDiscovererTest.py‎

Lines changed: 47 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -22,136 +22,136 @@ def setUp(self):
2222

2323
def test_stops_timer_and_discoverer_on_exit(self):
2424
# Given
25-
_discoverer = MagicMock(spec=Discoverer)
25+
discoverer = MagicMock(spec=Discoverer)
2626
timer = MagicMock(spec=IReusableTimer)
2727

28-
with ScheduledDiscoverer(_discoverer, timer) as discoverer:
29-
discoverer.start(GROUP)
28+
with ScheduledDiscoverer(discoverer, timer) as scheduled_discoverer:
29+
scheduled_discoverer.start(GROUP)
3030

3131
# When
3232

3333
# Then
3434
timer.cancel.assert_called_once()
35-
_discoverer.stop.assert_called_once()
35+
discoverer.stop.assert_called_once()
3636

3737
def test_stops_timer_and_discoverer_when_stopped(self):
3838
# Given
39-
_discoverer = MagicMock(spec=Discoverer)
39+
discoverer = MagicMock(spec=Discoverer)
4040
timer = MagicMock(spec=IReusableTimer)
41-
discoverer = ScheduledDiscoverer(_discoverer, timer)
42-
discoverer.start(GROUP)
41+
scheduled_discoverer = ScheduledDiscoverer(discoverer, timer)
42+
scheduled_discoverer.start(GROUP)
4343

4444
# When
45-
discoverer.stop()
45+
scheduled_discoverer.stop()
4646

4747
# Then
4848
timer.cancel.assert_called_once()
49-
_discoverer.stop.assert_called_once()
49+
discoverer.stop.assert_called_once()
5050

5151
def test_starts_discoverer_when_started(self):
5252
# Given
53-
_discoverer = MagicMock(spec=Discoverer)
53+
discoverer = MagicMock(spec=Discoverer)
5454
timer = MagicMock(spec=IReusableTimer)
55-
discoverer = ScheduledDiscoverer(_discoverer, timer)
55+
scheduled_discoverer = ScheduledDiscoverer(discoverer, timer)
5656

5757
# When
58-
discoverer.start(GROUP, SERVICE_QUERY)
58+
scheduled_discoverer.start(GROUP, SERVICE_QUERY)
5959

6060
# Then
61-
_discoverer.start.assert_called_once_with(GROUP, SERVICE_QUERY)
61+
discoverer.start.assert_called_once_with(GROUP, SERVICE_QUERY)
6262

6363
def test_registers_event_handler(self):
6464
# Given
65-
_discoverer = MagicMock(spec=Discoverer)
65+
discoverer = MagicMock(spec=Discoverer)
6666
timer = MagicMock(spec=IReusableTimer)
67-
discoverer = ScheduledDiscoverer(_discoverer, timer)
67+
scheduled_discoverer = ScheduledDiscoverer(discoverer, timer)
6868
handler = MagicMock(spec=OnDiscoveryEvent)
6969

7070
# When
71-
discoverer.register(handler)
71+
scheduled_discoverer.register(handler)
7272

7373
# Then
74-
_discoverer.register.assert_called_once_with(handler)
74+
discoverer.register.assert_called_once_with(handler)
7575

7676
def test_deregisters_event_handler(self):
7777
# Given
78-
_discoverer = MagicMock(spec=Discoverer)
78+
discoverer = MagicMock(spec=Discoverer)
7979
timer = MagicMock(spec=IReusableTimer)
80-
discoverer = ScheduledDiscoverer(_discoverer, timer)
80+
scheduled_discoverer = ScheduledDiscoverer(discoverer, timer)
8181
handler = MagicMock(spec=OnDiscoveryEvent)
82-
discoverer.register(handler)
82+
scheduled_discoverer.register(handler)
8383

8484
# When
85-
discoverer.deregister(handler)
85+
scheduled_discoverer.deregister(handler)
8686

8787
# Then
88-
_discoverer.deregister.assert_called_once_with(handler)
88+
discoverer.deregister.assert_called_once_with(handler)
8989

9090
def test_returns_event_handlers(self):
9191
# Given
92-
_discoverer = MagicMock(spec=Discoverer)
92+
discoverer = MagicMock(spec=Discoverer)
9393
timer = MagicMock(spec=IReusableTimer)
94-
discoverer = ScheduledDiscoverer(_discoverer, timer)
95-
discoverer.start(GROUP, SERVICE_QUERY)
94+
scheduled_discoverer = ScheduledDiscoverer(discoverer, timer)
95+
scheduled_discoverer.start(GROUP, SERVICE_QUERY)
9696
handler = MagicMock(spec=OnDiscoveryEvent)
97-
discoverer.register(handler)
97+
scheduled_discoverer.register(handler)
9898

9999
# When
100-
result = discoverer.get_handlers()
100+
result = scheduled_discoverer.get_handlers()
101101

102102
# Then
103-
self.assertEqual(_discoverer.get_handlers(), result)
103+
self.assertEqual(discoverer.get_handlers(), result)
104104

105105
def test_sends_service_query(self):
106106
# Given
107-
_discoverer = MagicMock(spec=Discoverer)
107+
discoverer = MagicMock(spec=Discoverer)
108108
timer = MagicMock(spec=IReusableTimer)
109-
discoverer = ScheduledDiscoverer(_discoverer, timer)
109+
scheduled_discoverer = ScheduledDiscoverer(discoverer, timer)
110110

111111
# When
112-
discoverer.discover(SERVICE_QUERY)
112+
scheduled_discoverer.discover(SERVICE_QUERY)
113113

114114
# Then
115-
_discoverer.discover.assert_called_once_with(SERVICE_QUERY)
115+
discoverer.discover.assert_called_once_with(SERVICE_QUERY)
116116

117117
def test_schedules_discover_once(self):
118118
# Given
119-
_discoverer = MagicMock(spec=Discoverer)
119+
discoverer = MagicMock(spec=Discoverer)
120120
timer = MagicMock(spec=IReusableTimer)
121-
discoverer = ScheduledDiscoverer(_discoverer, timer)
122-
discoverer.start(GROUP)
121+
scheduled_discoverer = ScheduledDiscoverer(discoverer, timer)
122+
scheduled_discoverer.start(GROUP)
123123

124124
# When
125-
discoverer.schedule(SERVICE_QUERY, 60, True)
125+
scheduled_discoverer.schedule(SERVICE_QUERY, 60, True)
126126

127127
# Then
128-
timer.start.assert_called_once_with(60, discoverer._execute, [SERVICE_QUERY])
128+
timer.start.assert_called_once_with(60, scheduled_discoverer._execute, [SERVICE_QUERY])
129129

130130
def test_schedules_periodic_discover(self):
131131
# Given
132-
_discoverer = MagicMock(spec=Discoverer)
132+
discoverer = MagicMock(spec=Discoverer)
133133
timer = MagicMock(spec=IReusableTimer)
134-
discoverer = ScheduledDiscoverer(_discoverer, timer)
135-
discoverer.start(GROUP)
134+
scheduled_discoverer = ScheduledDiscoverer(discoverer, timer)
135+
scheduled_discoverer.start(GROUP)
136136

137137
# When
138-
discoverer.schedule(SERVICE_QUERY, 60, False)
138+
scheduled_discoverer.schedule(SERVICE_QUERY, 60, False)
139139

140140
# Then
141-
timer.start.assert_called_once_with(60, discoverer._execute_and_restart, [SERVICE_QUERY])
141+
timer.start.assert_called_once_with(60, scheduled_discoverer._execute_and_restart, [SERVICE_QUERY])
142142

143143
def test_execute_and_restart_calls_discover_and_restarts_timer(self):
144144
# Given
145-
_discoverer = MagicMock(spec=Discoverer)
145+
discoverer = MagicMock(spec=Discoverer)
146146
timer = MagicMock(spec=IReusableTimer)
147-
discoverer = ScheduledDiscoverer(_discoverer, timer)
148-
discoverer.start(GROUP)
147+
scheduled_discoverer = ScheduledDiscoverer(discoverer, timer)
148+
scheduled_discoverer.start(GROUP)
149149

150150
# When
151-
discoverer._execute_and_restart(SERVICE_QUERY)
151+
scheduled_discoverer._execute_and_restart(SERVICE_QUERY)
152152

153153
# Then
154-
_discoverer.discover.assert_called_once_with(SERVICE_QUERY)
154+
discoverer.discover.assert_called_once_with(SERVICE_QUERY)
155155
timer.restart.assert_called_once()
156156

157157

0 commit comments

Comments
 (0)