← Back to branch summary

~ahasenack/landscape-client/landscape-client-1.5.5-0ubuntu0.9.04.0

« back to all changes in this revision

Viewing changes to landscape/package/tests/test_store.py

  • Committer: Bazaar Package Importer
  • Author(s): Rick Clark
  • Date: 2008-09-08 16:35:57 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20080908163557-l3ixzj5dxz37wnw2
Tags: 1.0.18-0ubuntu1
New upstream release 

Show diffs side-by-side

added added

removed removed

Lines of Context:
landscape/package/tests/test_store.py
 
1
import threading
 
2
import time
 
3
import os
 
4
 
 
5
from landscape.tests.helpers import LandscapeTest
 
6
 
 
7
from landscape.package.store import PackageStore, UnknownHashIDRequest
 
8
 
 
9
 
 
10
class PackageStoreTest(LandscapeTest):
 
11
 
 
12
    def setUp(self):
 
13
        super(PackageStoreTest, self).setUp()
 
14
 
 
15
        self.filename = self.makeFile()
 
16
        self.store1 = PackageStore(self.filename)
 
17
        self.store2 = PackageStore(self.filename)
 
18
 
 
19
    def test_wb_transactional_commits(self):
 
20
        mock_db = self.mocker.replace(self.store1._db)
 
21
        mock_db.commit()
 
22
        self.mocker.replay()
 
23
        self.store1.set_hash_ids({})
 
24
 
 
25
    def test_wb_transactional_rolls_back(self):
 
26
        mock_db = self.mocker.replace(self.store1._db)
 
27
        mock_db.rollback()
 
28
        self.mocker.replay()
 
29
        self.assertRaises(Exception, self.store1.set_hash_ids, None)
 
30
 
 
31
    def test_set_and_get_hash_id(self):
 
32
        self.store1.set_hash_ids({"ha\x00sh1": 123, "ha\x00sh2": 456})
 
33
        self.assertEquals(self.store2.get_hash_id("ha\x00sh1"), 123)
 
34
        self.assertEquals(self.store2.get_hash_id("ha\x00sh2"), 456)
 
35
 
 
36
    def test_get_id_hash(self):
 
37
        self.store1.set_hash_ids({"hash1": 123, "hash2": 456})
 
38
        self.assertEquals(self.store2.get_id_hash(123), "hash1")
 
39
        self.assertEquals(self.store2.get_id_hash(456), "hash2")
 
40
 
 
41
    def test_get_unexistent_hash(self):
 
42
        self.assertEquals(self.store1.get_hash_id("hash1"), None)
 
43
 
 
44
    def test_get_unexistent_id(self):
 
45
        self.assertEquals(self.store1.get_id_hash(123), None)
 
46
 
 
47
    def test_overwrite_id_hash(self):
 
48
        self.store1.set_hash_ids({"hash1": 123})
 
49
        self.store2.set_hash_ids({"hash2": 123})
 
50
        self.assertEquals(self.store1.get_hash_id("hash1"), None)
 
51
        self.assertEquals(self.store1.get_hash_id("hash2"), 123)
 
52
 
 
53
    def test_overwrite_hash_id(self):
 
54
        self.store1.set_hash_ids({"hash1": 123})
 
55
        self.store2.set_hash_ids({"hash1": 456})
 
56
        self.assertEquals(self.store1.get_id_hash(123), None)
 
57
        self.assertEquals(self.store1.get_id_hash(456), "hash1")
 
58
 
 
59
    def test_set_hash_ids_timing(self):
 
60
        """Setting 20k hashes must take less than 5 seconds."""
 
61
        hashes = dict((str(i), i) for i in range(20000))
 
62
        started = time.time()
 
63
        self.store1.set_hash_ids(hashes)
 
64
        self.assertTrue(time.time()-started < 5,
 
65
                        "Setting 20k hashes took more than 5 seconds.")
 
66
 
 
67
    def test_add_and_get_available_packages(self):
 
68
        self.store1.add_available([1, 2])
 
69
        self.assertEquals(self.store2.get_available(), [1, 2])
 
70
 
 
71
    def test_add_available_conflicting(self):
 
72
        """Adding the same available pacakge id twice is fine."""
 
73
        self.store1.add_available([1])
 
74
        self.store1.add_available([1])
 
75
        self.assertEquals(self.store2.get_available(), [1])
 
76
 
 
77
    def test_add_available_timing(self):
 
78
        """Adding 20k ids must take less than 5 seconds."""
 
79
        started = time.time()
 
80
        self.store1.add_available(range(20000))
 
81
        self.assertTrue(time.time()-started < 5,
 
82
                        "Adding 20k available ids took more than 5 seconds.")
 
83
 
 
84
    def test_remove_available(self):
 
85
        self.store1.add_available([1, 2, 3, 4])
 
86
        self.store1.remove_available([2, 3])
 
87
        self.assertEquals(self.store2.get_available(), [1, 4])
 
88
 
 
89
    def test_remove_available_timing(self):
 
90
        self.store1.add_available(range(20000))
 
91
        started = time.time()
 
92
        self.store1.remove_available(range(20000))
 
93
        self.assertTrue(time.time()-started < 5,
 
94
                        "Removing 20k available ids took more than 5 seconds.")
 
95
 
 
96
    def test_clear_available(self):
 
97
        self.store1.add_available([1, 2, 3, 4])
 
98
        self.store1.clear_available()
 
99
        self.assertEquals(self.store2.get_available(), [])
 
100
 
 
101
    def test_add_and_get_available_upgrades_packages(self):
 
102
        self.store1.add_available_upgrades([1, 2])
 
103
        self.assertEquals(self.store2.get_available_upgrades(), [1, 2])
 
104
 
 
105
    def test_add_available_upgrades_conflicting(self):
 
106
        """Adding the same available_upgrades pacakge id twice is fine."""
 
107
        self.store1.add_available_upgrades([1])
 
108
        self.store1.add_available_upgrades([1])
 
109
        self.assertEquals(self.store2.get_available_upgrades(), [1])
 
110
 
 
111
    def test_add_available_upgrades_timing(self):
 
112
        """Adding 20k ids must take less than 5 seconds."""
 
113
        started = time.time()
 
114
        self.store1.add_available_upgrades(range(20000))
 
115
        self.assertTrue(time.time()-started < 5,
 
116
                        "Adding 20k available upgrades ids took "
 
117
                        "more than 5 seconds.")
 
118
 
 
119
    def test_remove_available_upgrades(self):
 
120
        self.store1.add_available_upgrades([1, 2, 3, 4])
 
121
        self.store1.remove_available_upgrades([2, 3])
 
122
        self.assertEquals(self.store2.get_available_upgrades(), [1, 4])
 
123
 
 
124
    def test_remove_available_upgrades_timing(self):
 
125
        self.store1.add_available_upgrades(range(20000))
 
126
        started = time.time()
 
127
        self.store1.remove_available_upgrades(range(20000))
 
128
        self.assertTrue(time.time()-started < 5,
 
129
                        "Removing 20k available upgrades ids took "
 
130
                        "more than 5 seconds.")
 
131
 
 
132
    def test_clear_available_upgrades(self):
 
133
        self.store1.add_available_upgrades([1, 2, 3, 4])
 
134
        self.store1.clear_available_upgrades()
 
135
        self.assertEquals(self.store2.get_available_upgrades(), [])
 
136
 
 
137
    def test_add_and_get_installed_packages(self):
 
138
        self.store1.add_installed([1, 2])
 
139
        self.assertEquals(self.store2.get_installed(), [1, 2])
 
140
 
 
141
    def test_add_installed_conflicting(self):
 
142
        """Adding the same installed pacakge id twice is fine."""
 
143
        self.store1.add_installed([1])
 
144
        self.store1.add_installed([1])
 
145
        self.assertEquals(self.store2.get_installed(), [1])
 
146
 
 
147
    def test_add_installed_timing(self):
 
148
        """Adding 20k ids must take less than 5 seconds."""
 
149
        started = time.time()
 
150
        self.store1.add_installed(range(20000))
 
151
        self.assertTrue(time.time()-started < 5,
 
152
                        "Adding 20k installed ids took more than 5 seconds.")
 
153
 
 
154
    def test_remove_installed(self):
 
155
        self.store1.add_installed([1, 2, 3, 4])
 
156
        self.store1.remove_installed([2, 3])
 
157
        self.assertEquals(self.store2.get_installed(), [1, 4])
 
158
 
 
159
    def test_remove_installed_timing(self):
 
160
        self.store1.add_installed(range(20000))
 
161
        started = time.time()
 
162
        self.store1.remove_installed(range(20000))
 
163
        self.assertTrue(time.time()-started < 5,
 
164
                        "Removing 20k installed ids took more than 5 seconds.")
 
165
 
 
166
    def test_clear_installed(self):
 
167
        self.store1.add_installed([1, 2, 3, 4])
 
168
        self.store1.clear_installed()
 
169
        self.assertEquals(self.store2.get_installed(), [])
 
170
 
 
171
    def test_add_hash_id_request(self):
 
172
        hashes = ("ha\x00sh1", "ha\x00sh2")
 
173
        request1 = self.store1.add_hash_id_request(hashes)
 
174
        request2 = self.store2.get_hash_id_request(request1.id)
 
175
        self.assertEquals(request1.id, request2.id)
 
176
        self.assertEquals(request1.hashes, list(hashes))
 
177
        self.assertEquals(request2.hashes, list(hashes))
 
178
 
 
179
    def test_iter_hash_id_requests(self):
 
180
        hashes1 = ["ha\x00sh1", "ha\x00sh2"]
 
181
        hashes2 = ["ha\x00sh3", "ha\x00sh4"]
 
182
        request1 = self.store1.add_hash_id_request(hashes1)
 
183
        request2 = self.store1.add_hash_id_request(hashes2)
 
184
        hashes = [hash for request in self.store2.iter_hash_id_requests()
 
185
                       for hash in request.hashes]
 
186
        self.assertEquals(hashes, hashes1 + hashes2)
 
187
 
 
188
    def test_get_initial_hash_id_request_timestamp(self):
 
189
        time_mock = self.mocker.replace("time.time")
 
190
        time_mock()
 
191
        self.mocker.result(123)
 
192
        self.mocker.replay()
 
193
 
 
194
        try:
 
195
            request1 = self.store1.add_hash_id_request(["hash1"])
 
196
            request2 = self.store2.get_hash_id_request(request1.id)
 
197
 
 
198
            self.assertEquals(request2.timestamp, 123)
 
199
 
 
200
            # We handle mocker explicitly so that our hacked time()
 
201
            # won't break Twisted's internals.
 
202
            self.mocker.verify()
 
203
        finally:
 
204
            self.mocker.reset()
 
205
 
 
206
    def test_update_hash_id_request_timestamp(self):
 
207
        request1 = self.store1.add_hash_id_request(["hash1"])
 
208
        request2 = self.store2.get_hash_id_request(request1.id)
 
209
 
 
210
        request1.timestamp = 456
 
211
 
 
212
        self.assertEquals(request2.timestamp, 456)
 
213
 
 
214
    def test_default_hash_id_request_message_id(self):
 
215
        request = self.store1.add_hash_id_request(["hash1"])
 
216
        self.assertEquals(request.message_id, None)
 
217
 
 
218
    def test_update_hash_id_request_message_id(self):
 
219
        request1 = self.store1.add_hash_id_request(["hash1"])
 
220
        request2 = self.store2.get_hash_id_request(request1.id)
 
221
 
 
222
        request1.message_id = 456
 
223
 
 
224
        self.assertEquals(request2.message_id, 456)
 
225
 
 
226
    def test_get_hash_id_request_with_unknown_request_id(self):
 
227
        self.assertRaises(UnknownHashIDRequest,
 
228
                          self.store1.get_hash_id_request, 123)
 
229
 
 
230
    def test_remove_hash_id_request(self):
 
231
        request = self.store1.add_hash_id_request(["hash1"])
 
232
        request.remove()
 
233
        self.assertRaises(UnknownHashIDRequest,
 
234
                          self.store1.get_hash_id_request, request.id)
 
235
 
 
236
    def test_add_task(self):
 
237
        data = {"answer": 42}
 
238
        task = self.store1.add_task("reporter", data)
 
239
        self.assertEquals(type(task.id), int)
 
240
        self.assertEquals(task.queue, "reporter")
 
241
        self.assertEquals(task.data, data)
 
242
 
 
243
    def test_get_next_task(self):
 
244
        task1 = self.store1.add_task("reporter", [1])
 
245
        task2 = self.store1.add_task("reporter", [2])
 
246
        task3 = self.store1.add_task("changer", [3])
 
247
 
 
248
        task = self.store2.get_next_task("reporter")
 
249
        self.assertEquals(task.id, task1.id)
 
250
        self.assertEquals(task.data, [1])
 
251
 
 
252
        task = self.store2.get_next_task("changer")
 
253
        self.assertEquals(task.id, task3.id)
 
254
        self.assertEquals(task.data, [3])
 
255
 
 
256
        task = self.store2.get_next_task("reporter")
 
257
        self.assertEquals(task.id, task1.id)
 
258
        self.assertEquals(task.data, [1])
 
259
 
 
260
        task.remove()
 
261
 
 
262
        task = self.store2.get_next_task("reporter")
 
263
        self.assertEquals(task.id, task2.id)
 
264
        self.assertEquals(task.data, [2])
 
265
 
 
266
        task.remove()
 
267
 
 
268
        task = self.store2.get_next_task("reporter")
 
269
        self.assertEquals(task, None)
 
270
 
 
271
    def test_get_task_timestamp(self):
 
272
        time_mock = self.mocker.replace("time.time")
 
273
        time_mock()
 
274
        self.mocker.result(123)
 
275
        self.mocker.replay()
 
276
 
 
277
        try:
 
278
            self.store1.add_task("reporter", [1])
 
279
            task = self.store2.get_next_task("reporter")
 
280
 
 
281
            self.assertEquals(task.timestamp, 123)
 
282
 
 
283
            # We handle mocker explicitly so that our hacked time()
 
284
            # won't break Twisted's internals.
 
285
            self.mocker.verify()
 
286
        finally:
 
287
            self.mocker.reset()
 
288
 
 
289
    def test_next_tasks_ordered_by_timestamp(self):
 
290
        time_mock = self.mocker.replace("time.time")
 
291
        time_mock()
 
292
        self.mocker.result(222)
 
293
        time_mock()
 
294
        self.mocker.result(111)
 
295
        self.mocker.replay()
 
296
 
 
297
        try:
 
298
            task1 = self.store1.add_task("reporter", [1])
 
299
            task2 = self.store1.add_task("reporter", [2])
 
300
 
 
301
            task = self.store2.get_next_task("reporter")
 
302
            self.assertEquals(task.timestamp, 111)
 
303
 
 
304
            task.remove()
 
305
 
 
306
            task = self.store2.get_next_task("reporter")
 
307
            self.assertEquals(task.timestamp, 222)
 
308
 
 
309
            # We handle mocker explicitly so that our hacked time()
 
310
            # won't break Twisted's internals.
 
311
            self.mocker.verify()
 
312
        finally:
 
313
            self.mocker.reset()
 
314
 
 
315
    def test_clear_hash_id_requests(self):
 
316
        request1 = self.store1.add_hash_id_request(["hash1"])
 
317
        request2 = self.store1.add_hash_id_request(["hash2"])
 
318
        self.store1.clear_hash_id_requests()
 
319
        self.assertRaises(UnknownHashIDRequest,
 
320
                          self.store1.get_hash_id_request, request1.id)
 
321
        self.assertRaises(UnknownHashIDRequest,
 
322
                          self.store1.get_hash_id_request, request2.id)
 
323
    
 
324
    def test_clear_tasks(self):
 
325
        data = {"answer": 42}
 
326
        task = self.store1.add_task("reporter", data)
 
327
        self.assertEquals(type(task.id), int)
 
328
        self.assertEquals(task.queue, "reporter")
 
329
        self.assertEquals(task.data, data)
 
330
        self.store1.clear_tasks()
 
331
        task = self.store2.get_next_task("reporter")
 
332
        self.assertEquals(task, None)
 
333
 
 
334
    def test_clear_tasks_except_1_task(self):
 
335
        data = {"answer": 42}
 
336
        task = self.store1.add_task("reporter", data)
 
337
        data = {"answer": 43}
 
338
        task2 = self.store1.add_task("reporter", data)
 
339
        self.store1.clear_tasks(except_tasks=(task2,))
 
340
        task = self.store2.get_next_task("reporter")
 
341
        self.assertEquals(task.id, task2.id)
 
342
        task.remove()
 
343
        task = self.store2.get_next_task("reporter")
 
344
        self.assertEquals(task, None)
 
345
 
 
346
    def test_clear_tasks_except_2_tasks(self):
 
347
        data = {"answer": 42}
 
348
        task = self.store1.add_task("reporter", data)
 
349
        data = {"answer": 43}
 
350
        task2 = self.store1.add_task("reporter", data)
 
351
        data = {"answer": 44}
 
352
        task3 = self.store1.add_task("reporter", data)
 
353
        self.store1.clear_tasks(except_tasks=(task2, task3))
 
354
        task = self.store2.get_next_task("reporter")
 
355
        self.assertEquals(task.id, task2.id)
 
356
        task.remove()
 
357
        task = self.store2.get_next_task("reporter")
 
358
        self.assertEquals(task.id, task3.id)
 
359
        task.remove()
 
360
        task = self.store2.get_next_task("reporter")
 
361
        self.assertEquals(task, None)
 
362
 
 
363
    def test_parallel_database_access(self):
 
364
        error = []
 
365
 
 
366
        def func1():
 
367
            func1.store1 = PackageStore(self.filename)
 
368
            func1.store1.add_task("reporter", "data")
 
369
            func1.store1.add_task("reporter", "data")
 
370
            func1.task = func1.store1.get_next_task("reporter")
 
371
 
 
372
        def func2():
 
373
            func2.store2 = PackageStore(self.filename)
 
374
            try:
 
375
                func2.store2.add_task("reporter", "data")
 
376
            except Exception, e:
 
377
                error.append(str(e))
 
378
 
 
379
        for func in [func1, func2]:
 
380
            thread = threading.Thread(target=func)
 
381
            thread.start()
 
382
            thread.join()
 
383
 
 
384
        self.assertEquals(error, [])
 
385