Merge lp:~jseutter/landscape-client/assert-equal into lp:~landscape/landscape-client/trunk

[Jerry Seutter]

This MP contains changes to test files only.
- Replace assertEquals with assertEqual. assertEquals use is discouraged.
- PEP8 and lint cleanups.

Some PEP8 violations remain because of sample data.

Some lint warnings remain because of try: import except: snippets (for Dapper sqlite3 support?):

landscape/package/tests/test_store.py:8: redefinition of unused 'sqlite3' from line 6
landscape/lib/tests/test_amp.py:8: redefinition of unused 'Clock' from line 6
landscape/broker/tests/test_exchangestore.py:6: redefinition of unused 'sqlite3' from line 4
landscape/tests/test_patch.py:4: redefinition of unused 'sqlite3' from line 2

[Free Ekanayaka (free.ekanayaka)]

Nice cleanup, +1!

Yes, the sqlite3 import workaround is for Dapper, I guess we can just drop it. We're not going to release for Dapper anymore.

review: Approve

[Alberto Donato (ack)]

Good! +1

review: Approve

[lp:~jseutter/landscape-client/assert-equal]

339. By Alberto Donato on 2011-07-06

Merge sources.list-preserve-old-permissions [f=804548] [r=bigkevmcd,therve]

340. By Jerry Seutter on 2011-07-06

Test file refactoring only. Refactored assertEquals -> assertEqual and
did some PEP8 and lint cleanups.
[r=ack,free] [f=805746]

=== modified file 'landscape/broker/tests/test_amp.py'
--- landscape/broker/tests/test_amp.py	2010-04-23 09:44:28 +0000
+++ landscape/broker/tests/test_amp.py	2011-07-06 21:14:28 +0000
@@ -126,8 +126,8 @@
         """
 
         def assert_response(response):
-            self.assertEquals(response, None)
-            self.assertEquals(
+            self.assertEqual(response, None)
+            self.assertEqual(
                 self.exchanger.get_client_accepted_message_types(),
                 sorted(["type"] + DEFAULT_ACCEPTED_TYPES))
 

=== modified file 'landscape/broker/tests/test_client.py'
--- landscape/broker/tests/test_client.py	2010-05-12 13:48:30 +0000
+++ landscape/broker/tests/test_client.py	2011-07-06 21:14:28 +0000
@@ -34,7 +34,7 @@
         plugins = [BrokerClientPlugin(), BrokerClientPlugin()]
         self.client.add(plugins[0])
         self.client.add(plugins[1])
-        self.assertEquals(self.client.get_plugins(), plugins)
+        self.assertEqual(self.client.get_plugins(), plugins)
 
     def test_get_plugins_returns_a_copy(self):
         """
@@ -43,7 +43,7 @@
         """
         plugins = self.client.get_plugins()
         plugins.append(BrokerClientPlugin())
-        self.assertEquals(self.client.get_plugins(), [])
+        self.assertEqual(self.client.get_plugins(), [])
 
     def test_get_named_plugin(self):
         """
@@ -53,7 +53,7 @@
         plugin = BrokerClientPlugin()
         plugin.plugin_name = "foo"
         self.client.add(plugin)
-        self.assertEquals(self.client.get_plugin("foo"), plugin)
+        self.assertEqual(self.client.get_plugin("foo"), plugin)
 
     def test_run_interval(self):
         """
@@ -89,7 +89,7 @@
         result2 = self.client.register_message("bar", lambda m: None)
 
         def got_result(result):
-            self.assertEquals(
+            self.assertEqual(
                 self.exchanger.get_client_accepted_message_types(),
                 sorted(["bar", "foo"] + DEFAULT_ACCEPTED_TYPES))
 
@@ -106,7 +106,7 @@
         self.mocker.replay()
 
         def dispatch_message(result):
-            self.assertEquals(self.client.dispatch_message(message), 123)
+            self.assertEqual(self.client.dispatch_message(message), 123)
 
         result = self.client.register_message("foo", handle_message)
         return result.addCallback(dispatch_message)
@@ -138,7 +138,7 @@
         """
         error = self.assertRaises(HandlerNotFoundError,
                                   self.client.dispatch_message, {"type": "x"})
-        self.assertEquals(str(error), "x")
+        self.assertEqual(str(error), "x")
 
     def test_message(self):
         """
@@ -152,7 +152,7 @@
         self.mocker.replay()
 
         def dispatch_message(result):
-            self.assertEquals(self.client.message(message), True)
+            self.assertEqual(self.client.message(message), True)
 
         result = self.client.register_message("foo", handle_message)
         return result.addCallback(dispatch_message)
@@ -163,7 +163,7 @@
         handler was found.
         """
         message = {"type": "foo"}
-        self.assertEquals(self.client.message(message), False)
+        self.assertEqual(self.client.message(message), False)
 
     def test_exchange(self):
         """

=== modified file 'landscape/broker/tests/test_config.py'
--- landscape/broker/tests/test_config.py	2010-04-12 11:40:06 +0000
+++ landscape/broker/tests/test_config.py	2011-07-06 21:14:28 +0000
@@ -22,8 +22,8 @@
         configuration.load(["--http-proxy", "foo",
                             "--https-proxy", "bar",
                             "--url", "whatever"])
-        self.assertEquals(os.environ["http_proxy"], "foo")
-        self.assertEquals(os.environ["https_proxy"], "bar")
+        self.assertEqual(os.environ["http_proxy"], "foo")
+        self.assertEqual(os.environ["https_proxy"], "bar")
 
     def test_loading_without_http_proxies_does_not_touch_environment(self):
         """
@@ -36,8 +36,8 @@
 
         configuration = BrokerConfiguration()
         configuration.load(["--url", "whatever"])
-        self.assertEquals(os.environ["http_proxy"], "heyo")
-        self.assertEquals(os.environ["https_proxy"], "baroo")
+        self.assertEqual(os.environ["http_proxy"], "heyo")
+        self.assertEqual(os.environ["https_proxy"], "baroo")
 
     def test_loading_resets_http_proxies(self):
         """
@@ -55,12 +55,12 @@
         configuration.load(["--http-proxy", "x",
                             "--https-proxy", "y",
                             "--url", "whatever"])
-        self.assertEquals(os.environ["http_proxy"], "x")
-        self.assertEquals(os.environ["https_proxy"], "y")
+        self.assertEqual(os.environ["http_proxy"], "x")
+        self.assertEqual(os.environ["https_proxy"], "y")
 
         configuration.load(["--url", "whatever"])
-        self.assertEquals(os.environ["http_proxy"], "original")
-        self.assertEquals(os.environ["https_proxy"], "originals")
+        self.assertEqual(os.environ["http_proxy"], "original")
+        self.assertEqual(os.environ["https_proxy"], "originals")
 
     def test_intervals_are_ints(self):
         """
@@ -74,5 +74,5 @@
         configuration = BrokerConfiguration()
         configuration.load(["--config", filename, "--url", "whatever"])
 
-        self.assertEquals(configuration.urgent_exchange_interval, 12)
-        self.assertEquals(configuration.exchange_interval, 34)
+        self.assertEqual(configuration.urgent_exchange_interval, 12)
+        self.assertEqual(configuration.exchange_interval, 34)

=== modified file 'landscape/broker/tests/test_exchange.py'
--- landscape/broker/tests/test_exchange.py	2011-03-25 08:42:48 +0000
+++ landscape/broker/tests/test_exchange.py	2011-07-06 21:14:28 +0000
@@ -47,11 +47,11 @@
         self.mstore.set_accepted_types(["empty"])
         self.exchanger.send({"type": "empty"})
         self.exchanger.exchange()
-        self.assertEquals(len(self.transport.payloads), 1)
+        self.assertEqual(len(self.transport.payloads), 1)
         messages = self.transport.payloads[0]["messages"]
-        self.assertEquals(messages, [{"type": "empty",
-                                      "timestamp": 0,
-                                      "api": SERVER_API}])
+        self.assertEqual(messages, [{"type": "empty",
+                                     "timestamp": 0,
+                                     "api": SERVER_API}])
 
     def test_send_urgent(self):
         """
@@ -61,7 +61,7 @@
         self.mstore.set_accepted_types(["empty"])
         self.exchanger.send({"type": "empty"}, urgent=True)
         self.wait_for_exchange(urgent=True)
-        self.assertEquals(len(self.transport.payloads), 1)
+        self.assertEqual(len(self.transport.payloads), 1)
         self.assertMessages(self.transport.payloads[0]["messages"],
                             [{"type": "empty"}])
 
@@ -75,7 +75,7 @@
         self.wait_for_exchange(urgent=True, factor=0.5)
         self.exchanger.send({"type": "empty"}, urgent=True)
         self.wait_for_exchange(urgent=True, factor=0.5)
-        self.assertEquals(len(self.transport.payloads), 1)
+        self.assertEqual(len(self.transport.payloads), 1)
         self.assertMessages(self.transport.payloads[0]["messages"],
                             [{"type": "empty"}, {"type": "empty"}])
 
@@ -96,7 +96,7 @@
         """
         payload = self.exchanger.make_payload()
         self.assertTrue("accepted-types" in payload)
-        self.assertEquals(payload["accepted-types"], md5("").digest())
+        self.assertEqual(payload["accepted-types"], md5("").digest())
 
     def test_set_accepted_types(self):
         """
@@ -105,7 +105,7 @@
         """
         self.exchanger.handle_message(
             {"type": "accepted-types", "types": ["foo"]})
-        self.assertEquals(self.mstore.get_accepted_types(), ["foo"])
+        self.assertEqual(self.mstore.get_accepted_types(), ["foo"])
 
     def test_message_type_acceptance_changed_event(self):
         stash = []
@@ -117,8 +117,8 @@
             {"type": "accepted-types", "types": ["a", "b"]})
         self.exchanger.handle_message(
             {"type": "accepted-types", "types": ["b", "c"]})
-        self.assertEquals(stash, [("a", True), ("b", True),
-                                  ("a", False), ("c", True)])
+        self.assertEqual(stash, [("a", True), ("b", True),
+                                 ("a", False), ("c", True)])
 
     def test_accepted_types_roundtrip(self):
         """
@@ -129,8 +129,8 @@
             {"type": "accepted-types", "types": ["ack", "bar"]})
         payload = self.exchanger.make_payload()
         self.assertTrue("accepted-types" in payload)
-        self.assertEquals(payload["accepted-types"],
-                          md5("ack;bar").digest())
+        self.assertEqual(payload["accepted-types"],
+                         md5("ack;bar").digest())
 
     def test_accepted_types_causes_urgent_if_held_messages_exist(self):
         """
@@ -138,11 +138,11 @@
         have a held message, an urgent exchange should occur.
         """
         self.exchanger.send({"type": "holdme"})
-        self.assertEquals(self.mstore.get_pending_messages(), [])
+        self.assertEqual(self.mstore.get_pending_messages(), [])
         self.exchanger.handle_message(
             {"type": "accepted-types", "types": ["holdme"]})
         self.wait_for_exchange(urgent=True)
-        self.assertEquals(len(self.transport.payloads), 1)
+        self.assertEqual(len(self.transport.payloads), 1)
         self.assertMessages(self.transport.payloads[0]["messages"],
                             [{"type": "holdme"}])
 
@@ -152,10 +152,10 @@
         then no urgent exchange should occur.
         """
         self.exchanger.send({"type": "holdme"})
-        self.assertEquals(self.transport.payloads, [])
+        self.assertEqual(self.transport.payloads, [])
         self.reactor.fire("message",
                           {"type": "accepted-types", "types": ["irrelevant"]})
-        self.assertEquals(len(self.transport.payloads), 0)
+        self.assertEqual(len(self.transport.payloads), 0)
 
     def test_sequence_is_committed_immediately(self):
         """
@@ -174,13 +174,13 @@
         def handler(message):
             persist = Persist(filename=self.persist_filename)
             store = MessageStore(persist, self.config.message_store_path)
-            self.assertEquals(store.get_pending_offset(), 1)
-            self.assertEquals(store.get_sequence(), 1)
+            self.assertEqual(store.get_pending_offset(), 1)
+            self.assertEqual(store.get_sequence(), 1)
             handled.append(True)
 
         self.exchanger.register_message("inbound", handler)
         self.exchanger.exchange()
-        self.assertEquals(handled, [True], self.logfile.getvalue())
+        self.assertEqual(handled, [True], self.logfile.getvalue())
 
     def test_messages_from_server_commit(self):
         """
@@ -194,14 +194,14 @@
         def handler(message):
             Persist(filename=self.persist_filename)
             store = MessageStore(self.persist, self.config.message_store_path)
-            self.assertEquals(store.get_server_sequence(),
-                              self.message_counter)
+            self.assertEqual(store.get_server_sequence(),
+                             self.message_counter)
             self.message_counter += 1
             handled.append(True)
 
         self.exchanger.register_message("inbound", handler)
         self.exchanger.exchange()
-        self.assertEquals(handled, [True] * 3, self.logfile.getvalue())
+        self.assertEqual(handled, [True] * 3, self.logfile.getvalue())
 
     def test_messages_from_server_causing_urgent_exchanges(self):
         """
@@ -219,11 +219,11 @@
 
         self.exchanger.exchange()
 
-        self.assertEquals(len(self.transport.payloads), 1)
+        self.assertEqual(len(self.transport.payloads), 1)
 
         self.wait_for_exchange(urgent=True)
 
-        self.assertEquals(len(self.transport.payloads), 2)
+        self.assertEqual(len(self.transport.payloads), 2)
         self.assertMessages(self.transport.payloads[1]["messages"],
                             [{"type": "empty"}])
 
@@ -236,7 +236,7 @@
         self.mstore.add({"type": "data", "data": 0})
         self.mstore.add({"type": "data", "data": 1})
         self.exchanger.exchange()
-        self.assertEquals(self.mstore.get_sequence(), 2)
+        self.assertEqual(self.mstore.get_sequence(), 2)
 
         self.mstore.add({"type": "data", "data": 2})
         self.mstore.add({"type": "data", "data": 3})
@@ -248,7 +248,7 @@
 
         self.transport.exchange = desynched_send_data
         self.exchanger.exchange()
-        self.assertEquals(self.mstore.get_sequence(), 1)
+        self.assertEqual(self.mstore.get_sequence(), 1)
         del self.transport.exchange
 
         exchanged = []
@@ -258,15 +258,15 @@
 
         self.reactor.call_on("exchange-done", exchange_callback)
         self.wait_for_exchange(urgent=True)
-        self.assertEquals(exchanged, [True])
+        self.assertEqual(exchanged, [True])
 
         payload = self.transport.payloads[-1]
         self.assertMessages(payload["messages"],
                             [{"type": "data", "data": 1},
                              {"type": "data", "data": 2},
                              {"type": "data", "data": 3}])
-        self.assertEquals(payload["sequence"], 1)
-        self.assertEquals(payload["next-expected-sequence"], 0)
+        self.assertEqual(payload["sequence"], 1)
+        self.assertEqual(payload["next-expected-sequence"], 0)
 
     def test_start_with_urgent_exchange(self):
         """
@@ -278,7 +278,7 @@
                                     self.config)
         exchanger.start()
         self.wait_for_exchange(urgent=True)
-        self.assertEquals(len(transport.payloads), 1)
+        self.assertEqual(len(transport.payloads), 1)
 
     def test_reschedule_after_exchange(self):
         """
@@ -288,13 +288,13 @@
         self.exchanger.schedule_exchange(urgent=True)
 
         self.wait_for_exchange(urgent=True)
-        self.assertEquals(len(self.transport.payloads), 1)
-
-        self.wait_for_exchange()
-        self.assertEquals(len(self.transport.payloads), 2)
-
-        self.wait_for_exchange()
-        self.assertEquals(len(self.transport.payloads), 3)
+        self.assertEqual(len(self.transport.payloads), 1)
+
+        self.wait_for_exchange()
+        self.assertEqual(len(self.transport.payloads), 2)
+
+        self.wait_for_exchange()
+        self.assertEqual(len(self.transport.payloads), 3)
 
     def test_leave_urgent_exchange_mode_after_exchange(self):
         """
@@ -304,9 +304,9 @@
         self.mstore.set_accepted_types(["empty"])
         self.exchanger.send({"type": "empty"}, urgent=True)
         self.wait_for_exchange(urgent=True)
-        self.assertEquals(len(self.transport.payloads), 1)
+        self.assertEqual(len(self.transport.payloads), 1)
         self.wait_for_exchange(urgent=True)
-        self.assertEquals(len(self.transport.payloads), 1)  # no change
+        self.assertEqual(len(self.transport.payloads), 1)  # no change
 
     def test_ancient_causes_resynchronize(self):
         """
@@ -388,7 +388,7 @@
         self.transport.exchange = desynched_send_data
         self.exchanger.exchange()
 
-        self.assertEquals(self.mstore.get_sequence(), 0)
+        self.assertEqual(self.mstore.get_sequence(), 0)
         del self.transport.exchange
 
         exchanged = []
@@ -398,9 +398,9 @@
 
         self.reactor.call_on("exchange-done", exchange_callback)
         self.wait_for_exchange(urgent=True)
-        self.assertEquals(exchanged, [])
+        self.assertEqual(exchanged, [])
         self.wait_for_exchange()
-        self.assertEquals(exchanged, [True])
+        self.assertEqual(exchanged, [True])
 
     def test_old_sequence_id_does_not_cause_resynchronize(self):
         resynchronized = []
@@ -414,7 +414,7 @@
         self.transport.next_expected_sequence = 0
 
         self.exchanger.exchange()
-        self.assertEquals(resynchronized, [])
+        self.assertEqual(resynchronized, [])
 
     def test_per_api_payloads(self):
         """
@@ -433,9 +433,9 @@
         # the client API.
         payload = self.transport.payloads[-1]
         self.assertMessages(payload["messages"], [])
-        self.assertEquals(payload.get("client-api"), CLIENT_API)
-        self.assertEquals(payload.get("server-api"), SERVER_API)
-        self.assertEquals(self.transport.message_api, SERVER_API)
+        self.assertEqual(payload.get("client-api"), CLIENT_API)
+        self.assertEqual(payload.get("server-api"), SERVER_API)
+        self.assertEqual(self.transport.message_api, SERVER_API)
 
         self.mstore.add({"type": "a", "api": "1.0"})
         self.mstore.add({"type": "b", "api": "1.0"})
@@ -452,9 +452,9 @@
         self.assertMessages(payload["messages"],
                             [{"type": "a", "api": "1.0"},
                              {"type": "b", "api": "1.0"}])
-        self.assertEquals(payload.get("client-api"), CLIENT_API)
-        self.assertEquals(payload.get("server-api"), "1.0")
-        self.assertEquals(self.transport.message_api, "1.0")
+        self.assertEqual(payload.get("client-api"), CLIENT_API)
+        self.assertEqual(payload.get("server-api"), "1.0")
+        self.assertEqual(self.transport.message_api, "1.0")
 
         self.exchanger.exchange()
 
@@ -462,9 +462,9 @@
         self.assertMessages(payload["messages"],
                             [{"type": "c", "api": "1.1"},
                              {"type": "d", "api": "1.1"}])
-        self.assertEquals(payload.get("client-api"), CLIENT_API)
-        self.assertEquals(payload.get("server-api"), "1.1")
-        self.assertEquals(self.transport.message_api, "1.1")
+        self.assertEqual(payload.get("client-api"), CLIENT_API)
+        self.assertEqual(payload.get("server-api"), "1.1")
+        self.assertEqual(self.transport.message_api, "1.1")
 
         self.exchanger.exchange()
 
@@ -472,9 +472,9 @@
         self.assertMessages(payload["messages"],
                             [{"type": "e", "api": None},
                              {"type": "f", "api": None}])
-        self.assertEquals(payload.get("client-api"), CLIENT_API)
-        self.assertEquals(payload.get("server-api"), "2.0")
-        self.assertEquals(self.transport.message_api, "2.0")
+        self.assertEqual(payload.get("client-api"), CLIENT_API)
+        self.assertEqual(payload.get("server-api"), "2.0")
+        self.assertEqual(self.transport.message_api, "2.0")
 
     def test_include_total_messages_none(self):
         """
@@ -483,7 +483,7 @@
         """
         self.mstore.set_accepted_types(["empty"])
         self.exchanger.exchange()
-        self.assertEquals(self.transport.payloads[0]["total-messages"], 0)
+        self.assertEqual(self.transport.payloads[0]["total-messages"], 0)
 
     def test_include_total_messages_some(self):
         """
@@ -493,7 +493,7 @@
         self.mstore.set_accepted_types(["empty"])
         self.mstore.add({"type": "empty"})
         self.exchanger.exchange()
-        self.assertEquals(self.transport.payloads[0]["total-messages"], 1)
+        self.assertEqual(self.transport.payloads[0]["total-messages"], 1)
 
     def test_include_total_messages_more(self):
         """
@@ -508,7 +508,7 @@
         self.mstore.add({"type": "empty"})
         self.mstore.add({"type": "empty"})
         exchanger.exchange()
-        self.assertEquals(self.transport.payloads[0]["total-messages"], 2)
+        self.assertEqual(self.transport.payloads[0]["total-messages"], 2)
 
     def test_impending_exchange(self):
         """
@@ -519,9 +519,9 @@
         events = []
         self.reactor.call_on("impending-exchange", lambda: events.append(True))
         self.wait_for_exchange(delta=-11)
-        self.assertEquals(events, [])
+        self.assertEqual(events, [])
         self.reactor.advance(1)
-        self.assertEquals(events, [True])
+        self.assertEqual(events, [True])
 
     def test_impending_exchange_on_urgent(self):
         """
@@ -539,9 +539,9 @@
         events = []
         self.reactor.call_on("impending-exchange", lambda: events.append(True))
         self.reactor.advance(9)
-        self.assertEquals(events, [])
+        self.assertEqual(events, [])
         self.reactor.advance(1)
-        self.assertEquals(events, [True])
+        self.assertEqual(events, [True])
 
     def test_impending_exchange_gets_reschudeled_with_urgent_reschedule(self):
         """
@@ -568,9 +568,9 @@
         # * schedule impending-exchange to be fired in 10 seconds
         exchanger.schedule_exchange(urgent=True)
         self.reactor.advance(10)
-        self.assertEquals(events, [True])
+        self.assertEqual(events, [True])
         self.reactor.advance(10)
-        self.assertEquals(len(self.transport.payloads), 1)
+        self.assertEqual(len(self.transport.payloads), 1)
         # Now the urgent exchange should be fired, which should automatically
         # schedule a regular exchange.
         # Let's make sure that that *original* impending-exchange event has
@@ -578,14 +578,14 @@
         self.reactor.advance(60 * 60  # time till exchange
                              - 10  # time till notification
                              - 20)  # time that we've already advanced
-        self.assertEquals(events, [True])
+        self.assertEqual(events, [True])
         # Ok, so no new events means that the original call was
         # cancelled. great.
         # Just a bit more sanity checking:
         self.reactor.advance(20)
-        self.assertEquals(events, [True, True])
+        self.assertEqual(events, [True, True])
         self.reactor.advance(10)
-        self.assertEquals(len(self.transport.payloads), 2)
+        self.assertEqual(len(self.transport.payloads), 2)
 
     def test_pre_exchange_event(self):
         reactor_mock = self.mocker.patch(self.reactor)
@@ -623,7 +623,7 @@
 
         self.reactor.call_on("exchange-failed", exchange_failed_callback)
         self.exchanger.exchange()
-        self.assertEquals(exchanged, [True])
+        self.assertEqual(exchanged, [True])
 
     def test_stop(self):
         self.exchanger.schedule_exchange()
@@ -645,7 +645,7 @@
         self.assertFalse(self.transport.payloads)
 
     def test_default_exchange_intervals(self):
-        self.assertEquals(self.exchanger.get_exchange_intervals(), (60, 900))
+        self.assertEqual(self.exchanger.get_exchange_intervals(), (60, 900))
 
     def test_set_intervals(self):
         """
@@ -659,15 +659,15 @@
 
         self.exchanger.exchange()
 
-        self.assertEquals(self.exchanger.get_exchange_intervals(),
-                          (1234, 5678))
-        self.assertEquals(self.config.exchange_interval, 5678)
-        self.assertEquals(self.config.urgent_exchange_interval, 1234)
+        self.assertEqual(self.exchanger.get_exchange_intervals(),
+                         (1234, 5678))
+        self.assertEqual(self.config.exchange_interval, 5678)
+        self.assertEqual(self.config.urgent_exchange_interval, 1234)
 
         new_config = BrokerConfiguration()
         new_config.load_configuration_file(self.config_filename)
-        self.assertEquals(new_config.exchange_interval, 5678)
-        self.assertEquals(new_config.urgent_exchange_interval, 1234)
+        self.assertEqual(new_config.exchange_interval, 5678)
+        self.assertEqual(new_config.urgent_exchange_interval, 1234)
 
     def test_set_intervals_with_urgent_exchange_only(self):
         server_message = [{"type": "set-intervals", "urgent-exchange": 1234}]
@@ -675,14 +675,14 @@
 
         self.exchanger.exchange()
 
-        self.assertEquals(self.exchanger.get_exchange_intervals(), (1234, 900))
+        self.assertEqual(self.exchanger.get_exchange_intervals(), (1234, 900))
 
         # Let's make sure it works.
         self.exchanger.schedule_exchange(urgent=True)
         self.reactor.advance(1233)
-        self.assertEquals(len(self.transport.payloads), 1)
+        self.assertEqual(len(self.transport.payloads), 1)
         self.reactor.advance(1)
-        self.assertEquals(len(self.transport.payloads), 2)
+        self.assertEqual(len(self.transport.payloads), 2)
 
     def test_set_intervals_with_exchange_only(self):
         server_message = [{"type": "set-intervals", "exchange": 5678}]
@@ -690,13 +690,13 @@
 
         self.exchanger.exchange()
 
-        self.assertEquals(self.exchanger.get_exchange_intervals(), (60, 5678))
+        self.assertEqual(self.exchanger.get_exchange_intervals(), (60, 5678))
 
         # Let's make sure it works.
         self.reactor.advance(5677)
-        self.assertEquals(len(self.transport.payloads), 1)
+        self.assertEqual(len(self.transport.payloads), 1)
         self.reactor.advance(1)
-        self.assertEquals(len(self.transport.payloads), 2)
+        self.assertEqual(len(self.transport.payloads), 2)
 
     def test_register_message(self):
         """
@@ -709,7 +709,7 @@
         server_message = [msg]
         self.transport.responses.append(server_message)
         self.exchanger.exchange()
-        self.assertEquals(messages, [msg])
+        self.assertEqual(messages, [msg])
 
     def test_register_multiple_message_handlers(self):
         """
@@ -731,15 +731,15 @@
         server_message = [msg]
         self.transport.responses.append(server_message)
         self.exchanger.exchange()
-        self.assertEquals(messages, [("one", msg), ("two", msg)])
+        self.assertEqual(messages, [("one", msg), ("two", msg)])
 
     def test_server_uuid_is_stored_on_message_store(self):
         self.transport.extra["server-uuid"] = "first-uuid"
         self.exchanger.exchange()
-        self.assertEquals(self.mstore.get_server_uuid(), "first-uuid")
+        self.assertEqual(self.mstore.get_server_uuid(), "first-uuid")
         self.transport.extra["server-uuid"] = "second-uuid"
         self.exchanger.exchange()
-        self.assertEquals(self.mstore.get_server_uuid(), "second-uuid")
+        self.assertEqual(self.mstore.get_server_uuid(), "second-uuid")
 
     def test_server_uuid_change_cause_event(self):
         called = []
@@ -752,25 +752,25 @@
         # letting the system know about the change.
         self.transport.extra["server-uuid"] = "first-uuid"
         self.exchanger.exchange()
-        self.assertEquals(len(called), 1)
-        self.assertEquals(called[-1], (None, "first-uuid"))
+        self.assertEqual(len(called), 1)
+        self.assertEqual(called[-1], (None, "first-uuid"))
 
         # Using the same one again, nothing should happen:
         self.transport.extra["server-uuid"] = "first-uuid"
         self.exchanger.exchange()
-        self.assertEquals(len(called), 1)
+        self.assertEqual(len(called), 1)
 
         # Changing it, we should get an event again:
         self.transport.extra["server-uuid"] = "second-uuid"
         self.exchanger.exchange()
-        self.assertEquals(len(called), 2)
-        self.assertEquals(called[-1], ("first-uuid", "second-uuid"))
+        self.assertEqual(len(called), 2)
+        self.assertEqual(called[-1], ("first-uuid", "second-uuid"))
 
         # And then, it shouldn't emit it once more, since it continues
         # to be the same.
         self.transport.extra["server-uuid"] = "second-uuid"
         self.exchanger.exchange()
-        self.assertEquals(len(called), 2)
+        self.assertEqual(len(called), 2)
 
     def test_server_uuid_event_not_emitted_with_matching_stored_uuid(self):
         """
@@ -786,7 +786,7 @@
         self.mstore.set_server_uuid("the-uuid")
         self.transport.extra["server-uuid"] = "the-uuid"
         self.exchanger.exchange()
-        self.assertEquals(called, [])
+        self.assertEqual(called, [])
 
     def test_server_uuid_change_is_logged(self):
         self.transport.extra["server-uuid"] = "the-uuid"
@@ -819,8 +819,8 @@
             self.exchange_store.get_message_context(message['operation-id']))
         message_context = self.exchange_store.get_message_context(
             message['operation-id'])
-        self.assertEquals(message_context.operation_id, 123456)
-        self.assertEquals(message_context.message_type, "type-R")
+        self.assertEqual(message_context.operation_id, 123456)
+        self.assertEqual(message_context.message_type, "type-R")
 
     def test_one_way_messages_do_not_have_their_context_stored(self):
         """
@@ -835,7 +835,7 @@
         self.exchanger.exchange()
 
         ids_after = self.exchange_store.all_operation_ids()
-        self.assertEquals(ids_before, ids_after)
+        self.assertEqual(ids_before, ids_after)
 
     def test_obsolete_response_messages_are_discarded(self):
         """
@@ -859,9 +859,9 @@
         message_id = self.exchanger.send(
             {"type": "resynchronize", "operation-id": 234567})
         self.exchanger.exchange()
-        self.assertEquals(2, len(self.transport.payloads))
+        self.assertEqual(2, len(self.transport.payloads))
         messages = self.transport.payloads[1]["messages"]
-        self.assertEquals([], messages)
+        self.assertEqual([], messages)
         self.assertIs(None, message_id)
         expected_log_entry = (
             "Response message with operation-id 234567 was discarded because "
@@ -894,15 +894,15 @@
         self.exchanger.register_client_accepted_message_type("type-C")
         self.exchanger.register_client_accepted_message_type("type-A")
         types = self.exchanger.get_client_accepted_message_types()
-        self.assertEquals(types,
-                          sorted(["type-A", "type-B", "type-C"] +
-                                 DEFAULT_ACCEPTED_TYPES))
+        self.assertEqual(types,
+                         sorted(["type-A", "type-B", "type-C"] +
+                                DEFAULT_ACCEPTED_TYPES))
 
     def test_exchange_sends_message_type_when_no_hash(self):
         self.exchanger.register_client_accepted_message_type("type-A")
         self.exchanger.register_client_accepted_message_type("type-B")
         self.exchanger.exchange()
-        self.assertEquals(
+        self.assertEqual(
             self.transport.payloads[0]["client-accepted-types"],
             sorted(["type-A", "type-B"] + DEFAULT_ACCEPTED_TYPES))
 
@@ -926,7 +926,7 @@
         self.exchanger.register_client_accepted_message_type("type-B")
         self.exchanger.exchange()
         self.exchanger.exchange()
-        self.assertEquals(
+        self.assertEqual(
             self.transport.payloads[1]["client-accepted-types"],
             sorted(["type-A", "type-B"] + DEFAULT_ACCEPTED_TYPES))
 
@@ -941,7 +941,7 @@
         self.exchanger.exchange()
         self.exchanger.register_client_accepted_message_type("type-B")
         self.exchanger.exchange()
-        self.assertEquals(
+        self.assertEqual(
             self.transport.payloads[1]["client-accepted-types"],
             sorted(["type-A", "type-B"] + DEFAULT_ACCEPTED_TYPES))
 
@@ -958,7 +958,7 @@
         self.transport.extra["client-accepted-types-hash"] = "lol"
         self.exchanger.exchange()
         self.exchanger.exchange()
-        self.assertEquals(
+        self.assertEqual(
             self.transport.payloads[2]["client-accepted-types"],
             sorted(["type-A"] + DEFAULT_ACCEPTED_TYPES))
 
@@ -970,28 +970,28 @@
         """
         self.exchanger.register_message("typefoo", lambda m: None)
         types = self.exchanger.get_client_accepted_message_types()
-        self.assertEquals(types, sorted(["typefoo"] + DEFAULT_ACCEPTED_TYPES))
+        self.assertEqual(types, sorted(["typefoo"] + DEFAULT_ACCEPTED_TYPES))
 
 
 class GetAcceptedTypesDiffTest(LandscapeTest):
 
     def test_diff_empty(self):
-        self.assertEquals(get_accepted_types_diff([], []),
-                          "")
+        self.assertEqual(get_accepted_types_diff([], []),
+                         "")
 
     def test_diff_add(self):
-        self.assertEquals(get_accepted_types_diff([], ["wubble"]),
-                          "+wubble")
+        self.assertEqual(get_accepted_types_diff([], ["wubble"]),
+                         "+wubble")
 
     def test_diff_remove(self):
-        self.assertEquals(get_accepted_types_diff(["wubble"], []),
-                          "-wubble")
+        self.assertEqual(get_accepted_types_diff(["wubble"], []),
+                         "-wubble")
 
     def test_diff_no_change(self):
-        self.assertEquals(get_accepted_types_diff(["ooga"], ["ooga"]),
-                          "ooga")
+        self.assertEqual(get_accepted_types_diff(["ooga"], ["ooga"]),
+                         "ooga")
 
     def test_diff_complex(self):
-        self.assertEquals(get_accepted_types_diff(["foo", "bar"],
-                                                  ["foo", "ooga"]),
-                          "+ooga foo -bar")
+        self.assertEqual(get_accepted_types_diff(["foo", "bar"],
+                                                 ["foo", "ooga"]),
+                         "+ooga foo -bar")

=== modified file 'landscape/broker/tests/test_exchangestore.py'
--- landscape/broker/tests/test_exchangestore.py	2010-06-08 16:48:25 +0000
+++ landscape/broker/tests/test_exchangestore.py	2011-07-06 21:14:28 +0000
@@ -31,11 +31,11 @@
             "SELECT operation_id, secure_id, message_type, timestamp "
             "FROM message_context WHERE operation_id=?", (123,))
         results = cursor.fetchall()
-        self.assertEquals(1, len(results))
+        self.assertEqual(1, len(results))
         [row] = results
-        self.assertEquals(123, row[0])
-        self.assertEquals('abc', row[1])
-        self.assertEquals('change-packages', row[2])
+        self.assertEqual(123, row[0])
+        self.assertEqual('abc', row[1])
+        self.assertEqual('change-packages', row[2])
         self.assertTrue(row[3] > now)
 
     def test_add_message_context_with_duplicate_operation_id(self):
@@ -52,9 +52,9 @@
         now = time.time()
         self.store1.add_message_context(234, 'bcd', 'change-packages')
         context = self.store2.get_message_context(234)
-        self.assertEquals(234, context.operation_id)
-        self.assertEquals('bcd', context.secure_id)
-        self.assertEquals('change-packages', context.message_type)
+        self.assertEqual(234, context.operation_id)
+        self.assertEqual('bcd', context.secure_id)
+        self.assertEqual('change-packages', context.message_type)
         self.assertTrue(context.timestamp > now)
 
     def test_get_message_context_with_nonexistent_operation_id(self):
@@ -74,11 +74,11 @@
         Calling C{all_operation_ids} on an empty database returns an empty
         list.
         """
-        self.assertEquals([], self.store1.all_operation_ids())
+        self.assertEqual([], self.store1.all_operation_ids())
 
     def test_all_operation_ids(self):
         """C{all_operation_ids} works correctly."""
         self.store1.add_message_context(456, 'cde', 'change-packages')
-        self.assertEquals([456], self.store2.all_operation_ids())
+        self.assertEqual([456], self.store2.all_operation_ids())
         self.store2.add_message_context(567, 'def', 'change-packages')
-        self.assertEquals([456, 567], self.store1.all_operation_ids())
+        self.assertEqual([456, 567], self.store1.all_operation_ids())

=== modified file 'landscape/broker/tests/test_ping.py'
--- landscape/broker/tests/test_ping.py	2010-04-23 11:37:25 +0000
+++ landscape/broker/tests/test_ping.py	2011-07-06 21:14:28 +0000
@@ -60,7 +60,7 @@
                             self.broker_service.identity,
                             get_page=client.get_page)
         pinger.ping()
-        self.assertEquals(
+        self.assertEqual(
             client.fetches,
             [(url, True, {"Content-Type": "application/x-www-form-urlencoded"},
               "insecure_id=10")])
@@ -77,7 +77,7 @@
                             get_page=client.get_page)
         d = pinger.ping()
         d.addCallback(self.assertEqual, False)
-        self.assertEquals(client.fetches, [])
+        self.assertEqual(client.fetches, [])
 
     def test_respond(self):
         """
@@ -105,12 +105,13 @@
                             get_page=client.failing_get_page)
         d = pinger.ping()
         failures = []
+
         def errback(failure):
             failures.append(failure)
         d.addErrback(errback)
-        self.assertEquals(len(failures), 1)
-        self.assertEquals(failures[0].getErrorMessage(), "That's a failure!")
-        self.assertEquals(failures[0].type, AssertionError)
+        self.assertEqual(len(failures), 1)
+        self.assertEqual(failures[0].getErrorMessage(), "That's a failure!")
+        self.assertEqual(failures[0].type, AssertionError)
 
 
 class PingerTest(LandscapeTest):
@@ -126,6 +127,7 @@
         super(PingerTest, self).setUp()
         self.url = "http://localhost:8081/whatever"
         self.page_getter = FakePageGetter(None)
+
         def factory(reactor, url, insecure_id):
             return PingClient(reactor, url, insecure_id,
                               get_page=self.page_getter.get_page)
@@ -152,9 +154,9 @@
         self.pinger.start()
         self.broker_service.identity.insecure_id = 23
         self.broker_service.reactor.advance(9)
-        self.assertEquals(len(self.page_getter.fetches), 0)
+        self.assertEqual(len(self.page_getter.fetches), 0)
         self.broker_service.reactor.advance(1)
-        self.assertEquals(len(self.page_getter.fetches), 1)
+        self.assertEqual(len(self.page_getter.fetches), 1)
 
     def test_load_insecure_id(self):
         """
@@ -177,7 +179,7 @@
         # 70 = ping delay + urgent exchange delay
         self.broker_service.reactor.advance(70)
 
-        self.assertEquals(len(self.broker_service.transport.payloads), 1)
+        self.assertEqual(len(self.broker_service.transport.payloads), 1)
 
     def test_negative_response(self):
         """
@@ -187,7 +189,7 @@
         self.broker_service.identity.insecure_id = 42
         self.page_getter.response = {"messages": False}
         self.broker_service.reactor.advance(10)
-        self.assertEquals(len(self.broker_service.transport.payloads), 0)
+        self.assertEqual(len(self.broker_service.transport.payloads), 0)
 
     def test_ping_error(self):
         """
@@ -200,8 +202,10 @@
         class BadPingClient(object):
             def __init__(self, *args, **kwargs):
                 pass
+
             def ping(self):
                 return fail(ZeroDivisionError("Couldn't fetch page"))
+
         pinger = Pinger(self.broker_service.reactor, "http://foo.com/",
                         self.broker_service.identity,
                         self.broker_service.exchanger,
@@ -218,28 +222,28 @@
         self.assertTrue("Couldn't fetch page" in log)
 
     def test_get_interval(self):
-        self.assertEquals(self.pinger.get_interval(), 10)
+        self.assertEqual(self.pinger.get_interval(), 10)
 
     def test_set_intervals_handling(self):
         self.pinger.start()
 
         self.broker_service.reactor.fire("message",
                                          {"type": "set-intervals", "ping": 73})
-        self.assertEquals(self.pinger.get_interval(), 73)
+        self.assertEqual(self.pinger.get_interval(), 73)
 
         # The server may set specific intervals only, not including the ping.
         self.broker_service.reactor.fire("message", {"type": "set-intervals"})
-        self.assertEquals(self.pinger.get_interval(), 73)
+        self.assertEqual(self.pinger.get_interval(), 73)
 
         self.broker_service.identity.insecure_id = 23
         self.broker_service.reactor.advance(72)
-        self.assertEquals(len(self.page_getter.fetches), 0)
+        self.assertEqual(len(self.page_getter.fetches), 0)
         self.broker_service.reactor.advance(1)
-        self.assertEquals(len(self.page_getter.fetches), 1)
+        self.assertEqual(len(self.page_getter.fetches), 1)
 
     def test_get_url(self):
-        self.assertEquals(self.pinger.get_url(),
-                          "http://localhost:8081/whatever")
+        self.assertEqual(self.pinger.get_url(),
+                         "http://localhost:8081/whatever")
 
     def test_set_url(self):
         url = "http://example.com/mysuperping"
@@ -247,7 +251,7 @@
         self.pinger.start()
         self.broker_service.identity.insecure_id = 23
         self.broker_service.reactor.advance(10)
-        self.assertEquals(self.page_getter.fetches[0][0], url)
+        self.assertEqual(self.page_getter.fetches[0][0], url)
 
     def test_set_url_after_start(self):
         url = "http://example.com/mysuperping"
@@ -255,4 +259,4 @@
         self.pinger.set_url(url)
         self.broker_service.identity.insecure_id = 23
         self.broker_service.reactor.advance(10)
-        self.assertEquals(self.page_getter.fetches[0][0], url)
+        self.assertEqual(self.page_getter.fetches[0][0], url)

=== modified file 'landscape/broker/tests/test_server.py'
--- landscape/broker/tests/test_server.py	2010-05-07 10:35:25 +0000
+++ landscape/broker/tests/test_server.py	2011-07-06 21:14:28 +0000
@@ -68,14 +68,14 @@
         client components that need to communicate with the server. After
         the registration they can be fetched with L{BrokerServer.get_clients}.
         """
-        self.assertEquals(self.broker.get_clients(), [])
-        self.assertEquals(self.broker.get_client("test"), None)
-        self.assertEquals(self.broker.get_connectors(), [])
-        self.assertEquals(self.broker.get_connector("test"), None)
+        self.assertEqual(self.broker.get_clients(), [])
+        self.assertEqual(self.broker.get_client("test"), None)
+        self.assertEqual(self.broker.get_connectors(), [])
+        self.assertEqual(self.broker.get_connector("test"), None)
 
         def assert_registered(ignored):
-            self.assertEquals(len(self.broker.get_clients()), 1)
-            self.assertEquals(len(self.broker.get_connectors()), 1)
+            self.assertEqual(len(self.broker.get_clients()), 1)
+            self.assertEqual(len(self.broker.get_connectors()), 1)
             self.assertTrue(
                 isinstance(self.broker.get_client("test"), FakeClient))
             self.assertTrue(
@@ -126,7 +126,7 @@
         """
         open(self.config_filename, "a").write("computer_title = New Title")
         result = self.broker.reload_configuration()
-        result.addCallback(lambda x: self.assertEquals(
+        result.addCallback(lambda x: self.assertEqual(
             self.config.computer_title, "New Title"))
         return result
 
@@ -162,7 +162,7 @@
         if no message types are accepted by the Landscape server.
         """
         self.mstore.set_accepted_types([])
-        self.assertEquals(self.broker.get_accepted_message_types(), [])
+        self.assertEqual(self.broker.get_accepted_message_types(), [])
 
     def test_get_accepted_message_types(self):
         """
@@ -170,15 +170,15 @@
         message types accepted by the Landscape server.
         """
         self.mstore.set_accepted_types(["foo", "bar"])
-        self.assertEquals(sorted(self.broker.get_accepted_message_types()),
-                          ["bar", "foo"])
+        self.assertEqual(sorted(self.broker.get_accepted_message_types()),
+                         ["bar", "foo"])
 
     def test_get_server_uuid_with_unset_uuid(self):
         """
         The L{BrokerServer.get_server_uuid} method returns C{None} if the uuid
         of the Landscape server we're pointing at is unknown.
         """
-        self.assertEquals(self.broker.get_server_uuid(), None)
+        self.assertEqual(self.broker.get_server_uuid(), None)
 
     def test_get_server_uuid(self):
         """
@@ -186,7 +186,7 @@
         Landscape server we're pointing at.
         """
         self.mstore.set_server_uuid("the-uuid")
-        self.assertEquals(self.broker.get_server_uuid(), "the-uuid")
+        self.assertEqual(self.broker.get_server_uuid(), "the-uuid")
 
     def test_register_client_accepted_message_type(self):
         """
@@ -195,8 +195,8 @@
         """
         self.broker.register_client_accepted_message_type("type1")
         self.broker.register_client_accepted_message_type("type2")
-        self.assertEquals(self.exchanger.get_client_accepted_message_types(),
-                          sorted(["type1", "type2"] + DEFAULT_ACCEPTED_TYPES))
+        self.assertEqual(self.exchanger.get_client_accepted_message_types(),
+                         sorted(["type1", "type2"] + DEFAULT_ACCEPTED_TYPES))
 
     def test_fire_event(self):
         """
@@ -284,8 +284,8 @@
         the given events.
         """
         result = self.broker.listen_events(["event"])
-        self.assertEquals(self.reactor.fire("event"), [None])
-        self.assertEquals(self.reactor.fire("event"), [])
+        self.assertEqual(self.reactor.fire("event"), [None])
+        self.assertEqual(self.reactor.fire("event"), [])
         return self.assertSuccess(result, "event")
 
 

=== modified file 'landscape/broker/tests/test_service.py'
--- landscape/broker/tests/test_service.py	2010-08-11 11:56:29 +0000
+++ landscape/broker/tests/test_service.py	2011-07-06 21:14:28 +0000
@@ -22,7 +22,7 @@
         """
         A L{BrokerService} instance has a proper C{persist} attribute.
         """
-        self.assertEquals(
+        self.assertEqual(
             self.service.persist.filename,
             os.path.join(self.config.data_path, "broker.bpickle"))
 
@@ -31,38 +31,38 @@
         A L{BrokerService} instance has a proper C{transport} attribute.
         """
         self.assertTrue(isinstance(self.service.transport, HTTPTransport))
-        self.assertEquals(self.service.transport.get_url(), self.config.url)
+        self.assertEqual(self.service.transport.get_url(), self.config.url)
 
     def test_message_store(self):
         """
         A L{BrokerService} instance has a proper C{message_store} attribute.
         """
-        self.assertEquals(self.service.message_store.get_accepted_types(), ())
+        self.assertEqual(self.service.message_store.get_accepted_types(), ())
 
     def test_identity(self):
         """
         A L{BrokerService} instance has a proper C{identity} attribute.
         """
-        self.assertEquals(self.service.identity.account_name, "some_account")
+        self.assertEqual(self.service.identity.account_name, "some_account")
 
     def test_exchanger(self):
         """
         A L{BrokerService} instance has a proper C{exchanger} attribute.
         """
-        self.assertEquals(self.service.exchanger.get_exchange_intervals(),
-                          (60, 900))
+        self.assertEqual(self.service.exchanger.get_exchange_intervals(),
+                         (60, 900))
 
     def test_pinger(self):
         """
         A L{BrokerService} instance has a proper C{pinger} attribute.
         """
-        self.assertEquals(self.service.pinger.get_url(), self.config.ping_url)
+        self.assertEqual(self.service.pinger.get_url(), self.config.ping_url)
 
     def test_registration(self):
         """
         A L{BrokerService} instance has a proper C{registration} attribute.
         """
-        self.assertEquals(self.service.registration.should_register(), False)
+        self.assertEqual(self.service.registration.should_register(), False)
 
     def test_wb_exit(self):
         """

=== modified file 'landscape/broker/tests/test_store.py'
--- landscape/broker/tests/test_store.py	2011-06-28 17:10:04 +0000
+++ landscape/broker/tests/test_store.py	2011-07-06 21:14:28 +0000
@@ -42,51 +42,51 @@
         return self.time
 
     def test_get_set_sequence(self):
-        self.assertEquals(self.store.get_sequence(), 0)
+        self.assertEqual(self.store.get_sequence(), 0)
         self.store.set_sequence(3)
-        self.assertEquals(self.store.get_sequence(), 3)
+        self.assertEqual(self.store.get_sequence(), 3)
 
         # Ensure it's actually saved.
         self.store.commit()
         store = self.create_store()
-        self.assertEquals(store.get_sequence(), 3)
+        self.assertEqual(store.get_sequence(), 3)
 
     def test_get_set_server_sequence(self):
-        self.assertEquals(self.store.get_server_sequence(), 0)
+        self.assertEqual(self.store.get_server_sequence(), 0)
         self.store.set_server_sequence(3)
-        self.assertEquals(self.store.get_server_sequence(), 3)
+        self.assertEqual(self.store.get_server_sequence(), 3)
 
         # Ensure it's actually saved.
         self.store.commit()
         store = self.create_store()
-        self.assertEquals(store.get_server_sequence(), 3)
+        self.assertEqual(store.get_server_sequence(), 3)
 
     def test_get_set_server_uuid(self):
-        self.assertEquals(self.store.get_server_uuid(), None)
+        self.assertEqual(self.store.get_server_uuid(), None)
         self.store.set_server_uuid("abcd-efgh")
-        self.assertEquals(self.store.get_server_uuid(), "abcd-efgh")
+        self.assertEqual(self.store.get_server_uuid(), "abcd-efgh")
 
         # Ensure it's actually saved.
         self.store.commit()
         store = self.create_store()
-        self.assertEquals(store.get_server_uuid(), "abcd-efgh")
+        self.assertEqual(store.get_server_uuid(), "abcd-efgh")
 
     def test_get_pending_offset(self):
-        self.assertEquals(self.store.get_pending_offset(), 0)
+        self.assertEqual(self.store.get_pending_offset(), 0)
         self.store.set_pending_offset(3)
-        self.assertEquals(self.store.get_pending_offset(), 3)
+        self.assertEqual(self.store.get_pending_offset(), 3)
 
     def test_add_pending_offset(self):
-        self.assertEquals(self.store.get_pending_offset(), 0)
-        self.store.add_pending_offset(3)
-        self.assertEquals(self.store.get_pending_offset(), 3)
-        self.store.add_pending_offset(3)
-        self.assertEquals(self.store.get_pending_offset(), 6)
+        self.assertEqual(self.store.get_pending_offset(), 0)
+        self.store.add_pending_offset(3)
+        self.assertEqual(self.store.get_pending_offset(), 3)
+        self.store.add_pending_offset(3)
+        self.assertEqual(self.store.get_pending_offset(), 6)
         self.store.add_pending_offset(-3)
-        self.assertEquals(self.store.get_pending_offset(), 3)
+        self.assertEqual(self.store.get_pending_offset(), 3)
 
     def test_no_pending_messages(self):
-        self.assertEquals(self.store.get_pending_messages(1), [])
+        self.assertEqual(self.store.get_pending_messages(1), [])
 
     def test_delete_no_messages(self):
         self.store.delete_old_messages()
@@ -102,8 +102,8 @@
         self.store.set_accepted_types(["empty", "unaccepted"])
         self.store.set_pending_offset(0)
         messages = self.store.get_pending_messages()
-        self.assertEquals(len(messages), 1)
-        self.assertEquals(messages[0]["type"], "unaccepted")
+        self.assertEqual(len(messages), 1)
+        self.assertEqual(messages[0]["type"], "unaccepted")
 
     def test_delete_all_messages(self):
         """Resetting the message store means removing *ALL* messages."""
@@ -115,8 +115,8 @@
         self.store.set_pending_offset(2)
         self.store.delete_all_messages()
         self.store.set_accepted_types(["empty", "unaccepted"])
-        self.assertEquals(self.store.get_pending_offset(), 0)
-        self.assertEquals(self.store.get_pending_messages(), [])
+        self.assertEqual(self.store.get_pending_offset(), 0)
+        self.assertEqual(self.store.get_pending_messages(), [])
 
     def test_one_message(self):
         self.store.add(dict(type="data", data="A thing"))
@@ -130,38 +130,38 @@
         for i in range(10):
             self.store.add(dict(type="data", data=str(i)))
         il = [m["data"] for m in self.store.get_pending_messages(5)]
-        self.assertEquals(il, map(str, [0, 1, 2, 3, 4]))
+        self.assertEqual(il, map(str, [0, 1, 2, 3, 4]))
 
     def test_offset(self):
         self.store.set_pending_offset(5)
         for i in range(15):
             self.store.add(dict(type="data", data=str(i)))
         il = [m["data"] for m in self.store.get_pending_messages(5)]
-        self.assertEquals(il, map(str, [5, 6, 7, 8, 9]))
+        self.assertEqual(il, map(str, [5, 6, 7, 8, 9]))
 
     def test_exercise_multi_dir(self):
         for i in range(35):
             self.store.add(dict(type="data", data=str(i)))
         il = [m["data"] for m in self.store.get_pending_messages(50)]
-        self.assertEquals(il, map(str, range(35)))
+        self.assertEqual(il, map(str, range(35)))
 
     def test_wb_clean_up_empty_directories(self):
         for i in range(60):
             self.store.add(dict(type="data", data=str(i)))
         il = [m["data"] for m in self.store.get_pending_messages(60)]
-        self.assertEquals(il, map(str, range(60)))
-        self.assertEquals(set(os.listdir(self.temp_dir)), set(["0", "1", "2"]))
+        self.assertEqual(il, map(str, range(60)))
+        self.assertEqual(set(os.listdir(self.temp_dir)), set(["0", "1", "2"]))
 
         self.store.set_pending_offset(60)
         self.store.delete_old_messages()
-        self.assertEquals(os.listdir(self.temp_dir), [])
+        self.assertEqual(os.listdir(self.temp_dir), [])
 
     def test_unaccepted(self):
         for i in range(10):
             self.store.add(dict(type=["data", "unaccepted"][i % 2],
                                 data=str(i)))
         il = [m["data"] for m in self.store.get_pending_messages(20)]
-        self.assertEquals(il, map(str, [0, 2, 4, 6, 8]))
+        self.assertEqual(il, map(str, [0, 2, 4, 6, 8]))
 
     def test_unaccepted_with_offset(self):
         for i in range(10):
@@ -169,7 +169,7 @@
                                 data=str(i)))
         self.store.set_pending_offset(2)
         il = [m["data"] for m in self.store.get_pending_messages(20)]
-        self.assertEquals(il, map(str, [4, 6, 8]))
+        self.assertEqual(il, map(str, [4, 6, 8]))
 
     def test_unaccepted_reaccepted(self):
         for i in range(10):
@@ -179,7 +179,7 @@
         il = [m["data"] for m in self.store.get_pending_messages(2)]
         self.store.set_accepted_types(["data", "unaccepted"])
         il = [m["data"] for m in self.store.get_pending_messages(20)]
-        self.assertEquals(il, map(str, [4, 6, 8, 1, 3, 5, 7, 9]))
+        self.assertEqual(il, map(str, [4, 6, 8, 1, 3, 5, 7, 9]))
 
     def test_accepted_unaccepted(self):
         for i in range(10):
@@ -191,10 +191,10 @@
         self.store.set_pending_offset(2)
         self.store.set_accepted_types(["unaccepted"])
         il = [m["data"] for m in self.store.get_pending_messages(20)]
-        self.assertEquals(il, map(str, [1, 3, 5, 7, 9]))
+        self.assertEqual(il, map(str, [1, 3, 5, 7, 9]))
         self.store.set_accepted_types(["data", "unaccepted"])
         il = [m["data"] for m in self.store.get_pending_messages(20)]
-        self.assertEquals(il, map(str, [1, 3, 5, 7, 9, 4, 6, 8]))
+        self.assertEqual(il, map(str, [1, 3, 5, 7, 9, 4, 6, 8]))
 
     def test_accepted_unaccepted_old(self):
         for i in range(10):
@@ -203,18 +203,18 @@
         self.store.set_pending_offset(2)
         self.store.set_accepted_types(["unaccepted"])
         il = [m["data"] for m in self.store.get_pending_messages(20)]
-        self.assertEquals(il, map(str, [1, 3, 5, 7, 9]))
+        self.assertEqual(il, map(str, [1, 3, 5, 7, 9]))
         # Now, if the server asks us to go back and process
         # previously accepted messages that are now unaccepted,
         # they should be put on hold.
         self.store.set_pending_offset(0)
         il = [m["data"] for m in self.store.get_pending_messages(20)]
-        self.assertEquals(il, map(str, [1, 3, 5, 7, 9]))
+        self.assertEqual(il, map(str, [1, 3, 5, 7, 9]))
         # When the server starts accepting them again, these old
         # messages will also be delivered.
         self.store.set_accepted_types(["data", "unaccepted"])
         il = [m["data"] for m in self.store.get_pending_messages(20)]
-        self.assertEquals(il, map(str, [1, 3, 5, 7, 9, 0, 2, 4, 6, 8]))
+        self.assertEqual(il, map(str, [1, 3, 5, 7, 9, 0, 2, 4, 6, 8]))
 
     def test_wb_handle_broken_messages(self):
         self.log_helper.ignore_errors(ValueError)
@@ -228,7 +228,7 @@
         file.write("bpickle will break reading this")
         file.close()
 
-        self.assertEquals(self.store.get_pending_messages(), [])
+        self.assertEqual(self.store.get_pending_messages(), [])
 
         # FIXME This is an unfortunate assertion because it relies on
         # a message generated by external code.  As it turns out, this
@@ -265,14 +265,14 @@
 
         messages = self.store.get_pending_messages()
 
-        self.assertEquals(messages, [{"type": "data", "data": "2",
-                                      "api": SERVER_API}])
+        self.assertEqual(messages, [{"type": "data", "data": "2",
+                                     "api": SERVER_API}])
 
         self.store.set_pending_offset(len(messages))
 
         messages = self.store.get_pending_messages()
         self.store.delete_old_messages()
-        self.assertEquals(messages, [])
+        self.assertEqual(messages, [])
         self.assertTrue("ValueError" in self.logfile.getvalue())
 
     def test_atomic_message_writing(self):
@@ -296,30 +296,30 @@
         self.assertRaises(IOError, self.store.add, {"type": "data", "data": 2})
         self.mocker.verify()
         self.mocker.reset()
-        self.assertEquals(self.store.get_pending_messages(),
+        self.assertEqual(self.store.get_pending_messages(),
                          [{"type": "data", "data": 1, "api": SERVER_API}])
 
     def test_api_attribute(self):
-        self.assertEquals(self.store.api, SERVER_API)
+        self.assertEqual(self.store.api, SERVER_API)
         new_api = "New API version!"
         self.store.api = new_api
-        self.assertEquals(self.store.api, new_api)
+        self.assertEqual(self.store.api, new_api)
 
     def test_default_api_on_messages(self):
         self.store.add({"type": "empty"})
-        self.assertEquals(self.store.get_pending_messages(),
-                          [{"type": "empty", "api": SERVER_API}])
+        self.assertEqual(self.store.get_pending_messages(),
+                         [{"type": "empty", "api": SERVER_API}])
 
     def test_custom_api_on_store(self):
         self.store.api = "X.Y"
         self.store.add({"type": "empty"})
-        self.assertEquals(self.store.get_pending_messages(),
-                          [{"type": "empty", "api": "X.Y"}])
+        self.assertEqual(self.store.get_pending_messages(),
+                         [{"type": "empty", "api": "X.Y"}])
 
     def test_custom_api_on_messages(self):
         self.store.add({"type": "empty", "api": "X.Y"})
-        self.assertEquals(self.store.get_pending_messages(),
-                          [{"type": "empty", "api": "X.Y"}])
+        self.assertEqual(self.store.get_pending_messages(),
+                         [{"type": "empty", "api": "X.Y"}])
 
     def test_coercion(self):
         """
@@ -347,17 +347,17 @@
         self.store.add({"type": "data",
                         "data": u"\N{HIRAGANA LETTER A}".encode("utf-8"),
                         "api": "whatever"})
-        self.assertEquals(self.store.get_pending_messages(),
-                          [{"type": "data", "api": "whatever",
-                            "data": u"\N{HIRAGANA LETTER A}"}])
+        self.assertEqual(self.store.get_pending_messages(),
+                         [{"type": "data", "api": "whatever",
+                           "data": u"\N{HIRAGANA LETTER A}"}])
 
     def test_count_pending_messages(self):
         """It is possible to get the total number of pending messages."""
-        self.assertEquals(self.store.count_pending_messages(), 0)
+        self.assertEqual(self.store.count_pending_messages(), 0)
         self.store.add({"type": "empty"})
-        self.assertEquals(self.store.count_pending_messages(), 1)
+        self.assertEqual(self.store.count_pending_messages(), 1)
         self.store.add({"type": "data", "data": "yay"})
-        self.assertEquals(self.store.count_pending_messages(), 2)
+        self.assertEqual(self.store.count_pending_messages(), 2)
 
     def test_commit(self):
         """
@@ -373,8 +373,8 @@
         self.assertTrue(os.path.exists(filename))
 
         store = MessageStore(Persist(filename=filename), self.temp_dir)
-        self.assertEquals(set(store.get_accepted_types()),
-                          set(["foo", "bar"]))
+        self.assertEqual(set(store.get_accepted_types()),
+                         set(["foo", "bar"]))
 
     def test_is_pending_pre_and_post_message_delivery(self):
         self.log_helper.ignore_errors(ValueError)
@@ -438,6 +438,6 @@
         file.write("bpickle will break reading this")
         file.close()
 
-        self.assertEquals(self.store.get_pending_messages(), [])
+        self.assertEqual(self.store.get_pending_messages(), [])
 
         self.assertFalse(self.store.is_pending(id))

=== modified file 'landscape/broker/tests/test_transport.py'
--- landscape/broker/tests/test_transport.py	2011-06-29 17:50:48 +0000
+++ landscape/broker/tests/test_transport.py	2011-07-06 21:14:28 +0000
@@ -53,12 +53,12 @@
     def test_get_url(self):
         url = "http://example/ooga"
         transport = HTTPTransport(url)
-        self.assertEquals(transport.get_url(), url)
+        self.assertEqual(transport.get_url(), url)
 
     def test_set_url(self):
         transport = HTTPTransport("http://example/ooga")
         transport.set_url("http://example/message-system")
-        self.assertEquals(transport.get_url(), "http://example/message-system")
+        self.assertEqual(transport.get_url(), "http://example/message-system")
 
     def test_request_data(self):
         """
@@ -76,13 +76,13 @@
                                message_api="X.Y")
 
         def got_result(ignored):
-            self.assertEquals(r.request.received_headers["x-computer-id"],
-                              "34")
-            self.assertEquals(r.request.received_headers["user-agent"],
-                              "landscape-client/%s" % (VERSION,))
-            self.assertEquals(r.request.received_headers["x-message-api"],
-                              "X.Y")
-            self.assertEquals(bpickle.loads(r.content), "HI")
+            self.assertEqual(r.request.received_headers["x-computer-id"],
+                             "34")
+            self.assertEqual(r.request.received_headers["user-agent"],
+                             "landscape-client/%s" % (VERSION,))
+            self.assertEqual(r.request.received_headers["x-message-api"],
+                             "X.Y")
+            self.assertEqual(bpickle.loads(r.content), "HI")
         result.addCallback(got_result)
         return result
 
@@ -103,13 +103,13 @@
                                message_api="X.Y")
 
         def got_result(ignored):
-            self.assertEquals(r.request.received_headers["x-computer-id"],
-                              "34")
-            self.assertEquals(r.request.received_headers["user-agent"],
-                              "landscape-client/%s" % (VERSION,))
-            self.assertEquals(r.request.received_headers["x-message-api"],
-                              "X.Y")
-            self.assertEquals(bpickle.loads(r.content), "HI")
+            self.assertEqual(r.request.received_headers["x-computer-id"],
+                             "34")
+            self.assertEqual(r.request.received_headers["user-agent"],
+                             "landscape-client/%s" % (VERSION,))
+            self.assertEqual(r.request.received_headers["x-message-api"],
+                             "X.Y")
+            self.assertEqual(bpickle.loads(r.content), "HI")
         result.addCallback(got_result)
         return result
 
@@ -134,8 +134,8 @@
                                message_api="X.Y")
 
         def got_result(ignored):
-            self.assertEquals(r.request, None)
-            self.assertEquals(r.content, None)
+            self.assertEqual(r.request, None)
+            self.assertEqual(r.content, None)
             self.assertTrue("server certificate verification failed"
                             in self.logfile.getvalue())
         result.addCallback(got_result)
@@ -167,7 +167,7 @@
         transport.exchange("pay load")
 
         file_path = os.path.join(path, static_filename())
-        self.assertEquals("pay load", bpickle.loads(read_file(file_path)))
+        self.assertEqual("pay load", bpickle.loads(read_file(file_path)))
 
     def test_exchange_works_without_payload_recording(self):
         """
@@ -176,10 +176,11 @@
         """
         transport = HTTPTransport("http://localhost")
         self.called = False
-                
+
         def fake_curl(param1, param2, param3):
             """Stub out the curl network call."""
             self.called = True
+
             class Curly(object):
                 def getinfo(self, param1):
                     return 200
@@ -190,6 +191,7 @@
 
         self.assertTrue(self.called)
 
+
 class PayloadRecorderTest(MockerTestCase):
 
     def test_get_payload_filename(self):
@@ -207,7 +209,7 @@
 
         payload_name = recorder.get_payload_filename()
 
-        self.assertEquals("12.346", payload_name)
+        self.assertEqual("12.346", payload_name)
 
     def test_get_payload_filename_no_duplicates(self):
         """
@@ -228,8 +230,8 @@
         payload_name_1 = recorder.get_payload_filename()
         payload_name_2 = recorder.get_payload_filename()
 
-        self.assertEquals("12.345", payload_name_1)
-        self.assertEquals("12.346", payload_name_2)
+        self.assertEqual("12.345", payload_name_1)
+        self.assertEqual("12.346", payload_name_2)
 
     def test_save(self):
         """L{PayloadRecorder.save} should save the payload to the filesystem.
@@ -242,7 +244,7 @@
         recorder.get_payload_filename = static_filename
         recorder.save("payload data")
         file_path = os.path.join(path, static_filename())
-        self.assertEquals("payload data", read_file(file_path))
+        self.assertEqual("payload data", read_file(file_path))
 
     def test_create_destination_dir(self):
         """
@@ -263,4 +265,4 @@
         create_file(os.path.join(path, "one"), "one")
         create_file(os.path.join(path, "two"), "two")
         PayloadRecorder(path)
-        self.assertEquals([], os.listdir(path))
+        self.assertEqual([], os.listdir(path))

=== modified file 'landscape/lib/tests/test_amp.py'
--- landscape/lib/tests/test_amp.py	2010-06-08 07:59:32 +0000
+++ landscape/lib/tests/test_amp.py	2011-07-06 21:14:28 +0000
@@ -2,10 +2,7 @@
 from twisted.internet.defer import Deferred, DeferredList
 from twisted.internet.protocol import ClientCreator
 from twisted.internet.error import ConnectionDone, ConnectError
-try:
-    from twisted.internet.task import Clock
-except ImportError:
-    Clock = None # Dapper doesn't have it
+from twisted.internet.task import Clock
 
 from landscape.lib.twisted_util import gather_results
 from landscape.lib.amp import (
@@ -456,7 +453,7 @@
         The L{MethodCallClientFactory} class has a default value of 30 seconds
         for the maximum reconnection delay.
         """
-        self.assertEquals(self.factory.maxDelay, 30)
+        self.assertEqual(self.factory.maxDelay, 30)
 
     def test_add_notifier(self):
         """
@@ -494,7 +491,7 @@
         self.factory.retry = self.mocker.mock()
         self.factory.retry(KWARGS)
         self.mocker.replay()
-        self.assertEquals(self.factory.retries, 0)
+        self.assertEqual(self.factory.retries, 0)
         self.factory.clientConnectionFailed(None, None)
 
     def test_client_connection_failed_with_max_retries_reached(self):
@@ -571,7 +568,7 @@
         self.connector.disconnect()
 
         def assert_factor(ignored):
-            self.assertEquals(self.connector._factory.factor, 1.0)
+            self.assertEqual(self.connector._factory.factor, 1.0)
 
         result = self.connector.connect(factor=1.0)
         return result.addCallback(assert_factor)
@@ -650,7 +647,7 @@
             self.port = reactor.listenUNIX(self.socket, self.server_factory)
 
         def assert_failure(error):
-            self.assertEquals(str(error), "Forbidden method 'secret'")
+            self.assertEqual(str(error), "Forbidden method 'secret'")
 
         reactor.callLater(0.5, restart_listening)
         result = self.words.secret()
@@ -686,7 +683,7 @@
             self.port = reactor.listenUNIX(self.socket, self.server_factory)
 
         def assert_failure(error):
-            self.assertEquals(str(error), "Forbidden method 'secret'")
+            self.assertEqual(str(error), "Forbidden method 'secret'")
 
         # Use our own reconnect handler
         self.connector._factory.remove_notifier(self.words._handle_reconnect)
@@ -710,13 +707,13 @@
             self.port = reactor.listenUNIX(self.socket, self.server_factory)
 
         def assert_guess(response):
-            self.assertEquals(response, "Guessed!")
+            self.assertEqual(response, "Guessed!")
 
         def assert_secret(failure):
-            self.assertEquals(str(failure.value), "Forbidden method 'secret'")
+            self.assertEqual(str(failure.value), "Forbidden method 'secret'")
 
         def assert_motd(response):
-            self.assertEquals(response, "Words are cool")
+            self.assertEqual(response, "Words are cool")
 
         reactor.callLater(0.1, restart_listening)
 
@@ -767,7 +764,7 @@
             reactor.callLater(0.1, reconnected.callback, None)
 
         def assert_failure(error):
-            self.assertEquals(str(error), "timeout")
+            self.assertEqual(str(error), "timeout")
             return reconnected
 
         reactor.callLater(0.9, restart_listening)

=== modified file 'landscape/lib/tests/test_bootstrap.py'
--- landscape/lib/tests/test_bootstrap.py	2008-06-10 10:56:01 +0000
+++ landscape/lib/tests/test_bootstrap.py	2011-07-06 21:14:28 +0000
@@ -117,7 +117,7 @@
         filename = self.makeFile("CONTENT")
         file = self.bootstrap_class(filename)
         file.bootstrap()
-        self.assertEquals(open(filename).read(), "CONTENT")
+        self.assertEqual(open(filename).read(), "CONTENT")
 
 
 class BootstrapDirectoryTest(BootstrapCreationTest):

=== modified file 'landscape/lib/tests/test_bpickle.py'
--- landscape/lib/tests/test_bpickle.py	2008-06-10 10:56:01 +0000
+++ landscape/lib/tests/test_bpickle.py	2011-07-06 21:14:28 +0000
@@ -6,7 +6,7 @@
 class BPickleTest(unittest.TestCase):
 
     def test_int(self):
-        self.assertEquals(bpickle.loads(bpickle.dumps(1)), 1)
+        self.assertEqual(bpickle.loads(bpickle.dumps(1)), 1)
 
     def test_float(self):
         self.assertAlmostEquals(bpickle.loads(bpickle.dumps(2.3)), 2.3)
@@ -17,35 +17,34 @@
         self.assertAlmostEquals(bpickle.loads(bpickle.dumps(number)), number)
 
     def test_string(self):
-        self.assertEquals(bpickle.loads(bpickle.dumps('foo')), 'foo')
+        self.assertEqual(bpickle.loads(bpickle.dumps('foo')), 'foo')
 
     def test_list(self):
-        self.assertEquals(bpickle.loads(bpickle.dumps([1, 2, 'hello', 3.0])),
-                          [1, 2, 'hello', 3.0])
+        self.assertEqual(bpickle.loads(bpickle.dumps([1, 2, 'hello', 3.0])),
+                         [1, 2, 'hello', 3.0])
 
     def test_tuple(self):
         data = bpickle.dumps((1, [], 2, 'hello', 3.0))
-        self.assertEquals(bpickle.loads(data),
-                          (1, [], 2, 'hello', 3.0))
+        self.assertEqual(bpickle.loads(data),
+                         (1, [], 2, 'hello', 3.0))
 
     def test_none(self):
-        self.assertEquals(bpickle.loads(bpickle.dumps(None)), None)
+        self.assertEqual(bpickle.loads(bpickle.dumps(None)), None)
 
     def test_unicode(self):
-        self.assertEquals(bpickle.loads(bpickle.dumps(u'\xc0')), u'\xc0')
+        self.assertEqual(bpickle.loads(bpickle.dumps(u'\xc0')), u'\xc0')
 
     def test_bool(self):
-        self.assertEquals(bpickle.loads(bpickle.dumps(True)), True)
+        self.assertEqual(bpickle.loads(bpickle.dumps(True)), True)
 
     def test_dict(self):
         dumped_tostr = bpickle.dumps({True: "hello"})
-        self.assertEquals(bpickle.loads(dumped_tostr),
-                          {True: "hello"})
+        self.assertEqual(bpickle.loads(dumped_tostr),
+                         {True: "hello"})
         dumped_tobool = bpickle.dumps({True: False})
-        self.assertEquals(bpickle.loads(dumped_tobool),
-                          {True: False})
+        self.assertEqual(bpickle.loads(dumped_tobool),
+                         {True: False})
 
     def test_long(self):
         long = 99999999999999999999999999999
-        self.assertEquals(bpickle.loads(bpickle.dumps(long)), long)
-
+        self.assertEqual(bpickle.loads(bpickle.dumps(long)), long)

=== modified file 'landscape/lib/tests/test_bpickle_dbus.py'
--- landscape/lib/tests/test_bpickle_dbus.py	2008-06-10 10:56:01 +0000
+++ landscape/lib/tests/test_bpickle_dbus.py	2011-07-06 21:14:28 +0000
@@ -45,7 +45,7 @@
         post = set(bpickle.dumps_table.iteritems())
         self.assertTrue(pre.issubset(post))
         self.assertTrue(object in bpickle.dumps_table)
-        self.assertTrue(len(original)+1, len(bpickle.dumps_table))
+        self.assertTrue(len(original) + 1, len(bpickle.dumps_table))
 
     def test_dumps_utf8string(self):
         """
@@ -56,9 +56,9 @@
             from dbus.types import UTF8String
 
             value = UTF8String("")
-            self.assertEquals(dumps_utf8string(value), "u0:")
+            self.assertEqual(dumps_utf8string(value), "u0:")
             value = UTF8String("Charlie!")
-            self.assertEquals(dumps_utf8string(value), "u8:Charlie!")
+            self.assertEqual(dumps_utf8string(value), "u8:Charlie!")
         except ImportError:
             pass
 

=== modified file 'landscape/lib/tests/test_command.py'
--- landscape/lib/tests/test_command.py	2009-03-18 10:13:12 +0000
+++ landscape/lib/tests/test_command.py	2011-07-06 21:14:28 +0000
@@ -9,24 +9,24 @@
         super(CommandTest, self).setUp()
 
     def test_basic(self):
-        self.assertEquals(run_command("echo test"), "test")
+        self.assertEqual(run_command("echo test"), "test")
 
     def test_non_0_exit_status(self):
         try:
             run_command("false")
         except CommandError, error:
-            self.assertEquals(error.command, "false")
-            self.assertEquals(error.output, "")
-            self.assertEquals(error.exit_status, 1)
+            self.assertEqual(error.command, "false")
+            self.assertEqual(error.output, "")
+            self.assertEqual(error.exit_status, 1)
         else:
             self.fail("CommandError not raised")
 
     def test_error_str(self):
-        self.assertEquals(str(CommandError("test_command", 1, "test output")),
-                          "'test_command' exited with status 1 "
-                          "(test output)")
+        self.assertEqual(str(CommandError("test_command", 1, "test output")),
+                         "'test_command' exited with status 1 "
+                         "(test output)")
 
     def test_error_repr(self):
-        self.assertEquals(repr(CommandError("test_command", 1, "test output")),
-                          "<CommandError command=<test_command> "
-                          "exit_status=1 output=<test output>>")
+        self.assertEqual(repr(CommandError("test_command", 1, "test output")),
+                         "<CommandError command=<test_command> "
+                         "exit_status=1 output=<test output>>")

=== modified file 'landscape/lib/tests/test_disk.py'
--- landscape/lib/tests/test_disk.py	2010-06-07 17:23:44 +0000
+++ landscape/lib/tests/test_disk.py	2011-07-06 21:14:28 +0000
@@ -43,23 +43,23 @@
     def test_get_filesystem_for_path(self):
         self.set_mount_points(["/"])
         info = get_filesystem_for_path("/", self.mount_file, self.statvfs)
-        self.assertEquals(info["mount-point"], "/")
+        self.assertEqual(info["mount-point"], "/")
 
     def test_get_filesystem_subpath(self):
         self.set_mount_points(["/"])
         self.stat_results["/"] = (4096, 0, 1000, 500, 0, 0, 0, 0, 0)
         info = get_filesystem_for_path("/home", self.mount_file, self.statvfs)
-        self.assertEquals(info["mount-point"], "/")
+        self.assertEqual(info["mount-point"], "/")
 
     def test_get_filesystem_subpath_closest(self):
         self.set_mount_points(["/", "/home"])
         info = get_filesystem_for_path("/home", self.mount_file, self.statvfs)
-        self.assertEquals(info["mount-point"], "/home")
+        self.assertEqual(info["mount-point"], "/home")
 
     def test_get_filesystem_subpath_not_stupid(self):
         self.set_mount_points(["/", "/ho"])
         info = get_filesystem_for_path("/home", self.mount_file, self.statvfs)
-        self.assertEquals(info["mount-point"], "/")
+        self.assertEqual(info["mount-point"], "/")
 
     def test_symlink_home(self):
         symlink_path = self.makeFile()
@@ -68,7 +68,7 @@
         self.set_mount_points(["/", "/foo"])
         info = get_filesystem_for_path(symlink_path,
                                        self.mount_file, self.statvfs)
-        self.assertEquals(info["mount-point"], "/foo")
+        self.assertEqual(info["mount-point"], "/foo")
 
     def test_whitelist(self):
         self.set_mount_points(["/"])

=== modified file 'landscape/lib/tests/test_fd.py'
--- landscape/lib/tests/test_fd.py	2009-04-01 16:05:35 +0000
+++ landscape/lib/tests/test_fd.py	2011-07-06 21:14:28 +0000
@@ -9,7 +9,7 @@
 
 class CleanFDsTests(LandscapeTest):
     """Tests for L{clean_fds}."""
-    
+
     def mock_rlimit(self, limit):
         getrlimit_mock = self.mocker.replace("resource.getrlimit")
         getrlimit_mock(resource.RLIMIT_NOFILE)
@@ -42,7 +42,7 @@
         self.mocker.count(4093)
         self.mocker.replay()
         clean_fds()
-        self.assertEquals(closed_fds, range(3, 4096))
+        self.assertEqual(closed_fds, range(3, 4096))
 
     def test_ignore_OSErrors(self):
         """
@@ -53,6 +53,7 @@
         self.mock_rlimit(10)
 
         closed_fds = []
+
         def remember_and_throw(fd):
             closed_fds.append(fd)
             raise OSError("Bad FD!")
@@ -64,7 +65,7 @@
 
         self.mocker.replay()
         clean_fds()
-        self.assertEquals(closed_fds, range(3, 10))
+        self.assertEqual(closed_fds, range(3, 10))
 
     def test_dont_ignore_other_errors(self):
         """

=== modified file 'landscape/lib/tests/test_fetch.py'
--- landscape/lib/tests/test_fetch.py	2011-01-20 19:25:15 +0000
+++ landscape/lib/tests/test_fetch.py	2011-07-06 21:14:28 +0000
@@ -84,113 +84,113 @@
     def test_basic(self):
         curl = CurlStub("result")
         result = fetch("http://example.com", curl=curl)
-        self.assertEquals(result, "result")
-        self.assertEquals(curl.options,
-                          {pycurl.URL: "http://example.com",
-                           pycurl.FOLLOWLOCATION: True,
-                           pycurl.MAXREDIRS: 5,
-                           pycurl.CONNECTTIMEOUT: 30,
-                           pycurl.LOW_SPEED_LIMIT: 1,
-                           pycurl.LOW_SPEED_TIME: 600,
-                           pycurl.NOSIGNAL: 1,
-                           pycurl.WRITEFUNCTION: Any(),
-                           pycurl.DNS_CACHE_TIMEOUT: 0,
-                           pycurl.ENCODING: "gzip,deflate"})
+        self.assertEqual(result, "result")
+        self.assertEqual(curl.options,
+                         {pycurl.URL: "http://example.com",
+                          pycurl.FOLLOWLOCATION: True,
+                          pycurl.MAXREDIRS: 5,
+                          pycurl.CONNECTTIMEOUT: 30,
+                          pycurl.LOW_SPEED_LIMIT: 1,
+                          pycurl.LOW_SPEED_TIME: 600,
+                          pycurl.NOSIGNAL: 1,
+                          pycurl.WRITEFUNCTION: Any(),
+                          pycurl.DNS_CACHE_TIMEOUT: 0,
+                          pycurl.ENCODING: "gzip,deflate"})
 
     def test_post(self):
         curl = CurlStub("result")
         result = fetch("http://example.com", post=True, curl=curl)
-        self.assertEquals(result, "result")
-        self.assertEquals(curl.options,
-                          {pycurl.URL: "http://example.com",
-                           pycurl.FOLLOWLOCATION: True,
-                           pycurl.MAXREDIRS: 5,
-                           pycurl.CONNECTTIMEOUT: 30,
-                           pycurl.LOW_SPEED_LIMIT: 1,
-                           pycurl.LOW_SPEED_TIME: 600,
-                           pycurl.NOSIGNAL: 1,
-                           pycurl.WRITEFUNCTION: Any(),
-                           pycurl.POST: True,
-                           pycurl.DNS_CACHE_TIMEOUT: 0,
-                           pycurl.ENCODING: "gzip,deflate"})
+        self.assertEqual(result, "result")
+        self.assertEqual(curl.options,
+                         {pycurl.URL: "http://example.com",
+                          pycurl.FOLLOWLOCATION: True,
+                          pycurl.MAXREDIRS: 5,
+                          pycurl.CONNECTTIMEOUT: 30,
+                          pycurl.LOW_SPEED_LIMIT: 1,
+                          pycurl.LOW_SPEED_TIME: 600,
+                          pycurl.NOSIGNAL: 1,
+                          pycurl.WRITEFUNCTION: Any(),
+                          pycurl.POST: True,
+                          pycurl.DNS_CACHE_TIMEOUT: 0,
+                          pycurl.ENCODING: "gzip,deflate"})
 
     def test_post_data(self):
         curl = CurlStub("result")
         result = fetch("http://example.com", post=True, data="data", curl=curl)
-        self.assertEquals(result, "result")
-        self.assertEquals(curl.options[pycurl.READFUNCTION](), "data")
-        self.assertEquals(curl.options,
-                          {pycurl.URL: "http://example.com",
-                           pycurl.FOLLOWLOCATION: True,
-                           pycurl.MAXREDIRS: 5,
-                           pycurl.CONNECTTIMEOUT: 30,
-                           pycurl.LOW_SPEED_LIMIT: 1,
-                           pycurl.LOW_SPEED_TIME: 600,
-                           pycurl.NOSIGNAL: 1,
-                           pycurl.WRITEFUNCTION: Any(),
-                           pycurl.POST: True,
-                           pycurl.POSTFIELDSIZE: 4,
-                           pycurl.READFUNCTION: Any(),
-                           pycurl.DNS_CACHE_TIMEOUT: 0,
-                           pycurl.ENCODING: "gzip,deflate"})
+        self.assertEqual(result, "result")
+        self.assertEqual(curl.options[pycurl.READFUNCTION](), "data")
+        self.assertEqual(curl.options,
+                         {pycurl.URL: "http://example.com",
+                          pycurl.FOLLOWLOCATION: True,
+                          pycurl.MAXREDIRS: 5,
+                          pycurl.CONNECTTIMEOUT: 30,
+                          pycurl.LOW_SPEED_LIMIT: 1,
+                          pycurl.LOW_SPEED_TIME: 600,
+                          pycurl.NOSIGNAL: 1,
+                          pycurl.WRITEFUNCTION: Any(),
+                          pycurl.POST: True,
+                          pycurl.POSTFIELDSIZE: 4,
+                          pycurl.READFUNCTION: Any(),
+                          pycurl.DNS_CACHE_TIMEOUT: 0,
+                          pycurl.ENCODING: "gzip,deflate"})
 
     def test_cainfo(self):
         curl = CurlStub("result")
         result = fetch("https://example.com", cainfo="cainfo", curl=curl)
-        self.assertEquals(result, "result")
-        self.assertEquals(curl.options,
-                          {pycurl.URL: "https://example.com",
-                           pycurl.FOLLOWLOCATION: True,
-                           pycurl.MAXREDIRS: 5,
-                           pycurl.CONNECTTIMEOUT: 30,
-                           pycurl.LOW_SPEED_LIMIT: 1,
-                           pycurl.LOW_SPEED_TIME: 600,
-                           pycurl.NOSIGNAL: 1,
-                           pycurl.WRITEFUNCTION: Any(),
-                           pycurl.CAINFO: "cainfo",
-                           pycurl.DNS_CACHE_TIMEOUT: 0,
-                           pycurl.ENCODING: "gzip,deflate"})
+        self.assertEqual(result, "result")
+        self.assertEqual(curl.options,
+                         {pycurl.URL: "https://example.com",
+                          pycurl.FOLLOWLOCATION: True,
+                          pycurl.MAXREDIRS: 5,
+                          pycurl.CONNECTTIMEOUT: 30,
+                          pycurl.LOW_SPEED_LIMIT: 1,
+                          pycurl.LOW_SPEED_TIME: 600,
+                          pycurl.NOSIGNAL: 1,
+                          pycurl.WRITEFUNCTION: Any(),
+                          pycurl.CAINFO: "cainfo",
+                          pycurl.DNS_CACHE_TIMEOUT: 0,
+                          pycurl.ENCODING: "gzip,deflate"})
 
     def test_cainfo_on_http(self):
         curl = CurlStub("result")
         result = fetch("http://example.com", cainfo="cainfo", curl=curl)
-        self.assertEquals(result, "result")
+        self.assertEqual(result, "result")
         self.assertTrue(pycurl.CAINFO not in curl.options)
 
     def test_headers(self):
         curl = CurlStub("result")
         result = fetch("http://example.com",
                        headers={"a": "1", "b": "2"}, curl=curl)
-        self.assertEquals(result, "result")
-        self.assertEquals(curl.options,
-                          {pycurl.URL: "http://example.com",
-                           pycurl.FOLLOWLOCATION: True,
-                           pycurl.MAXREDIRS: 5,
-                           pycurl.CONNECTTIMEOUT: 30,
-                           pycurl.LOW_SPEED_LIMIT: 1,
-                           pycurl.LOW_SPEED_TIME: 600,
-                           pycurl.NOSIGNAL: 1,
-                           pycurl.WRITEFUNCTION: Any(),
-                           pycurl.HTTPHEADER: ["a: 1", "b: 2"],
-                           pycurl.DNS_CACHE_TIMEOUT: 0,
-                           pycurl.ENCODING: "gzip,deflate"})
+        self.assertEqual(result, "result")
+        self.assertEqual(curl.options,
+                         {pycurl.URL: "http://example.com",
+                          pycurl.FOLLOWLOCATION: True,
+                          pycurl.MAXREDIRS: 5,
+                          pycurl.CONNECTTIMEOUT: 30,
+                          pycurl.LOW_SPEED_LIMIT: 1,
+                          pycurl.LOW_SPEED_TIME: 600,
+                          pycurl.NOSIGNAL: 1,
+                          pycurl.WRITEFUNCTION: Any(),
+                          pycurl.HTTPHEADER: ["a: 1", "b: 2"],
+                          pycurl.DNS_CACHE_TIMEOUT: 0,
+                          pycurl.ENCODING: "gzip,deflate"})
 
     def test_timeouts(self):
         curl = CurlStub("result")
         result = fetch("http://example.com", connect_timeout=5,
                        total_timeout=30, curl=curl)
-        self.assertEquals(result, "result")
-        self.assertEquals(curl.options,
-                          {pycurl.URL: "http://example.com",
-                           pycurl.FOLLOWLOCATION: True,
-                           pycurl.MAXREDIRS: 5,
-                           pycurl.CONNECTTIMEOUT: 5,
-                           pycurl.LOW_SPEED_LIMIT: 1,
-                           pycurl.LOW_SPEED_TIME: 30,
-                           pycurl.NOSIGNAL: 1,
-                           pycurl.WRITEFUNCTION: Any(),
-                           pycurl.DNS_CACHE_TIMEOUT: 0,
-                           pycurl.ENCODING: "gzip,deflate"})
+        self.assertEqual(result, "result")
+        self.assertEqual(curl.options,
+                         {pycurl.URL: "http://example.com",
+                          pycurl.FOLLOWLOCATION: True,
+                          pycurl.MAXREDIRS: 5,
+                          pycurl.CONNECTTIMEOUT: 5,
+                          pycurl.LOW_SPEED_LIMIT: 1,
+                          pycurl.LOW_SPEED_TIME: 30,
+                          pycurl.NOSIGNAL: 1,
+                          pycurl.WRITEFUNCTION: Any(),
+                          pycurl.DNS_CACHE_TIMEOUT: 0,
+                          pycurl.ENCODING: "gzip,deflate"})
 
     def test_unicode(self):
         """
@@ -199,8 +199,8 @@
         """
         curl = CurlStub("result")
         result = fetch(u"http://example.com", curl=curl)
-        self.assertEquals(result, "result")
-        self.assertEquals(curl.options[pycurl.URL], "http://example.com")
+        self.assertEqual(result, "result")
+        self.assertEqual(curl.options[pycurl.URL], "http://example.com")
         self.assertTrue(isinstance(curl.options[pycurl.URL], str))
 
     def test_non_200_result(self):
@@ -208,36 +208,36 @@
         try:
             fetch("http://example.com", curl=curl)
         except HTTPCodeError, error:
-            self.assertEquals(error.http_code, 404)
-            self.assertEquals(error.body, "result")
+            self.assertEqual(error.http_code, 404)
+            self.assertEqual(error.body, "result")
         else:
             self.fail("HTTPCodeError not raised")
 
     def test_http_error_str(self):
-        self.assertEquals(str(HTTPCodeError(501, "")),
-                          "Server returned HTTP code 501")
+        self.assertEqual(str(HTTPCodeError(501, "")),
+                         "Server returned HTTP code 501")
 
     def test_http_error_repr(self):
-        self.assertEquals(repr(HTTPCodeError(501, "")),
-                          "<HTTPCodeError http_code=501>")
+        self.assertEqual(repr(HTTPCodeError(501, "")),
+                         "<HTTPCodeError http_code=501>")
 
     def test_pycurl_error(self):
         curl = CurlStub(error=pycurl.error(60, "pycurl error"))
         try:
             fetch("http://example.com", curl=curl)
         except PyCurlError, error:
-            self.assertEquals(error.error_code, 60)
-            self.assertEquals(error.message, "pycurl error")
+            self.assertEqual(error.error_code, 60)
+            self.assertEqual(error.message, "pycurl error")
         else:
             self.fail("PyCurlError not raised")
 
     def test_pycurl_error_str(self):
-        self.assertEquals(str(PyCurlError(60, "pycurl error")),
-                          "Error 60: pycurl error")
+        self.assertEqual(str(PyCurlError(60, "pycurl error")),
+                         "Error 60: pycurl error")
 
     def test_pycurl_error_repr(self):
-        self.assertEquals(repr(PyCurlError(60, "pycurl error")),
-                          "<PyCurlError args=(60, 'pycurl error')>")
+        self.assertEqual(repr(PyCurlError(60, "pycurl error")),
+                         "<PyCurlError args=(60, 'pycurl error')>")
 
     def test_create_curl(self):
         curls = []
@@ -251,34 +251,36 @@
             pycurl.Curl = pycurl_Curl
             result = fetch("http://example.com")
             curl = curls[0]
-            self.assertEquals(result, "result")
-            self.assertEquals(curl.options,
-                              {pycurl.URL: "http://example.com",
-                               pycurl.FOLLOWLOCATION: True,
-                               pycurl.MAXREDIRS: 5,
-                               pycurl.CONNECTTIMEOUT: 30,
-                               pycurl.LOW_SPEED_LIMIT: 1,
-                               pycurl.LOW_SPEED_TIME: 600,
-                               pycurl.NOSIGNAL: 1,
-                               pycurl.WRITEFUNCTION: Any(),
-                               pycurl.DNS_CACHE_TIMEOUT: 0,
-                               pycurl.ENCODING: "gzip,deflate"})
+            self.assertEqual(result, "result")
+            self.assertEqual(curl.options,
+                             {pycurl.URL: "http://example.com",
+                              pycurl.FOLLOWLOCATION: True,
+                              pycurl.MAXREDIRS: 5,
+                              pycurl.CONNECTTIMEOUT: 30,
+                              pycurl.LOW_SPEED_LIMIT: 1,
+                              pycurl.LOW_SPEED_TIME: 600,
+                              pycurl.NOSIGNAL: 1,
+                              pycurl.WRITEFUNCTION: Any(),
+                              pycurl.DNS_CACHE_TIMEOUT: 0,
+                              pycurl.ENCODING: "gzip,deflate"})
         finally:
             pycurl.Curl = Curl
 
     def test_async_fetch(self):
         curl = CurlStub("result")
         d = fetch_async("http://example.com/", curl=curl)
+
         def got_result(result):
-            self.assertEquals(result, "result")
+            self.assertEqual(result, "result")
         return d.addCallback(got_result)
 
     def test_async_fetch_with_error(self):
         curl = CurlStub("result", {pycurl.HTTP_CODE: 501})
         d = fetch_async("http://example.com/", curl=curl)
+
         def got_error(failure):
-            self.assertEquals(failure.value.http_code, 501)
-            self.assertEquals(failure.value.body, "result")
+            self.assertEqual(failure.value.http_code, 501)
+            self.assertEqual(failure.value.body, "result")
             return failure
         d.addErrback(got_error)
         self.assertFailure(d, HTTPCodeError)
@@ -306,7 +308,7 @@
                              errback=errback, curl=curl)
 
         def completed(result):
-            self.assertEquals(url_results, {})
+            self.assertEqual(url_results, {})
 
         return d.addCallback(completed)
 
@@ -321,8 +323,8 @@
 
         def errback(failure, url):
             failed_urls.append(url)
-            self.assertEquals(failure.value.body, "wrong")
-            self.assertEquals(failure.value.http_code, 501)
+            self.assertEqual(failure.value.body, "wrong")
+            self.assertEqual(failure.value.http_code, 501)
             return failure
 
         curl = CurlManyStub(url_results)
@@ -332,7 +334,7 @@
         def check_failure(failure):
             self.assertTrue(isinstance(failure.subFailure.value,
                                        HTTPCodeError))
-            self.assertEquals(failed_urls, ["http://wrong/"])
+            self.assertEqual(failed_urls, ["http://wrong/"])
 
         self.assertFailure(result, FirstError)
         return result.addCallback(check_failure)
@@ -342,10 +344,10 @@
         L{url_to_filename} extracts the filename part of an URL, optionally
         prepending a directory path to it.
         """
-        self.assertEquals(url_to_filename("http://some/file"), "file")
-        self.assertEquals(url_to_filename("http://some/file/"), "file")
-        self.assertEquals(url_to_filename("http://some/file", directory="dir"),
-                          os.path.join("dir", "file"))
+        self.assertEqual(url_to_filename("http://some/file"), "file")
+        self.assertEqual(url_to_filename("http://some/file/"), "file")
+        self.assertEqual(url_to_filename("http://some/file", directory="dir"),
+                         os.path.join("dir", "file"))
 
     def test_fetch_to_files(self):
         """
@@ -362,7 +364,7 @@
         def check_files(ignored):
             for result in url_results.itervalues():
                 fd = open(os.path.join(directory, result))
-                self.assertEquals(fd.read(), result)
+                self.assertEqual(fd.read(), result)
                 fd.close()
 
         result.addCallback(check_files)
@@ -401,14 +403,14 @@
                                 curl=curl)
 
         def check_messages(failure):
-            self.assertEquals(len(messages), 1)
-            self.assertEquals(messages[0],
-                              "Couldn't fetch file from http://im/wrong "
-                              "(Server returned HTTP code 404)")
+            self.assertEqual(len(messages), 1)
+            self.assertEqual(messages[0],
+                             "Couldn't fetch file from http://im/wrong "
+                             "(Server returned HTTP code 404)")
             messages.pop()
 
         def check_files(ignored):
-            self.assertEquals(messages, [])
+            self.assertEqual(messages, [])
             self.assertFalse(os.path.exists(os.path.join(directory, "wrong")))
 
         result.addErrback(check_messages)
@@ -428,7 +430,7 @@
 
         def check_error(failure):
             error = str(failure.value.subFailure.value)
-            self.assertEquals(error, "[Errno 2] No such file or directory: "
+            self.assertEqual(error, "[Errno 2] No such file or directory: "
                               "'i/dont/exist/right'")
             self.assertFalse(os.path.exists(os.path.join(directory, "right")))
 

=== modified file 'landscape/lib/tests/test_fs.py'
--- landscape/lib/tests/test_fs.py	2010-04-01 08:28:22 +0000
+++ landscape/lib/tests/test_fs.py	2011-07-06 21:14:28 +0000
@@ -10,7 +10,7 @@
         With no options L{read_file} reads the whole file passed as argument.
         """
         path = self.makeFile("foo")
-        self.assertEquals(read_file(path), "foo")
+        self.assertEqual(read_file(path), "foo")
 
     def test_read_file_with_limit(self):
         """
@@ -18,14 +18,14 @@
         given limit.
         """
         path = self.makeFile("foo bar")
-        self.assertEquals(read_file(path, limit=3), " bar")
+        self.assertEqual(read_file(path, limit=3), " bar")
 
     def test_read_file_with_negative_limit(self):
         """
         With a negative limit L{read_file} reads only the tail of the file.
         """
         path = self.makeFile("foo bar from end")
-        self.assertEquals(read_file(path, limit=-3), "end")
+        self.assertEqual(read_file(path, limit=-3), "end")
 
     def test_read_file_with_limit_bigger_than_file(self):
         """
@@ -33,8 +33,8 @@
         file.
         """
         path = self.makeFile("foo bar from end")
-        self.assertEquals(read_file(path, limit=100), "foo bar from end")
-        self.assertEquals(read_file(path, limit=-100), "foo bar from end")
+        self.assertEqual(read_file(path, limit=100), "foo bar from end")
+        self.assertEqual(read_file(path, limit=-100), "foo bar from end")
 
 
 class TouchFileTest(LandscapeTest):

=== modified file 'landscape/lib/tests/test_gpg.py'
--- landscape/lib/tests/test_gpg.py	2009-10-27 09:33:45 +0000
+++ landscape/lib/tests/test_gpg.py	2011-07-06 21:14:28 +0000
@@ -32,7 +32,8 @@
             result = gpg_verify("/some/file", "/some/signature", gpg=gpg)
 
             def check_result(ignored):
-                self.assertEquals(open(gpg_options).read(),
+                self.assertEqual(
+                    open(gpg_options).read(),
                     "--no-options --homedir %s --no-default-keyring "
                     "--ignore-time-conflict --keyring /etc/apt/trusted.gpg "
                     "--verify /some/signature /some/file" % gpg_home)
@@ -64,9 +65,9 @@
             result = gpg_verify("/some/file", "/some/signature", gpg=gpg)
 
             def check_failure(failure):
-                self.assertEquals(str(failure.value),
-                                  "%s failed (out='out\n', err='err\n', "
-                                  "code='1')" % gpg)
+                self.assertEqual(str(failure.value),
+                                 "%s failed (out='out\n', err='err\n', "
+                                 "code='1')" % gpg)
                 self.assertFalse(os.path.exists(gpg_home))
 
             result.addCallback(self.fail)

=== modified file 'landscape/lib/tests/test_lsb_release.py'
--- landscape/lib/tests/test_lsb_release.py	2009-10-09 10:01:02 +0000
+++ landscape/lib/tests/test_lsb_release.py	2011-07-06 21:14:28 +0000
@@ -16,11 +16,11 @@
                                              "DISTRIB_DESCRIPTION="
                                              "\"Ubuntu 6.06.1 LTS\"\n")
 
-        self.assertEquals(parse_lsb_release(lsb_release_filename),
-                          {"distributor-id": "Ubuntu",
-                           "description": "Ubuntu 6.06.1 LTS",
-                           "release": "6.06",
-                           "code-name": "dapper"})
+        self.assertEqual(parse_lsb_release(lsb_release_filename),
+                         {"distributor-id": "Ubuntu",
+                          "description": "Ubuntu 6.06.1 LTS",
+                          "release": "6.06",
+                          "code-name": "dapper"})
 
     def test_parse_lsb_release_with_missing_or_extra_fields(self):
         """
@@ -29,5 +29,5 @@
         """
         lsb_release_filename = self.makeFile("DISTRIB_ID=Ubuntu\n"
                                              "FOO=Bar\n")
-        self.assertEquals(parse_lsb_release(lsb_release_filename),
-                          {"distributor-id": "Ubuntu"})
+        self.assertEqual(parse_lsb_release(lsb_release_filename),
+                         {"distributor-id": "Ubuntu"})

=== modified file 'landscape/lib/tests/test_monitor.py'
--- landscape/lib/tests/test_monitor.py	2008-06-10 10:56:01 +0000
+++ landscape/lib/tests/test_monitor.py	2011-07-06 21:14:28 +0000
@@ -17,24 +17,24 @@
         self.timer = Timer(create_time=self.reactor.time)
 
     def test_since_start(self):
-        self.assertEquals(self.timer.since_start(), 0.0)
+        self.assertEqual(self.timer.since_start(), 0.0)
 
         self.reactor.advance(1)
-        self.assertEquals(self.timer.since_start(), 1.0)
+        self.assertEqual(self.timer.since_start(), 1.0)
 
         self.reactor.advance(2)
-        self.assertEquals(self.timer.since_start(), 3.0)
+        self.assertEqual(self.timer.since_start(), 3.0)
 
     def test_since_reset(self):
         self.reactor.advance(1)
-        self.assertEquals(self.timer.since_reset(), 1.0)
+        self.assertEqual(self.timer.since_reset(), 1.0)
 
         self.reactor.advance(1)
-        self.assertEquals(self.timer.since_start(), 2.0)
+        self.assertEqual(self.timer.since_start(), 2.0)
 
         self.reactor.advance(2)
         self.timer.reset()
-        self.assertEquals(self.timer.since_start(), 4.0)
+        self.assertEqual(self.timer.since_start(), 4.0)
 
 
 class MonitorTest(ReactorHavingTest):
@@ -44,25 +44,25 @@
         self.monitor = Monitor("test", create_time=self.reactor.time)
 
     def test_ping(self):
-        self.assertEquals(self.monitor.count, 0)
-        self.assertEquals(self.monitor.total_count, 0)
+        self.assertEqual(self.monitor.count, 0)
+        self.assertEqual(self.monitor.total_count, 0)
 
         self.monitor.ping()
-        self.assertEquals(self.monitor.count, 1)
-        self.assertEquals(self.monitor.total_count, 1)
+        self.assertEqual(self.monitor.count, 1)
+        self.assertEqual(self.monitor.total_count, 1)
 
     def test_reset(self):
-        self.assertEquals(self.monitor.count, 0)
+        self.assertEqual(self.monitor.count, 0)
 
         self.monitor.ping()
         self.monitor.ping()
-        self.assertEquals(self.monitor.count, 2)
-        self.assertEquals(self.monitor.total_count, 2)
+        self.assertEqual(self.monitor.count, 2)
+        self.assertEqual(self.monitor.total_count, 2)
 
         self.monitor.reset()
         self.monitor.ping()
-        self.assertEquals(self.monitor.count, 1)
-        self.assertEquals(self.monitor.total_count, 3)
+        self.assertEqual(self.monitor.count, 1)
+        self.assertEqual(self.monitor.total_count, 3)
 
     def test_log(self):
         for i in range(100):
@@ -169,39 +169,39 @@
         If no time has passed and the monitor hasn't received any
         pings it should return 100%.
         """
-        self.assertEquals(self.monitor.percent, 1.0)
+        self.assertEqual(self.monitor.percent, 1.0)
 
     def test_percent(self):
         self.reactor.advance(1)
-        self.assertEquals(self.monitor.percent, 0.0)
+        self.assertEqual(self.monitor.percent, 0.0)
 
         self.monitor.ping()
         self.reactor.advance(1)
-        self.assertEquals(self.monitor.percent, 0.5)
+        self.assertEqual(self.monitor.percent, 0.5)
 
     def test_percent_reset(self):
         self.reactor.advance(1)
-        self.assertEquals(self.monitor.percent, 0.0)
+        self.assertEqual(self.monitor.percent, 0.0)
 
         self.monitor.reset()
         self.monitor.ping()
         self.reactor.advance(1)
-        self.assertEquals(self.monitor.percent, 1.0)
+        self.assertEqual(self.monitor.percent, 1.0)
 
     def test_expected_count(self):
         self.reactor.advance(1)
-        self.assertEquals(self.monitor.expected_count, 1.0)
+        self.assertEqual(self.monitor.expected_count, 1.0)
 
         self.reactor.advance(1)
-        self.assertEquals(self.monitor.expected_count, 2.0)
+        self.assertEqual(self.monitor.expected_count, 2.0)
 
     def test_expected_count_reset(self):
         self.reactor.advance(1)
-        self.assertEquals(self.monitor.expected_count, 1.0)
+        self.assertEqual(self.monitor.expected_count, 1.0)
 
         self.monitor.reset()
         self.reactor.advance(1)
-        self.assertEquals(self.monitor.expected_count, 1.0)
+        self.assertEqual(self.monitor.expected_count, 1.0)
 
     def test_log(self):
         for i in range(100):
@@ -229,13 +229,13 @@
                                         create_time=self.reactor.time)
 
     def test_expected_count(self):
-        self.assertEquals(self.monitor.expected_count, 0)
+        self.assertEqual(self.monitor.expected_count, 0)
 
         self.reactor.advance(99)
-        self.assertEquals(self.monitor.expected_count, 0)
+        self.assertEqual(self.monitor.expected_count, 0)
 
         self.reactor.advance(1)
-        self.assertEquals(self.monitor.expected_count, 1)
+        self.assertEqual(self.monitor.expected_count, 1)
 
     def test_ping(self):
         self.assertFalse(self.monitor.warn())

=== modified file 'landscape/lib/tests/test_persist.py'
--- landscape/lib/tests/test_persist.py	2009-11-06 13:41:30 +0000
+++ landscape/lib/tests/test_persist.py	2011-07-06 21:14:28 +0000
@@ -22,14 +22,14 @@
 
     def test_path_string_to_tuple(self):
         for path_string, path_tuple in self.paths:
-            self.assertEquals(path_string_to_tuple(path_string), path_tuple)
+            self.assertEqual(path_string_to_tuple(path_string), path_tuple)
 
     def test_path_string_to_tuple_error(self):
         self.assertRaises(PersistError, path_string_to_tuple, "ab[0][c]")
 
     def test_path_tuple_to_string(self):
         for path_string, path_tuple in self.paths:
-            self.assertEquals(path_tuple_to_string(path_tuple), path_string)
+            self.assertEqual(path_tuple_to_string(path_tuple), path_string)
 
 
 class BasePersistTest(LandscapeTest):
@@ -125,60 +125,60 @@
         for path, value in self.set_items:
             self.persist.set(path, value)
         result = self.persist.get((), hard=True)
-        self.assertEquals(result, self.set_result,
-                          self.format(result, self.set_result))
+        self.assertEqual(result, self.set_result,
+                         self.format(result, self.set_result))
 
     def test_set_tuple_paths(self):
         for path, value in self.set_items:
             self.persist.set(path_string_to_tuple(path), value)
         result = self.persist.get((), hard=True)
-        self.assertEquals(result, self.set_result,
-                          self.format(result, self.set_result))
+        self.assertEqual(result, self.set_result,
+                         self.format(result, self.set_result))
 
     def test_set_from_result(self):
         for path in self.set_result:
             self.persist.set(path, self.set_result[path])
         result = self.persist.get((), hard=True)
-        self.assertEquals(result, self.set_result,
-                          self.format(result, self.set_result))
+        self.assertEqual(result, self.set_result,
+                         self.format(result, self.set_result))
 
     def test_get(self):
         for path in self.set_result:
             self.persist.set(path, self.set_result[path])
         for path, value in self.get_items:
-            self.assertEquals(self.persist.get(path), value)
+            self.assertEqual(self.persist.get(path), value)
 
     def test_get_tuple_paths(self):
         for path in self.set_result:
             self.persist.set(path_string_to_tuple(path), self.set_result[path])
         for path, value in self.get_items:
-            self.assertEquals(self.persist.get(path), value)
+            self.assertEqual(self.persist.get(path), value)
 
     def test_add(self):
         for path, value in self.add_items:
             self.persist.add(path, value)
         result = self.persist.get((), hard=True)
-        self.assertEquals(result, self.add_result,
-                          self.format(result, self.add_result))
+        self.assertEqual(result, self.add_result,
+                         self.format(result, self.add_result))
 
     def test_add_unique(self):
         self.persist.add("a", "b")
-        self.assertEquals(self.persist.get("a"), ["b"])
+        self.assertEqual(self.persist.get("a"), ["b"])
         self.persist.add("a", "b")
-        self.assertEquals(self.persist.get("a"), ["b", "b"])
+        self.assertEqual(self.persist.get("a"), ["b", "b"])
         self.persist.add("a", "b", unique=True)
-        self.assertEquals(self.persist.get("a"), ["b", "b"])
+        self.assertEqual(self.persist.get("a"), ["b", "b"])
         self.persist.add("a", "c", unique=True)
-        self.assertEquals(self.persist.get("a"), ["b", "b", "c"])
+        self.assertEqual(self.persist.get("a"), ["b", "b", "c"])
 
     def test_keys(self):
         self.persist.set("a", {"b": 1, "c": {"d": 2}, "e": list("foo")})
         keys = self.persist.keys
-        self.assertEquals(set(keys((), hard=True)), set(["a"]))
-        self.assertEquals(set(keys("a")), set(["b", "c", "e"]))
-        self.assertEquals(set(keys("a.d")), set([]))
-        self.assertEquals(set(keys("a.e")), set([0, 1, 2]))
-        self.assertEquals(set(keys("a.f")), set([]))
+        self.assertEqual(set(keys((), hard=True)), set(["a"]))
+        self.assertEqual(set(keys("a")), set(["b", "c", "e"]))
+        self.assertEqual(set(keys("a.d")), set([]))
+        self.assertEqual(set(keys("a.e")), set([0, 1, 2]))
+        self.assertEqual(set(keys("a.f")), set([]))
         self.assertRaises(PersistError, keys, "a.b")
 
     def test_has(self):
@@ -211,19 +211,19 @@
         self.assertRaises(PersistError, remove, "a.c.d.e")
 
         self.assertTrue(remove(("a", "e", "o")))
-        self.assertEquals(get("a.e"), ["f", "t"])
+        self.assertEqual(get("a.e"), ["f", "t"])
 
         self.assertFalse(remove("a.e[2]"))
-        self.assertEquals(get("a.e"), ["f", "t"])
+        self.assertEqual(get("a.e"), ["f", "t"])
 
         self.assertTrue(remove("a.e[1]"))
-        self.assertEquals(get("a.e"), ["f"])
+        self.assertEqual(get("a.e"), ["f"])
 
         self.assertTrue(remove("a.e", "f"))
         self.assertFalse(has("a.e"))
 
         self.assertFalse(remove("a.b[1]"))
-        self.assertEquals(get("a.b"), [1])
+        self.assertEqual(get("a.b"), [1])
 
         self.assertTrue(remove("a.b", 1))
         self.assertFalse(has("a.b"))
@@ -240,43 +240,43 @@
         get = self.persist.get
 
         self.assertTrue(move("a.b", "a.c.b"))
-        self.assertEquals(get("a"), {"c": {"b": [1], "d": 2}})
+        self.assertEqual(get("a"), {"c": {"b": [1], "d": 2}})
 
         self.assertTrue(move("a.c.b[0]", "a.c.b"))
-        self.assertEquals(get("a"), {"c": {"b": 1, "d": 2}})
+        self.assertEqual(get("a"), {"c": {"b": 1, "d": 2}})
 
         self.assertTrue(move(("a", "c", "b"), ("a", "c", "b", 0)))
-        self.assertEquals(get("a"), {"c": {"b": [1], "d": 2}})
+        self.assertEqual(get("a"), {"c": {"b": [1], "d": 2}})
 
     def test_copy_values_on_set(self):
         d = {"b": 1}
         d_orig = d.copy()
         self.persist.set("a", d)
         d["c"] = 2
-        self.assertEquals(self.persist.get("a"), d_orig)
+        self.assertEqual(self.persist.get("a"), d_orig)
 
     def test_copy_values_on_add(self):
         d = {"b": 1}
         d_orig = d.copy()
         self.persist.add("a", d)
         d["c"] = 2
-        self.assertEquals(self.persist.get("a[0]"), d_orig)
+        self.assertEqual(self.persist.get("a[0]"), d_orig)
 
     def test_copy_values_on_get(self):
         self.persist.set("a", {"b": 1})
         d = self.persist.get("a")
         d_orig = d.copy()
         d["c"] = 2
-        self.assertEquals(self.persist.get("a"), d_orig)
+        self.assertEqual(self.persist.get("a"), d_orig)
 
     def test_root_at(self):
         rooted = self.persist.root_at("my-module")
         rooted.set("option", 1)
-        self.assertEquals(self.persist.get("my-module.option"), 1)
+        self.assertEqual(self.persist.get("my-module.option"), 1)
 
 
 class SaveLoadPersistTest(BasePersistTest):
-        
+
     def test_readonly(self):
         self.assertFalse(self.persist.readonly)
         self.persist.readonly = True
@@ -331,8 +331,8 @@
         persist.load(filename)
 
         result = persist.get((), hard=True)
-        self.assertEquals(result, self.set_result,
-                          self.format(result, self.set_result))
+        self.assertEqual(result, self.set_result,
+                         self.format(result, self.set_result))
 
     def test_save_on_unexistent_dir(self):
         dirname = self.makeFile()
@@ -379,7 +379,7 @@
         persist.save()
 
         persist = self.build_persist(filename=filename)
-        self.assertEquals(persist.get("foo"), "bar")
+        self.assertEqual(persist.get("foo"), "bar")
 
     def test_load_restores_backup(self):
         filename = self.makePersistFile("foobar")
@@ -391,7 +391,7 @@
         persist = self.build_persist()
         persist.load(filename)
 
-        self.assertEquals(persist.get("a"), 1)
+        self.assertEqual(persist.get("a"), 1)
 
     def test_load_empty_files_wont_break(self):
         filename = self.makeFile("")

=== modified file 'landscape/lib/tests/test_process.py'
--- landscape/lib/tests/test_process.py	2010-02-08 15:27:19 +0000
+++ landscape/lib/tests/test_process.py	2011-07-06 21:14:28 +0000
@@ -11,7 +11,7 @@
         """
         We use os.listdir("/proc") to get the list of active processes, if a
         process ends before we attempt to read the process' information, then
-        this should not trigger an error. 
+        this should not trigger an error.
         """
         listdir_mock = self.mocker.replace("os.listdir")
         listdir_mock("/proc")
@@ -48,7 +48,7 @@
 
         process_info = ProcessInformation("/proc")
         processes = list(process_info.get_all_process_info())
-        self.assertEquals(processes, [])
+        self.assertEqual(processes, [])
         self.assertTrue(fakefile1.closed)
         self.assertTrue(fakefile2.closed)
 
@@ -74,7 +74,7 @@
     """
 
     def test_calculate_pcpu_real_data(self):
-        self.assertEquals(
+        self.assertEqual(
             calculate_pcpu(51286, 5000, 19000.07, 9281.0, 100), 3.0)
 
     def test_calculate_pcpu(self):
@@ -84,8 +84,8 @@
 
         This should be cpu utilisation of 20%
         """
-        self.assertEquals(calculate_pcpu(8000, 2000, 1000, 50000, 100),
-                          20.0)
+        self.assertEqual(calculate_pcpu(8000, 2000, 1000, 50000, 100),
+                         20.0)
 
     def test_calculate_pcpu_capped(self):
         """
@@ -95,12 +95,12 @@
         This should be cpu utilisation of 200% but capped at 99% CPU
         utilisation.
         """
-        self.assertEquals(calculate_pcpu(98000, 2000, 1000, 50000, 100),
-                          99.0)
+        self.assertEqual(calculate_pcpu(98000, 2000, 1000, 50000, 100),
+                         99.0)
 
     def test_calculate_pcpu_floored(self):
         """
         This calculates the pcpu based on 1 jiffies allocated to a process
         over 80 jiffies this should be negative, but floored to 0.0.
         """
-        self.assertEquals(calculate_pcpu(1, 0, 50, 800, 10), 0.0)
+        self.assertEqual(calculate_pcpu(1, 0, 50, 800, 10), 0.0)

=== modified file 'landscape/lib/tests/test_scriptcontent.py'
--- landscape/lib/tests/test_scriptcontent.py	2008-09-18 22:09:56 +0000
+++ landscape/lib/tests/test_scriptcontent.py	2011-07-06 21:14:28 +0000
@@ -3,21 +3,22 @@
 from landscape.lib.scriptcontent import (build_script,
     generate_script_hash)
 
+
 class ScriptContentTest(unittest.TestCase):
 
     def test_concatenate(self):
-        self.assertEquals(build_script(u"/bin/sh", u"echo 1.0\n"), 
-                          "#!/bin/sh\necho 1.0\n")
+        self.assertEqual(build_script(u"/bin/sh", u"echo 1.0\n"),
+                         "#!/bin/sh\necho 1.0\n")
 
     def test_concatenate_null_strings(self):
-        self.assertEquals(build_script(None, None), 
-                          "#!\n")
+        self.assertEqual(build_script(None, None),
+                         "#!\n")
 
     def test_generate_script_hash(self):
         hash1 = generate_script_hash("#!/bin/sh\necho 1.0\n")
         hash2 = generate_script_hash("#!/bin/sh\necho 1.0\n")
         hash3 = generate_script_hash("#!/bin/sh\necho 3.0\n")
 
-        self.assertEquals(hash1, hash2)
+        self.assertEqual(hash1, hash2)
         self.assertNotEqual(hash1, hash3)
         self.assertTrue(isinstance(hash1, str))

=== modified file 'landscape/lib/tests/test_sequenceranges.py'
--- landscape/lib/tests/test_sequenceranges.py	2011-01-28 14:06:10 +0000
+++ landscape/lib/tests/test_sequenceranges.py	2011-07-06 21:14:28 +0000
@@ -12,35 +12,35 @@
         self.sequence = [1, 2, 15, 16, 17, 19, 21, 22, 23, 24, 26, 27]
 
     def test_empty_to_sequence(self):
-        self.assertEquals(SequenceRanges().to_sequence(), [])
+        self.assertEqual(SequenceRanges().to_sequence(), [])
 
     def test_empty_to_ranges(self):
-        self.assertEquals(SequenceRanges().to_ranges(), [])
+        self.assertEqual(SequenceRanges().to_ranges(), [])
 
     def test_from_to_sequence(self):
         obj = SequenceRanges.from_sequence(self.sequence)
-        self.assertEquals(obj.to_sequence(), self.sequence)
+        self.assertEqual(obj.to_sequence(), self.sequence)
 
     def test_from_to_ranges(self):
         obj = SequenceRanges.from_ranges(self.ranges)
-        self.assertEquals(obj.to_ranges(), self.ranges)
+        self.assertEqual(obj.to_ranges(), self.ranges)
 
     def test_to_ranges_immutable(self):
         obj = SequenceRanges.from_ranges(self.ranges)
         obj.to_ranges().append(123)
-        self.assertEquals(obj.to_ranges(), self.ranges)
+        self.assertEqual(obj.to_ranges(), self.ranges)
 
     def test_from_sequence_to_ranges(self):
         obj = SequenceRanges.from_sequence(self.sequence)
-        self.assertEquals(list(obj.to_ranges()), self.ranges)
+        self.assertEqual(list(obj.to_ranges()), self.ranges)
 
     def test_from_ranges_to_sequence(self):
         obj = SequenceRanges.from_ranges(self.ranges)
-        self.assertEquals(list(obj.to_sequence()), self.sequence)
+        self.assertEqual(list(obj.to_sequence()), self.sequence)
 
     def test_iter(self):
         obj = SequenceRanges.from_ranges(self.ranges)
-        self.assertEquals(list(obj), self.sequence)
+        self.assertEqual(list(obj), self.sequence)
 
     def test_contains(self):
         obj = SequenceRanges.from_ranges(self.ranges)
@@ -61,44 +61,44 @@
     def test_add(self):
         obj = SequenceRanges()
         obj.add(1)
-        self.assertEquals(obj.to_ranges(), [1])
+        self.assertEqual(obj.to_ranges(), [1])
         obj.add(2)
-        self.assertEquals(obj.to_ranges(), [1, 2])
-        obj.add(3)
-        self.assertEquals(obj.to_ranges(), [(1, 3)])
-        obj.add(3)
-        self.assertEquals(obj.to_ranges(), [(1, 3)])
+        self.assertEqual(obj.to_ranges(), [1, 2])
+        obj.add(3)
+        self.assertEqual(obj.to_ranges(), [(1, 3)])
+        obj.add(3)
+        self.assertEqual(obj.to_ranges(), [(1, 3)])
 
     def test_remove(self):
         obj = SequenceRanges.from_ranges([(1, 3)])
         obj.remove(2)
-        self.assertEquals(obj.to_ranges(), [1, 3])
+        self.assertEqual(obj.to_ranges(), [1, 3])
         obj.remove(1)
-        self.assertEquals(obj.to_ranges(), [3])
+        self.assertEqual(obj.to_ranges(), [3])
         obj.remove(3)
-        self.assertEquals(obj.to_ranges(), [])
+        self.assertEqual(obj.to_ranges(), [])
         obj.remove(4)
-        self.assertEquals(obj.to_ranges(), [])
+        self.assertEqual(obj.to_ranges(), [])
 
 
 class SequenceToRangesTest(unittest.TestCase):
 
     def test_empty(self):
-        self.assertEquals(list(sequence_to_ranges([])), [])
+        self.assertEqual(list(sequence_to_ranges([])), [])
 
     def test_one_element(self):
-        self.assertEquals(list(sequence_to_ranges([1])), [1])
+        self.assertEqual(list(sequence_to_ranges([1])), [1])
 
     def test_two_elements(self):
-        self.assertEquals(list(sequence_to_ranges([1, 2])), [1, 2])
+        self.assertEqual(list(sequence_to_ranges([1, 2])), [1, 2])
 
     def test_three_elements(self):
-        self.assertEquals(list(sequence_to_ranges([1, 2, 3])), [(1, 3)])
+        self.assertEqual(list(sequence_to_ranges([1, 2, 3])), [(1, 3)])
 
     def test_many_elements(self):
         sequence = [1, 2, 15, 16, 17, 19, 21, 22, 23, 24, 26, 27]
-        self.assertEquals(list(sequence_to_ranges(sequence)),
-                          [1, 2, (15, 17), 19, (21, 24), 26, 27])
+        self.assertEqual(list(sequence_to_ranges(sequence)),
+                         [1, 2, (15, 17), 19, (21, 24), 26, 27])
 
     def test_out_of_order(self):
         self.assertRaises(SequenceError, sequence_to_ranges([2, 1]).next)
@@ -110,59 +110,59 @@
 class RangesToSequenceTest(unittest.TestCase):
 
     def test_empty(self):
-        self.assertEquals(list(ranges_to_sequence([])), [])
+        self.assertEqual(list(ranges_to_sequence([])), [])
 
     def test_one_element(self):
-        self.assertEquals(list(ranges_to_sequence([1])), [1])
+        self.assertEqual(list(ranges_to_sequence([1])), [1])
 
     def test_two_elements(self):
-        self.assertEquals(list(ranges_to_sequence([1, 2])), [1, 2])
+        self.assertEqual(list(ranges_to_sequence([1, 2])), [1, 2])
 
     def test_three_elements(self):
-        self.assertEquals(list(ranges_to_sequence([(1, 3)])), [1, 2, 3])
+        self.assertEqual(list(ranges_to_sequence([(1, 3)])), [1, 2, 3])
 
     def test_many_elements(self):
         ranges = [1, 2, (15, 17), 19, (21, 24), 26, 27]
-        self.assertEquals(list(ranges_to_sequence(ranges)),
-                          [1, 2, 15, 16, 17, 19, 21, 22, 23, 24, 26, 27])
+        self.assertEqual(list(ranges_to_sequence(ranges)),
+                         [1, 2, 15, 16, 17, 19, 21, 22, 23, 24, 26, 27])
 
 
 class FindRangesIndexTest(unittest.TestCase):
 
     def test_empty(self):
-        self.assertEquals(find_ranges_index([], 2), 0)
+        self.assertEqual(find_ranges_index([], 2), 0)
 
     def test_sequence(self):
-        self.assertEquals(find_ranges_index([1, 2, 3, 4, 5], 0), 0)
-        self.assertEquals(find_ranges_index([1, 2, 3, 4, 5], 1), 0)
-        self.assertEquals(find_ranges_index([1, 2, 3, 4, 5], 2), 1)
-        self.assertEquals(find_ranges_index([1, 2, 3, 4, 5], 3), 2)
-        self.assertEquals(find_ranges_index([1, 2, 3, 4, 5], 4), 3)
-        self.assertEquals(find_ranges_index([1, 2, 3, 4, 5], 5), 4)
-        self.assertEquals(find_ranges_index([1, 2, 3, 4, 5], 6), 5)
+        self.assertEqual(find_ranges_index([1, 2, 3, 4, 5], 0), 0)
+        self.assertEqual(find_ranges_index([1, 2, 3, 4, 5], 1), 0)
+        self.assertEqual(find_ranges_index([1, 2, 3, 4, 5], 2), 1)
+        self.assertEqual(find_ranges_index([1, 2, 3, 4, 5], 3), 2)
+        self.assertEqual(find_ranges_index([1, 2, 3, 4, 5], 4), 3)
+        self.assertEqual(find_ranges_index([1, 2, 3, 4, 5], 5), 4)
+        self.assertEqual(find_ranges_index([1, 2, 3, 4, 5], 6), 5)
 
     def test_sequence_with_missing(self):
-        self.assertEquals(find_ranges_index([1, 2, 4, 5], 2), 1)
-        self.assertEquals(find_ranges_index([1, 2, 4, 5], 3), 2)
-        self.assertEquals(find_ranges_index([1, 2, 4, 5], 4), 2)
+        self.assertEqual(find_ranges_index([1, 2, 4, 5], 2), 1)
+        self.assertEqual(find_ranges_index([1, 2, 4, 5], 3), 2)
+        self.assertEqual(find_ranges_index([1, 2, 4, 5], 4), 2)
 
     def test_range(self):
-        self.assertEquals(find_ranges_index([1, (2, 4), 5], 0), 0)
-        self.assertEquals(find_ranges_index([1, (2, 4), 5], 1), 0)
-        self.assertEquals(find_ranges_index([1, (2, 4), 5], 2), 1)
-        self.assertEquals(find_ranges_index([1, (2, 4), 5], 3), 1)
-        self.assertEquals(find_ranges_index([1, (2, 4), 5], 4), 1)
-        self.assertEquals(find_ranges_index([1, (2, 4), 5], 5), 2)
-        self.assertEquals(find_ranges_index([1, (2, 4), 5], 6), 3)
+        self.assertEqual(find_ranges_index([1, (2, 4), 5], 0), 0)
+        self.assertEqual(find_ranges_index([1, (2, 4), 5], 1), 0)
+        self.assertEqual(find_ranges_index([1, (2, 4), 5], 2), 1)
+        self.assertEqual(find_ranges_index([1, (2, 4), 5], 3), 1)
+        self.assertEqual(find_ranges_index([1, (2, 4), 5], 4), 1)
+        self.assertEqual(find_ranges_index([1, (2, 4), 5], 5), 2)
+        self.assertEqual(find_ranges_index([1, (2, 4), 5], 6), 3)
 
     def test_range_with_missing(self):
-        self.assertEquals(find_ranges_index([1, (3, 4), 5], 0), 0)
-        self.assertEquals(find_ranges_index([1, (3, 4), 5], 1), 0)
-        self.assertEquals(find_ranges_index([1, (3, 4), 5], 2), 1)
-        self.assertEquals(find_ranges_index([1, (3, 4), 5], 3), 1)
-        self.assertEquals(find_ranges_index([1, (3, 4), 5], 4), 1)
-        self.assertEquals(find_ranges_index([1, (3, 4), 5], 5), 2)
-        self.assertEquals(find_ranges_index([1, (3, 4), 5], 6), 3)
+        self.assertEqual(find_ranges_index([1, (3, 4), 5], 0), 0)
+        self.assertEqual(find_ranges_index([1, (3, 4), 5], 1), 0)
+        self.assertEqual(find_ranges_index([1, (3, 4), 5], 2), 1)
+        self.assertEqual(find_ranges_index([1, (3, 4), 5], 3), 1)
+        self.assertEqual(find_ranges_index([1, (3, 4), 5], 4), 1)
+        self.assertEqual(find_ranges_index([1, (3, 4), 5], 5), 2)
+        self.assertEqual(find_ranges_index([1, (3, 4), 5], 6), 3)
 
 
 class AddToRangesTest(unittest.TestCase):
@@ -170,61 +170,61 @@
     def test_empty(self):
         ranges = []
         add_to_ranges(ranges, 1)
-        self.assertEquals(ranges, [1])
+        self.assertEqual(ranges, [1])
 
     def test_append(self):
         ranges = [1]
         add_to_ranges(ranges, 2)
-        self.assertEquals(ranges, [1, 2])
+        self.assertEqual(ranges, [1, 2])
 
     def test_prepend(self):
         ranges = [2]
         add_to_ranges(ranges, 1)
-        self.assertEquals(ranges, [1, 2])
+        self.assertEqual(ranges, [1, 2])
 
     def test_insert(self):
         ranges = [1, 4]
         add_to_ranges(ranges, 2)
-        self.assertEquals(ranges, [1, 2, 4])
+        self.assertEqual(ranges, [1, 2, 4])
 
     def test_merge_sequence(self):
         ranges = [1, 2, 4, 5]
         add_to_ranges(ranges, 3)
-        self.assertEquals(ranges, [(1, 5)])
+        self.assertEqual(ranges, [(1, 5)])
 
     def test_merge_ranges(self):
         ranges = [(1, 3), (5, 7)]
         add_to_ranges(ranges, 4)
-        self.assertEquals(ranges, [(1, 7)])
+        self.assertEqual(ranges, [(1, 7)])
 
     def test_merge_sequence_and_ranges(self):
         ranges = [(1, 3), 5, 6, 7]
         add_to_ranges(ranges, 4)
-        self.assertEquals(ranges, [(1, 7)])
+        self.assertEqual(ranges, [(1, 7)])
 
     def test_merge_sequence_and_ranges_with_gaps(self):
         ranges = [1, (3, 5), 7, 9]
         add_to_ranges(ranges, 6)
-        self.assertEquals(ranges, [1, (3, 7), 9])
+        self.assertEqual(ranges, [1, (3, 7), 9])
 
     def test_dont_merge_ranges_with_gap(self):
         ranges = [(1, 3), (7, 9)]
         add_to_ranges(ranges, 5)
-        self.assertEquals(ranges, [(1, 3), 5, (7, 9)])
+        self.assertEqual(ranges, [(1, 3), 5, (7, 9)])
 
     def test_duplicate(self):
         ranges = [1]
         add_to_ranges(ranges, 1)
-        self.assertEquals(ranges, [1])
+        self.assertEqual(ranges, [1])
 
     def test_duplicate_in_range(self):
         ranges = [(1, 3)]
         add_to_ranges(ranges, 1)
-        self.assertEquals(ranges, [(1, 3)])
+        self.assertEqual(ranges, [(1, 3)])
         add_to_ranges(ranges, 2)
-        self.assertEquals(ranges, [(1, 3)])
+        self.assertEqual(ranges, [(1, 3)])
         add_to_ranges(ranges, 3)
-        self.assertEquals(ranges, [(1, 3)])
+        self.assertEqual(ranges, [(1, 3)])
 
 
 class RemoveFromRangesTest(unittest.TestCase):
@@ -232,57 +232,57 @@
     def test_empty(self):
         ranges = []
         remove_from_ranges(ranges, 1)
-        self.assertEquals(ranges, [])
+        self.assertEqual(ranges, [])
 
     def test_single(self):
         ranges = [1]
         remove_from_ranges(ranges, 1)
-        self.assertEquals(ranges, [])
+        self.assertEqual(ranges, [])
 
     def test_remove_before(self):
         ranges = [1, 2]
         remove_from_ranges(ranges, 1)
-        self.assertEquals(ranges, [2])
+        self.assertEqual(ranges, [2])
 
     def test_remove_after(self):
         ranges = [1, 2]
         remove_from_ranges(ranges, 2)
-        self.assertEquals(ranges, [1])
+        self.assertEqual(ranges, [1])
 
     def test_remove_inside(self):
         ranges = [1, 2, 3]
         remove_from_ranges(ranges, 2)
-        self.assertEquals(ranges, [1, 3])
+        self.assertEqual(ranges, [1, 3])
 
     def test_remove_unexistent(self):
         ranges = [1, 3]
         remove_from_ranges(ranges, 2)
-        self.assertEquals(ranges, [1, 3])
+        self.assertEqual(ranges, [1, 3])
 
     def test_split_range(self):
         ranges = [(1, 5)]
         remove_from_ranges(ranges, 3)
-        self.assertEquals(ranges, [1, 2, 4, 5])
+        self.assertEqual(ranges, [1, 2, 4, 5])
 
     def test_split_range_into_ranges(self):
         ranges = [(1, 7)]
         remove_from_ranges(ranges, 4)
-        self.assertEquals(ranges, [(1, 3), (5, 7)])
+        self.assertEqual(ranges, [(1, 3), (5, 7)])
 
     def test_decrement_left(self):
         ranges = [(1, 5)]
         remove_from_ranges(ranges, 1)
-        self.assertEquals(ranges, [(2, 5)])
+        self.assertEqual(ranges, [(2, 5)])
 
     def test_decrement_right(self):
         ranges = [(1, 5)]
         remove_from_ranges(ranges, 5)
-        self.assertEquals(ranges, [(1, 4)])
+        self.assertEqual(ranges, [(1, 4)])
 
     def test_dont_removing_unmatched_range(self):
         ranges = [(1, 3), (5, 7)]
         remove_from_ranges(ranges, 4)
-        self.assertEquals(ranges, [(1, 3), (5, 7)])
+        self.assertEqual(ranges, [(1, 3), (5, 7)])
 
 
 def test_suite():

=== modified file 'landscape/lib/tests/test_sysstats.py'
--- landscape/lib/tests/test_sysstats.py	2009-08-07 22:36:33 +0000
+++ landscape/lib/tests/test_sysstats.py	2011-07-06 21:14:28 +0000
@@ -38,29 +38,29 @@
     def test_get_memory_info(self):
         filename = self.makeFile(SAMPLE_MEMORY_INFO)
         memstats = MemoryStats(filename)
-        self.assertEquals(memstats.total_memory, 1510)
-        self.assertEquals(memstats.free_memory, 503)
-        self.assertEquals(memstats.used_memory, 1007)
-        self.assertEquals(memstats.total_swap, 1584)
-        self.assertEquals(memstats.free_swap, 1567)
-        self.assertEquals(memstats.used_swap, 17)
-        self.assertEquals("%.2f" % memstats.free_memory_percentage, "33.31")
-        self.assertEquals("%.2f" % memstats.free_swap_percentage, "98.93")
-        self.assertEquals("%.2f" % memstats.used_memory_percentage, "66.69")
-        self.assertEquals("%.2f" % memstats.used_swap_percentage, "1.07")
+        self.assertEqual(memstats.total_memory, 1510)
+        self.assertEqual(memstats.free_memory, 503)
+        self.assertEqual(memstats.used_memory, 1007)
+        self.assertEqual(memstats.total_swap, 1584)
+        self.assertEqual(memstats.free_swap, 1567)
+        self.assertEqual(memstats.used_swap, 17)
+        self.assertEqual("%.2f" % memstats.free_memory_percentage, "33.31")
+        self.assertEqual("%.2f" % memstats.free_swap_percentage, "98.93")
+        self.assertEqual("%.2f" % memstats.used_memory_percentage, "66.69")
+        self.assertEqual("%.2f" % memstats.used_swap_percentage, "1.07")
 
     def test_get_memory_info_without_swap(self):
         sample = re.subn(r"Swap(Free|Total): *\d+ kB", r"Swap\1:       0",
                          SAMPLE_MEMORY_INFO)[0]
         filename = self.makeFile(sample)
         memstats = MemoryStats(filename)
-        self.assertEquals(memstats.total_swap, 0)
-        self.assertEquals(memstats.free_swap, 0)
-        self.assertEquals(memstats.used_swap, 0)
-        self.assertEquals(memstats.used_swap_percentage, 0)
-        self.assertEquals(memstats.free_swap_percentage, 0)
-        self.assertEquals(type(memstats.used_swap_percentage), float)
-        self.assertEquals(type(memstats.free_swap_percentage), float)
+        self.assertEqual(memstats.total_swap, 0)
+        self.assertEqual(memstats.free_swap, 0)
+        self.assertEqual(memstats.used_swap, 0)
+        self.assertEqual(memstats.used_swap_percentage, 0)
+        self.assertEqual(memstats.free_swap_percentage, 0)
+        self.assertEqual(type(memstats.used_swap_percentage), float)
+        self.assertEqual(type(memstats.free_swap_percentage), float)
 
 
 class FakeWhoQTest(LandscapeTest):
@@ -68,7 +68,7 @@
     helpers = [EnvironSaverHelper]
 
     def fake_who(self, users):
-        dirname = self.makeDir() 
+        dirname = self.makeDir()
         os.environ["PATH"] = "%s:%s" % (dirname, os.environ["PATH"])
 
         self.who_path = os.path.join(dirname, "who")
@@ -87,19 +87,19 @@
     def test_one_user(self):
         self.fake_who("joe")
         result = get_logged_in_users()
-        result.addCallback(self.assertEquals, ["joe"])
+        result.addCallback(self.assertEqual, ["joe"])
         return result
 
     def test_one_user_multiple_times(self):
         self.fake_who("joe joe joe joe")
         result = get_logged_in_users()
-        result.addCallback(self.assertEquals, ["joe"])
+        result.addCallback(self.assertEqual, ["joe"])
         return result
 
     def test_many_users(self):
         self.fake_who("joe moe boe doe")
         result = get_logged_in_users()
-        result.addCallback(self.assertEquals, ["boe", "doe", "joe", "moe"])
+        result.addCallback(self.assertEqual, ["boe", "doe", "joe", "moe"])
         return result
 
     def test_command_error(self):
@@ -108,9 +108,10 @@
         who.write("#!/bin/sh\necho ERROR 1>&2\nexit 1\n")
         who.close()
         result = get_logged_in_users()
+
         def assert_failure(failure):
             failure.trap(CommandError)
-            self.assertEquals(str(failure.value), "ERROR\n")
+            self.assertEqual(str(failure.value), "ERROR\n")
         result.addErrback(assert_failure)
         return result
 
@@ -137,50 +138,50 @@
 
     def test_non_existent_thermal_zone_directory(self):
         thermal_zones = list(get_thermal_zones("/non-existent/thermal_zone"))
-        self.assertEquals(thermal_zones, [])
+        self.assertEqual(thermal_zones, [])
 
     def test_empty_thermal_zone_directory(self):
-        self.assertEquals(self.get_thermal_zones(), [])
+        self.assertEqual(self.get_thermal_zones(), [])
 
     def test_one_thermal_zone(self):
         self.write_thermal_zone("THM0", "50 C")
         thermal_zones = self.get_thermal_zones()
-        self.assertEquals(len(thermal_zones), 1)
+        self.assertEqual(len(thermal_zones), 1)
 
-        self.assertEquals(thermal_zones[0].name, "THM0")
-        self.assertEquals(thermal_zones[0].temperature, "50 C")
-        self.assertEquals(thermal_zones[0].temperature_value, 50)
-        self.assertEquals(thermal_zones[0].temperature_unit, "C")
-        self.assertEquals(thermal_zones[0].path,
-                          os.path.join(self.thermal_zone_path, "THM0"))
+        self.assertEqual(thermal_zones[0].name, "THM0")
+        self.assertEqual(thermal_zones[0].temperature, "50 C")
+        self.assertEqual(thermal_zones[0].temperature_value, 50)
+        self.assertEqual(thermal_zones[0].temperature_unit, "C")
+        self.assertEqual(thermal_zones[0].path,
+                         os.path.join(self.thermal_zone_path, "THM0"))
 
     def test_two_thermal_zones(self):
         self.write_thermal_zone("THM0", "50 C")
         self.write_thermal_zone("THM1", "51 C")
         thermal_zones = self.get_thermal_zones()
-        self.assertEquals(len(thermal_zones), 2)
-        self.assertEquals(thermal_zones[0].temperature, "50 C")
-        self.assertEquals(thermal_zones[0].temperature_value, 50)
-        self.assertEquals(thermal_zones[0].temperature_unit, "C")
-        self.assertEquals(thermal_zones[1].temperature, "51 C")
-        self.assertEquals(thermal_zones[1].temperature_value, 51)
-        self.assertEquals(thermal_zones[1].temperature_unit, "C")
+        self.assertEqual(len(thermal_zones), 2)
+        self.assertEqual(thermal_zones[0].temperature, "50 C")
+        self.assertEqual(thermal_zones[0].temperature_value, 50)
+        self.assertEqual(thermal_zones[0].temperature_unit, "C")
+        self.assertEqual(thermal_zones[1].temperature, "51 C")
+        self.assertEqual(thermal_zones[1].temperature_value, 51)
+        self.assertEqual(thermal_zones[1].temperature_unit, "C")
 
     def test_badly_formatted_temperature(self):
         self.write_thermal_zone("THM0", "SOMETHING BAD")
         thermal_zones = self.get_thermal_zones()
-        self.assertEquals(len(thermal_zones), 1)
-        self.assertEquals(thermal_zones[0].temperature, "SOMETHING BAD")
-        self.assertEquals(thermal_zones[0].temperature_value, None)
-        self.assertEquals(thermal_zones[0].temperature_unit, None)
+        self.assertEqual(len(thermal_zones), 1)
+        self.assertEqual(thermal_zones[0].temperature, "SOMETHING BAD")
+        self.assertEqual(thermal_zones[0].temperature_value, None)
+        self.assertEqual(thermal_zones[0].temperature_unit, None)
 
     def test_badly_formatted_with_missing_space(self):
         self.write_thermal_zone("THM0", "SOMETHINGBAD")
         thermal_zones = self.get_thermal_zones()
-        self.assertEquals(len(thermal_zones), 1)
-        self.assertEquals(thermal_zones[0].temperature, "SOMETHINGBAD")
-        self.assertEquals(thermal_zones[0].temperature_value, None)
-        self.assertEquals(thermal_zones[0].temperature_unit, None)
+        self.assertEqual(len(thermal_zones), 1)
+        self.assertEqual(thermal_zones[0].temperature, "SOMETHINGBAD")
+        self.assertEqual(thermal_zones[0].temperature_value, None)
+        self.assertEqual(thermal_zones[0].temperature_unit, None)
 
     def test_temperature_file_with_missing_label(self):
         self.write_thermal_zone("THM0", "SOMETHINGBAD")
@@ -190,7 +191,7 @@
         file.write("bad-label: foo bar\n")
         file.close()
         thermal_zones = self.get_thermal_zones()
-        self.assertEquals(len(thermal_zones), 1)
-        self.assertEquals(thermal_zones[0].temperature, None)
-        self.assertEquals(thermal_zones[0].temperature_value, None)
-        self.assertEquals(thermal_zones[0].temperature_unit, None)
+        self.assertEqual(len(thermal_zones), 1)
+        self.assertEqual(thermal_zones[0].temperature, None)
+        self.assertEqual(thermal_zones[0].temperature_value, None)
+        self.assertEqual(thermal_zones[0].temperature_unit, None)

=== modified file 'landscape/lib/tests/test_timestamp.py'
--- landscape/lib/tests/test_timestamp.py	2008-06-10 10:56:01 +0000
+++ landscape/lib/tests/test_timestamp.py	2011-07-06 21:14:28 +0000
@@ -12,9 +12,9 @@
         date = datetime.utcfromtimestamp(1000)
         timestamp = to_timestamp(date)
         self.assertTrue(isinstance(timestamp, int))
-        self.assertEquals(timestamp, 1000)
+        self.assertEqual(timestamp, 1000)
 
     def test_before_epoch_conversion(self):
         """Test converting a date before the epoch."""
         date = datetime.utcfromtimestamp(-1000)
-        self.assertEquals(to_timestamp(date), -1000)
+        self.assertEqual(to_timestamp(date), -1000)

=== modified file 'landscape/lib/tests/test_warning.py'
--- landscape/lib/tests/test_warning.py	2009-04-09 14:48:58 +0000
+++ landscape/lib/tests/test_warning.py	2011-07-06 21:14:28 +0000
@@ -20,8 +20,8 @@
 
         # Warning filters are processed beginning to end, and the first filter
         # which matches a particular warning is used.
-        
-        self.assertEquals(
+
+        self.assertEqual(
             filters,
             # The frontmost should "default" (i.e.  print) on UserWarnings
             [("default", None, UserWarning, None, 0),

=== modified file 'landscape/manager/tests/test_config.py'
--- landscape/manager/tests/test_config.py	2011-04-14 09:58:34 +0000
+++ landscape/manager/tests/test_config.py	2011-07-06 21:14:28 +0000
@@ -22,7 +22,7 @@
         which plugins should be active.
         """
         self.config.load(["--manager-plugins", "ProcessKiller"])
-        self.assertEquals(self.config.plugin_factories, ["ProcessKiller"])
+        self.assertEqual(self.config.plugin_factories, ["ProcessKiller"])
 
     def test_include_script_execution(self):
         """
@@ -30,15 +30,15 @@
         command line option.
         """
         self.config.load(["--include-manager-plugins", "ScriptExecution"])
-        self.assertEquals(len(self.config.plugin_factories),
-                          len(ALL_PLUGINS) + 1)
+        self.assertEqual(len(self.config.plugin_factories),
+                         len(ALL_PLUGINS) + 1)
         self.assertTrue('ScriptExecution' in self.config.plugin_factories)
 
     def test_get_allowed_script_users(self):
         """
         If no script users are specified, the default is 'nobody'.
         """
-        self.assertEquals(self.config.get_allowed_script_users(), ["nobody"])
+        self.assertEqual(self.config.get_allowed_script_users(), ["nobody"])
 
     def test_get_allowed_script_users_all(self):
         """
@@ -54,5 +54,5 @@
         as.
         """
         self.config.load(["--script-users", "foo, bar,baz"])
-        self.assertEquals(self.config.get_allowed_script_users(),
-                          ["foo", "bar", "baz"])
+        self.assertEqual(self.config.get_allowed_script_users(),
+                         ["foo", "bar", "baz"])

=== modified file 'landscape/manager/tests/test_customgraph.py'
--- landscape/manager/tests/test_customgraph.py	2010-06-22 10:51:24 +0000
+++ landscape/manager/tests/test_customgraph.py	2011-07-06 21:14:28 +0000
@@ -49,7 +49,7 @@
                      "username": username,
                      "graph-id": 123})
 
-        self.assertEquals(
+        self.assertEqual(
             self.store.get_graphs(),
             [(123,
               os.path.join(self.data_path, "custom-graph-scripts",
@@ -77,8 +77,8 @@
                      "username": "foo",
                      "graph-id": 123})
         graph = self.store.get_graph(123)
-        self.assertEquals(graph[0], 123)
-        self.assertEquals(graph[2], u"foo")
+        self.assertEqual(graph[0], 123)
+        self.assertEqual(graph[2], u"foo")
         self.assertTrue(error_message in self.logfile.getvalue())
 
     def test_add_graph_for_user(self):
@@ -103,7 +103,7 @@
                      "code": "echo hi!",
                      "username": "bar",
                      "graph-id": 123})
-        self.assertEquals(
+        self.assertEqual(
             self.store.get_graphs(),
             [(123, os.path.join(self.data_path, "custom-graph-scripts",
                                 "graph-123"),
@@ -176,7 +176,6 @@
                   "type": "custom-graph"}])
         return self.graph_manager.run().addCallback(check)
 
-
     def test_run_with_nonzero_exit_code(self):
         filename = self.makeFile()
         tempfile = file(filename, "w")
@@ -184,6 +183,7 @@
         tempfile.close()
         os.chmod(filename, 0777)
         self.store.add_graph(123, filename, None)
+
         def check(ignore):
             self.graph_manager.exchange()
             self.assertMessages(
@@ -204,9 +204,9 @@
         self.graph_manager.process_factory = factory
         result = self.graph_manager.run()
 
-        self.assertEquals(len(factory.spawns), 1)
+        self.assertEqual(len(factory.spawns), 1)
         spawn = factory.spawns[0]
-        self.assertEquals(spawn[1], filename)
+        self.assertEqual(spawn[1], filename)
 
         self._exit_process_protocol(spawn[0], "foobar")
 
@@ -230,9 +230,9 @@
         self.graph_manager.process_factory = factory
         result = self.graph_manager.run()
 
-        self.assertEquals(len(factory.spawns), 1)
+        self.assertEqual(len(factory.spawns), 1)
         spawn = factory.spawns[0]
-        self.assertEquals(spawn[1], filename)
+        self.assertEqual(spawn[1], filename)
 
         self._exit_process_protocol(spawn[0], "")
 
@@ -257,7 +257,7 @@
         self.graph_manager.process_factory = factory
         result = self.graph_manager.run()
 
-        self.assertEquals(len(factory.spawns), 2)
+        self.assertEqual(len(factory.spawns), 2)
         spawn = factory.spawns[0]
         self._exit_process_protocol(spawn[0], "")
         spawn = factory.spawns[1]
@@ -287,7 +287,7 @@
         self.graph_manager.process_factory = factory
         result = self.graph_manager.run()
 
-        self.assertEquals(len(factory.spawns), 2)
+        self.assertEqual(len(factory.spawns), 2)
         spawn = factory.spawns[0]
         self._exit_process_protocol(spawn[0], "foo")
         spawn = factory.spawns[1]
@@ -316,6 +316,7 @@
         self.graph_manager.process_factory = factory
 
         mock_getpwnam = self.mocker.replace("pwd.getpwnam", passthrough=False)
+
         class pwnam(object):
             pw_uid = 1234
             pw_gid = 5678
@@ -326,14 +327,14 @@
 
         result = self.graph_manager.run()
 
-        self.assertEquals(len(factory.spawns), 1)
+        self.assertEqual(len(factory.spawns), 1)
         spawn = factory.spawns[0]
-        self.assertEquals(spawn[1], filename)
-        self.assertEquals(spawn[2], ())
-        self.assertEquals(spawn[3], {})
-        self.assertEquals(spawn[4], "/")
-        self.assertEquals(spawn[5], 1234)
-        self.assertEquals(spawn[6], 5678)
+        self.assertEqual(spawn[1], filename)
+        self.assertEqual(spawn[2], ())
+        self.assertEqual(spawn[3], {})
+        self.assertEqual(spawn[4], "/")
+        self.assertEqual(spawn[5], 1234)
+        self.assertEqual(spawn[6], 5678)
 
         self._exit_process_protocol(spawn[0], "spam")
 
@@ -350,7 +351,7 @@
         self.graph_manager.process_factory = factory
         result = self.graph_manager.run()
 
-        self.assertEquals(len(factory.spawns), 0)
+        self.assertEqual(len(factory.spawns), 0)
 
         def check(ignore):
             self.graph_manager.exchange()
@@ -379,7 +380,7 @@
         self.graph_manager.process_factory = factory
         result = self.graph_manager.run()
 
-        self.assertEquals(len(factory.spawns), 0)
+        self.assertEqual(len(factory.spawns), 0)
 
         def check(ignore):
             self.graph_manager.exchange()
@@ -400,11 +401,11 @@
         self.graph_manager.process_factory = factory
         result = self.graph_manager.run()
 
-        self.assertEquals(len(factory.spawns), 1)
+        self.assertEqual(len(factory.spawns), 1)
         spawn = factory.spawns[0]
         protocol = spawn[0]
         protocol.makeConnection(DummyProcess())
-        self.assertEquals(spawn[1], filename)
+        self.assertEqual(spawn[1], filename)
 
         self.manager.reactor.advance(110)
         protocol.processEnded(Failure(ProcessDone(0)))
@@ -432,7 +433,7 @@
         self.graph_manager.process_factory = factory
         self.graph_manager.run()
 
-        self.assertEquals(len(factory.spawns), 0)
+        self.assertEqual(len(factory.spawns), 0)
 
         self.graph_manager.exchange()
         self.assertMessages(
@@ -500,7 +501,7 @@
                      "username": username,
                      "graph-id": 123})
         self.graph_manager.exchange()
-        self.graph_manager._get_script_hash = lambda x: 1/0
+        self.graph_manager._get_script_hash = lambda x: 1 / 0
         self.graph_manager.do_send = True
         self.graph_manager.exchange()
         self.assertMessages(
@@ -572,7 +573,7 @@
         self.graph_manager.process_factory = factory
         result = self.graph_manager.run()
 
-        self.assertEquals(len(factory.spawns), 1)
+        self.assertEqual(len(factory.spawns), 1)
         spawn = factory.spawns[0]
 
         self.manager.dispatch_message(
@@ -617,7 +618,7 @@
         self.graph_manager.process_factory = factory
         result = self.graph_manager.run()
 
-        self.assertEquals(len(factory.spawns), 1)
+        self.assertEqual(len(factory.spawns), 1)
         spawn = factory.spawns[0]
 
         self.manager.dispatch_message(
@@ -655,7 +656,7 @@
         self.graph_manager.process_factory = factory
         result = self.graph_manager.run()
 
-        self.assertEquals(len(factory.spawns), 0)
+        self.assertEqual(len(factory.spawns), 0)
 
         return result.addCallback(self.assertIdentical, None)
 
@@ -666,14 +667,14 @@
         of results.
         """
         self.graph_manager.registry.broker.call_if_accepted = (
-            lambda *args: 1/0)
+            lambda *args: 1 / 0)
         factory = StubProcessFactory()
         self.graph_manager.process_factory = factory
         result = self.graph_manager.run()
 
-        self.assertEquals(len(factory.spawns), 0)
+        self.assertEqual(len(factory.spawns), 0)
 
-        return result.addCallback(self.assertEquals, [])
+        return result.addCallback(self.assertEqual, [])
 
     def test_run_unknown_user_with_unicode(self):
         """
@@ -690,7 +691,7 @@
         self.graph_manager.process_factory = factory
         result = self.graph_manager.run()
 
-        self.assertEquals(len(factory.spawns), 0)
+        self.assertEqual(len(factory.spawns), 0)
 
         def check(ignore):
             self.graph_manager.exchange()

=== modified file 'landscape/manager/tests/test_packagemanager.py'
--- landscape/manager/tests/test_packagemanager.py	2010-04-26 07:38:03 +0000
+++ landscape/manager/tests/test_packagemanager.py	2011-07-06 21:14:28 +0000
@@ -104,7 +104,7 @@
 
         package_manager_mock = self.mocker.patch(self.package_manager)
         package_manager_mock.spawn_handler(PackageChanger)
-        self.mocker.count(2) # Once for registration, then again explicitly.
+        self.mocker.count(2)  # Once for registration, then again explicitly.
         self.mocker.replay()
 
         self.manager.add(self.package_manager)
@@ -121,7 +121,7 @@
 
         package_manager_mock = self.mocker.patch(self.package_manager)
         package_manager_mock.spawn_handler(PackageChanger)
-        self.mocker.count(2) # Once for registration, then again explicitly.
+        self.mocker.count(2)  # Once for registration, then again explicitly.
         self.mocker.replay()
 
         self.manager.add(self.package_manager)
@@ -137,7 +137,7 @@
 
         package_manager_mock = self.mocker.patch(self.package_manager)
         package_manager_mock.spawn_handler(ReleaseUpgrader)
-        self.mocker.count(2) # Once for registration, then again explicitly.
+        self.mocker.count(2)  # Once for registration, then again explicitly.
         self.mocker.replay()
 
         self.manager.add(self.package_manager)
@@ -154,7 +154,7 @@
         self.manager.dispatch_message(message)
         task = self.package_store.get_next_task("changer")
         self.assertTrue(task)
-        self.assertEquals(task.data, message)
+        self.assertEqual(task.data, message)
 
     def test_release_upgrade_handling(self):
         """
@@ -172,7 +172,7 @@
         self.manager.dispatch_message(message)
         task = self.package_store.get_next_task("release-upgrader")
         self.assertTrue(task)
-        self.assertEquals(task.data, message)
+        self.assertEqual(task.data, message)
 
     def test_spawn_changer(self):
         """
@@ -341,4 +341,4 @@
         self.manager.dispatch_message(message)
         task = self.package_store.get_next_task("changer")
         self.assertTrue(task)
-        self.assertEquals(task.data, message)
+        self.assertEqual(task.data, message)

=== modified file 'landscape/manager/tests/test_processkiller.py'
--- landscape/manager/tests/test_processkiller.py	2010-04-26 15:19:55 +0000
+++ landscape/manager/tests/test_processkiller.py	2011-07-06 21:14:28 +0000
@@ -100,7 +100,7 @@
         # a signal.
         self.assertTrue(return_code < 0)
         process_info = process_info_factory.get_process_info(popen.pid)
-        self.assertEquals(process_info, None)
+        self.assertEqual(process_info, None)
 
         service = self.broker_service
         self.assertMessages(service.message_store.get_pending_messages(),

=== modified file 'landscape/manager/tests/test_scriptexecution.py'
--- landscape/manager/tests/test_scriptexecution.py	2010-04-26 14:10:43 +0000
+++ landscape/manager/tests/test_scriptexecution.py	2011-07-06 21:14:28 +0000
@@ -42,13 +42,13 @@
         commands.
         """
         result = self.plugin.run_script("/bin/sh", "echo hi")
-        result.addCallback(self.assertEquals, "hi\n")
+        result.addCallback(self.assertEqual, "hi\n")
         return result
 
     def test_other_interpreter(self):
         """Non-shell interpreters can be specified."""
         result = self.plugin.run_script("/usr/bin/python", "print 'hi'")
-        result.addCallback(self.assertEquals, "hi\n")
+        result.addCallback(self.assertEqual, "hi\n")
         return result
 
     def test_other_interpreter_env(self):
@@ -78,8 +78,8 @@
         # run_script is truly async
         d1 = self.plugin.run_script("/bin/sh", "cat " + fifo)
         d2 = self.plugin.run_script("/bin/sh", "echo hi > " + fifo)
-        d1.addCallback(self.assertEquals, "hi\n")
-        d2.addCallback(self.assertEquals, "")
+        d1.addCallback(self.assertEqual, "hi\n")
+        d2.addCallback(self.assertEqual, "")
         return gatherResults([d1, d2])
 
     def test_accented_run_in_code(self):
@@ -91,7 +91,7 @@
         result = self.plugin.run_script(
             u"/bin/sh", u"echo %s" % (accented_content,))
         result.addCallback(
-            self.assertEquals, "%s\n" % (accented_content.encode("utf-8"),))
+            self.assertEqual, "%s\n" % (accented_content.encode("utf-8"),))
         return result
 
     def test_accented_run_in_interpreter(self):
@@ -119,7 +119,7 @@
         mock_umask(0077)
         self.mocker.replay()
         result = self.plugin.run_script("/bin/sh", "umask")
-        result.addCallback(self.assertEquals, "0022\n")
+        result.addCallback(self.assertEqual, "0022\n")
         return result
 
     def test_restore_umask_in_event_of_error(self):
@@ -147,7 +147,7 @@
             attachments={u"file1": "some data"})
 
         def check(result):
-            self.assertEquals(result, "file1\nsome data")
+            self.assertEqual(result, "file1\nsome data")
         result.addCallback(check)
         return result
 
@@ -157,7 +157,7 @@
         execution plugin tries to remove the script file.
         """
         result = self.plugin.run_script("/bin/sh", "echo hi && rm $0")
-        result.addCallback(self.assertEquals, "hi\n")
+        result.addCallback(self.assertEqual, "hi\n")
         return result
 
     def test_self_remove_attachments(self):
@@ -171,7 +171,7 @@
             attachments={u"file1": "some data"})
 
         def check(result):
-            self.assertEquals(result, "file1\n")
+            self.assertEqual(result, "file1\n")
         result.addCallback(check)
         return result
 
@@ -187,12 +187,12 @@
 
         result = self.plugin.run_script("/bin/sh", "echo hi", user=username)
 
-        self.assertEquals(len(factory.spawns), 1)
+        self.assertEqual(len(factory.spawns), 1)
         spawn = factory.spawns[0]
-        self.assertEquals(spawn[4], path)
-        self.assertEquals(spawn[5], uid)
-        self.assertEquals(spawn[6], gid)
-        result.addCallback(self.assertEquals, "foobar")
+        self.assertEqual(spawn[4], path)
+        self.assertEqual(spawn[5], uid)
+        self.assertEqual(spawn[6], gid)
+        result.addCallback(self.assertEqual, "foobar")
 
         protocol = spawn[0]
         protocol.childDataReceived(1, "foobar")
@@ -250,13 +250,13 @@
         result = self.plugin.run_script("/bin/sh", "echo hi", user=username,
             attachments={u"file 1": "some data"})
 
-        self.assertEquals(len(factory.spawns), 1)
+        self.assertEqual(len(factory.spawns), 1)
         spawn = factory.spawns[0]
         self.assertIn("LANDSCAPE_ATTACHMENTS", spawn[3].keys())
         attachment_dir = spawn[3]["LANDSCAPE_ATTACHMENTS"]
-        self.assertEquals(stat.S_IMODE(os.stat(attachment_dir).st_mode), 0700)
+        self.assertEqual(stat.S_IMODE(os.stat(attachment_dir).st_mode), 0700)
         filename = os.path.join(attachment_dir, "file 1")
-        self.assertEquals(stat.S_IMODE(os.stat(filename).st_mode), 0600)
+        self.assertEqual(stat.S_IMODE(os.stat(filename).st_mode), 0600)
 
         protocol = spawn[0]
         protocol.childDataReceived(1, "foobar")
@@ -265,7 +265,7 @@
         protocol.processEnded(Failure(ProcessDone(0)))
 
         def check(data):
-            self.assertEquals(data, "foobar")
+            self.assertEqual(data, "foobar")
             self.assertFalse(os.path.exists(attachment_dir))
         return result.addCallback(check)
 
@@ -275,7 +275,7 @@
         self.plugin.process_factory = factory
         self.plugin.size_limit = 100
         result = self.plugin.run_script("/bin/sh", "")
-        result.addCallback(self.assertEquals, "x" * 100)
+        result.addCallback(self.assertEqual, "x" * 100)
 
         protocol = factory.spawns[0][0]
         protocol.childDataReceived(1, "x" * 200)
@@ -310,7 +310,7 @@
 
         def got_error(f):
             self.assertTrue(f.check(ProcessTimeLimitReachedError))
-            self.assertEquals(f.value.data, "hi\n")
+            self.assertEqual(f.value.data, "hi\n")
         result.addErrback(got_error)
         return result
 
@@ -327,7 +327,7 @@
         protocol.childDataReceived(1, "hi\n")
         protocol.processEnded(Failure(ProcessDone(0)))
         self.manager.reactor.advance(501)
-        self.assertEquals(transport.signals, [])
+        self.assertEqual(transport.signals, [])
 
     def test_cancel_doesnt_blow_after_success(self):
         """
@@ -346,7 +346,7 @@
         self.manager.reactor.advance(501)
 
         def got_result(output):
-            self.assertEquals(output, "hi")
+            self.assertEqual(output, "hi")
         result.addCallback(got_result)
         return result
 
@@ -412,7 +412,7 @@
 
         def eb(failure):
             failure.trap(UnknownInterpreterError)
-            self.assertEquals(
+            self.assertEqual(
                 failure.value.interpreter,
                 "/bin/cantpossiblyexist")
         return d.addCallback(cb).addErrback(eb)
@@ -433,7 +433,7 @@
         script has the correct content.
         """
         data = open(executable, "r").read()
-        self.assertEquals(data, "#!%s\n%s" % (interp, code))
+        self.assertEqual(data, "#!%s\n%s" % (interp, code))
 
     def _send_script(self, interpreter, code, operation_id=123,
                      user=pwd.getpwuid(os.getuid())[0],
@@ -652,7 +652,7 @@
             self.assertTrue(self.broker_service.exchanger.is_urgent())
             [message] = (
                 self.broker_service.message_store.get_pending_messages())
-            self.assertEquals(
+            self.assertEqual(
                 message["result-text"],
                  u"\x7fELF\x01\x01\x01\x00\x00\x00\ufffd\x01")
 

=== modified file 'landscape/manager/tests/test_service.py'
--- landscape/manager/tests/test_service.py	2010-08-11 11:56:29 +0000
+++ landscape/manager/tests/test_service.py	2011-07-06 21:14:28 +0000
@@ -26,7 +26,7 @@
         By default the L{ManagerService.plugins} list holds an instance of
         every enabled manager plugin.
         """
-        self.assertEquals(len(self.service.plugins), len(ALL_PLUGINS))
+        self.assertEqual(len(self.service.plugins), len(ALL_PLUGINS))
 
     def test_get_plugins(self):
         """
@@ -59,7 +59,7 @@
             self.broker_service.port.stopListening()
 
         def assert_broker_connection(ignored):
-            self.assertEquals(len(self.broker_service.broker.get_clients()), 1)
+            self.assertEqual(len(self.broker_service.broker.get_clients()), 1)
             self.assertIs(self.service.broker, self.service.manager.broker)
             result = self.service.broker.ping()
             return result.addCallback(stop_service)

=== modified file 'landscape/manager/tests/test_shutdownmanager.py'
--- landscape/manager/tests/test_shutdownmanager.py	2010-04-23 13:39:22 +0000
+++ landscape/manager/tests/test_shutdownmanager.py	2011-07-06 21:14:28 +0000
@@ -34,14 +34,14 @@
         [arguments] = self.process_factory.spawns
         protocol = arguments[0]
         self.assertTrue(isinstance(protocol, ShutdownProcessProtocol))
-        self.assertEquals(
+        self.assertEqual(
             arguments[1:3],
             ("/sbin/shutdown", ["/sbin/shutdown", "-r", "+4",
                                 "Landscape is rebooting the system"]))
 
         def restart_performed(ignore):
             self.assertTrue(self.broker_service.exchanger.is_urgent())
-            self.assertEquals(
+            self.assertEqual(
                 self.broker_service.message_store.get_pending_messages(),
                 [{"type": "operation-result", "api": SERVER_API,
                   "operation-id": 100, "timestamp": 10, "status": SUCCEEDED,
@@ -65,7 +65,7 @@
         message = {"type": "shutdown", "reboot": False, "operation-id": 100}
         self.plugin.perform_shutdown(message)
         [arguments] = self.process_factory.spawns
-        self.assertEquals(
+        self.assertEqual(
             arguments[1:3],
             ("/sbin/shutdown", ["/sbin/shutdown", "-h", "+4",
                                 "Landscape is shutting down the system"]))
@@ -81,7 +81,7 @@
 
         def restart_failed(message_id):
             self.assertTrue(self.broker_service.exchanger.is_urgent())
-            self.assertEquals(
+            self.assertEqual(
                 self.broker_service.message_store.get_pending_messages(),
                 [{"type": "operation-result", "api": SERVER_API,
                   "operation-id": 100, "timestamp": 0, "status": FAILED,
@@ -105,7 +105,7 @@
         stash = []
 
         def restart_performed(ignore):
-            self.assertEquals(stash, [])
+            self.assertEqual(stash, [])
             stash.append(True)
 
         [arguments] = self.process_factory.spawns
@@ -128,6 +128,6 @@
         protocol.childDataReceived(0, "Data may arrive ")
         protocol.childDataReceived(0, "in batches.")
         self.manager.reactor.advance(10)
-        self.assertEquals(protocol.get_data(), "Data may arrive in batches.")
+        self.assertEqual(protocol.get_data(), "Data may arrive in batches.")
         protocol.childDataReceived(0, "Even when you least expect it.")
-        self.assertEquals(protocol.get_data(), "Data may arrive in batches.")
+        self.assertEqual(protocol.get_data(), "Data may arrive in batches.")

=== modified file 'landscape/manager/tests/test_store.py'
--- landscape/manager/tests/test_store.py	2008-10-22 16:54:38 +0000
+++ landscape/manager/tests/test_store.py	2011-07-06 21:14:28 +0000
@@ -18,36 +18,36 @@
 
     def test_get_graph(self):
         graph = self.store.get_graph(1)
-        self.assertEquals(graph, (1, u"file 1", u"user1"))
+        self.assertEqual(graph, (1, u"file 1", u"user1"))
 
     def test_get_graphs(self):
         graphs = self.store.get_graphs()
-        self.assertEquals(graphs, [(1, u"file 1", u"user1")])
+        self.assertEqual(graphs, [(1, u"file 1", u"user1")])
 
     def test_get_no_graphs(self):
         self.store.remove_graph(1)
         graphs = self.store.get_graphs()
-        self.assertEquals(graphs, [])
+        self.assertEqual(graphs, [])
 
     def test_add_graph(self):
         self.store.add_graph(2, u"file 2", u"user2")
         graph = self.store.get_graph(2)
-        self.assertEquals(graph, (2, u"file 2", u"user2"))
+        self.assertEqual(graph, (2, u"file 2", u"user2"))
 
     def test_add_update_graph(self):
         self.store.add_graph(1, u"file 2", u"user2")
         graph = self.store.get_graph(1)
-        self.assertEquals(graph, (1, u"file 2", u"user2"))
+        self.assertEqual(graph, (1, u"file 2", u"user2"))
 
     def test_remove_graph(self):
         self.store.remove_graph(1)
         graphs = self.store.get_graphs()
-        self.assertEquals(graphs, [])
+        self.assertEqual(graphs, [])
 
     def test_remove_unknown_graph(self):
         self.store.remove_graph(2)
         graphs = self.store.get_graphs()
-        self.assertEquals(graphs, [(1, u"file 1", u"user1")])
+        self.assertEqual(graphs, [(1, u"file 1", u"user1")])
 
     def test_get_accumulate_unknown_graph(self):
         accumulate = self.store.get_graph_accumulate(2)
@@ -56,9 +56,9 @@
     def test_set_accumulate_graph(self):
         self.store.set_graph_accumulate(2, 1234, 2.0)
         accumulate = self.store.get_graph_accumulate(2)
-        self.assertEquals(accumulate, (2, 1234, 2.0))
+        self.assertEqual(accumulate, (2, 1234, 2.0))
 
     def test_update_accumulate_graph(self):
         self.store.set_graph_accumulate(1, 4567, 2.0)
         accumulate = self.store.get_graph_accumulate(1)
-        self.assertEquals(accumulate, (1, 4567, 2.0))
+        self.assertEqual(accumulate, (1, 4567, 2.0))

=== modified file 'landscape/manager/tests/test_usermanager.py'
--- landscape/manager/tests/test_usermanager.py	2010-09-09 17:01:02 +0000
+++ landscape/manager/tests/test_usermanager.py	2011-07-06 21:14:28 +0000
@@ -125,7 +125,7 @@
         def handle_callback2(result, messages):
             message_store = self.broker_service.message_store
             new_messages = message_store.get_pending_messages()
-            self.assertEquals(messages, new_messages)
+            self.assertEqual(messages, new_messages)
             return result
 
         plugin = self.setup_environment([], [], None)
@@ -148,7 +148,7 @@
 
         def handle_callback(result):
             messages = self.broker_service.message_store.get_pending_messages()
-            self.assertEquals(len(messages), 3)
+            self.assertEqual(len(messages), 3)
             messages = [messages[0], messages[2]]
             self.assertMessages(messages,
                                 [{"type": "users",
@@ -190,7 +190,7 @@
 
         def handle_callback(result):
             messages = self.broker_service.message_store.get_pending_messages()
-            self.assertEquals(len(messages), 3)
+            self.assertEqual(len(messages), 3)
             # Ignore the message created by plugin.run.
             self.assertMessages(messages[1:],
                                 [{"type": "operation-result",
@@ -238,7 +238,7 @@
         def handle_callback2(result, messages):
             mstore = self.broker_service.message_store
             new_messages = mstore.get_pending_messages()
-            self.assertEquals(messages, new_messages)
+            self.assertEqual(messages, new_messages)
             return result
 
         users = [("jdoe", "x", 1000, 1000, "John Doe,,,,",
@@ -262,7 +262,7 @@
 
         def handle_callback(result):
             messages = self.broker_service.message_store.get_pending_messages()
-            self.assertEquals(len(messages), 3)
+            self.assertEqual(len(messages), 3)
             self.assertMessages([messages[0], messages[2]],
                                 [{"type": "users",
                                   "create-group-members": {u"users":
@@ -311,7 +311,7 @@
 
         def handle_callback(result):
             messages = self.broker_service.message_store.get_pending_messages()
-            self.assertEquals(len(messages), 3)
+            self.assertEqual(len(messages), 3)
             # Ignore the message created by plugin.run.
             self.assertMessages([messages[2], messages[1]],
                                 [{"timestamp": 0, "delete-users": ["jdoe"],
@@ -321,7 +321,6 @@
                                   "operation-id": 39, "timestamp": 0,
                                   "result-text": "remove_user succeeded"}])
 
-
         users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/home/bo",
                   "/bin/zsh")]
         self.setup_environment(users, [], None)
@@ -357,7 +356,6 @@
                                   "operation-id": 40, "timestamp": 0,
                                   "result-text": "remove_user succeeded"}])
 
-
         results = []
         results.append(self.manager.dispatch_message({"username": "foo",
                                                       "delete-home": True,
@@ -378,7 +376,7 @@
 
         def handle_callback(result):
             messages = self.broker_service.message_store.get_pending_messages()
-            self.assertEquals(len(messages), 1)
+            self.assertEqual(len(messages), 1)
             failure_string = "UserManagementError: remove_user failed"
             self.assertMessages(messages,
                                 [{"type": "operation-result", "status": FAILED,
@@ -407,7 +405,7 @@
         def handle_callback(result):
                 messages = (
                     self.broker_service.message_store.get_pending_messages())
-                self.assertEquals(len(messages), 3)
+                self.assertEqual(len(messages), 3)
                 # Ignore the message created by plugin.run.
                 self.assertMessages([messages[2], messages[1]],
                                     [{"timestamp": 0, "delete-users": ["jdoe"],
@@ -446,7 +444,7 @@
         def handle_callback2(result, messages):
             message_store = self.broker_service.message_store
             new_messages = message_store.get_pending_messages()
-            self.assertEquals(messages, new_messages)
+            self.assertEqual(messages, new_messages)
 
         users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/home/bo",
                   "/bin/zsh")]
@@ -470,7 +468,7 @@
 
         def handle_callback(result):
             messages = self.broker_service.message_store.get_pending_messages()
-            self.assertEquals(len(messages), 3)
+            self.assertEqual(len(messages), 3)
             self.assertMessages([messages[0], messages[2]],
                                 [{"type": "users",
                                   "create-users": [{"home-phone": None,
@@ -507,10 +505,11 @@
 
         def handle_callback(result):
             messages = self.broker_service.message_store.get_pending_messages()
-            self.assertEquals(len(messages), 3, messages)
+            self.assertEqual(len(messages), 3, messages)
             # Ignore the message created by plugin.run.
             self.assertMessages([messages[2], messages[1]],
-                                [{"timestamp": 0, "type": "users", "operation-id": 99,
+                                [{"timestamp": 0, "type": "users",
+                                  "operation-id": 99,
                                   "update-users": [{"home-phone": None,
                                                     "username": "jdoe",
                                                     "uid": 1000,
@@ -524,7 +523,8 @@
                                   "operation-id": 99, "timestamp": 0,
                                   "result-text": "lock_user succeeded"}])
 
-        users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/home/bo", "/bin/zsh")]
+        users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/home/bo",
+                  "/bin/zsh")]
         self.setup_environment(users, [], self.shadow_file)
         result = self.manager.dispatch_message(
             {"username": "jdoe",
@@ -543,7 +543,7 @@
 
         def handle_callback(result):
             messages = self.broker_service.message_store.get_pending_messages()
-            self.assertEquals(len(messages), 1)
+            self.assertEqual(len(messages), 1)
             failure_string = "UserManagementError: lock_user failed"
             self.assertMessages(messages,
                                 [{"type": "operation-result",
@@ -577,7 +577,7 @@
         def handle_callback2(result, messages):
             message_store = self.broker_service.message_store
             new_messages = message_store.get_pending_messages()
-            self.assertEquals(messages, new_messages)
+            self.assertEqual(messages, new_messages)
 
         users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/home/bo",
                   "/bin/zsh")]
@@ -598,7 +598,7 @@
         """
         def handle_callback(result):
             messages = self.broker_service.message_store.get_pending_messages()
-            self.assertEquals(len(messages), 3)
+            self.assertEqual(len(messages), 3)
             self.assertMessages([messages[0], messages[2]],
                                 [{"type": "users",
                                   "create-users": [{"home-phone": None,
@@ -639,10 +639,11 @@
 
         def handle_callback(result):
             messages = self.broker_service.message_store.get_pending_messages()
-            self.assertEquals(len(messages), 3)
+            self.assertEqual(len(messages), 3)
             # Ignore the message created by plugin.run.
             self.assertMessages([messages[2], messages[1]],
-                                [{"timestamp": 0, "type": "users", "operation-id": 99,
+                                [{"timestamp": 0, "type": "users",
+                                  "operation-id": 99,
                                   "update-users": [{"home-phone": None,
                                                     "username": "psmith",
                                                     "uid": 1000,
@@ -677,7 +678,7 @@
 
         def handle_callback(result):
             messages = self.broker_service.message_store.get_pending_messages()
-            self.assertEquals(len(messages), 1)
+            self.assertEqual(len(messages), 1)
             failure_string = "UserManagementError: unlock_user failed"
             self.assertMessages(messages,
                                 [{"type": "operation-result",
@@ -712,7 +713,7 @@
         def handle_callback2(result, messages):
             message_store = self.broker_service.message_store
             new_messages = message_store.get_pending_messages()
-            self.assertEquals(messages, new_messages)
+            self.assertEqual(messages, new_messages)
 
         users = [("psmith", "x", 1000, 1000, "Paul Smith,,,,", "/home/psmith",
                   "/bin/zsh")]
@@ -736,7 +737,7 @@
 
         def handle_callback(result):
             messages = self.broker_service.message_store.get_pending_messages()
-            self.assertEquals(len(messages), 3)
+            self.assertEqual(len(messages), 3)
             self.assertMessages([messages[0], messages[2]],
                                 [{"type": "users",
                                   "create-users": [{"home-phone": None,
@@ -781,7 +782,7 @@
 
         def handle_callback(result):
             messages = self.broker_service.message_store.get_pending_messages()
-            self.assertEquals(len(messages), 2)
+            self.assertEqual(len(messages), 2)
             # Ignore the message created by plugin.run.
             self.assertMessages([messages[1], messages[0]],
                                 [{"type": "users", "timestamp": 0,
@@ -819,7 +820,7 @@
         def handle_callback2(result, messages):
             message_store = self.broker_service.message_store
             new_messages = message_store.get_pending_messages()
-            self.assertEquals(messages, new_messages)
+            self.assertEqual(messages, new_messages)
 
         plugin = self.setup_environment([], [], None)
         result = self.manager.dispatch_message(
@@ -829,7 +830,6 @@
         result.addCallback(handle_callback1)
         return result
 
-
     def test_add_group_event_with_external_changes(self):
         """
         If external user changes have been made but not detected by
@@ -840,7 +840,7 @@
 
         def handle_callback(result):
             messages = self.broker_service.message_store.get_pending_messages()
-            self.assertEquals(len(messages), 3)
+            self.assertEqual(len(messages), 3)
             # We skip the operation-result message.
             self.assertMessages([messages[0], messages[2]],
                                 [{"type": "users",
@@ -859,7 +859,6 @@
         result.addCallback(handle_callback)
         return result
 
-
     def test_edit_group_event(self):
         """
         When an C{edit-group} message is received the specified group
@@ -872,25 +871,25 @@
 
         def handle_callback(result):
             messages = self.broker_service.message_store.get_pending_messages()
-            self.assertEquals(len(messages), 3)
+            self.assertEqual(len(messages), 3)
             # Ignore the message created when the initial snapshot was
             # taken before the operation was performed.
-            self.assertMessages(messages,
-                                [{"create-groups": [{"gid": 50,
-                                                     "name": "sales"}],
-                                  "timestamp": 0,
-                                  "type": "users"},
-                                 {"type": "operation-result",
-                                  "status": SUCCEEDED,
-                                  "operation-id": 123, "timestamp": 0,
-                                  "result-text": "set_group_details succeeded"},
-                                 {"delete-groups": ["sales"],
-                                  "create-groups": [{"gid": 50,
-                                                     "name": "bizdev"}],
-                                  "timestamp": 0,
-                                  "operation-id": 123,
-                                  "type": "users"},])
-
+            expected = [{"create-groups": [{"gid": 50,
+                                            "name": "sales"}],
+                         "timestamp": 0,
+                         "type": "users"},
+                        {"type": "operation-result",
+                         "status": SUCCEEDED,
+                         "operation-id": 123, "timestamp": 0,
+                         "result-text": "set_group_details succeeded"},
+                        {"delete-groups": ["sales"],
+                         "create-groups": [{"gid": 50,
+                                            "name": "bizdev"}],
+                         "timestamp": 0,
+                         "operation-id": 123,
+                         "type": "users"},
+                        ]
+            self.assertMessages(messages, expected)
 
         groups = [("sales", "x", 50, [])]
         self.setup_environment([], groups, None)
@@ -920,7 +919,7 @@
         def handle_callback2(result, messages):
             message_store = self.broker_service.message_store
             new_messages = message_store.get_pending_messages()
-            self.assertEquals(messages, new_messages)
+            self.assertEqual(messages, new_messages)
 
         groups = [("sales", "x", 50, [])]
         plugin = self.setup_environment([], groups, None)
@@ -953,7 +952,7 @@
         def handle_callback2(result):
             message_store = self.broker_service.message_store
             messages = message_store.get_pending_messages()
-            self.assertEquals(len(messages), 3)
+            self.assertEqual(len(messages), 3)
             self.assertMessages([messages[0], messages[2]],
                                 [{"type": "users",
                                   "create-groups": [{"gid": 1001,
@@ -964,14 +963,12 @@
                                   "create-groups": [{"gid": 1001,
                                                      "name": "webdev"}]}])
 
-
         groups = [("sales", "x", 1001, [])]
         plugin = self.setup_environment([], groups, None)
         result = plugin.run()
         result.addCallback(handle_callback1)
         return result
 
-
     def test_add_group_member_event(self):
         """
         When an C{add-group-member} message is received the new user
@@ -983,19 +980,18 @@
 
         def handle_callback(result):
             messages = self.broker_service.message_store.get_pending_messages()
-            self.assertEquals(len(messages), 3)
+            self.assertEqual(len(messages), 3)
             # Ignore the message created when the initial snapshot was
             # taken before the operation was performed.
-            self.assertMessages([messages[2], messages[1]],
-                                [{"type": "users", "timestamp": 0,
-                                  "operation-id": 123,
-                                  "create-group-members": {"bizdev": ["jdoe"]}},
-                                 {"type": "operation-result",
-                                  "timestamp": 0,
-                                  "status": SUCCEEDED,
-                                  "operation-id": 123,
-                                  "result-text": "add_group_member succeeded"}])
-
+            expected = [{"type": "users", "timestamp": 0,
+                         "operation-id": 123,
+                         "create-group-members": {"bizdev": ["jdoe"]}},
+                        {"type": "operation-result",
+                         "timestamp": 0,
+                         "status": SUCCEEDED,
+                         "operation-id": 123,
+                         "result-text": "add_group_member succeeded"}]
+            self.assertMessages([messages[2], messages[1]], expected)
 
         users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/bin/sh",
                   "/home/jdoe")]
@@ -1009,7 +1005,6 @@
         result.addCallback(handle_callback)
         return result
 
-
     def test_add_group_member_with_username_and_groupname_event(self):
         """
         When an C{add-group-member} message is received with a
@@ -1022,17 +1017,16 @@
 
         def handle_callback(result):
             messages = self.broker_service.message_store.get_pending_messages()
-            self.assertEquals(len(messages), 3)
+            self.assertEqual(len(messages), 3)
             # Ignore the message created when the initial snapshot was
             # taken before the operation was performed.
-            self.assertMessages([messages[2], messages[1]],
-                               [{"type": "users", "timestamp": 0,
-                                  "operation-id": 123,
-                                  "create-group-members": {"bizdev": ["jdoe"]}},
-                                 {"type": "operation-result", "timestamp": 0,
-                                  "status": SUCCEEDED, "operation-id": 123,
-                                 "result-text": "add_group_member succeeded"}])
-
+            expected = [{"type": "users", "timestamp": 0,
+                         "operation-id": 123,
+                         "create-group-members": {"bizdev": ["jdoe"]}},
+                        {"type": "operation-result", "timestamp": 0,
+                         "status": SUCCEEDED, "operation-id": 123,
+                         "result-text": "add_group_member succeeded"}]
+            self.assertMessages([messages[2], messages[1]], expected)
 
         users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/bin/sh",
                   "/home/jdoe")]
@@ -1065,7 +1059,7 @@
         def handle_callback2(result, messages):
             message_store = self.broker_service.message_store
             new_messages = message_store.get_pending_messages()
-            self.assertEquals(messages, new_messages)
+            self.assertEqual(messages, new_messages)
 
         users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/bin/sh",
                   "/home/jdoe")]
@@ -1090,21 +1084,21 @@
 
         def handle_callback(result):
             messages = self.broker_service.message_store.get_pending_messages()
-            self.assertEquals(len(messages), 3)
-            self.assertMessages([messages[0], messages[2]],
-                                [{"type": "users",
-                                  "create-users": [{"home-phone": None,
-                                                    "username": "jdoe",
-                                                    "uid": 1000,
-                                                    "enabled": True,
-                                                    "location": None,
-                                                    "work-phone": None,
-                                                    "primary-gid": 1000,
-                                                    "name": "John Doe"}],
-                                  "create-groups": [{"gid": 1001,
-                                                     "name": "bizdev"}]},
-                                 {"type": "users", "operation-id": 123,
-                                  "create-group-members": {"bizdev": ["jdoe"]}}])
+            self.assertEqual(len(messages), 3)
+            expected = [{"type": "users",
+                          "create-users": [{"home-phone": None,
+                                            "username": "jdoe",
+                                            "uid": 1000,
+                                            "enabled": True,
+                                            "location": None,
+                                            "work-phone": None,
+                                            "primary-gid": 1000,
+                                            "name": "John Doe"}],
+                          "create-groups": [{"gid": 1001,
+                                             "name": "bizdev"}]},
+                         {"type": "users", "operation-id": 123,
+                          "create-group-members": {"bizdev": ["jdoe"]}}]
+            self.assertMessages([messages[0], messages[2]], expected)
 
         users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/bin/sh",
                   "/home/jdoe")]
@@ -1129,9 +1123,10 @@
 
         def handle_callback(result):
             messages = self.broker_service.message_store.get_pending_messages()
-            self.assertEquals(len(messages), 3)
+            self.assertEqual(len(messages), 3)
             # Ignore the message created by plugin.run.
-            self.assertMessages([messages[2], messages[1]],
+            self.assertMessages(
+                [messages[2], messages[1]],
                 [{"type": "users", "timestamp": 0,
                   "operation-id": 123,
                   "delete-group-members": {"bizdev": ["jdoe"]}},
@@ -1140,7 +1135,6 @@
                   "operation-id": 123, "timestamp": 0,
                   "result-text": "remove_group_member succeeded"}])
 
-
         users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/bin/sh",
                   "/home/jdoe")]
         groups = [("bizdev", "x", 1001, ["jdoe"])]
@@ -1169,7 +1163,7 @@
         def handle_callback2(result, messages):
             message_store = self.broker_service.message_store
             new_messages = message_store.get_pending_messages()
-            self.assertEquals(messages, new_messages)
+            self.assertEqual(messages, new_messages)
 
         users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/bin/sh",
                   "/home/jdoe")]
@@ -1193,22 +1187,22 @@
 
         def handle_callback(result):
             messages = self.broker_service.message_store.get_pending_messages()
-            self.assertEquals(len(messages), 3)
-            self.assertMessages([messages[0], messages[2]],
-                                [{"timestamp": 0, "type": "users",
-                                  "create-users": [{"home-phone": None,
-                                                    "username": "jdoe",
-                                                    "uid": 1000,
-                                                    "enabled": True,
-                                                    "location": None,
-                                                    "work-phone": None,
-                                                    "primary-gid": 1000,
-                                                    "name": "John Doe"}],
-                                  "create-groups": [{"gid": 1001,
-                                                     "name": "bizdev"}],
-                                  "create-group-members": {"bizdev": ["jdoe"]}},
-                                 {"type": "users", "operation-id": 123,
-                                  "delete-group-members": {"bizdev": ["jdoe"]}}])
+            self.assertEqual(len(messages), 3)
+            expected = [{"timestamp": 0, "type": "users",
+                         "create-users": [{"home-phone": None,
+                                           "username": "jdoe",
+                                           "uid": 1000,
+                                           "enabled": True,
+                                           "location": None,
+                                           "work-phone": None,
+                                           "primary-gid": 1000,
+                                           "name": "John Doe"}],
+                         "create-groups": [{"gid": 1001,
+                                            "name": "bizdev"}],
+                         "create-group-members": {"bizdev": ["jdoe"]}},
+                        {"type": "users", "operation-id": 123,
+                         "delete-group-members": {"bizdev": ["jdoe"]}}]
+            self.assertMessages([messages[0], messages[2]], expected)
 
         users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/bin/sh",
                   "/home/jdoe")]
@@ -1232,7 +1226,6 @@
         """
 
         def handle_callback1(result):
-
             result = self.manager.dispatch_message(
                 {"groupname": "sales", "type": "remove-group",
                  "operation-id": 123})
@@ -1243,7 +1236,7 @@
         def handle_callback2(result):
             message_store = self.broker_service.message_store
             messages = message_store.get_pending_messages()
-            self.assertEquals(len(messages), 3)
+            self.assertEqual(len(messages), 3)
             # Ignore the message created when the initial snapshot was
             # taken before the operation was performed.
             self.assertMessages([messages[2], messages[1]],
@@ -1280,7 +1273,7 @@
         def handle_callback2(result, messages):
             message_store = self.broker_service.message_store
             new_messages = message_store.get_pending_messages()
-            self.assertEquals(messages, new_messages)
+            self.assertEqual(messages, new_messages)
 
         groups = [("sales", "x", 50, [])]
         plugin = self.setup_environment([], groups, None)
@@ -1310,7 +1303,7 @@
         def handle_callback2(result):
             message_store = self.broker_service.message_store
             messages = message_store.get_pending_messages()
-            self.assertEquals(len(messages), 3)
+            self.assertEqual(len(messages), 3)
             self.assertMessages([messages[0], messages[2]],
                                 [{"type": "users",
                                   "create-groups": [{"gid": 1001,
@@ -1343,7 +1336,7 @@
                  "psmith:!:13348:0:99999:7:::\n"
                  "yo:$1$q7sz09uw$q.A3526M/SHu8vUb.Jo1A/:13349:0:99999:7:::\n")
         fd.close()
-        self.assertEquals(self.user_manager.get_locked_usernames(), ["psmith"])
+        self.assertEqual(self.user_manager.get_locked_usernames(), ["psmith"])
 
     def test_get_locked_usernames_with_empty_shadow_file(self):
         """
@@ -1353,7 +1346,7 @@
         fd = open(self.shadow_file, "w")
         fd.write("\n")
         fd.close()
-        self.assertEquals(self.user_manager.get_locked_usernames(), [])
+        self.assertEqual(self.user_manager.get_locked_usernames(), [])
 
     def test_get_locked_usernames_with_non_existing_shadow_file(self):
         """
@@ -1362,7 +1355,7 @@
         """
         self.log_helper.ignore_errors("Error reading shadow file.*")
         self.assertFalse(os.path.exists(self.shadow_file))
-        self.assertEquals(self.user_manager.get_locked_usernames(), [])
+        self.assertEqual(self.user_manager.get_locked_usernames(), [])
         self.assertIn("Error reading shadow file. [Errno 2] No such file or "
                       "directory", self.logfile.getvalue())
 

=== modified file 'landscape/monitor/tests/test_activeprocessinfo.py'
--- landscape/monitor/tests/test_activeprocessinfo.py	2010-04-09 14:43:09 +0000
+++ landscape/monitor/tests/test_activeprocessinfo.py	2011-07-06 21:14:28 +0000
@@ -36,9 +36,9 @@
         self.monitor.add(plugin)
         plugin.exchange()
         message = self.mstore.get_pending_messages()[0]
-        self.assertEquals(message["type"], "active-process-info")
+        self.assertEqual(message["type"], "active-process-info")
         self.assertTrue("kill-all-processes" in message)
-        self.assertEquals(message["kill-all-processes"], True)
+        self.assertEqual(message["kill-all-processes"], True)
         self.assertTrue("add-processes" in message)
 
     def test_only_first_run_includes_kill_message(self):
@@ -56,14 +56,14 @@
                                  process_name="blargh")
         self.monitor.exchange()
         messages = self.mstore.get_pending_messages()
-        self.assertEquals(len(messages), 2)
+        self.assertEqual(len(messages), 2)
         message = messages[0]
-        self.assertEquals(message["type"], "active-process-info")
+        self.assertEqual(message["type"], "active-process-info")
         self.assertTrue("kill-all-processes" in message)
         self.assertTrue("add-processes" in message)
 
         message = messages[1]
-        self.assertEquals(message["type"], "active-process-info")
+        self.assertEqual(message["type"], "active-process-info")
         self.assertTrue("add-processes" in message)
 
     def test_terminating_process_race(self):
@@ -113,7 +113,7 @@
         self.monitor.add(plugin)
         plugin.exchange()
         message = self.mstore.get_pending_messages()[0]
-        self.assertEquals(message["type"], "active-process-info")
+        self.assertEqual(message["type"], "active-process-info")
         self.assertTrue("kill-all-processes" in message)
         self.assertTrue("add-processes" in message)
         expected_process_0 = {"state": "R", "gid": 0, "pid": 1,
@@ -127,8 +127,8 @@
                               "start-time": 112, "percent-cpu": 0.0}
         processes = message["add-processes"]
         processes.sort(key=operator.itemgetter("pid"))
-        self.assertEquals(processes, [expected_process_0, expected_process_1,
-                                      expected_process_2])
+        self.assertEqual(processes, [expected_process_0, expected_process_1,
+                                     expected_process_2])
 
     def test_skip_non_numeric_subdirs(self):
         """Test ensures the plugin doesn't touch non-process dirs in /proc."""
@@ -144,14 +144,14 @@
         self.monitor.add(plugin)
         plugin.exchange()
         message = self.mstore.get_pending_messages()[0]
-        self.assertEquals(message["type"], "active-process-info")
+        self.assertEqual(message["type"], "active-process-info")
         self.assertTrue("kill-all-processes" in message)
         self.assertTrue("add-processes" in message)
 
         expected_process = {"pid": 1, "state": "R", "name": "init",
                             "vm-size": 11676, "uid": 0, "gid": 0,
                             "start-time": 112, "percent-cpu": 0.0}
-        self.assertEquals(message["add-processes"], [expected_process])
+        self.assertEqual(message["add-processes"], [expected_process])
 
     def test_plugin_manager(self):
         """Test plugin manager integration."""
@@ -196,48 +196,48 @@
 
         plugin.exchange()
         messages = self.mstore.get_pending_messages()
-        self.assertEquals(len(messages), 2)
+        self.assertEqual(len(messages), 2)
 
         # The first time the plugin runs we expect all known processes
         # to be killed.
         message = messages[0]
-        self.assertEquals(message["type"], "active-process-info")
+        self.assertEqual(message["type"], "active-process-info")
         self.assertTrue("kill-all-processes" in message)
-        self.assertEquals(message["kill-all-processes"], True)
+        self.assertEqual(message["kill-all-processes"], True)
         self.assertTrue("add-processes" in message)
         expected_process_0 = {"state": "R", "gid": 0, "pid": 1,
-                              "vm-size": 11676, "name": "init", 
+                              "vm-size": 11676, "name": "init",
                               "uid": 0, "start-time": 101,
                               "percent-cpu": 0.0}
         expected_process_1 = {"state": "T", "gid": 1000, "pid": 671,
-                              "vm-size": 11676, "name": "blargh", 
+                              "vm-size": 11676, "name": "blargh",
                               "uid": 1000, "start-time": 102,
                               "percent-cpu": 0.0}
         expected_process_2 = {"state": "I", "gid": 1000, "pid": 672,
-                              "vm-size": 11676, "name": "blarpy", 
+                              "vm-size": 11676, "name": "blarpy",
                               "uid": 1000, "start-time": 104,
                               "percent-cpu": 0.0}
         processes = message["add-processes"]
         processes.sort(key=operator.itemgetter("pid"))
-        self.assertEquals(processes, [expected_process_0, expected_process_1,
-                                      expected_process_2])
+        self.assertEqual(processes, [expected_process_0, expected_process_1,
+                                     expected_process_2])
 
         # Report diff-like changes to processes, such as terminated
         # processes and new processes.
         message = messages[1]
-        self.assertEquals(message["type"], "active-process-info")
+        self.assertEqual(message["type"], "active-process-info")
 
         self.assertTrue("add-processes" in message)
-        self.assertEquals(len(message["add-processes"]), 1)
+        self.assertEqual(len(message["add-processes"]), 1)
         expected_process = {"state": "R", "gid": 0, "pid": 12753,
                             "vm-size": 11676, "name": "wubble",
                             "uid": 0, "start-time": 107,
                             "percent-cpu": 0.0}
-        self.assertEquals(message["add-processes"], [expected_process])
+        self.assertEqual(message["add-processes"], [expected_process])
 
         self.assertTrue("kill-processes" in message)
-        self.assertEquals(len(message["kill-processes"]), 1)
-        self.assertEquals(message["kill-processes"], [671])
+        self.assertEqual(len(message["kill-processes"]), 1)
+        self.assertEqual(message["kill-processes"], [671])
 
     def test_only_queue_message_when_process_data_is_available(self):
         """Test ensures that messages are only queued when data changes."""
@@ -249,10 +249,10 @@
         self.monitor.add(plugin)
 
         plugin.exchange()
-        self.assertEquals(len(self.mstore.get_pending_messages()), 1)
+        self.assertEqual(len(self.mstore.get_pending_messages()), 1)
 
         plugin.exchange()
-        self.assertEquals(len(self.mstore.get_pending_messages()), 1)
+        self.assertEqual(len(self.mstore.get_pending_messages()), 1)
 
     def test_only_report_active_processes(self):
         """Test ensures the plugin only reports active processes."""
@@ -283,7 +283,7 @@
 
         plugin.exchange()
         messages = self.mstore.get_pending_messages()
-        self.assertEquals(len(messages), 1)
+        self.assertEqual(len(messages), 1)
 
         message = messages[0]
         self.assertTrue("kill-all-processes" in message)
@@ -292,7 +292,7 @@
 
         pids = [process["pid"] for process in message["add-processes"]]
         pids.sort()
-        self.assertEquals(pids, [673, 674, 675, 676, 677, 678])
+        self.assertEqual(pids, [673, 674, 675, 676, 677, 678])
 
     def test_report_interesting_state_changes(self):
         """Test ensures that interesting state changes are reported."""
@@ -307,14 +307,14 @@
         plugin.exchange()
 
         messages = self.mstore.get_pending_messages()
-        self.assertEquals(len(messages), 1)
+        self.assertEqual(len(messages), 1)
         message = messages[0]
 
         self.assertTrue("kill-all-processes" in message)
         self.assertTrue("kill-processes" not in message)
         self.assertTrue("add-processes" in message)
-        self.assertEquals(message["add-processes"][0]["pid"], 672)
-        self.assertEquals(message["add-processes"][0]["state"], u"R")
+        self.assertEqual(message["add-processes"][0]["pid"], 672)
+        self.assertEqual(message["add-processes"][0]["state"], u"R")
 
         # Convert the process to a zombie and ensure it gets reported.
         self.builder.remove_data(672)
@@ -325,12 +325,12 @@
         plugin.exchange()
 
         messages = self.mstore.get_pending_messages()
-        self.assertEquals(len(messages), 2)
+        self.assertEqual(len(messages), 2)
         message = messages[1]
 
         self.assertTrue("kill-all-processes" not in message)
         self.assertTrue("update-processes" in message)
-        self.assertEquals(message["update-processes"][0]["state"], u"Z")
+        self.assertEqual(message["update-processes"][0]["state"], u"Z")
 
     def test_call_on_accepted(self):
         """
@@ -340,12 +340,12 @@
         plugin = ActiveProcessInfo(proc_dir=self.sample_dir, uptime=100,
                                    jiffies=10)
         self.monitor.add(plugin)
-        self.assertEquals(len(self.mstore.get_pending_messages()), 0)
+        self.assertEqual(len(self.mstore.get_pending_messages()), 0)
         result = self.monitor.fire_event(
             "message-type-acceptance-changed", "active-process-info", True)
 
         def assert_messages(ignored):
-            self.assertEquals(len(self.mstore.get_pending_messages()), 1)
+            self.assertEqual(len(self.mstore.get_pending_messages()), 1)
 
         result.addCallback(assert_messages)
         return result
@@ -441,7 +441,7 @@
         message = plugin.get_message()
 
         def assert_message(message_id):
-            self.assertEquals(message, plugin.get_message())
+            self.assertEqual(message, plugin.get_message())
 
         result = plugin.exchange()
         result.addCallback(assert_message)
@@ -465,7 +465,7 @@
         plugin.exchange()
 
         messages = self.mstore.get_pending_messages()
-        self.assertEquals(len(messages), 1)
+        self.assertEqual(len(messages), 1)
 
         self.builder.remove_data(1)
         self.builder.create_data(1, self.builder.RUNNING, uid=0, gid=0,
@@ -474,7 +474,7 @@
         plugin.exchange()
 
         messages = self.mstore.get_pending_messages()
-        self.assertEquals(len(messages), 2)
+        self.assertEqual(len(messages), 2)
         self.assertMessages(messages, [{"timestamp": 0,
                                         "api": SERVER_API,
                                         "type": "active-process-info",
@@ -534,14 +534,14 @@
         self.monitor.add(plugin)
         plugin.exchange()
         message = self.mstore.get_pending_messages()[0]
-        self.assertEquals(message["type"], "active-process-info")
+        self.assertEqual(message["type"], "active-process-info")
         self.assertTrue("kill-all-processes" in message)
         self.assertTrue("add-processes" in message)
         expected_process_0 = {"state": "R", "gid": 0, "pid": 1,
                               "vm-size": 11676, "name": "NetworkManagerDaemon",
                               "uid": 0, "start-time": 103, "percent-cpu": 0.0}
         processes = message["add-processes"]
-        self.assertEquals(processes, [expected_process_0])
+        self.assertEqual(processes, [expected_process_0])
 
     def test_strip_command_line_name_whitespace(self):
         """Whitespace should be stripped from command-line names."""
@@ -553,8 +553,8 @@
         self.monitor.add(plugin)
         plugin.exchange()
         message = self.mstore.get_pending_messages()[0]
-        self.assertEquals(message["add-processes"][0]["name"],
-                          u"postgres: writer process")
+        self.assertEqual(message["add-processes"][0]["name"],
+                         u"postgres: writer process")
 
     def test_read_process_with_no_cmdline(self):
         """Test reading a process without a cmdline file."""
@@ -568,14 +568,14 @@
         self.monitor.add(plugin)
         plugin.exchange()
         message = self.mstore.get_pending_messages()[0]
-        self.assertEquals(message["type"], "active-process-info")
+        self.assertEqual(message["type"], "active-process-info")
         self.assertTrue("kill-all-processes" in message)
         self.assertTrue("add-processes" in message)
         expected_process_0 = {"state": "R", "gid": 0, "pid": 1,
                               "vm-size": 11676, "name": "ProcessWithLong",
                               "uid": 0, "start-time": 103, "percent-cpu": 0.0}
         processes = message["add-processes"]
-        self.assertEquals(processes, [expected_process_0])
+        self.assertEqual(processes, [expected_process_0])
 
     def test_generate_cpu_usage(self):
         """
@@ -596,7 +596,7 @@
         self.monitor.add(plugin)
         plugin.exchange()
         message = self.mstore.get_pending_messages()[0]
-        self.assertEquals(message["type"], "active-process-info")
+        self.assertEqual(message["type"], "active-process-info")
         self.assertTrue("kill-all-processes" in message)
         self.assertTrue("add-processes" in message)
         processes = message["add-processes"]
@@ -605,7 +605,7 @@
                               "uid": 0, "start-time": 300,
                               "percent-cpu": 4.00}
         processes = message["add-processes"]
-        self.assertEquals(processes, [expected_process_0])
+        self.assertEqual(processes, [expected_process_0])
 
     def test_generate_cpu_usage_capped(self):
         """
@@ -627,7 +627,7 @@
         self.monitor.add(plugin)
         plugin.exchange()
         message = self.mstore.get_pending_messages()[0]
-        self.assertEquals(message["type"], "active-process-info")
+        self.assertEqual(message["type"], "active-process-info")
         self.assertTrue("kill-all-processes" in message)
         self.assertTrue("add-processes" in message)
         processes = message["add-processes"]
@@ -636,4 +636,4 @@
                               "uid": 0, "start-time": 300,
                               "percent-cpu": 99.00}
         processes = message["add-processes"]
-        self.assertEquals(processes, [expected_process_0])
+        self.assertEqual(processes, [expected_process_0])

=== modified file 'landscape/monitor/tests/test_aptpreferences.py'
--- landscape/monitor/tests/test_aptpreferences.py	2010-12-10 13:49:46 +0000
+++ landscape/monitor/tests/test_aptpreferences.py	2011-07-06 21:14:28 +0000
@@ -33,8 +33,8 @@
         preferences_filename = os.path.join(self.etc_apt_directory,
                                             "preferences")
         self.makeFile(path=preferences_filename, content="crap")
-        self.assertEquals(self.plugin.get_data(),
-                          {preferences_filename: "crap"})
+        self.assertEqual(self.plugin.get_data(),
+                         {preferences_filename: "crap"})
 
     def test_get_data_with_empty_preferences_directory(self):
         """
@@ -56,8 +56,8 @@
         self.makeDir(path=preferences_directory)
         filename1 = self.makeFile(dirname=preferences_directory, content="foo")
         filename2 = self.makeFile(dirname=preferences_directory, content="bar")
-        self.assertEquals(self.plugin.get_data(), {filename1: "foo",
-                                                   filename2: "bar"})
+        self.assertEqual(self.plugin.get_data(), {filename1: "foo",
+                                                  filename2: "bar"})
 
     def test_get_data_with_one_big_file(self):
         """
@@ -68,7 +68,7 @@
                                             "preferences")
         limit = self.plugin.size_limit
         self.makeFile(path=preferences_filename, content="a" * (limit + 1))
-        self.assertEquals(self.plugin.get_data(), {
+        self.assertEqual(self.plugin.get_data(), {
             preferences_filename: "a" * (limit - len(preferences_filename))})
 
     def test_get_data_with_many_big_files(self):
@@ -84,9 +84,9 @@
                                   content="a" * (limit / 2))
         filename2 = self.makeFile(dirname=preferences_directory,
                                   content="b" * (limit / 2))
-        self.assertEquals(self.plugin.get_data(),
-                          {filename1: "a" * (limit / 2 - len(filename1)),
-                           filename2: "b" * (limit / 2 - len(filename2))})
+        self.assertEqual(self.plugin.get_data(),
+                         {filename1: "a" * (limit / 2 - len(filename1)),
+                          filename2: "b" * (limit / 2 - len(filename2))})
 
     def test_exchange_without_apt_preferences_data(self):
         """
@@ -94,7 +94,7 @@
         """
         self.mstore.set_accepted_types(["apt-preferences"])
         self.plugin.exchange()
-        self.assertEquals(self.mstore.get_pending_messages(), [])
+        self.assertEqual(self.mstore.get_pending_messages(), [])
 
     def test_exchange(self):
         """
@@ -113,10 +113,10 @@
                                                  content="foo")
         self.plugin.exchange()
         messages = self.mstore.get_pending_messages()
-        self.assertEquals(messages[0]["type"], "apt-preferences")
-        self.assertEquals(messages[0]["data"],
-                          {main_preferences_filename: u"crap",
-                           sub_preferences_filename: u"foo"})
+        self.assertEqual(messages[0]["type"], "apt-preferences")
+        self.assertEqual(messages[0]["data"],
+                         {main_preferences_filename: u"crap",
+                          sub_preferences_filename: u"foo"})
         for filename in messages[0]["data"]:
             self.assertTrue(isinstance(filename, unicode))
 
@@ -125,7 +125,7 @@
         os.remove(sub_preferences_filename)
         self.plugin.exchange()
         messages = self.mstore.get_pending_messages()
-        self.assertEquals(messages[1]["type"], "apt-preferences")
+        self.assertEqual(messages[1]["type"], "apt-preferences")
         self.assertIdentical(messages[1]["data"], None)
 
     def test_exchange_only_once(self):
@@ -140,9 +140,9 @@
         self.makeFile(path=preferences_filename, content="crap")
         self.plugin.exchange()
         messages = self.mstore.get_pending_messages()
-        self.assertEquals(len(messages), 1)
+        self.assertEqual(len(messages), 1)
         messages = self.mstore.get_pending_messages()
-        self.assertEquals(len(messages), 1)
+        self.assertEqual(len(messages), 1)
 
     def test_run(self):
         """
@@ -174,4 +174,4 @@
         self.reactor.fire("resynchronize")
         self.plugin.run()
         messages = self.mstore.get_pending_messages()
-        self.assertEquals(len(messages), 2)
+        self.assertEqual(len(messages), 2)