← Back to branch summary

~ubuntu-branches/ubuntu/natty/landscape-client/natty-proposed

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Andreas Hasenack
  • Date: 2011-07-22 12:49:00 UTC
  • mfrom: (1.2.9 upstream)
  • Revision ID: package-import@ubuntu.com-20110722124900-jvfq819ekbtnac61
Tags: 11.07.1.1-0ubuntu0.11.04.0
https://launchpad.net/bugs/809210
https://launchpad.net/bugs/804008
https://launchpad.net/bugs/804548
https://launchpad.net/bugs/805746
https://launchpad.net/bugs/804548
https://launchpad.net/bugs/795794
https://launchpad.net/bugs/797069
https://launchpad.net/bugs/795752
https://launchpad.net/bugs/780406
https://launchpad.net/bugs/732490
https://launchpad.net/bugs/759764
https://launchpad.net/bugs/758928
https://launchpad.net/bugs/760486
* Try to load the old persist file if the current one doesn't exist or is
  empty (LP: #809210).
* Fallback to gethostname to get something interesting out of get_fqdn.
* Fix wrong ownership and permissions when the reporter is run as a result
  of applying a repository profile (LP: #804008).
* Keep original sources.list ownership (LP: #804548).
* Refactored tests (LP: #805746).
* Preserve permissions of sources.list (LP: #804548).
* Added a broker command line option (--record) that saves exchanges with the
  server to the filesystem 
* Detect if running in a vmware guest (LP: #795794).
* Report VM type when run in the cloud (LP: #797069).
* Report VM type in non-cloud registration (LP: #795752).
* Report the package reporter result even in case of success, not just in
  case of failure (LP: #780406).
* Report package reporter errors (LP: #732490).
* Fix dependencies for hardy removing references to python 2.4 packages for
  pycurl and dbus (LP: #759764).
* The landscape client now reports whether it is running on a virtual machine
  or not.
* Add a plugin which manages APT sources.list and the associated GPG keys
  (LP: #758928).
* Limit the number of items in a network message to 200, to prevent problems
  when communication is interrupted with the server and the client
  accumulates too many network items, thus overloading the server when it's
  available again (LP: #760486).
* Updated version number in __init__.py so that the client reports the
  correct one in its user-agent string.

Show diffs side-by-side

added added

removed removed

Lines of Context:
landscape/package/tests/test_taskhandler.py
31
31
        to the smart-update stamp file.
32
32
        """
33
33
        config = PackageTaskHandlerConfiguration()
34
 
        self.assertEquals(
 
34
        self.assertEqual(
35
35
            config.smart_update_stamp_filename,
36
36
            "/var/lib/landscape/client/package/smart-update-stamp")
37
37
 
54
54
    def test_use_hash_id_db(self):
55
55
 
56
56
        # We don't have this hash=>id mapping
57
 
        self.assertEquals(self.store.get_hash_id("hash"), None)
 
57
        self.assertEqual(self.store.get_hash_id("hash"), None)
58
58
 
59
59
        # An appropriate hash=>id database is available
60
60
        self.config.data_path = self.makeDir()
75
75
 
76
76
        # Now we do have the hash=>id mapping
77
77
        def callback(ignored):
78
 
            self.assertEquals(self.store.get_hash_id("hash"), 123)
 
78
            self.assertEqual(self.store.get_hash_id("hash"), 123)
79
79
        result.addCallback(callback)
80
80
 
81
81
        return result
241
241
 
242
242
        self.mocker.replay()
243
243
 
244
 
        self.assertEquals(self.handler.run(), "WAYO!")
 
244
        self.assertEqual(self.handler.run(), "WAYO!")
245
245
 
246
246
    def test_handle_tasks(self):
247
247
        queue_name = PackageTaskHandler.queue_name
267
267
 
268
268
        handle_tasks_result = self.handler.handle_tasks()
269
269
 
270
 
        self.assertEquals(stash, [])
 
270
        self.assertEqual(stash, [])
271
271
 
272
272
        results[1].callback(None)
273
 
        self.assertEquals(stash, [])
274
 
        self.assertEquals(self.store.get_next_task(queue_name).data, 0)
 
273
        self.assertEqual(stash, [])
 
274
        self.assertEqual(self.store.get_next_task(queue_name).data, 0)
275
275
 
276
276
        results[0].callback(None)
277
 
        self.assertEquals(stash, [0, 1])
 
277
        self.assertEqual(stash, [0, 1])
278
278
        self.assertTrue(handle_tasks_result.called)
279
 
        self.assertEquals(self.store.get_next_task(queue_name).data, 2)
 
279
        self.assertEqual(self.store.get_next_task(queue_name).data, 2)
280
280
 
281
281
        results[2].callback(None)
282
 
        self.assertEquals(stash, [0, 1, 2])
 
282
        self.assertEqual(stash, [0, 1, 2])
283
283
        self.assertTrue(handle_tasks_result.called)
284
 
        self.assertEquals(self.store.get_next_task(queue_name), None)
 
284
        self.assertEqual(self.store.get_next_task(queue_name), None)
285
285
 
286
286
        handle_tasks_result = self.handler.handle_tasks()
287
287
        self.assertTrue(handle_tasks_result.called)
308
308
        handle_tasks_result = self.handler.handle_tasks()
309
309
        handle_tasks_result.addErrback(stash.append)
310
310
 
311
 
        self.assertEquals(len(stash), 1)
312
 
        self.assertEquals(stash[0].type, MyException)
 
311
        self.assertEqual(len(stash), 1)
 
312
        self.assertEqual(stash[0].type, MyException)
313
313
 
314
314
    def test_default_handle_task(self):
315
315
        result = self.handler.handle_task(None)
355
355
 
356
356
        handler_args = []
357
357
        HandlerMock(ANY, ANY, ANY, ANY)
358
 
        self.mocker.passthrough() # Let the real constructor run for testing.
 
358
        self.mocker.passthrough()  # Let the real constructor run for testing.
359
359
        self.mocker.call(lambda *args: handler_args.extend(args))
360
360
 
361
361
        call_when_running = []
366
366
        connector_mock.disconnect()
367
367
        reactor_mock.call_later(0, reactor.stop)
368
368
 
369
 
 
370
369
        # Okay, the whole playground is set.
371
370
        self.mocker.replay()
372
371
 
376
375
 
377
376
            try:
378
377
                # Verify the arguments passed to the reporter constructor.
379
 
                self.assertEquals(type(store), PackageStore)
380
 
                self.assertEquals(type(facade), SmartFacade)
381
 
                self.assertEquals(type(broker), LazyRemoteBroker)
382
 
                self.assertEquals(type(config),
383
 
                                  PackageTaskHandlerConfiguration)
 
378
                self.assertEqual(type(store), PackageStore)
 
379
                self.assertEqual(type(facade), SmartFacade)
 
380
                self.assertEqual(type(broker), LazyRemoteBroker)
 
381
                self.assertEqual(type(config),
 
382
                                 PackageTaskHandlerConfiguration)
384
383
 
385
384
                # Let's see if the store path is where it should be.
386
385
                filename = os.path.join(self.data_path, "package", "database")
387
386
                store.add_available([1, 2, 3])
388
387
                other_store = PackageStore(filename)
389
 
                self.assertEquals(other_store.get_available(), [1, 2, 3])
 
388
                self.assertEqual(other_store.get_available(), [1, 2, 3])
390
389
 
391
390
                # Check the hash=>id database directory as well
392
391
                self.assertTrue(os.path.exists(
396
395
                # Put reactor back in place before returning.
397
396
                self.mocker.reset()
398
397
 
399
 
 
400
398
        result = run_task_handler(HandlerMock, ["-c", self.config_filename])
401
399
        return result.addCallback(assert_task_handler)
402
400
 
418
416
            run_task_handler(PackageTaskHandler,
419
417
                             ["-c", self.config_filename, "--quiet"])
420
418
        except SystemExit, e:
421
 
            self.assertEquals(str(e), "")
 
419
            self.assertEqual(str(e), "")
422
420
        else:
423
421
            self.fail("SystemExit not raised")
424
422