← Back to branch summary

~canonical-platform-qa/autopilot/tests_for_known_apps

« back to all changes in this revision

Viewing changes to autopilot/tests/unit/test_utilities.py

  • Committer: Tarmac
  • Author(s): Omer Akram
  • Date: 2014-11-10 23:03:39 UTC
  • mfrom: (513.3.59 trunk.working)
  • Revision ID: tarmac-20141110230339-azwlbc628ki2khez
Provide a generic way set interval between events.

Approved by Christopher Lee, PS Jenkins bot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
autopilot/tests/unit/test_utilities.py
32
32
import timeit
33
33
 
34
34
from autopilot.utilities import (
 
35
    _raise_if_time_delta_not_sane,
35
36
    _raise_on_unknown_kwargs,
 
37
    _sleep_for_calculated_delta,
36
38
    cached_result,
37
39
    compatible_repr,
38
40
    deprecated,
 
41
    EventDelay,
39
42
    sleep,
40
43
)
41
44
 
92
95
            patched_time.sleep.assert_called_once_with(1.0)
93
96
 
94
97
 
 
98
class EventDelayTests(TestCase):
 
99
 
 
100
    def test_mocked_event_delayer_contextmanager(self):
 
101
        event_delayer = EventDelay()
 
102
        with event_delayer.mocked():
 
103
            # The first call of delay() only stores the last time
 
104
            # stamp, it is only the second call where the delay
 
105
            # actually happens. So we call delay() twice here to
 
106
            # ensure mocking is working as expected.
 
107
            event_delayer.delay(duration=0)
 
108
            event_delayer.delay(duration=3)
 
109
            self.assertAlmostEqual(sleep.total_time_slept(), 3, places=1)
 
110
 
 
111
    def test_last_event_start_at_zero(self):
 
112
        event_delayer = EventDelay()
 
113
        self.assertThat(event_delayer.last_event_time(), Equals(0.0))
 
114
 
 
115
    def test_last_event_delay_counter_updates_on_first_call(self):
 
116
        event_delayer = EventDelay()
 
117
        event_delayer.delay(duration=1.0, current_time=lambda: 10)
 
118
 
 
119
        self.assertThat(event_delayer._last_event, Equals(10.0))
 
120
 
 
121
    def test_first_call_to_delay_causes_no_sleep(self):
 
122
        event_delayer = EventDelay()
 
123
        with sleep.mocked() as mocked_sleep:
 
124
            event_delayer.delay(duration=0.0)
 
125
            self.assertThat(mocked_sleep.total_time_slept(), Equals(0.0))
 
126
 
 
127
    def test_second_call_to_delay_causes_sleep(self):
 
128
        event_delayer = EventDelay()
 
129
        with sleep.mocked() as mocked_sleep:
 
130
            event_delayer.delay(duration=0, current_time=lambda: 100)
 
131
            event_delayer.delay(duration=10, current_time=lambda: 105)
 
132
            self.assertThat(mocked_sleep.total_time_slept(), Equals(5.0))
 
133
 
 
134
    def test_no_delay_if_time_jumps_since_last_event(self):
 
135
        event_delayer = EventDelay()
 
136
        with sleep.mocked() as mocked_sleep:
 
137
            event_delayer.delay(duration=2, current_time=lambda: 100)
 
138
            event_delayer.delay(duration=2, current_time=lambda: 110)
 
139
            self.assertThat(mocked_sleep.total_time_slept(), Equals(0.0))
 
140
 
 
141
    def test_no_delay_if_given_delay_time_negative(self):
 
142
        event_delayer = EventDelay()
 
143
        with sleep.mocked() as mocked_sleep:
 
144
            event_delayer.delay(duration=-2, current_time=lambda: 100)
 
145
            event_delayer.delay(duration=-2, current_time=lambda: 101)
 
146
            self.assertThat(mocked_sleep.total_time_slept(), Equals(0.0))
 
147
 
 
148
    def test_sleep_delta_calculator_returns_zero_if_time_delta_negative(self):
 
149
        result = _sleep_for_calculated_delta(100, 97, 2)
 
150
        self.assertThat(result, Equals(0.0))
 
151
 
 
152
    def test_sleep_delta_calculator_doesnt_sleep_if_time_delta_negative(self):
 
153
        with sleep.mocked() as mocked_sleep:
 
154
            _sleep_for_calculated_delta(100, 97, 2)
 
155
            self.assertThat(mocked_sleep.total_time_slept(), Equals(0.0))
 
156
 
 
157
    def test_sleep_delta_calculator_returns_zero_if_time_delta_zero(self):
 
158
        result = _sleep_for_calculated_delta(100, 98, 2)
 
159
        self.assertThat(result, Equals(0.0))
 
160
 
 
161
    def test_sleep_delta_calculator_doesnt_sleep_if_time_delta_zero(self):
 
162
        with sleep.mocked() as mocked_sleep:
 
163
            _sleep_for_calculated_delta(100, 98, 2)
 
164
            self.assertThat(mocked_sleep.total_time_slept(), Equals(0.0))
 
165
 
 
166
    def test_sleep_delta_calculator_returns_non_zero_if_delta_not_zero(self):
 
167
        with sleep.mocked():
 
168
            result = _sleep_for_calculated_delta(101, 100, 2)
 
169
            self.assertThat(result, Equals(1.0))
 
170
 
 
171
    def test_sleep_delta_calc_returns_zero_if_gap_duration_negative(self):
 
172
        result = _sleep_for_calculated_delta(100, 99, -2)
 
173
        self.assertEquals(result, 0.0)
 
174
 
 
175
    def test_sleep_delta_calc_raises_if_last_event_ahead_current_time(self):
 
176
        self.assertRaises(
 
177
            ValueError,
 
178
            _sleep_for_calculated_delta,
 
179
            current_time=100,
 
180
            last_event_time=110,
 
181
            gap_duration=2
 
182
        )
 
183
 
 
184
    def test_sleep_delta_calc_raises_if_last_event_equals_current_time(self):
 
185
        self.assertRaises(
 
186
            ValueError,
 
187
            _sleep_for_calculated_delta,
 
188
            current_time=100,
 
189
            last_event_time=100,
 
190
            gap_duration=2
 
191
        )
 
192
 
 
193
    def test_sleep_delta_calc_raises_if_current_time_negative(self):
 
194
        self.assertRaises(
 
195
            ValueError,
 
196
            _sleep_for_calculated_delta,
 
197
            current_time=-100,
 
198
            last_event_time=10,
 
199
            gap_duration=10
 
200
        )
 
201
 
 
202
    def test_time_sanity_checker_raises_if_time_smaller_than_last_event(self):
 
203
        self.assertRaises(
 
204
            ValueError,
 
205
            _raise_if_time_delta_not_sane,
 
206
            current_time=90,
 
207
            last_event_time=100
 
208
        )
 
209
 
 
210
    def test_time_sanity_checker_raises_if_time_equal_last_event_time(self):
 
211
        self.assertRaises(
 
212
            ValueError,
 
213
            _raise_if_time_delta_not_sane,
 
214
            current_time=100,
 
215
            last_event_time=100
 
216
        )
 
217
 
 
218
    def test_time_sanity_checker_raises_if_time_negative_last_event_not(self):
 
219
        self.assertRaises(
 
220
            ValueError,
 
221
            _raise_if_time_delta_not_sane,
 
222
            current_time=-100,
 
223
            last_event_time=100
 
224
        )
 
225
 
 
226
 
95
227
class CompatibleReprTests(TestCase):
96
228
 
97
229
    def test_py3_unicode_is_untouched(self):