Merge lp:~jseutter/landscape-client/assert-equal into lp:~landscape/landscape-client/trunk
- assert-equal
- Merge into trunk
Status: | Merged |
---|---|
Approved by: | Alberto Donato |
Approved revision: | no longer in the source branch. |
Merge reported by: | Jerry Seutter |
Merged at revision: | not available |
Proposed branch: | lp:~jseutter/landscape-client/assert-equal |
Merge into: | lp:~landscape/landscape-client/trunk |
Diff against target: |
12957 lines (+2542/-2548) 96 files modified
landscape/broker/tests/test_amp.py (+2/-2) landscape/broker/tests/test_client.py (+8/-8) landscape/broker/tests/test_config.py (+10/-10) landscape/broker/tests/test_exchange.py (+116/-116) landscape/broker/tests/test_exchangestore.py (+10/-10) landscape/broker/tests/test_ping.py (+22/-18) landscape/broker/tests/test_server.py (+16/-16) landscape/broker/tests/test_service.py (+8/-8) landscape/broker/tests/test_store.py (+58/-58) landscape/broker/tests/test_transport.py (+27/-25) landscape/lib/tests/test_amp.py (+10/-13) landscape/lib/tests/test_bootstrap.py (+1/-1) landscape/lib/tests/test_bpickle.py (+14/-15) landscape/lib/tests/test_bpickle_dbus.py (+3/-3) landscape/lib/tests/test_command.py (+10/-10) landscape/lib/tests/test_disk.py (+5/-5) landscape/lib/tests/test_fd.py (+4/-3) landscape/lib/tests/test_fetch.py (+126/-124) landscape/lib/tests/test_fs.py (+5/-5) landscape/lib/tests/test_gpg.py (+5/-4) landscape/lib/tests/test_lsb_release.py (+7/-7) landscape/lib/tests/test_monitor.py (+27/-27) landscape/lib/tests/test_persist.py (+37/-37) landscape/lib/tests/test_process.py (+8/-8) landscape/lib/tests/test_scriptcontent.py (+6/-5) landscape/lib/tests/test_sequenceranges.py (+79/-79) landscape/lib/tests/test_sysstats.py (+51/-50) landscape/lib/tests/test_timestamp.py (+2/-2) landscape/lib/tests/test_warning.py (+2/-2) landscape/manager/tests/test_config.py (+6/-6) landscape/manager/tests/test_customgraph.py (+32/-31) landscape/manager/tests/test_packagemanager.py (+6/-6) landscape/manager/tests/test_processkiller.py (+1/-1) landscape/manager/tests/test_scriptexecution.py (+25/-25) landscape/manager/tests/test_service.py (+2/-2) landscape/manager/tests/test_shutdownmanager.py (+7/-7) landscape/manager/tests/test_store.py (+9/-9) landscape/manager/tests/test_usermanager.py (+106/-113) landscape/monitor/tests/test_activeprocessinfo.py (+47/-47) landscape/monitor/tests/test_aptpreferences.py (+17/-17) landscape/monitor/tests/test_computerinfo.py (+42/-42) landscape/monitor/tests/test_computeruptime.py (+58/-58) landscape/monitor/tests/test_config.py (+4/-4) landscape/monitor/tests/test_hardwareinventory.py (+38/-38) landscape/monitor/tests/test_loadaverage.py (+10/-10) landscape/monitor/tests/test_memoryinfo.py (+8/-8) landscape/monitor/tests/test_monitor.py (+4/-4) landscape/monitor/tests/test_mountinfo.py (+97/-97) landscape/monitor/tests/test_networkactivity.py (+6/-6) landscape/monitor/tests/test_networkdevice.py (+4/-4) landscape/monitor/tests/test_packagemonitor.py (+9/-9) landscape/monitor/tests/test_plugin.py (+9/-9) landscape/monitor/tests/test_processorinfo.py (+87/-85) landscape/monitor/tests/test_rebootrequired.py (+7/-7) landscape/monitor/tests/test_service.py (+2/-2) landscape/monitor/tests/test_temperature.py (+20/-20) landscape/monitor/tests/test_usermonitor.py (+2/-3) landscape/package/tests/test_changer.py (+49/-49) landscape/package/tests/test_facade.py (+72/-72) landscape/package/tests/test_interface.py (+7/-7) landscape/package/tests/test_releaseupgrader.py (+63/-63) landscape/package/tests/test_reporter.py (+76/-76) landscape/package/tests/test_skeleton.py (+6/-7) landscape/package/tests/test_store.py (+109/-115) landscape/package/tests/test_taskhandler.py (+21/-23) landscape/sysinfo/tests/test_deployment.py (+3/-3) landscape/sysinfo/tests/test_disk.py (+39/-39) landscape/sysinfo/tests/test_landscapelink.py (+1/-1) landscape/sysinfo/tests/test_load.py (+2/-2) landscape/sysinfo/tests/test_loggedinusers.py (+10/-7) landscape/sysinfo/tests/test_memory.py (+3/-4) landscape/sysinfo/tests/test_network.py (+1/-1) landscape/sysinfo/tests/test_processes.py (+8/-7) landscape/sysinfo/tests/test_sysinfo.py (+107/-106) landscape/sysinfo/tests/test_temperature.py (+6/-6) landscape/tests/test_accumulate.py (+28/-28) landscape/tests/test_configuration.py (+18/-20) landscape/tests/test_deployment.py (+46/-46) landscape/tests/test_diff.py (+8/-8) landscape/tests/test_hal.py (+8/-8) landscape/tests/test_log.py (+20/-20) landscape/tests/test_patch.py (+29/-30) landscape/tests/test_plugin.py (+3/-3) landscape/tests/test_reactor.py (+48/-38) landscape/tests/test_schema.py (+41/-51) landscape/tests/test_service.py (+1/-1) landscape/tests/test_sysvconfig.py (+2/-2) landscape/tests/test_textmessage.py (+8/-8) landscape/tests/test_watchdog.py (+62/-63) landscape/upgraders/tests/test_broker.py (+1/-1) landscape/upgraders/tests/test_legacy.py (+37/-37) landscape/upgraders/tests/test_monitor.py (+1/-1) landscape/upgraders/tests/test_package.py (+1/-1) landscape/user/tests/test_changes.py (+50/-50) landscape/user/tests/test_management.py (+54/-54) landscape/user/tests/test_provider.py (+149/-149) |
To merge this branch: | bzr merge lp:~jseutter/landscape-client/assert-equal |
Related bugs: |
Reviewer | Review Type | Date Requested | Status |
---|---|---|---|
Alberto Donato (community) | Approve | ||
Free Ekanayaka (community) | Approve | ||
Review via email: mp+66955@code.launchpad.net |
Commit message
Description of the change
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/
landscape/
landscape/
landscape/
- 339. By Alberto Donato
-
Merge sources.
list-preserve- old-permissions [f=804548] [r=bigkevmcd, therve] - 340. By Jerry Seutter
-
Test file refactoring only. Refactored assertEquals -> assertEqual and
did some PEP8 and lint cleanups.
[r=ack,free] [f=805746]
Preview Diff
1 | === modified file 'landscape/broker/tests/test_amp.py' | |||
2 | --- landscape/broker/tests/test_amp.py 2010-04-23 09:44:28 +0000 | |||
3 | +++ landscape/broker/tests/test_amp.py 2011-07-06 21:14:28 +0000 | |||
4 | @@ -126,8 +126,8 @@ | |||
5 | 126 | """ | 126 | """ |
6 | 127 | 127 | ||
7 | 128 | def assert_response(response): | 128 | def assert_response(response): |
10 | 129 | self.assertEquals(response, None) | 129 | self.assertEqual(response, None) |
11 | 130 | self.assertEquals( | 130 | self.assertEqual( |
12 | 131 | self.exchanger.get_client_accepted_message_types(), | 131 | self.exchanger.get_client_accepted_message_types(), |
13 | 132 | sorted(["type"] + DEFAULT_ACCEPTED_TYPES)) | 132 | sorted(["type"] + DEFAULT_ACCEPTED_TYPES)) |
14 | 133 | 133 | ||
15 | 134 | 134 | ||
16 | === modified file 'landscape/broker/tests/test_client.py' | |||
17 | --- landscape/broker/tests/test_client.py 2010-05-12 13:48:30 +0000 | |||
18 | +++ landscape/broker/tests/test_client.py 2011-07-06 21:14:28 +0000 | |||
19 | @@ -34,7 +34,7 @@ | |||
20 | 34 | plugins = [BrokerClientPlugin(), BrokerClientPlugin()] | 34 | plugins = [BrokerClientPlugin(), BrokerClientPlugin()] |
21 | 35 | self.client.add(plugins[0]) | 35 | self.client.add(plugins[0]) |
22 | 36 | self.client.add(plugins[1]) | 36 | self.client.add(plugins[1]) |
24 | 37 | self.assertEquals(self.client.get_plugins(), plugins) | 37 | self.assertEqual(self.client.get_plugins(), plugins) |
25 | 38 | 38 | ||
26 | 39 | def test_get_plugins_returns_a_copy(self): | 39 | def test_get_plugins_returns_a_copy(self): |
27 | 40 | """ | 40 | """ |
28 | @@ -43,7 +43,7 @@ | |||
29 | 43 | """ | 43 | """ |
30 | 44 | plugins = self.client.get_plugins() | 44 | plugins = self.client.get_plugins() |
31 | 45 | plugins.append(BrokerClientPlugin()) | 45 | plugins.append(BrokerClientPlugin()) |
33 | 46 | self.assertEquals(self.client.get_plugins(), []) | 46 | self.assertEqual(self.client.get_plugins(), []) |
34 | 47 | 47 | ||
35 | 48 | def test_get_named_plugin(self): | 48 | def test_get_named_plugin(self): |
36 | 49 | """ | 49 | """ |
37 | @@ -53,7 +53,7 @@ | |||
38 | 53 | plugin = BrokerClientPlugin() | 53 | plugin = BrokerClientPlugin() |
39 | 54 | plugin.plugin_name = "foo" | 54 | plugin.plugin_name = "foo" |
40 | 55 | self.client.add(plugin) | 55 | self.client.add(plugin) |
42 | 56 | self.assertEquals(self.client.get_plugin("foo"), plugin) | 56 | self.assertEqual(self.client.get_plugin("foo"), plugin) |
43 | 57 | 57 | ||
44 | 58 | def test_run_interval(self): | 58 | def test_run_interval(self): |
45 | 59 | """ | 59 | """ |
46 | @@ -89,7 +89,7 @@ | |||
47 | 89 | result2 = self.client.register_message("bar", lambda m: None) | 89 | result2 = self.client.register_message("bar", lambda m: None) |
48 | 90 | 90 | ||
49 | 91 | def got_result(result): | 91 | def got_result(result): |
51 | 92 | self.assertEquals( | 92 | self.assertEqual( |
52 | 93 | self.exchanger.get_client_accepted_message_types(), | 93 | self.exchanger.get_client_accepted_message_types(), |
53 | 94 | sorted(["bar", "foo"] + DEFAULT_ACCEPTED_TYPES)) | 94 | sorted(["bar", "foo"] + DEFAULT_ACCEPTED_TYPES)) |
54 | 95 | 95 | ||
55 | @@ -106,7 +106,7 @@ | |||
56 | 106 | self.mocker.replay() | 106 | self.mocker.replay() |
57 | 107 | 107 | ||
58 | 108 | def dispatch_message(result): | 108 | def dispatch_message(result): |
60 | 109 | self.assertEquals(self.client.dispatch_message(message), 123) | 109 | self.assertEqual(self.client.dispatch_message(message), 123) |
61 | 110 | 110 | ||
62 | 111 | result = self.client.register_message("foo", handle_message) | 111 | result = self.client.register_message("foo", handle_message) |
63 | 112 | return result.addCallback(dispatch_message) | 112 | return result.addCallback(dispatch_message) |
64 | @@ -138,7 +138,7 @@ | |||
65 | 138 | """ | 138 | """ |
66 | 139 | error = self.assertRaises(HandlerNotFoundError, | 139 | error = self.assertRaises(HandlerNotFoundError, |
67 | 140 | self.client.dispatch_message, {"type": "x"}) | 140 | self.client.dispatch_message, {"type": "x"}) |
69 | 141 | self.assertEquals(str(error), "x") | 141 | self.assertEqual(str(error), "x") |
70 | 142 | 142 | ||
71 | 143 | def test_message(self): | 143 | def test_message(self): |
72 | 144 | """ | 144 | """ |
73 | @@ -152,7 +152,7 @@ | |||
74 | 152 | self.mocker.replay() | 152 | self.mocker.replay() |
75 | 153 | 153 | ||
76 | 154 | def dispatch_message(result): | 154 | def dispatch_message(result): |
78 | 155 | self.assertEquals(self.client.message(message), True) | 155 | self.assertEqual(self.client.message(message), True) |
79 | 156 | 156 | ||
80 | 157 | result = self.client.register_message("foo", handle_message) | 157 | result = self.client.register_message("foo", handle_message) |
81 | 158 | return result.addCallback(dispatch_message) | 158 | return result.addCallback(dispatch_message) |
82 | @@ -163,7 +163,7 @@ | |||
83 | 163 | handler was found. | 163 | handler was found. |
84 | 164 | """ | 164 | """ |
85 | 165 | message = {"type": "foo"} | 165 | message = {"type": "foo"} |
87 | 166 | self.assertEquals(self.client.message(message), False) | 166 | self.assertEqual(self.client.message(message), False) |
88 | 167 | 167 | ||
89 | 168 | def test_exchange(self): | 168 | def test_exchange(self): |
90 | 169 | """ | 169 | """ |
91 | 170 | 170 | ||
92 | === modified file 'landscape/broker/tests/test_config.py' | |||
93 | --- landscape/broker/tests/test_config.py 2010-04-12 11:40:06 +0000 | |||
94 | +++ landscape/broker/tests/test_config.py 2011-07-06 21:14:28 +0000 | |||
95 | @@ -22,8 +22,8 @@ | |||
96 | 22 | configuration.load(["--http-proxy", "foo", | 22 | configuration.load(["--http-proxy", "foo", |
97 | 23 | "--https-proxy", "bar", | 23 | "--https-proxy", "bar", |
98 | 24 | "--url", "whatever"]) | 24 | "--url", "whatever"]) |
101 | 25 | self.assertEquals(os.environ["http_proxy"], "foo") | 25 | self.assertEqual(os.environ["http_proxy"], "foo") |
102 | 26 | self.assertEquals(os.environ["https_proxy"], "bar") | 26 | self.assertEqual(os.environ["https_proxy"], "bar") |
103 | 27 | 27 | ||
104 | 28 | def test_loading_without_http_proxies_does_not_touch_environment(self): | 28 | def test_loading_without_http_proxies_does_not_touch_environment(self): |
105 | 29 | """ | 29 | """ |
106 | @@ -36,8 +36,8 @@ | |||
107 | 36 | 36 | ||
108 | 37 | configuration = BrokerConfiguration() | 37 | configuration = BrokerConfiguration() |
109 | 38 | configuration.load(["--url", "whatever"]) | 38 | configuration.load(["--url", "whatever"]) |
112 | 39 | self.assertEquals(os.environ["http_proxy"], "heyo") | 39 | self.assertEqual(os.environ["http_proxy"], "heyo") |
113 | 40 | self.assertEquals(os.environ["https_proxy"], "baroo") | 40 | self.assertEqual(os.environ["https_proxy"], "baroo") |
114 | 41 | 41 | ||
115 | 42 | def test_loading_resets_http_proxies(self): | 42 | def test_loading_resets_http_proxies(self): |
116 | 43 | """ | 43 | """ |
117 | @@ -55,12 +55,12 @@ | |||
118 | 55 | configuration.load(["--http-proxy", "x", | 55 | configuration.load(["--http-proxy", "x", |
119 | 56 | "--https-proxy", "y", | 56 | "--https-proxy", "y", |
120 | 57 | "--url", "whatever"]) | 57 | "--url", "whatever"]) |
123 | 58 | self.assertEquals(os.environ["http_proxy"], "x") | 58 | self.assertEqual(os.environ["http_proxy"], "x") |
124 | 59 | self.assertEquals(os.environ["https_proxy"], "y") | 59 | self.assertEqual(os.environ["https_proxy"], "y") |
125 | 60 | 60 | ||
126 | 61 | configuration.load(["--url", "whatever"]) | 61 | configuration.load(["--url", "whatever"]) |
129 | 62 | self.assertEquals(os.environ["http_proxy"], "original") | 62 | self.assertEqual(os.environ["http_proxy"], "original") |
130 | 63 | self.assertEquals(os.environ["https_proxy"], "originals") | 63 | self.assertEqual(os.environ["https_proxy"], "originals") |
131 | 64 | 64 | ||
132 | 65 | def test_intervals_are_ints(self): | 65 | def test_intervals_are_ints(self): |
133 | 66 | """ | 66 | """ |
134 | @@ -74,5 +74,5 @@ | |||
135 | 74 | configuration = BrokerConfiguration() | 74 | configuration = BrokerConfiguration() |
136 | 75 | configuration.load(["--config", filename, "--url", "whatever"]) | 75 | configuration.load(["--config", filename, "--url", "whatever"]) |
137 | 76 | 76 | ||
140 | 77 | self.assertEquals(configuration.urgent_exchange_interval, 12) | 77 | self.assertEqual(configuration.urgent_exchange_interval, 12) |
141 | 78 | self.assertEquals(configuration.exchange_interval, 34) | 78 | self.assertEqual(configuration.exchange_interval, 34) |
142 | 79 | 79 | ||
143 | === modified file 'landscape/broker/tests/test_exchange.py' | |||
144 | --- landscape/broker/tests/test_exchange.py 2011-03-25 08:42:48 +0000 | |||
145 | +++ landscape/broker/tests/test_exchange.py 2011-07-06 21:14:28 +0000 | |||
146 | @@ -47,11 +47,11 @@ | |||
147 | 47 | self.mstore.set_accepted_types(["empty"]) | 47 | self.mstore.set_accepted_types(["empty"]) |
148 | 48 | self.exchanger.send({"type": "empty"}) | 48 | self.exchanger.send({"type": "empty"}) |
149 | 49 | self.exchanger.exchange() | 49 | self.exchanger.exchange() |
151 | 50 | self.assertEquals(len(self.transport.payloads), 1) | 50 | self.assertEqual(len(self.transport.payloads), 1) |
152 | 51 | messages = self.transport.payloads[0]["messages"] | 51 | messages = self.transport.payloads[0]["messages"] |
156 | 52 | self.assertEquals(messages, [{"type": "empty", | 52 | self.assertEqual(messages, [{"type": "empty", |
157 | 53 | "timestamp": 0, | 53 | "timestamp": 0, |
158 | 54 | "api": SERVER_API}]) | 54 | "api": SERVER_API}]) |
159 | 55 | 55 | ||
160 | 56 | def test_send_urgent(self): | 56 | def test_send_urgent(self): |
161 | 57 | """ | 57 | """ |
162 | @@ -61,7 +61,7 @@ | |||
163 | 61 | self.mstore.set_accepted_types(["empty"]) | 61 | self.mstore.set_accepted_types(["empty"]) |
164 | 62 | self.exchanger.send({"type": "empty"}, urgent=True) | 62 | self.exchanger.send({"type": "empty"}, urgent=True) |
165 | 63 | self.wait_for_exchange(urgent=True) | 63 | self.wait_for_exchange(urgent=True) |
167 | 64 | self.assertEquals(len(self.transport.payloads), 1) | 64 | self.assertEqual(len(self.transport.payloads), 1) |
168 | 65 | self.assertMessages(self.transport.payloads[0]["messages"], | 65 | self.assertMessages(self.transport.payloads[0]["messages"], |
169 | 66 | [{"type": "empty"}]) | 66 | [{"type": "empty"}]) |
170 | 67 | 67 | ||
171 | @@ -75,7 +75,7 @@ | |||
172 | 75 | self.wait_for_exchange(urgent=True, factor=0.5) | 75 | self.wait_for_exchange(urgent=True, factor=0.5) |
173 | 76 | self.exchanger.send({"type": "empty"}, urgent=True) | 76 | self.exchanger.send({"type": "empty"}, urgent=True) |
174 | 77 | self.wait_for_exchange(urgent=True, factor=0.5) | 77 | self.wait_for_exchange(urgent=True, factor=0.5) |
176 | 78 | self.assertEquals(len(self.transport.payloads), 1) | 78 | self.assertEqual(len(self.transport.payloads), 1) |
177 | 79 | self.assertMessages(self.transport.payloads[0]["messages"], | 79 | self.assertMessages(self.transport.payloads[0]["messages"], |
178 | 80 | [{"type": "empty"}, {"type": "empty"}]) | 80 | [{"type": "empty"}, {"type": "empty"}]) |
179 | 81 | 81 | ||
180 | @@ -96,7 +96,7 @@ | |||
181 | 96 | """ | 96 | """ |
182 | 97 | payload = self.exchanger.make_payload() | 97 | payload = self.exchanger.make_payload() |
183 | 98 | self.assertTrue("accepted-types" in payload) | 98 | self.assertTrue("accepted-types" in payload) |
185 | 99 | self.assertEquals(payload["accepted-types"], md5("").digest()) | 99 | self.assertEqual(payload["accepted-types"], md5("").digest()) |
186 | 100 | 100 | ||
187 | 101 | def test_set_accepted_types(self): | 101 | def test_set_accepted_types(self): |
188 | 102 | """ | 102 | """ |
189 | @@ -105,7 +105,7 @@ | |||
190 | 105 | """ | 105 | """ |
191 | 106 | self.exchanger.handle_message( | 106 | self.exchanger.handle_message( |
192 | 107 | {"type": "accepted-types", "types": ["foo"]}) | 107 | {"type": "accepted-types", "types": ["foo"]}) |
194 | 108 | self.assertEquals(self.mstore.get_accepted_types(), ["foo"]) | 108 | self.assertEqual(self.mstore.get_accepted_types(), ["foo"]) |
195 | 109 | 109 | ||
196 | 110 | def test_message_type_acceptance_changed_event(self): | 110 | def test_message_type_acceptance_changed_event(self): |
197 | 111 | stash = [] | 111 | stash = [] |
198 | @@ -117,8 +117,8 @@ | |||
199 | 117 | {"type": "accepted-types", "types": ["a", "b"]}) | 117 | {"type": "accepted-types", "types": ["a", "b"]}) |
200 | 118 | self.exchanger.handle_message( | 118 | self.exchanger.handle_message( |
201 | 119 | {"type": "accepted-types", "types": ["b", "c"]}) | 119 | {"type": "accepted-types", "types": ["b", "c"]}) |
204 | 120 | self.assertEquals(stash, [("a", True), ("b", True), | 120 | self.assertEqual(stash, [("a", True), ("b", True), |
205 | 121 | ("a", False), ("c", True)]) | 121 | ("a", False), ("c", True)]) |
206 | 122 | 122 | ||
207 | 123 | def test_accepted_types_roundtrip(self): | 123 | def test_accepted_types_roundtrip(self): |
208 | 124 | """ | 124 | """ |
209 | @@ -129,8 +129,8 @@ | |||
210 | 129 | {"type": "accepted-types", "types": ["ack", "bar"]}) | 129 | {"type": "accepted-types", "types": ["ack", "bar"]}) |
211 | 130 | payload = self.exchanger.make_payload() | 130 | payload = self.exchanger.make_payload() |
212 | 131 | self.assertTrue("accepted-types" in payload) | 131 | self.assertTrue("accepted-types" in payload) |
215 | 132 | self.assertEquals(payload["accepted-types"], | 132 | self.assertEqual(payload["accepted-types"], |
216 | 133 | md5("ack;bar").digest()) | 133 | md5("ack;bar").digest()) |
217 | 134 | 134 | ||
218 | 135 | def test_accepted_types_causes_urgent_if_held_messages_exist(self): | 135 | def test_accepted_types_causes_urgent_if_held_messages_exist(self): |
219 | 136 | """ | 136 | """ |
220 | @@ -138,11 +138,11 @@ | |||
221 | 138 | have a held message, an urgent exchange should occur. | 138 | have a held message, an urgent exchange should occur. |
222 | 139 | """ | 139 | """ |
223 | 140 | self.exchanger.send({"type": "holdme"}) | 140 | self.exchanger.send({"type": "holdme"}) |
225 | 141 | self.assertEquals(self.mstore.get_pending_messages(), []) | 141 | self.assertEqual(self.mstore.get_pending_messages(), []) |
226 | 142 | self.exchanger.handle_message( | 142 | self.exchanger.handle_message( |
227 | 143 | {"type": "accepted-types", "types": ["holdme"]}) | 143 | {"type": "accepted-types", "types": ["holdme"]}) |
228 | 144 | self.wait_for_exchange(urgent=True) | 144 | self.wait_for_exchange(urgent=True) |
230 | 145 | self.assertEquals(len(self.transport.payloads), 1) | 145 | self.assertEqual(len(self.transport.payloads), 1) |
231 | 146 | self.assertMessages(self.transport.payloads[0]["messages"], | 146 | self.assertMessages(self.transport.payloads[0]["messages"], |
232 | 147 | [{"type": "holdme"}]) | 147 | [{"type": "holdme"}]) |
233 | 148 | 148 | ||
234 | @@ -152,10 +152,10 @@ | |||
235 | 152 | then no urgent exchange should occur. | 152 | then no urgent exchange should occur. |
236 | 153 | """ | 153 | """ |
237 | 154 | self.exchanger.send({"type": "holdme"}) | 154 | self.exchanger.send({"type": "holdme"}) |
239 | 155 | self.assertEquals(self.transport.payloads, []) | 155 | self.assertEqual(self.transport.payloads, []) |
240 | 156 | self.reactor.fire("message", | 156 | self.reactor.fire("message", |
241 | 157 | {"type": "accepted-types", "types": ["irrelevant"]}) | 157 | {"type": "accepted-types", "types": ["irrelevant"]}) |
243 | 158 | self.assertEquals(len(self.transport.payloads), 0) | 158 | self.assertEqual(len(self.transport.payloads), 0) |
244 | 159 | 159 | ||
245 | 160 | def test_sequence_is_committed_immediately(self): | 160 | def test_sequence_is_committed_immediately(self): |
246 | 161 | """ | 161 | """ |
247 | @@ -174,13 +174,13 @@ | |||
248 | 174 | def handler(message): | 174 | def handler(message): |
249 | 175 | persist = Persist(filename=self.persist_filename) | 175 | persist = Persist(filename=self.persist_filename) |
250 | 176 | store = MessageStore(persist, self.config.message_store_path) | 176 | store = MessageStore(persist, self.config.message_store_path) |
253 | 177 | self.assertEquals(store.get_pending_offset(), 1) | 177 | self.assertEqual(store.get_pending_offset(), 1) |
254 | 178 | self.assertEquals(store.get_sequence(), 1) | 178 | self.assertEqual(store.get_sequence(), 1) |
255 | 179 | handled.append(True) | 179 | handled.append(True) |
256 | 180 | 180 | ||
257 | 181 | self.exchanger.register_message("inbound", handler) | 181 | self.exchanger.register_message("inbound", handler) |
258 | 182 | self.exchanger.exchange() | 182 | self.exchanger.exchange() |
260 | 183 | self.assertEquals(handled, [True], self.logfile.getvalue()) | 183 | self.assertEqual(handled, [True], self.logfile.getvalue()) |
261 | 184 | 184 | ||
262 | 185 | def test_messages_from_server_commit(self): | 185 | def test_messages_from_server_commit(self): |
263 | 186 | """ | 186 | """ |
264 | @@ -194,14 +194,14 @@ | |||
265 | 194 | def handler(message): | 194 | def handler(message): |
266 | 195 | Persist(filename=self.persist_filename) | 195 | Persist(filename=self.persist_filename) |
267 | 196 | store = MessageStore(self.persist, self.config.message_store_path) | 196 | store = MessageStore(self.persist, self.config.message_store_path) |
270 | 197 | self.assertEquals(store.get_server_sequence(), | 197 | self.assertEqual(store.get_server_sequence(), |
271 | 198 | self.message_counter) | 198 | self.message_counter) |
272 | 199 | self.message_counter += 1 | 199 | self.message_counter += 1 |
273 | 200 | handled.append(True) | 200 | handled.append(True) |
274 | 201 | 201 | ||
275 | 202 | self.exchanger.register_message("inbound", handler) | 202 | self.exchanger.register_message("inbound", handler) |
276 | 203 | self.exchanger.exchange() | 203 | self.exchanger.exchange() |
278 | 204 | self.assertEquals(handled, [True] * 3, self.logfile.getvalue()) | 204 | self.assertEqual(handled, [True] * 3, self.logfile.getvalue()) |
279 | 205 | 205 | ||
280 | 206 | def test_messages_from_server_causing_urgent_exchanges(self): | 206 | def test_messages_from_server_causing_urgent_exchanges(self): |
281 | 207 | """ | 207 | """ |
282 | @@ -219,11 +219,11 @@ | |||
283 | 219 | 219 | ||
284 | 220 | self.exchanger.exchange() | 220 | self.exchanger.exchange() |
285 | 221 | 221 | ||
287 | 222 | self.assertEquals(len(self.transport.payloads), 1) | 222 | self.assertEqual(len(self.transport.payloads), 1) |
288 | 223 | 223 | ||
289 | 224 | self.wait_for_exchange(urgent=True) | 224 | self.wait_for_exchange(urgent=True) |
290 | 225 | 225 | ||
292 | 226 | self.assertEquals(len(self.transport.payloads), 2) | 226 | self.assertEqual(len(self.transport.payloads), 2) |
293 | 227 | self.assertMessages(self.transport.payloads[1]["messages"], | 227 | self.assertMessages(self.transport.payloads[1]["messages"], |
294 | 228 | [{"type": "empty"}]) | 228 | [{"type": "empty"}]) |
295 | 229 | 229 | ||
296 | @@ -236,7 +236,7 @@ | |||
297 | 236 | self.mstore.add({"type": "data", "data": 0}) | 236 | self.mstore.add({"type": "data", "data": 0}) |
298 | 237 | self.mstore.add({"type": "data", "data": 1}) | 237 | self.mstore.add({"type": "data", "data": 1}) |
299 | 238 | self.exchanger.exchange() | 238 | self.exchanger.exchange() |
301 | 239 | self.assertEquals(self.mstore.get_sequence(), 2) | 239 | self.assertEqual(self.mstore.get_sequence(), 2) |
302 | 240 | 240 | ||
303 | 241 | self.mstore.add({"type": "data", "data": 2}) | 241 | self.mstore.add({"type": "data", "data": 2}) |
304 | 242 | self.mstore.add({"type": "data", "data": 3}) | 242 | self.mstore.add({"type": "data", "data": 3}) |
305 | @@ -248,7 +248,7 @@ | |||
306 | 248 | 248 | ||
307 | 249 | self.transport.exchange = desynched_send_data | 249 | self.transport.exchange = desynched_send_data |
308 | 250 | self.exchanger.exchange() | 250 | self.exchanger.exchange() |
310 | 251 | self.assertEquals(self.mstore.get_sequence(), 1) | 251 | self.assertEqual(self.mstore.get_sequence(), 1) |
311 | 252 | del self.transport.exchange | 252 | del self.transport.exchange |
312 | 253 | 253 | ||
313 | 254 | exchanged = [] | 254 | exchanged = [] |
314 | @@ -258,15 +258,15 @@ | |||
315 | 258 | 258 | ||
316 | 259 | self.reactor.call_on("exchange-done", exchange_callback) | 259 | self.reactor.call_on("exchange-done", exchange_callback) |
317 | 260 | self.wait_for_exchange(urgent=True) | 260 | self.wait_for_exchange(urgent=True) |
319 | 261 | self.assertEquals(exchanged, [True]) | 261 | self.assertEqual(exchanged, [True]) |
320 | 262 | 262 | ||
321 | 263 | payload = self.transport.payloads[-1] | 263 | payload = self.transport.payloads[-1] |
322 | 264 | self.assertMessages(payload["messages"], | 264 | self.assertMessages(payload["messages"], |
323 | 265 | [{"type": "data", "data": 1}, | 265 | [{"type": "data", "data": 1}, |
324 | 266 | {"type": "data", "data": 2}, | 266 | {"type": "data", "data": 2}, |
325 | 267 | {"type": "data", "data": 3}]) | 267 | {"type": "data", "data": 3}]) |
328 | 268 | self.assertEquals(payload["sequence"], 1) | 268 | self.assertEqual(payload["sequence"], 1) |
329 | 269 | self.assertEquals(payload["next-expected-sequence"], 0) | 269 | self.assertEqual(payload["next-expected-sequence"], 0) |
330 | 270 | 270 | ||
331 | 271 | def test_start_with_urgent_exchange(self): | 271 | def test_start_with_urgent_exchange(self): |
332 | 272 | """ | 272 | """ |
333 | @@ -278,7 +278,7 @@ | |||
334 | 278 | self.config) | 278 | self.config) |
335 | 279 | exchanger.start() | 279 | exchanger.start() |
336 | 280 | self.wait_for_exchange(urgent=True) | 280 | self.wait_for_exchange(urgent=True) |
338 | 281 | self.assertEquals(len(transport.payloads), 1) | 281 | self.assertEqual(len(transport.payloads), 1) |
339 | 282 | 282 | ||
340 | 283 | def test_reschedule_after_exchange(self): | 283 | def test_reschedule_after_exchange(self): |
341 | 284 | """ | 284 | """ |
342 | @@ -288,13 +288,13 @@ | |||
343 | 288 | self.exchanger.schedule_exchange(urgent=True) | 288 | self.exchanger.schedule_exchange(urgent=True) |
344 | 289 | 289 | ||
345 | 290 | self.wait_for_exchange(urgent=True) | 290 | self.wait_for_exchange(urgent=True) |
353 | 291 | self.assertEquals(len(self.transport.payloads), 1) | 291 | self.assertEqual(len(self.transport.payloads), 1) |
354 | 292 | 292 | ||
355 | 293 | self.wait_for_exchange() | 293 | self.wait_for_exchange() |
356 | 294 | self.assertEquals(len(self.transport.payloads), 2) | 294 | self.assertEqual(len(self.transport.payloads), 2) |
357 | 295 | 295 | ||
358 | 296 | self.wait_for_exchange() | 296 | self.wait_for_exchange() |
359 | 297 | self.assertEquals(len(self.transport.payloads), 3) | 297 | self.assertEqual(len(self.transport.payloads), 3) |
360 | 298 | 298 | ||
361 | 299 | def test_leave_urgent_exchange_mode_after_exchange(self): | 299 | def test_leave_urgent_exchange_mode_after_exchange(self): |
362 | 300 | """ | 300 | """ |
363 | @@ -304,9 +304,9 @@ | |||
364 | 304 | self.mstore.set_accepted_types(["empty"]) | 304 | self.mstore.set_accepted_types(["empty"]) |
365 | 305 | self.exchanger.send({"type": "empty"}, urgent=True) | 305 | self.exchanger.send({"type": "empty"}, urgent=True) |
366 | 306 | self.wait_for_exchange(urgent=True) | 306 | self.wait_for_exchange(urgent=True) |
368 | 307 | self.assertEquals(len(self.transport.payloads), 1) | 307 | self.assertEqual(len(self.transport.payloads), 1) |
369 | 308 | self.wait_for_exchange(urgent=True) | 308 | self.wait_for_exchange(urgent=True) |
371 | 309 | self.assertEquals(len(self.transport.payloads), 1) # no change | 309 | self.assertEqual(len(self.transport.payloads), 1) # no change |
372 | 310 | 310 | ||
373 | 311 | def test_ancient_causes_resynchronize(self): | 311 | def test_ancient_causes_resynchronize(self): |
374 | 312 | """ | 312 | """ |
375 | @@ -388,7 +388,7 @@ | |||
376 | 388 | self.transport.exchange = desynched_send_data | 388 | self.transport.exchange = desynched_send_data |
377 | 389 | self.exchanger.exchange() | 389 | self.exchanger.exchange() |
378 | 390 | 390 | ||
380 | 391 | self.assertEquals(self.mstore.get_sequence(), 0) | 391 | self.assertEqual(self.mstore.get_sequence(), 0) |
381 | 392 | del self.transport.exchange | 392 | del self.transport.exchange |
382 | 393 | 393 | ||
383 | 394 | exchanged = [] | 394 | exchanged = [] |
384 | @@ -398,9 +398,9 @@ | |||
385 | 398 | 398 | ||
386 | 399 | self.reactor.call_on("exchange-done", exchange_callback) | 399 | self.reactor.call_on("exchange-done", exchange_callback) |
387 | 400 | self.wait_for_exchange(urgent=True) | 400 | self.wait_for_exchange(urgent=True) |
389 | 401 | self.assertEquals(exchanged, []) | 401 | self.assertEqual(exchanged, []) |
390 | 402 | self.wait_for_exchange() | 402 | self.wait_for_exchange() |
392 | 403 | self.assertEquals(exchanged, [True]) | 403 | self.assertEqual(exchanged, [True]) |
393 | 404 | 404 | ||
394 | 405 | def test_old_sequence_id_does_not_cause_resynchronize(self): | 405 | def test_old_sequence_id_does_not_cause_resynchronize(self): |
395 | 406 | resynchronized = [] | 406 | resynchronized = [] |
396 | @@ -414,7 +414,7 @@ | |||
397 | 414 | self.transport.next_expected_sequence = 0 | 414 | self.transport.next_expected_sequence = 0 |
398 | 415 | 415 | ||
399 | 416 | self.exchanger.exchange() | 416 | self.exchanger.exchange() |
401 | 417 | self.assertEquals(resynchronized, []) | 417 | self.assertEqual(resynchronized, []) |
402 | 418 | 418 | ||
403 | 419 | def test_per_api_payloads(self): | 419 | def test_per_api_payloads(self): |
404 | 420 | """ | 420 | """ |
405 | @@ -433,9 +433,9 @@ | |||
406 | 433 | # the client API. | 433 | # the client API. |
407 | 434 | payload = self.transport.payloads[-1] | 434 | payload = self.transport.payloads[-1] |
408 | 435 | self.assertMessages(payload["messages"], []) | 435 | self.assertMessages(payload["messages"], []) |
412 | 436 | self.assertEquals(payload.get("client-api"), CLIENT_API) | 436 | self.assertEqual(payload.get("client-api"), CLIENT_API) |
413 | 437 | self.assertEquals(payload.get("server-api"), SERVER_API) | 437 | self.assertEqual(payload.get("server-api"), SERVER_API) |
414 | 438 | self.assertEquals(self.transport.message_api, SERVER_API) | 438 | self.assertEqual(self.transport.message_api, SERVER_API) |
415 | 439 | 439 | ||
416 | 440 | self.mstore.add({"type": "a", "api": "1.0"}) | 440 | self.mstore.add({"type": "a", "api": "1.0"}) |
417 | 441 | self.mstore.add({"type": "b", "api": "1.0"}) | 441 | self.mstore.add({"type": "b", "api": "1.0"}) |
418 | @@ -452,9 +452,9 @@ | |||
419 | 452 | self.assertMessages(payload["messages"], | 452 | self.assertMessages(payload["messages"], |
420 | 453 | [{"type": "a", "api": "1.0"}, | 453 | [{"type": "a", "api": "1.0"}, |
421 | 454 | {"type": "b", "api": "1.0"}]) | 454 | {"type": "b", "api": "1.0"}]) |
425 | 455 | self.assertEquals(payload.get("client-api"), CLIENT_API) | 455 | self.assertEqual(payload.get("client-api"), CLIENT_API) |
426 | 456 | self.assertEquals(payload.get("server-api"), "1.0") | 456 | self.assertEqual(payload.get("server-api"), "1.0") |
427 | 457 | self.assertEquals(self.transport.message_api, "1.0") | 457 | self.assertEqual(self.transport.message_api, "1.0") |
428 | 458 | 458 | ||
429 | 459 | self.exchanger.exchange() | 459 | self.exchanger.exchange() |
430 | 460 | 460 | ||
431 | @@ -462,9 +462,9 @@ | |||
432 | 462 | self.assertMessages(payload["messages"], | 462 | self.assertMessages(payload["messages"], |
433 | 463 | [{"type": "c", "api": "1.1"}, | 463 | [{"type": "c", "api": "1.1"}, |
434 | 464 | {"type": "d", "api": "1.1"}]) | 464 | {"type": "d", "api": "1.1"}]) |
438 | 465 | self.assertEquals(payload.get("client-api"), CLIENT_API) | 465 | self.assertEqual(payload.get("client-api"), CLIENT_API) |
439 | 466 | self.assertEquals(payload.get("server-api"), "1.1") | 466 | self.assertEqual(payload.get("server-api"), "1.1") |
440 | 467 | self.assertEquals(self.transport.message_api, "1.1") | 467 | self.assertEqual(self.transport.message_api, "1.1") |
441 | 468 | 468 | ||
442 | 469 | self.exchanger.exchange() | 469 | self.exchanger.exchange() |
443 | 470 | 470 | ||
444 | @@ -472,9 +472,9 @@ | |||
445 | 472 | self.assertMessages(payload["messages"], | 472 | self.assertMessages(payload["messages"], |
446 | 473 | [{"type": "e", "api": None}, | 473 | [{"type": "e", "api": None}, |
447 | 474 | {"type": "f", "api": None}]) | 474 | {"type": "f", "api": None}]) |
451 | 475 | self.assertEquals(payload.get("client-api"), CLIENT_API) | 475 | self.assertEqual(payload.get("client-api"), CLIENT_API) |
452 | 476 | self.assertEquals(payload.get("server-api"), "2.0") | 476 | self.assertEqual(payload.get("server-api"), "2.0") |
453 | 477 | self.assertEquals(self.transport.message_api, "2.0") | 477 | self.assertEqual(self.transport.message_api, "2.0") |
454 | 478 | 478 | ||
455 | 479 | def test_include_total_messages_none(self): | 479 | def test_include_total_messages_none(self): |
456 | 480 | """ | 480 | """ |
457 | @@ -483,7 +483,7 @@ | |||
458 | 483 | """ | 483 | """ |
459 | 484 | self.mstore.set_accepted_types(["empty"]) | 484 | self.mstore.set_accepted_types(["empty"]) |
460 | 485 | self.exchanger.exchange() | 485 | self.exchanger.exchange() |
462 | 486 | self.assertEquals(self.transport.payloads[0]["total-messages"], 0) | 486 | self.assertEqual(self.transport.payloads[0]["total-messages"], 0) |
463 | 487 | 487 | ||
464 | 488 | def test_include_total_messages_some(self): | 488 | def test_include_total_messages_some(self): |
465 | 489 | """ | 489 | """ |
466 | @@ -493,7 +493,7 @@ | |||
467 | 493 | self.mstore.set_accepted_types(["empty"]) | 493 | self.mstore.set_accepted_types(["empty"]) |
468 | 494 | self.mstore.add({"type": "empty"}) | 494 | self.mstore.add({"type": "empty"}) |
469 | 495 | self.exchanger.exchange() | 495 | self.exchanger.exchange() |
471 | 496 | self.assertEquals(self.transport.payloads[0]["total-messages"], 1) | 496 | self.assertEqual(self.transport.payloads[0]["total-messages"], 1) |
472 | 497 | 497 | ||
473 | 498 | def test_include_total_messages_more(self): | 498 | def test_include_total_messages_more(self): |
474 | 499 | """ | 499 | """ |
475 | @@ -508,7 +508,7 @@ | |||
476 | 508 | self.mstore.add({"type": "empty"}) | 508 | self.mstore.add({"type": "empty"}) |
477 | 509 | self.mstore.add({"type": "empty"}) | 509 | self.mstore.add({"type": "empty"}) |
478 | 510 | exchanger.exchange() | 510 | exchanger.exchange() |
480 | 511 | self.assertEquals(self.transport.payloads[0]["total-messages"], 2) | 511 | self.assertEqual(self.transport.payloads[0]["total-messages"], 2) |
481 | 512 | 512 | ||
482 | 513 | def test_impending_exchange(self): | 513 | def test_impending_exchange(self): |
483 | 514 | """ | 514 | """ |
484 | @@ -519,9 +519,9 @@ | |||
485 | 519 | events = [] | 519 | events = [] |
486 | 520 | self.reactor.call_on("impending-exchange", lambda: events.append(True)) | 520 | self.reactor.call_on("impending-exchange", lambda: events.append(True)) |
487 | 521 | self.wait_for_exchange(delta=-11) | 521 | self.wait_for_exchange(delta=-11) |
489 | 522 | self.assertEquals(events, []) | 522 | self.assertEqual(events, []) |
490 | 523 | self.reactor.advance(1) | 523 | self.reactor.advance(1) |
492 | 524 | self.assertEquals(events, [True]) | 524 | self.assertEqual(events, [True]) |
493 | 525 | 525 | ||
494 | 526 | def test_impending_exchange_on_urgent(self): | 526 | def test_impending_exchange_on_urgent(self): |
495 | 527 | """ | 527 | """ |
496 | @@ -539,9 +539,9 @@ | |||
497 | 539 | events = [] | 539 | events = [] |
498 | 540 | self.reactor.call_on("impending-exchange", lambda: events.append(True)) | 540 | self.reactor.call_on("impending-exchange", lambda: events.append(True)) |
499 | 541 | self.reactor.advance(9) | 541 | self.reactor.advance(9) |
501 | 542 | self.assertEquals(events, []) | 542 | self.assertEqual(events, []) |
502 | 543 | self.reactor.advance(1) | 543 | self.reactor.advance(1) |
504 | 544 | self.assertEquals(events, [True]) | 544 | self.assertEqual(events, [True]) |
505 | 545 | 545 | ||
506 | 546 | def test_impending_exchange_gets_reschudeled_with_urgent_reschedule(self): | 546 | def test_impending_exchange_gets_reschudeled_with_urgent_reschedule(self): |
507 | 547 | """ | 547 | """ |
508 | @@ -568,9 +568,9 @@ | |||
509 | 568 | # * schedule impending-exchange to be fired in 10 seconds | 568 | # * schedule impending-exchange to be fired in 10 seconds |
510 | 569 | exchanger.schedule_exchange(urgent=True) | 569 | exchanger.schedule_exchange(urgent=True) |
511 | 570 | self.reactor.advance(10) | 570 | self.reactor.advance(10) |
513 | 571 | self.assertEquals(events, [True]) | 571 | self.assertEqual(events, [True]) |
514 | 572 | self.reactor.advance(10) | 572 | self.reactor.advance(10) |
516 | 573 | self.assertEquals(len(self.transport.payloads), 1) | 573 | self.assertEqual(len(self.transport.payloads), 1) |
517 | 574 | # Now the urgent exchange should be fired, which should automatically | 574 | # Now the urgent exchange should be fired, which should automatically |
518 | 575 | # schedule a regular exchange. | 575 | # schedule a regular exchange. |
519 | 576 | # Let's make sure that that *original* impending-exchange event has | 576 | # Let's make sure that that *original* impending-exchange event has |
520 | @@ -578,14 +578,14 @@ | |||
521 | 578 | self.reactor.advance(60 * 60 # time till exchange | 578 | self.reactor.advance(60 * 60 # time till exchange |
522 | 579 | - 10 # time till notification | 579 | - 10 # time till notification |
523 | 580 | - 20) # time that we've already advanced | 580 | - 20) # time that we've already advanced |
525 | 581 | self.assertEquals(events, [True]) | 581 | self.assertEqual(events, [True]) |
526 | 582 | # Ok, so no new events means that the original call was | 582 | # Ok, so no new events means that the original call was |
527 | 583 | # cancelled. great. | 583 | # cancelled. great. |
528 | 584 | # Just a bit more sanity checking: | 584 | # Just a bit more sanity checking: |
529 | 585 | self.reactor.advance(20) | 585 | self.reactor.advance(20) |
531 | 586 | self.assertEquals(events, [True, True]) | 586 | self.assertEqual(events, [True, True]) |
532 | 587 | self.reactor.advance(10) | 587 | self.reactor.advance(10) |
534 | 588 | self.assertEquals(len(self.transport.payloads), 2) | 588 | self.assertEqual(len(self.transport.payloads), 2) |
535 | 589 | 589 | ||
536 | 590 | def test_pre_exchange_event(self): | 590 | def test_pre_exchange_event(self): |
537 | 591 | reactor_mock = self.mocker.patch(self.reactor) | 591 | reactor_mock = self.mocker.patch(self.reactor) |
538 | @@ -623,7 +623,7 @@ | |||
539 | 623 | 623 | ||
540 | 624 | self.reactor.call_on("exchange-failed", exchange_failed_callback) | 624 | self.reactor.call_on("exchange-failed", exchange_failed_callback) |
541 | 625 | self.exchanger.exchange() | 625 | self.exchanger.exchange() |
543 | 626 | self.assertEquals(exchanged, [True]) | 626 | self.assertEqual(exchanged, [True]) |
544 | 627 | 627 | ||
545 | 628 | def test_stop(self): | 628 | def test_stop(self): |
546 | 629 | self.exchanger.schedule_exchange() | 629 | self.exchanger.schedule_exchange() |
547 | @@ -645,7 +645,7 @@ | |||
548 | 645 | self.assertFalse(self.transport.payloads) | 645 | self.assertFalse(self.transport.payloads) |
549 | 646 | 646 | ||
550 | 647 | def test_default_exchange_intervals(self): | 647 | def test_default_exchange_intervals(self): |
552 | 648 | self.assertEquals(self.exchanger.get_exchange_intervals(), (60, 900)) | 648 | self.assertEqual(self.exchanger.get_exchange_intervals(), (60, 900)) |
553 | 649 | 649 | ||
554 | 650 | def test_set_intervals(self): | 650 | def test_set_intervals(self): |
555 | 651 | """ | 651 | """ |
556 | @@ -659,15 +659,15 @@ | |||
557 | 659 | 659 | ||
558 | 660 | self.exchanger.exchange() | 660 | self.exchanger.exchange() |
559 | 661 | 661 | ||
564 | 662 | self.assertEquals(self.exchanger.get_exchange_intervals(), | 662 | self.assertEqual(self.exchanger.get_exchange_intervals(), |
565 | 663 | (1234, 5678)) | 663 | (1234, 5678)) |
566 | 664 | self.assertEquals(self.config.exchange_interval, 5678) | 664 | self.assertEqual(self.config.exchange_interval, 5678) |
567 | 665 | self.assertEquals(self.config.urgent_exchange_interval, 1234) | 665 | self.assertEqual(self.config.urgent_exchange_interval, 1234) |
568 | 666 | 666 | ||
569 | 667 | new_config = BrokerConfiguration() | 667 | new_config = BrokerConfiguration() |
570 | 668 | new_config.load_configuration_file(self.config_filename) | 668 | new_config.load_configuration_file(self.config_filename) |
573 | 669 | self.assertEquals(new_config.exchange_interval, 5678) | 669 | self.assertEqual(new_config.exchange_interval, 5678) |
574 | 670 | self.assertEquals(new_config.urgent_exchange_interval, 1234) | 670 | self.assertEqual(new_config.urgent_exchange_interval, 1234) |
575 | 671 | 671 | ||
576 | 672 | def test_set_intervals_with_urgent_exchange_only(self): | 672 | def test_set_intervals_with_urgent_exchange_only(self): |
577 | 673 | server_message = [{"type": "set-intervals", "urgent-exchange": 1234}] | 673 | server_message = [{"type": "set-intervals", "urgent-exchange": 1234}] |
578 | @@ -675,14 +675,14 @@ | |||
579 | 675 | 675 | ||
580 | 676 | self.exchanger.exchange() | 676 | self.exchanger.exchange() |
581 | 677 | 677 | ||
583 | 678 | self.assertEquals(self.exchanger.get_exchange_intervals(), (1234, 900)) | 678 | self.assertEqual(self.exchanger.get_exchange_intervals(), (1234, 900)) |
584 | 679 | 679 | ||
585 | 680 | # Let's make sure it works. | 680 | # Let's make sure it works. |
586 | 681 | self.exchanger.schedule_exchange(urgent=True) | 681 | self.exchanger.schedule_exchange(urgent=True) |
587 | 682 | self.reactor.advance(1233) | 682 | self.reactor.advance(1233) |
589 | 683 | self.assertEquals(len(self.transport.payloads), 1) | 683 | self.assertEqual(len(self.transport.payloads), 1) |
590 | 684 | self.reactor.advance(1) | 684 | self.reactor.advance(1) |
592 | 685 | self.assertEquals(len(self.transport.payloads), 2) | 685 | self.assertEqual(len(self.transport.payloads), 2) |
593 | 686 | 686 | ||
594 | 687 | def test_set_intervals_with_exchange_only(self): | 687 | def test_set_intervals_with_exchange_only(self): |
595 | 688 | server_message = [{"type": "set-intervals", "exchange": 5678}] | 688 | server_message = [{"type": "set-intervals", "exchange": 5678}] |
596 | @@ -690,13 +690,13 @@ | |||
597 | 690 | 690 | ||
598 | 691 | self.exchanger.exchange() | 691 | self.exchanger.exchange() |
599 | 692 | 692 | ||
601 | 693 | self.assertEquals(self.exchanger.get_exchange_intervals(), (60, 5678)) | 693 | self.assertEqual(self.exchanger.get_exchange_intervals(), (60, 5678)) |
602 | 694 | 694 | ||
603 | 695 | # Let's make sure it works. | 695 | # Let's make sure it works. |
604 | 696 | self.reactor.advance(5677) | 696 | self.reactor.advance(5677) |
606 | 697 | self.assertEquals(len(self.transport.payloads), 1) | 697 | self.assertEqual(len(self.transport.payloads), 1) |
607 | 698 | self.reactor.advance(1) | 698 | self.reactor.advance(1) |
609 | 699 | self.assertEquals(len(self.transport.payloads), 2) | 699 | self.assertEqual(len(self.transport.payloads), 2) |
610 | 700 | 700 | ||
611 | 701 | def test_register_message(self): | 701 | def test_register_message(self): |
612 | 702 | """ | 702 | """ |
613 | @@ -709,7 +709,7 @@ | |||
614 | 709 | server_message = [msg] | 709 | server_message = [msg] |
615 | 710 | self.transport.responses.append(server_message) | 710 | self.transport.responses.append(server_message) |
616 | 711 | self.exchanger.exchange() | 711 | self.exchanger.exchange() |
618 | 712 | self.assertEquals(messages, [msg]) | 712 | self.assertEqual(messages, [msg]) |
619 | 713 | 713 | ||
620 | 714 | def test_register_multiple_message_handlers(self): | 714 | def test_register_multiple_message_handlers(self): |
621 | 715 | """ | 715 | """ |
622 | @@ -731,15 +731,15 @@ | |||
623 | 731 | server_message = [msg] | 731 | server_message = [msg] |
624 | 732 | self.transport.responses.append(server_message) | 732 | self.transport.responses.append(server_message) |
625 | 733 | self.exchanger.exchange() | 733 | self.exchanger.exchange() |
627 | 734 | self.assertEquals(messages, [("one", msg), ("two", msg)]) | 734 | self.assertEqual(messages, [("one", msg), ("two", msg)]) |
628 | 735 | 735 | ||
629 | 736 | def test_server_uuid_is_stored_on_message_store(self): | 736 | def test_server_uuid_is_stored_on_message_store(self): |
630 | 737 | self.transport.extra["server-uuid"] = "first-uuid" | 737 | self.transport.extra["server-uuid"] = "first-uuid" |
631 | 738 | self.exchanger.exchange() | 738 | self.exchanger.exchange() |
633 | 739 | self.assertEquals(self.mstore.get_server_uuid(), "first-uuid") | 739 | self.assertEqual(self.mstore.get_server_uuid(), "first-uuid") |
634 | 740 | self.transport.extra["server-uuid"] = "second-uuid" | 740 | self.transport.extra["server-uuid"] = "second-uuid" |
635 | 741 | self.exchanger.exchange() | 741 | self.exchanger.exchange() |
637 | 742 | self.assertEquals(self.mstore.get_server_uuid(), "second-uuid") | 742 | self.assertEqual(self.mstore.get_server_uuid(), "second-uuid") |
638 | 743 | 743 | ||
639 | 744 | def test_server_uuid_change_cause_event(self): | 744 | def test_server_uuid_change_cause_event(self): |
640 | 745 | called = [] | 745 | called = [] |
641 | @@ -752,25 +752,25 @@ | |||
642 | 752 | # letting the system know about the change. | 752 | # letting the system know about the change. |
643 | 753 | self.transport.extra["server-uuid"] = "first-uuid" | 753 | self.transport.extra["server-uuid"] = "first-uuid" |
644 | 754 | self.exchanger.exchange() | 754 | self.exchanger.exchange() |
647 | 755 | self.assertEquals(len(called), 1) | 755 | self.assertEqual(len(called), 1) |
648 | 756 | self.assertEquals(called[-1], (None, "first-uuid")) | 756 | self.assertEqual(called[-1], (None, "first-uuid")) |
649 | 757 | 757 | ||
650 | 758 | # Using the same one again, nothing should happen: | 758 | # Using the same one again, nothing should happen: |
651 | 759 | self.transport.extra["server-uuid"] = "first-uuid" | 759 | self.transport.extra["server-uuid"] = "first-uuid" |
652 | 760 | self.exchanger.exchange() | 760 | self.exchanger.exchange() |
654 | 761 | self.assertEquals(len(called), 1) | 761 | self.assertEqual(len(called), 1) |
655 | 762 | 762 | ||
656 | 763 | # Changing it, we should get an event again: | 763 | # Changing it, we should get an event again: |
657 | 764 | self.transport.extra["server-uuid"] = "second-uuid" | 764 | self.transport.extra["server-uuid"] = "second-uuid" |
658 | 765 | self.exchanger.exchange() | 765 | self.exchanger.exchange() |
661 | 766 | self.assertEquals(len(called), 2) | 766 | self.assertEqual(len(called), 2) |
662 | 767 | self.assertEquals(called[-1], ("first-uuid", "second-uuid")) | 767 | self.assertEqual(called[-1], ("first-uuid", "second-uuid")) |
663 | 768 | 768 | ||
664 | 769 | # And then, it shouldn't emit it once more, since it continues | 769 | # And then, it shouldn't emit it once more, since it continues |
665 | 770 | # to be the same. | 770 | # to be the same. |
666 | 771 | self.transport.extra["server-uuid"] = "second-uuid" | 771 | self.transport.extra["server-uuid"] = "second-uuid" |
667 | 772 | self.exchanger.exchange() | 772 | self.exchanger.exchange() |
669 | 773 | self.assertEquals(len(called), 2) | 773 | self.assertEqual(len(called), 2) |
670 | 774 | 774 | ||
671 | 775 | def test_server_uuid_event_not_emitted_with_matching_stored_uuid(self): | 775 | def test_server_uuid_event_not_emitted_with_matching_stored_uuid(self): |
672 | 776 | """ | 776 | """ |
673 | @@ -786,7 +786,7 @@ | |||
674 | 786 | self.mstore.set_server_uuid("the-uuid") | 786 | self.mstore.set_server_uuid("the-uuid") |
675 | 787 | self.transport.extra["server-uuid"] = "the-uuid" | 787 | self.transport.extra["server-uuid"] = "the-uuid" |
676 | 788 | self.exchanger.exchange() | 788 | self.exchanger.exchange() |
678 | 789 | self.assertEquals(called, []) | 789 | self.assertEqual(called, []) |
679 | 790 | 790 | ||
680 | 791 | def test_server_uuid_change_is_logged(self): | 791 | def test_server_uuid_change_is_logged(self): |
681 | 792 | self.transport.extra["server-uuid"] = "the-uuid" | 792 | self.transport.extra["server-uuid"] = "the-uuid" |
682 | @@ -819,8 +819,8 @@ | |||
683 | 819 | self.exchange_store.get_message_context(message['operation-id'])) | 819 | self.exchange_store.get_message_context(message['operation-id'])) |
684 | 820 | message_context = self.exchange_store.get_message_context( | 820 | message_context = self.exchange_store.get_message_context( |
685 | 821 | message['operation-id']) | 821 | message['operation-id']) |
688 | 822 | self.assertEquals(message_context.operation_id, 123456) | 822 | self.assertEqual(message_context.operation_id, 123456) |
689 | 823 | self.assertEquals(message_context.message_type, "type-R") | 823 | self.assertEqual(message_context.message_type, "type-R") |
690 | 824 | 824 | ||
691 | 825 | def test_one_way_messages_do_not_have_their_context_stored(self): | 825 | def test_one_way_messages_do_not_have_their_context_stored(self): |
692 | 826 | """ | 826 | """ |
693 | @@ -835,7 +835,7 @@ | |||
694 | 835 | self.exchanger.exchange() | 835 | self.exchanger.exchange() |
695 | 836 | 836 | ||
696 | 837 | ids_after = self.exchange_store.all_operation_ids() | 837 | ids_after = self.exchange_store.all_operation_ids() |
698 | 838 | self.assertEquals(ids_before, ids_after) | 838 | self.assertEqual(ids_before, ids_after) |
699 | 839 | 839 | ||
700 | 840 | def test_obsolete_response_messages_are_discarded(self): | 840 | def test_obsolete_response_messages_are_discarded(self): |
701 | 841 | """ | 841 | """ |
702 | @@ -859,9 +859,9 @@ | |||
703 | 859 | message_id = self.exchanger.send( | 859 | message_id = self.exchanger.send( |
704 | 860 | {"type": "resynchronize", "operation-id": 234567}) | 860 | {"type": "resynchronize", "operation-id": 234567}) |
705 | 861 | self.exchanger.exchange() | 861 | self.exchanger.exchange() |
707 | 862 | self.assertEquals(2, len(self.transport.payloads)) | 862 | self.assertEqual(2, len(self.transport.payloads)) |
708 | 863 | messages = self.transport.payloads[1]["messages"] | 863 | messages = self.transport.payloads[1]["messages"] |
710 | 864 | self.assertEquals([], messages) | 864 | self.assertEqual([], messages) |
711 | 865 | self.assertIs(None, message_id) | 865 | self.assertIs(None, message_id) |
712 | 866 | expected_log_entry = ( | 866 | expected_log_entry = ( |
713 | 867 | "Response message with operation-id 234567 was discarded because " | 867 | "Response message with operation-id 234567 was discarded because " |
714 | @@ -894,15 +894,15 @@ | |||
715 | 894 | self.exchanger.register_client_accepted_message_type("type-C") | 894 | self.exchanger.register_client_accepted_message_type("type-C") |
716 | 895 | self.exchanger.register_client_accepted_message_type("type-A") | 895 | self.exchanger.register_client_accepted_message_type("type-A") |
717 | 896 | types = self.exchanger.get_client_accepted_message_types() | 896 | types = self.exchanger.get_client_accepted_message_types() |
721 | 897 | self.assertEquals(types, | 897 | self.assertEqual(types, |
722 | 898 | sorted(["type-A", "type-B", "type-C"] + | 898 | sorted(["type-A", "type-B", "type-C"] + |
723 | 899 | DEFAULT_ACCEPTED_TYPES)) | 899 | DEFAULT_ACCEPTED_TYPES)) |
724 | 900 | 900 | ||
725 | 901 | def test_exchange_sends_message_type_when_no_hash(self): | 901 | def test_exchange_sends_message_type_when_no_hash(self): |
726 | 902 | self.exchanger.register_client_accepted_message_type("type-A") | 902 | self.exchanger.register_client_accepted_message_type("type-A") |
727 | 903 | self.exchanger.register_client_accepted_message_type("type-B") | 903 | self.exchanger.register_client_accepted_message_type("type-B") |
728 | 904 | self.exchanger.exchange() | 904 | self.exchanger.exchange() |
730 | 905 | self.assertEquals( | 905 | self.assertEqual( |
731 | 906 | self.transport.payloads[0]["client-accepted-types"], | 906 | self.transport.payloads[0]["client-accepted-types"], |
732 | 907 | sorted(["type-A", "type-B"] + DEFAULT_ACCEPTED_TYPES)) | 907 | sorted(["type-A", "type-B"] + DEFAULT_ACCEPTED_TYPES)) |
733 | 908 | 908 | ||
734 | @@ -926,7 +926,7 @@ | |||
735 | 926 | self.exchanger.register_client_accepted_message_type("type-B") | 926 | self.exchanger.register_client_accepted_message_type("type-B") |
736 | 927 | self.exchanger.exchange() | 927 | self.exchanger.exchange() |
737 | 928 | self.exchanger.exchange() | 928 | self.exchanger.exchange() |
739 | 929 | self.assertEquals( | 929 | self.assertEqual( |
740 | 930 | self.transport.payloads[1]["client-accepted-types"], | 930 | self.transport.payloads[1]["client-accepted-types"], |
741 | 931 | sorted(["type-A", "type-B"] + DEFAULT_ACCEPTED_TYPES)) | 931 | sorted(["type-A", "type-B"] + DEFAULT_ACCEPTED_TYPES)) |
742 | 932 | 932 | ||
743 | @@ -941,7 +941,7 @@ | |||
744 | 941 | self.exchanger.exchange() | 941 | self.exchanger.exchange() |
745 | 942 | self.exchanger.register_client_accepted_message_type("type-B") | 942 | self.exchanger.register_client_accepted_message_type("type-B") |
746 | 943 | self.exchanger.exchange() | 943 | self.exchanger.exchange() |
748 | 944 | self.assertEquals( | 944 | self.assertEqual( |
749 | 945 | self.transport.payloads[1]["client-accepted-types"], | 945 | self.transport.payloads[1]["client-accepted-types"], |
750 | 946 | sorted(["type-A", "type-B"] + DEFAULT_ACCEPTED_TYPES)) | 946 | sorted(["type-A", "type-B"] + DEFAULT_ACCEPTED_TYPES)) |
751 | 947 | 947 | ||
752 | @@ -958,7 +958,7 @@ | |||
753 | 958 | self.transport.extra["client-accepted-types-hash"] = "lol" | 958 | self.transport.extra["client-accepted-types-hash"] = "lol" |
754 | 959 | self.exchanger.exchange() | 959 | self.exchanger.exchange() |
755 | 960 | self.exchanger.exchange() | 960 | self.exchanger.exchange() |
757 | 961 | self.assertEquals( | 961 | self.assertEqual( |
758 | 962 | self.transport.payloads[2]["client-accepted-types"], | 962 | self.transport.payloads[2]["client-accepted-types"], |
759 | 963 | sorted(["type-A"] + DEFAULT_ACCEPTED_TYPES)) | 963 | sorted(["type-A"] + DEFAULT_ACCEPTED_TYPES)) |
760 | 964 | 964 | ||
761 | @@ -970,28 +970,28 @@ | |||
762 | 970 | """ | 970 | """ |
763 | 971 | self.exchanger.register_message("typefoo", lambda m: None) | 971 | self.exchanger.register_message("typefoo", lambda m: None) |
764 | 972 | types = self.exchanger.get_client_accepted_message_types() | 972 | types = self.exchanger.get_client_accepted_message_types() |
766 | 973 | self.assertEquals(types, sorted(["typefoo"] + DEFAULT_ACCEPTED_TYPES)) | 973 | self.assertEqual(types, sorted(["typefoo"] + DEFAULT_ACCEPTED_TYPES)) |
767 | 974 | 974 | ||
768 | 975 | 975 | ||
769 | 976 | class GetAcceptedTypesDiffTest(LandscapeTest): | 976 | class GetAcceptedTypesDiffTest(LandscapeTest): |
770 | 977 | 977 | ||
771 | 978 | def test_diff_empty(self): | 978 | def test_diff_empty(self): |
774 | 979 | self.assertEquals(get_accepted_types_diff([], []), | 979 | self.assertEqual(get_accepted_types_diff([], []), |
775 | 980 | "") | 980 | "") |
776 | 981 | 981 | ||
777 | 982 | def test_diff_add(self): | 982 | def test_diff_add(self): |
780 | 983 | self.assertEquals(get_accepted_types_diff([], ["wubble"]), | 983 | self.assertEqual(get_accepted_types_diff([], ["wubble"]), |
781 | 984 | "+wubble") | 984 | "+wubble") |
782 | 985 | 985 | ||
783 | 986 | def test_diff_remove(self): | 986 | def test_diff_remove(self): |
786 | 987 | self.assertEquals(get_accepted_types_diff(["wubble"], []), | 987 | self.assertEqual(get_accepted_types_diff(["wubble"], []), |
787 | 988 | "-wubble") | 988 | "-wubble") |
788 | 989 | 989 | ||
789 | 990 | def test_diff_no_change(self): | 990 | def test_diff_no_change(self): |
792 | 991 | self.assertEquals(get_accepted_types_diff(["ooga"], ["ooga"]), | 991 | self.assertEqual(get_accepted_types_diff(["ooga"], ["ooga"]), |
793 | 992 | "ooga") | 992 | "ooga") |
794 | 993 | 993 | ||
795 | 994 | def test_diff_complex(self): | 994 | def test_diff_complex(self): |
799 | 995 | self.assertEquals(get_accepted_types_diff(["foo", "bar"], | 995 | self.assertEqual(get_accepted_types_diff(["foo", "bar"], |
800 | 996 | ["foo", "ooga"]), | 996 | ["foo", "ooga"]), |
801 | 997 | "+ooga foo -bar") | 997 | "+ooga foo -bar") |
802 | 998 | 998 | ||
803 | === modified file 'landscape/broker/tests/test_exchangestore.py' | |||
804 | --- landscape/broker/tests/test_exchangestore.py 2010-06-08 16:48:25 +0000 | |||
805 | +++ landscape/broker/tests/test_exchangestore.py 2011-07-06 21:14:28 +0000 | |||
806 | @@ -31,11 +31,11 @@ | |||
807 | 31 | "SELECT operation_id, secure_id, message_type, timestamp " | 31 | "SELECT operation_id, secure_id, message_type, timestamp " |
808 | 32 | "FROM message_context WHERE operation_id=?", (123,)) | 32 | "FROM message_context WHERE operation_id=?", (123,)) |
809 | 33 | results = cursor.fetchall() | 33 | results = cursor.fetchall() |
811 | 34 | self.assertEquals(1, len(results)) | 34 | self.assertEqual(1, len(results)) |
812 | 35 | [row] = results | 35 | [row] = results |
816 | 36 | self.assertEquals(123, row[0]) | 36 | self.assertEqual(123, row[0]) |
817 | 37 | self.assertEquals('abc', row[1]) | 37 | self.assertEqual('abc', row[1]) |
818 | 38 | self.assertEquals('change-packages', row[2]) | 38 | self.assertEqual('change-packages', row[2]) |
819 | 39 | self.assertTrue(row[3] > now) | 39 | self.assertTrue(row[3] > now) |
820 | 40 | 40 | ||
821 | 41 | def test_add_message_context_with_duplicate_operation_id(self): | 41 | def test_add_message_context_with_duplicate_operation_id(self): |
822 | @@ -52,9 +52,9 @@ | |||
823 | 52 | now = time.time() | 52 | now = time.time() |
824 | 53 | self.store1.add_message_context(234, 'bcd', 'change-packages') | 53 | self.store1.add_message_context(234, 'bcd', 'change-packages') |
825 | 54 | context = self.store2.get_message_context(234) | 54 | context = self.store2.get_message_context(234) |
829 | 55 | self.assertEquals(234, context.operation_id) | 55 | self.assertEqual(234, context.operation_id) |
830 | 56 | self.assertEquals('bcd', context.secure_id) | 56 | self.assertEqual('bcd', context.secure_id) |
831 | 57 | self.assertEquals('change-packages', context.message_type) | 57 | self.assertEqual('change-packages', context.message_type) |
832 | 58 | self.assertTrue(context.timestamp > now) | 58 | self.assertTrue(context.timestamp > now) |
833 | 59 | 59 | ||
834 | 60 | def test_get_message_context_with_nonexistent_operation_id(self): | 60 | def test_get_message_context_with_nonexistent_operation_id(self): |
835 | @@ -74,11 +74,11 @@ | |||
836 | 74 | Calling C{all_operation_ids} on an empty database returns an empty | 74 | Calling C{all_operation_ids} on an empty database returns an empty |
837 | 75 | list. | 75 | list. |
838 | 76 | """ | 76 | """ |
840 | 77 | self.assertEquals([], self.store1.all_operation_ids()) | 77 | self.assertEqual([], self.store1.all_operation_ids()) |
841 | 78 | 78 | ||
842 | 79 | def test_all_operation_ids(self): | 79 | def test_all_operation_ids(self): |
843 | 80 | """C{all_operation_ids} works correctly.""" | 80 | """C{all_operation_ids} works correctly.""" |
844 | 81 | self.store1.add_message_context(456, 'cde', 'change-packages') | 81 | self.store1.add_message_context(456, 'cde', 'change-packages') |
846 | 82 | self.assertEquals([456], self.store2.all_operation_ids()) | 82 | self.assertEqual([456], self.store2.all_operation_ids()) |
847 | 83 | self.store2.add_message_context(567, 'def', 'change-packages') | 83 | self.store2.add_message_context(567, 'def', 'change-packages') |
849 | 84 | self.assertEquals([456, 567], self.store1.all_operation_ids()) | 84 | self.assertEqual([456, 567], self.store1.all_operation_ids()) |
850 | 85 | 85 | ||
851 | === modified file 'landscape/broker/tests/test_ping.py' | |||
852 | --- landscape/broker/tests/test_ping.py 2010-04-23 11:37:25 +0000 | |||
853 | +++ landscape/broker/tests/test_ping.py 2011-07-06 21:14:28 +0000 | |||
854 | @@ -60,7 +60,7 @@ | |||
855 | 60 | self.broker_service.identity, | 60 | self.broker_service.identity, |
856 | 61 | get_page=client.get_page) | 61 | get_page=client.get_page) |
857 | 62 | pinger.ping() | 62 | pinger.ping() |
859 | 63 | self.assertEquals( | 63 | self.assertEqual( |
860 | 64 | client.fetches, | 64 | client.fetches, |
861 | 65 | [(url, True, {"Content-Type": "application/x-www-form-urlencoded"}, | 65 | [(url, True, {"Content-Type": "application/x-www-form-urlencoded"}, |
862 | 66 | "insecure_id=10")]) | 66 | "insecure_id=10")]) |
863 | @@ -77,7 +77,7 @@ | |||
864 | 77 | get_page=client.get_page) | 77 | get_page=client.get_page) |
865 | 78 | d = pinger.ping() | 78 | d = pinger.ping() |
866 | 79 | d.addCallback(self.assertEqual, False) | 79 | d.addCallback(self.assertEqual, False) |
868 | 80 | self.assertEquals(client.fetches, []) | 80 | self.assertEqual(client.fetches, []) |
869 | 81 | 81 | ||
870 | 82 | def test_respond(self): | 82 | def test_respond(self): |
871 | 83 | """ | 83 | """ |
872 | @@ -105,12 +105,13 @@ | |||
873 | 105 | get_page=client.failing_get_page) | 105 | get_page=client.failing_get_page) |
874 | 106 | d = pinger.ping() | 106 | d = pinger.ping() |
875 | 107 | failures = [] | 107 | failures = [] |
876 | 108 | |||
877 | 108 | def errback(failure): | 109 | def errback(failure): |
878 | 109 | failures.append(failure) | 110 | failures.append(failure) |
879 | 110 | d.addErrback(errback) | 111 | d.addErrback(errback) |
883 | 111 | self.assertEquals(len(failures), 1) | 112 | self.assertEqual(len(failures), 1) |
884 | 112 | self.assertEquals(failures[0].getErrorMessage(), "That's a failure!") | 113 | self.assertEqual(failures[0].getErrorMessage(), "That's a failure!") |
885 | 113 | self.assertEquals(failures[0].type, AssertionError) | 114 | self.assertEqual(failures[0].type, AssertionError) |
886 | 114 | 115 | ||
887 | 115 | 116 | ||
888 | 116 | class PingerTest(LandscapeTest): | 117 | class PingerTest(LandscapeTest): |
889 | @@ -126,6 +127,7 @@ | |||
890 | 126 | super(PingerTest, self).setUp() | 127 | super(PingerTest, self).setUp() |
891 | 127 | self.url = "http://localhost:8081/whatever" | 128 | self.url = "http://localhost:8081/whatever" |
892 | 128 | self.page_getter = FakePageGetter(None) | 129 | self.page_getter = FakePageGetter(None) |
893 | 130 | |||
894 | 129 | def factory(reactor, url, insecure_id): | 131 | def factory(reactor, url, insecure_id): |
895 | 130 | return PingClient(reactor, url, insecure_id, | 132 | return PingClient(reactor, url, insecure_id, |
896 | 131 | get_page=self.page_getter.get_page) | 133 | get_page=self.page_getter.get_page) |
897 | @@ -152,9 +154,9 @@ | |||
898 | 152 | self.pinger.start() | 154 | self.pinger.start() |
899 | 153 | self.broker_service.identity.insecure_id = 23 | 155 | self.broker_service.identity.insecure_id = 23 |
900 | 154 | self.broker_service.reactor.advance(9) | 156 | self.broker_service.reactor.advance(9) |
902 | 155 | self.assertEquals(len(self.page_getter.fetches), 0) | 157 | self.assertEqual(len(self.page_getter.fetches), 0) |
903 | 156 | self.broker_service.reactor.advance(1) | 158 | self.broker_service.reactor.advance(1) |
905 | 157 | self.assertEquals(len(self.page_getter.fetches), 1) | 159 | self.assertEqual(len(self.page_getter.fetches), 1) |
906 | 158 | 160 | ||
907 | 159 | def test_load_insecure_id(self): | 161 | def test_load_insecure_id(self): |
908 | 160 | """ | 162 | """ |
909 | @@ -177,7 +179,7 @@ | |||
910 | 177 | # 70 = ping delay + urgent exchange delay | 179 | # 70 = ping delay + urgent exchange delay |
911 | 178 | self.broker_service.reactor.advance(70) | 180 | self.broker_service.reactor.advance(70) |
912 | 179 | 181 | ||
914 | 180 | self.assertEquals(len(self.broker_service.transport.payloads), 1) | 182 | self.assertEqual(len(self.broker_service.transport.payloads), 1) |
915 | 181 | 183 | ||
916 | 182 | def test_negative_response(self): | 184 | def test_negative_response(self): |
917 | 183 | """ | 185 | """ |
918 | @@ -187,7 +189,7 @@ | |||
919 | 187 | self.broker_service.identity.insecure_id = 42 | 189 | self.broker_service.identity.insecure_id = 42 |
920 | 188 | self.page_getter.response = {"messages": False} | 190 | self.page_getter.response = {"messages": False} |
921 | 189 | self.broker_service.reactor.advance(10) | 191 | self.broker_service.reactor.advance(10) |
923 | 190 | self.assertEquals(len(self.broker_service.transport.payloads), 0) | 192 | self.assertEqual(len(self.broker_service.transport.payloads), 0) |
924 | 191 | 193 | ||
925 | 192 | def test_ping_error(self): | 194 | def test_ping_error(self): |
926 | 193 | """ | 195 | """ |
927 | @@ -200,8 +202,10 @@ | |||
928 | 200 | class BadPingClient(object): | 202 | class BadPingClient(object): |
929 | 201 | def __init__(self, *args, **kwargs): | 203 | def __init__(self, *args, **kwargs): |
930 | 202 | pass | 204 | pass |
931 | 205 | |||
932 | 203 | def ping(self): | 206 | def ping(self): |
933 | 204 | return fail(ZeroDivisionError("Couldn't fetch page")) | 207 | return fail(ZeroDivisionError("Couldn't fetch page")) |
934 | 208 | |||
935 | 205 | pinger = Pinger(self.broker_service.reactor, "http://foo.com/", | 209 | pinger = Pinger(self.broker_service.reactor, "http://foo.com/", |
936 | 206 | self.broker_service.identity, | 210 | self.broker_service.identity, |
937 | 207 | self.broker_service.exchanger, | 211 | self.broker_service.exchanger, |
938 | @@ -218,28 +222,28 @@ | |||
939 | 218 | self.assertTrue("Couldn't fetch page" in log) | 222 | self.assertTrue("Couldn't fetch page" in log) |
940 | 219 | 223 | ||
941 | 220 | def test_get_interval(self): | 224 | def test_get_interval(self): |
943 | 221 | self.assertEquals(self.pinger.get_interval(), 10) | 225 | self.assertEqual(self.pinger.get_interval(), 10) |
944 | 222 | 226 | ||
945 | 223 | def test_set_intervals_handling(self): | 227 | def test_set_intervals_handling(self): |
946 | 224 | self.pinger.start() | 228 | self.pinger.start() |
947 | 225 | 229 | ||
948 | 226 | self.broker_service.reactor.fire("message", | 230 | self.broker_service.reactor.fire("message", |
949 | 227 | {"type": "set-intervals", "ping": 73}) | 231 | {"type": "set-intervals", "ping": 73}) |
951 | 228 | self.assertEquals(self.pinger.get_interval(), 73) | 232 | self.assertEqual(self.pinger.get_interval(), 73) |
952 | 229 | 233 | ||
953 | 230 | # The server may set specific intervals only, not including the ping. | 234 | # The server may set specific intervals only, not including the ping. |
954 | 231 | self.broker_service.reactor.fire("message", {"type": "set-intervals"}) | 235 | self.broker_service.reactor.fire("message", {"type": "set-intervals"}) |
956 | 232 | self.assertEquals(self.pinger.get_interval(), 73) | 236 | self.assertEqual(self.pinger.get_interval(), 73) |
957 | 233 | 237 | ||
958 | 234 | self.broker_service.identity.insecure_id = 23 | 238 | self.broker_service.identity.insecure_id = 23 |
959 | 235 | self.broker_service.reactor.advance(72) | 239 | self.broker_service.reactor.advance(72) |
961 | 236 | self.assertEquals(len(self.page_getter.fetches), 0) | 240 | self.assertEqual(len(self.page_getter.fetches), 0) |
962 | 237 | self.broker_service.reactor.advance(1) | 241 | self.broker_service.reactor.advance(1) |
964 | 238 | self.assertEquals(len(self.page_getter.fetches), 1) | 242 | self.assertEqual(len(self.page_getter.fetches), 1) |
965 | 239 | 243 | ||
966 | 240 | def test_get_url(self): | 244 | def test_get_url(self): |
969 | 241 | self.assertEquals(self.pinger.get_url(), | 245 | self.assertEqual(self.pinger.get_url(), |
970 | 242 | "http://localhost:8081/whatever") | 246 | "http://localhost:8081/whatever") |
971 | 243 | 247 | ||
972 | 244 | def test_set_url(self): | 248 | def test_set_url(self): |
973 | 245 | url = "http://example.com/mysuperping" | 249 | url = "http://example.com/mysuperping" |
974 | @@ -247,7 +251,7 @@ | |||
975 | 247 | self.pinger.start() | 251 | self.pinger.start() |
976 | 248 | self.broker_service.identity.insecure_id = 23 | 252 | self.broker_service.identity.insecure_id = 23 |
977 | 249 | self.broker_service.reactor.advance(10) | 253 | self.broker_service.reactor.advance(10) |
979 | 250 | self.assertEquals(self.page_getter.fetches[0][0], url) | 254 | self.assertEqual(self.page_getter.fetches[0][0], url) |
980 | 251 | 255 | ||
981 | 252 | def test_set_url_after_start(self): | 256 | def test_set_url_after_start(self): |
982 | 253 | url = "http://example.com/mysuperping" | 257 | url = "http://example.com/mysuperping" |
983 | @@ -255,4 +259,4 @@ | |||
984 | 255 | self.pinger.set_url(url) | 259 | self.pinger.set_url(url) |
985 | 256 | self.broker_service.identity.insecure_id = 23 | 260 | self.broker_service.identity.insecure_id = 23 |
986 | 257 | self.broker_service.reactor.advance(10) | 261 | self.broker_service.reactor.advance(10) |
988 | 258 | self.assertEquals(self.page_getter.fetches[0][0], url) | 262 | self.assertEqual(self.page_getter.fetches[0][0], url) |
989 | 259 | 263 | ||
990 | === modified file 'landscape/broker/tests/test_server.py' | |||
991 | --- landscape/broker/tests/test_server.py 2010-05-07 10:35:25 +0000 | |||
992 | +++ landscape/broker/tests/test_server.py 2011-07-06 21:14:28 +0000 | |||
993 | @@ -68,14 +68,14 @@ | |||
994 | 68 | client components that need to communicate with the server. After | 68 | client components that need to communicate with the server. After |
995 | 69 | the registration they can be fetched with L{BrokerServer.get_clients}. | 69 | the registration they can be fetched with L{BrokerServer.get_clients}. |
996 | 70 | """ | 70 | """ |
1001 | 71 | self.assertEquals(self.broker.get_clients(), []) | 71 | self.assertEqual(self.broker.get_clients(), []) |
1002 | 72 | self.assertEquals(self.broker.get_client("test"), None) | 72 | self.assertEqual(self.broker.get_client("test"), None) |
1003 | 73 | self.assertEquals(self.broker.get_connectors(), []) | 73 | self.assertEqual(self.broker.get_connectors(), []) |
1004 | 74 | self.assertEquals(self.broker.get_connector("test"), None) | 74 | self.assertEqual(self.broker.get_connector("test"), None) |
1005 | 75 | 75 | ||
1006 | 76 | def assert_registered(ignored): | 76 | def assert_registered(ignored): |
1009 | 77 | self.assertEquals(len(self.broker.get_clients()), 1) | 77 | self.assertEqual(len(self.broker.get_clients()), 1) |
1010 | 78 | self.assertEquals(len(self.broker.get_connectors()), 1) | 78 | self.assertEqual(len(self.broker.get_connectors()), 1) |
1011 | 79 | self.assertTrue( | 79 | self.assertTrue( |
1012 | 80 | isinstance(self.broker.get_client("test"), FakeClient)) | 80 | isinstance(self.broker.get_client("test"), FakeClient)) |
1013 | 81 | self.assertTrue( | 81 | self.assertTrue( |
1014 | @@ -126,7 +126,7 @@ | |||
1015 | 126 | """ | 126 | """ |
1016 | 127 | open(self.config_filename, "a").write("computer_title = New Title") | 127 | open(self.config_filename, "a").write("computer_title = New Title") |
1017 | 128 | result = self.broker.reload_configuration() | 128 | result = self.broker.reload_configuration() |
1019 | 129 | result.addCallback(lambda x: self.assertEquals( | 129 | result.addCallback(lambda x: self.assertEqual( |
1020 | 130 | self.config.computer_title, "New Title")) | 130 | self.config.computer_title, "New Title")) |
1021 | 131 | return result | 131 | return result |
1022 | 132 | 132 | ||
1023 | @@ -162,7 +162,7 @@ | |||
1024 | 162 | if no message types are accepted by the Landscape server. | 162 | if no message types are accepted by the Landscape server. |
1025 | 163 | """ | 163 | """ |
1026 | 164 | self.mstore.set_accepted_types([]) | 164 | self.mstore.set_accepted_types([]) |
1028 | 165 | self.assertEquals(self.broker.get_accepted_message_types(), []) | 165 | self.assertEqual(self.broker.get_accepted_message_types(), []) |
1029 | 166 | 166 | ||
1030 | 167 | def test_get_accepted_message_types(self): | 167 | def test_get_accepted_message_types(self): |
1031 | 168 | """ | 168 | """ |
1032 | @@ -170,15 +170,15 @@ | |||
1033 | 170 | message types accepted by the Landscape server. | 170 | message types accepted by the Landscape server. |
1034 | 171 | """ | 171 | """ |
1035 | 172 | self.mstore.set_accepted_types(["foo", "bar"]) | 172 | self.mstore.set_accepted_types(["foo", "bar"]) |
1038 | 173 | self.assertEquals(sorted(self.broker.get_accepted_message_types()), | 173 | self.assertEqual(sorted(self.broker.get_accepted_message_types()), |
1039 | 174 | ["bar", "foo"]) | 174 | ["bar", "foo"]) |
1040 | 175 | 175 | ||
1041 | 176 | def test_get_server_uuid_with_unset_uuid(self): | 176 | def test_get_server_uuid_with_unset_uuid(self): |
1042 | 177 | """ | 177 | """ |
1043 | 178 | The L{BrokerServer.get_server_uuid} method returns C{None} if the uuid | 178 | The L{BrokerServer.get_server_uuid} method returns C{None} if the uuid |
1044 | 179 | of the Landscape server we're pointing at is unknown. | 179 | of the Landscape server we're pointing at is unknown. |
1045 | 180 | """ | 180 | """ |
1047 | 181 | self.assertEquals(self.broker.get_server_uuid(), None) | 181 | self.assertEqual(self.broker.get_server_uuid(), None) |
1048 | 182 | 182 | ||
1049 | 183 | def test_get_server_uuid(self): | 183 | def test_get_server_uuid(self): |
1050 | 184 | """ | 184 | """ |
1051 | @@ -186,7 +186,7 @@ | |||
1052 | 186 | Landscape server we're pointing at. | 186 | Landscape server we're pointing at. |
1053 | 187 | """ | 187 | """ |
1054 | 188 | self.mstore.set_server_uuid("the-uuid") | 188 | self.mstore.set_server_uuid("the-uuid") |
1056 | 189 | self.assertEquals(self.broker.get_server_uuid(), "the-uuid") | 189 | self.assertEqual(self.broker.get_server_uuid(), "the-uuid") |
1057 | 190 | 190 | ||
1058 | 191 | def test_register_client_accepted_message_type(self): | 191 | def test_register_client_accepted_message_type(self): |
1059 | 192 | """ | 192 | """ |
1060 | @@ -195,8 +195,8 @@ | |||
1061 | 195 | """ | 195 | """ |
1062 | 196 | self.broker.register_client_accepted_message_type("type1") | 196 | self.broker.register_client_accepted_message_type("type1") |
1063 | 197 | self.broker.register_client_accepted_message_type("type2") | 197 | self.broker.register_client_accepted_message_type("type2") |
1066 | 198 | self.assertEquals(self.exchanger.get_client_accepted_message_types(), | 198 | self.assertEqual(self.exchanger.get_client_accepted_message_types(), |
1067 | 199 | sorted(["type1", "type2"] + DEFAULT_ACCEPTED_TYPES)) | 199 | sorted(["type1", "type2"] + DEFAULT_ACCEPTED_TYPES)) |
1068 | 200 | 200 | ||
1069 | 201 | def test_fire_event(self): | 201 | def test_fire_event(self): |
1070 | 202 | """ | 202 | """ |
1071 | @@ -284,8 +284,8 @@ | |||
1072 | 284 | the given events. | 284 | the given events. |
1073 | 285 | """ | 285 | """ |
1074 | 286 | result = self.broker.listen_events(["event"]) | 286 | result = self.broker.listen_events(["event"]) |
1077 | 287 | self.assertEquals(self.reactor.fire("event"), [None]) | 287 | self.assertEqual(self.reactor.fire("event"), [None]) |
1078 | 288 | self.assertEquals(self.reactor.fire("event"), []) | 288 | self.assertEqual(self.reactor.fire("event"), []) |
1079 | 289 | return self.assertSuccess(result, "event") | 289 | return self.assertSuccess(result, "event") |
1080 | 290 | 290 | ||
1081 | 291 | 291 | ||
1082 | 292 | 292 | ||
1083 | === modified file 'landscape/broker/tests/test_service.py' | |||
1084 | --- landscape/broker/tests/test_service.py 2010-08-11 11:56:29 +0000 | |||
1085 | +++ landscape/broker/tests/test_service.py 2011-07-06 21:14:28 +0000 | |||
1086 | @@ -22,7 +22,7 @@ | |||
1087 | 22 | """ | 22 | """ |
1088 | 23 | A L{BrokerService} instance has a proper C{persist} attribute. | 23 | A L{BrokerService} instance has a proper C{persist} attribute. |
1089 | 24 | """ | 24 | """ |
1091 | 25 | self.assertEquals( | 25 | self.assertEqual( |
1092 | 26 | self.service.persist.filename, | 26 | self.service.persist.filename, |
1093 | 27 | os.path.join(self.config.data_path, "broker.bpickle")) | 27 | os.path.join(self.config.data_path, "broker.bpickle")) |
1094 | 28 | 28 | ||
1095 | @@ -31,38 +31,38 @@ | |||
1096 | 31 | A L{BrokerService} instance has a proper C{transport} attribute. | 31 | A L{BrokerService} instance has a proper C{transport} attribute. |
1097 | 32 | """ | 32 | """ |
1098 | 33 | self.assertTrue(isinstance(self.service.transport, HTTPTransport)) | 33 | self.assertTrue(isinstance(self.service.transport, HTTPTransport)) |
1100 | 34 | self.assertEquals(self.service.transport.get_url(), self.config.url) | 34 | self.assertEqual(self.service.transport.get_url(), self.config.url) |
1101 | 35 | 35 | ||
1102 | 36 | def test_message_store(self): | 36 | def test_message_store(self): |
1103 | 37 | """ | 37 | """ |
1104 | 38 | A L{BrokerService} instance has a proper C{message_store} attribute. | 38 | A L{BrokerService} instance has a proper C{message_store} attribute. |
1105 | 39 | """ | 39 | """ |
1107 | 40 | self.assertEquals(self.service.message_store.get_accepted_types(), ()) | 40 | self.assertEqual(self.service.message_store.get_accepted_types(), ()) |
1108 | 41 | 41 | ||
1109 | 42 | def test_identity(self): | 42 | def test_identity(self): |
1110 | 43 | """ | 43 | """ |
1111 | 44 | A L{BrokerService} instance has a proper C{identity} attribute. | 44 | A L{BrokerService} instance has a proper C{identity} attribute. |
1112 | 45 | """ | 45 | """ |
1114 | 46 | self.assertEquals(self.service.identity.account_name, "some_account") | 46 | self.assertEqual(self.service.identity.account_name, "some_account") |
1115 | 47 | 47 | ||
1116 | 48 | def test_exchanger(self): | 48 | def test_exchanger(self): |
1117 | 49 | """ | 49 | """ |
1118 | 50 | A L{BrokerService} instance has a proper C{exchanger} attribute. | 50 | A L{BrokerService} instance has a proper C{exchanger} attribute. |
1119 | 51 | """ | 51 | """ |
1122 | 52 | self.assertEquals(self.service.exchanger.get_exchange_intervals(), | 52 | self.assertEqual(self.service.exchanger.get_exchange_intervals(), |
1123 | 53 | (60, 900)) | 53 | (60, 900)) |
1124 | 54 | 54 | ||
1125 | 55 | def test_pinger(self): | 55 | def test_pinger(self): |
1126 | 56 | """ | 56 | """ |
1127 | 57 | A L{BrokerService} instance has a proper C{pinger} attribute. | 57 | A L{BrokerService} instance has a proper C{pinger} attribute. |
1128 | 58 | """ | 58 | """ |
1130 | 59 | self.assertEquals(self.service.pinger.get_url(), self.config.ping_url) | 59 | self.assertEqual(self.service.pinger.get_url(), self.config.ping_url) |
1131 | 60 | 60 | ||
1132 | 61 | def test_registration(self): | 61 | def test_registration(self): |
1133 | 62 | """ | 62 | """ |
1134 | 63 | A L{BrokerService} instance has a proper C{registration} attribute. | 63 | A L{BrokerService} instance has a proper C{registration} attribute. |
1135 | 64 | """ | 64 | """ |
1137 | 65 | self.assertEquals(self.service.registration.should_register(), False) | 65 | self.assertEqual(self.service.registration.should_register(), False) |
1138 | 66 | 66 | ||
1139 | 67 | def test_wb_exit(self): | 67 | def test_wb_exit(self): |
1140 | 68 | """ | 68 | """ |
1141 | 69 | 69 | ||
1142 | === modified file 'landscape/broker/tests/test_store.py' | |||
1143 | --- landscape/broker/tests/test_store.py 2011-06-28 17:10:04 +0000 | |||
1144 | +++ landscape/broker/tests/test_store.py 2011-07-06 21:14:28 +0000 | |||
1145 | @@ -42,51 +42,51 @@ | |||
1146 | 42 | return self.time | 42 | return self.time |
1147 | 43 | 43 | ||
1148 | 44 | def test_get_set_sequence(self): | 44 | def test_get_set_sequence(self): |
1150 | 45 | self.assertEquals(self.store.get_sequence(), 0) | 45 | self.assertEqual(self.store.get_sequence(), 0) |
1151 | 46 | self.store.set_sequence(3) | 46 | self.store.set_sequence(3) |
1153 | 47 | self.assertEquals(self.store.get_sequence(), 3) | 47 | self.assertEqual(self.store.get_sequence(), 3) |
1154 | 48 | 48 | ||
1155 | 49 | # Ensure it's actually saved. | 49 | # Ensure it's actually saved. |
1156 | 50 | self.store.commit() | 50 | self.store.commit() |
1157 | 51 | store = self.create_store() | 51 | store = self.create_store() |
1159 | 52 | self.assertEquals(store.get_sequence(), 3) | 52 | self.assertEqual(store.get_sequence(), 3) |
1160 | 53 | 53 | ||
1161 | 54 | def test_get_set_server_sequence(self): | 54 | def test_get_set_server_sequence(self): |
1163 | 55 | self.assertEquals(self.store.get_server_sequence(), 0) | 55 | self.assertEqual(self.store.get_server_sequence(), 0) |
1164 | 56 | self.store.set_server_sequence(3) | 56 | self.store.set_server_sequence(3) |
1166 | 57 | self.assertEquals(self.store.get_server_sequence(), 3) | 57 | self.assertEqual(self.store.get_server_sequence(), 3) |
1167 | 58 | 58 | ||
1168 | 59 | # Ensure it's actually saved. | 59 | # Ensure it's actually saved. |
1169 | 60 | self.store.commit() | 60 | self.store.commit() |
1170 | 61 | store = self.create_store() | 61 | store = self.create_store() |
1172 | 62 | self.assertEquals(store.get_server_sequence(), 3) | 62 | self.assertEqual(store.get_server_sequence(), 3) |
1173 | 63 | 63 | ||
1174 | 64 | def test_get_set_server_uuid(self): | 64 | def test_get_set_server_uuid(self): |
1176 | 65 | self.assertEquals(self.store.get_server_uuid(), None) | 65 | self.assertEqual(self.store.get_server_uuid(), None) |
1177 | 66 | self.store.set_server_uuid("abcd-efgh") | 66 | self.store.set_server_uuid("abcd-efgh") |
1179 | 67 | self.assertEquals(self.store.get_server_uuid(), "abcd-efgh") | 67 | self.assertEqual(self.store.get_server_uuid(), "abcd-efgh") |
1180 | 68 | 68 | ||
1181 | 69 | # Ensure it's actually saved. | 69 | # Ensure it's actually saved. |
1182 | 70 | self.store.commit() | 70 | self.store.commit() |
1183 | 71 | store = self.create_store() | 71 | store = self.create_store() |
1185 | 72 | self.assertEquals(store.get_server_uuid(), "abcd-efgh") | 72 | self.assertEqual(store.get_server_uuid(), "abcd-efgh") |
1186 | 73 | 73 | ||
1187 | 74 | def test_get_pending_offset(self): | 74 | def test_get_pending_offset(self): |
1189 | 75 | self.assertEquals(self.store.get_pending_offset(), 0) | 75 | self.assertEqual(self.store.get_pending_offset(), 0) |
1190 | 76 | self.store.set_pending_offset(3) | 76 | self.store.set_pending_offset(3) |
1192 | 77 | self.assertEquals(self.store.get_pending_offset(), 3) | 77 | self.assertEqual(self.store.get_pending_offset(), 3) |
1193 | 78 | 78 | ||
1194 | 79 | def test_add_pending_offset(self): | 79 | def test_add_pending_offset(self): |
1200 | 80 | self.assertEquals(self.store.get_pending_offset(), 0) | 80 | self.assertEqual(self.store.get_pending_offset(), 0) |
1201 | 81 | self.store.add_pending_offset(3) | 81 | self.store.add_pending_offset(3) |
1202 | 82 | self.assertEquals(self.store.get_pending_offset(), 3) | 82 | self.assertEqual(self.store.get_pending_offset(), 3) |
1203 | 83 | self.store.add_pending_offset(3) | 83 | self.store.add_pending_offset(3) |
1204 | 84 | self.assertEquals(self.store.get_pending_offset(), 6) | 84 | self.assertEqual(self.store.get_pending_offset(), 6) |
1205 | 85 | self.store.add_pending_offset(-3) | 85 | self.store.add_pending_offset(-3) |
1207 | 86 | self.assertEquals(self.store.get_pending_offset(), 3) | 86 | self.assertEqual(self.store.get_pending_offset(), 3) |
1208 | 87 | 87 | ||
1209 | 88 | def test_no_pending_messages(self): | 88 | def test_no_pending_messages(self): |
1211 | 89 | self.assertEquals(self.store.get_pending_messages(1), []) | 89 | self.assertEqual(self.store.get_pending_messages(1), []) |
1212 | 90 | 90 | ||
1213 | 91 | def test_delete_no_messages(self): | 91 | def test_delete_no_messages(self): |
1214 | 92 | self.store.delete_old_messages() | 92 | self.store.delete_old_messages() |
1215 | @@ -102,8 +102,8 @@ | |||
1216 | 102 | self.store.set_accepted_types(["empty", "unaccepted"]) | 102 | self.store.set_accepted_types(["empty", "unaccepted"]) |
1217 | 103 | self.store.set_pending_offset(0) | 103 | self.store.set_pending_offset(0) |
1218 | 104 | messages = self.store.get_pending_messages() | 104 | messages = self.store.get_pending_messages() |
1221 | 105 | self.assertEquals(len(messages), 1) | 105 | self.assertEqual(len(messages), 1) |
1222 | 106 | self.assertEquals(messages[0]["type"], "unaccepted") | 106 | self.assertEqual(messages[0]["type"], "unaccepted") |
1223 | 107 | 107 | ||
1224 | 108 | def test_delete_all_messages(self): | 108 | def test_delete_all_messages(self): |
1225 | 109 | """Resetting the message store means removing *ALL* messages.""" | 109 | """Resetting the message store means removing *ALL* messages.""" |
1226 | @@ -115,8 +115,8 @@ | |||
1227 | 115 | self.store.set_pending_offset(2) | 115 | self.store.set_pending_offset(2) |
1228 | 116 | self.store.delete_all_messages() | 116 | self.store.delete_all_messages() |
1229 | 117 | self.store.set_accepted_types(["empty", "unaccepted"]) | 117 | self.store.set_accepted_types(["empty", "unaccepted"]) |
1232 | 118 | self.assertEquals(self.store.get_pending_offset(), 0) | 118 | self.assertEqual(self.store.get_pending_offset(), 0) |
1233 | 119 | self.assertEquals(self.store.get_pending_messages(), []) | 119 | self.assertEqual(self.store.get_pending_messages(), []) |
1234 | 120 | 120 | ||
1235 | 121 | def test_one_message(self): | 121 | def test_one_message(self): |
1236 | 122 | self.store.add(dict(type="data", data="A thing")) | 122 | self.store.add(dict(type="data", data="A thing")) |
1237 | @@ -130,38 +130,38 @@ | |||
1238 | 130 | for i in range(10): | 130 | for i in range(10): |
1239 | 131 | self.store.add(dict(type="data", data=str(i))) | 131 | self.store.add(dict(type="data", data=str(i))) |
1240 | 132 | il = [m["data"] for m in self.store.get_pending_messages(5)] | 132 | il = [m["data"] for m in self.store.get_pending_messages(5)] |
1242 | 133 | self.assertEquals(il, map(str, [0, 1, 2, 3, 4])) | 133 | self.assertEqual(il, map(str, [0, 1, 2, 3, 4])) |
1243 | 134 | 134 | ||
1244 | 135 | def test_offset(self): | 135 | def test_offset(self): |
1245 | 136 | self.store.set_pending_offset(5) | 136 | self.store.set_pending_offset(5) |
1246 | 137 | for i in range(15): | 137 | for i in range(15): |
1247 | 138 | self.store.add(dict(type="data", data=str(i))) | 138 | self.store.add(dict(type="data", data=str(i))) |
1248 | 139 | il = [m["data"] for m in self.store.get_pending_messages(5)] | 139 | il = [m["data"] for m in self.store.get_pending_messages(5)] |
1250 | 140 | self.assertEquals(il, map(str, [5, 6, 7, 8, 9])) | 140 | self.assertEqual(il, map(str, [5, 6, 7, 8, 9])) |
1251 | 141 | 141 | ||
1252 | 142 | def test_exercise_multi_dir(self): | 142 | def test_exercise_multi_dir(self): |
1253 | 143 | for i in range(35): | 143 | for i in range(35): |
1254 | 144 | self.store.add(dict(type="data", data=str(i))) | 144 | self.store.add(dict(type="data", data=str(i))) |
1255 | 145 | il = [m["data"] for m in self.store.get_pending_messages(50)] | 145 | il = [m["data"] for m in self.store.get_pending_messages(50)] |
1257 | 146 | self.assertEquals(il, map(str, range(35))) | 146 | self.assertEqual(il, map(str, range(35))) |
1258 | 147 | 147 | ||
1259 | 148 | def test_wb_clean_up_empty_directories(self): | 148 | def test_wb_clean_up_empty_directories(self): |
1260 | 149 | for i in range(60): | 149 | for i in range(60): |
1261 | 150 | self.store.add(dict(type="data", data=str(i))) | 150 | self.store.add(dict(type="data", data=str(i))) |
1262 | 151 | il = [m["data"] for m in self.store.get_pending_messages(60)] | 151 | il = [m["data"] for m in self.store.get_pending_messages(60)] |
1265 | 152 | self.assertEquals(il, map(str, range(60))) | 152 | self.assertEqual(il, map(str, range(60))) |
1266 | 153 | self.assertEquals(set(os.listdir(self.temp_dir)), set(["0", "1", "2"])) | 153 | self.assertEqual(set(os.listdir(self.temp_dir)), set(["0", "1", "2"])) |
1267 | 154 | 154 | ||
1268 | 155 | self.store.set_pending_offset(60) | 155 | self.store.set_pending_offset(60) |
1269 | 156 | self.store.delete_old_messages() | 156 | self.store.delete_old_messages() |
1271 | 157 | self.assertEquals(os.listdir(self.temp_dir), []) | 157 | self.assertEqual(os.listdir(self.temp_dir), []) |
1272 | 158 | 158 | ||
1273 | 159 | def test_unaccepted(self): | 159 | def test_unaccepted(self): |
1274 | 160 | for i in range(10): | 160 | for i in range(10): |
1275 | 161 | self.store.add(dict(type=["data", "unaccepted"][i % 2], | 161 | self.store.add(dict(type=["data", "unaccepted"][i % 2], |
1276 | 162 | data=str(i))) | 162 | data=str(i))) |
1277 | 163 | il = [m["data"] for m in self.store.get_pending_messages(20)] | 163 | il = [m["data"] for m in self.store.get_pending_messages(20)] |
1279 | 164 | self.assertEquals(il, map(str, [0, 2, 4, 6, 8])) | 164 | self.assertEqual(il, map(str, [0, 2, 4, 6, 8])) |
1280 | 165 | 165 | ||
1281 | 166 | def test_unaccepted_with_offset(self): | 166 | def test_unaccepted_with_offset(self): |
1282 | 167 | for i in range(10): | 167 | for i in range(10): |
1283 | @@ -169,7 +169,7 @@ | |||
1284 | 169 | data=str(i))) | 169 | data=str(i))) |
1285 | 170 | self.store.set_pending_offset(2) | 170 | self.store.set_pending_offset(2) |
1286 | 171 | il = [m["data"] for m in self.store.get_pending_messages(20)] | 171 | il = [m["data"] for m in self.store.get_pending_messages(20)] |
1288 | 172 | self.assertEquals(il, map(str, [4, 6, 8])) | 172 | self.assertEqual(il, map(str, [4, 6, 8])) |
1289 | 173 | 173 | ||
1290 | 174 | def test_unaccepted_reaccepted(self): | 174 | def test_unaccepted_reaccepted(self): |
1291 | 175 | for i in range(10): | 175 | for i in range(10): |
1292 | @@ -179,7 +179,7 @@ | |||
1293 | 179 | il = [m["data"] for m in self.store.get_pending_messages(2)] | 179 | il = [m["data"] for m in self.store.get_pending_messages(2)] |
1294 | 180 | self.store.set_accepted_types(["data", "unaccepted"]) | 180 | self.store.set_accepted_types(["data", "unaccepted"]) |
1295 | 181 | il = [m["data"] for m in self.store.get_pending_messages(20)] | 181 | il = [m["data"] for m in self.store.get_pending_messages(20)] |
1297 | 182 | self.assertEquals(il, map(str, [4, 6, 8, 1, 3, 5, 7, 9])) | 182 | self.assertEqual(il, map(str, [4, 6, 8, 1, 3, 5, 7, 9])) |
1298 | 183 | 183 | ||
1299 | 184 | def test_accepted_unaccepted(self): | 184 | def test_accepted_unaccepted(self): |
1300 | 185 | for i in range(10): | 185 | for i in range(10): |
1301 | @@ -191,10 +191,10 @@ | |||
1302 | 191 | self.store.set_pending_offset(2) | 191 | self.store.set_pending_offset(2) |
1303 | 192 | self.store.set_accepted_types(["unaccepted"]) | 192 | self.store.set_accepted_types(["unaccepted"]) |
1304 | 193 | il = [m["data"] for m in self.store.get_pending_messages(20)] | 193 | il = [m["data"] for m in self.store.get_pending_messages(20)] |
1306 | 194 | self.assertEquals(il, map(str, [1, 3, 5, 7, 9])) | 194 | self.assertEqual(il, map(str, [1, 3, 5, 7, 9])) |
1307 | 195 | self.store.set_accepted_types(["data", "unaccepted"]) | 195 | self.store.set_accepted_types(["data", "unaccepted"]) |
1308 | 196 | il = [m["data"] for m in self.store.get_pending_messages(20)] | 196 | il = [m["data"] for m in self.store.get_pending_messages(20)] |
1310 | 197 | self.assertEquals(il, map(str, [1, 3, 5, 7, 9, 4, 6, 8])) | 197 | self.assertEqual(il, map(str, [1, 3, 5, 7, 9, 4, 6, 8])) |
1311 | 198 | 198 | ||
1312 | 199 | def test_accepted_unaccepted_old(self): | 199 | def test_accepted_unaccepted_old(self): |
1313 | 200 | for i in range(10): | 200 | for i in range(10): |
1314 | @@ -203,18 +203,18 @@ | |||
1315 | 203 | self.store.set_pending_offset(2) | 203 | self.store.set_pending_offset(2) |
1316 | 204 | self.store.set_accepted_types(["unaccepted"]) | 204 | self.store.set_accepted_types(["unaccepted"]) |
1317 | 205 | il = [m["data"] for m in self.store.get_pending_messages(20)] | 205 | il = [m["data"] for m in self.store.get_pending_messages(20)] |
1319 | 206 | self.assertEquals(il, map(str, [1, 3, 5, 7, 9])) | 206 | self.assertEqual(il, map(str, [1, 3, 5, 7, 9])) |
1320 | 207 | # Now, if the server asks us to go back and process | 207 | # Now, if the server asks us to go back and process |
1321 | 208 | # previously accepted messages that are now unaccepted, | 208 | # previously accepted messages that are now unaccepted, |
1322 | 209 | # they should be put on hold. | 209 | # they should be put on hold. |
1323 | 210 | self.store.set_pending_offset(0) | 210 | self.store.set_pending_offset(0) |
1324 | 211 | il = [m["data"] for m in self.store.get_pending_messages(20)] | 211 | il = [m["data"] for m in self.store.get_pending_messages(20)] |
1326 | 212 | self.assertEquals(il, map(str, [1, 3, 5, 7, 9])) | 212 | self.assertEqual(il, map(str, [1, 3, 5, 7, 9])) |
1327 | 213 | # When the server starts accepting them again, these old | 213 | # When the server starts accepting them again, these old |
1328 | 214 | # messages will also be delivered. | 214 | # messages will also be delivered. |
1329 | 215 | self.store.set_accepted_types(["data", "unaccepted"]) | 215 | self.store.set_accepted_types(["data", "unaccepted"]) |
1330 | 216 | il = [m["data"] for m in self.store.get_pending_messages(20)] | 216 | il = [m["data"] for m in self.store.get_pending_messages(20)] |
1332 | 217 | self.assertEquals(il, map(str, [1, 3, 5, 7, 9, 0, 2, 4, 6, 8])) | 217 | self.assertEqual(il, map(str, [1, 3, 5, 7, 9, 0, 2, 4, 6, 8])) |
1333 | 218 | 218 | ||
1334 | 219 | def test_wb_handle_broken_messages(self): | 219 | def test_wb_handle_broken_messages(self): |
1335 | 220 | self.log_helper.ignore_errors(ValueError) | 220 | self.log_helper.ignore_errors(ValueError) |
1336 | @@ -228,7 +228,7 @@ | |||
1337 | 228 | file.write("bpickle will break reading this") | 228 | file.write("bpickle will break reading this") |
1338 | 229 | file.close() | 229 | file.close() |
1339 | 230 | 230 | ||
1341 | 231 | self.assertEquals(self.store.get_pending_messages(), []) | 231 | self.assertEqual(self.store.get_pending_messages(), []) |
1342 | 232 | 232 | ||
1343 | 233 | # FIXME This is an unfortunate assertion because it relies on | 233 | # FIXME This is an unfortunate assertion because it relies on |
1344 | 234 | # a message generated by external code. As it turns out, this | 234 | # a message generated by external code. As it turns out, this |
1345 | @@ -265,14 +265,14 @@ | |||
1346 | 265 | 265 | ||
1347 | 266 | messages = self.store.get_pending_messages() | 266 | messages = self.store.get_pending_messages() |
1348 | 267 | 267 | ||
1351 | 268 | self.assertEquals(messages, [{"type": "data", "data": "2", | 268 | self.assertEqual(messages, [{"type": "data", "data": "2", |
1352 | 269 | "api": SERVER_API}]) | 269 | "api": SERVER_API}]) |
1353 | 270 | 270 | ||
1354 | 271 | self.store.set_pending_offset(len(messages)) | 271 | self.store.set_pending_offset(len(messages)) |
1355 | 272 | 272 | ||
1356 | 273 | messages = self.store.get_pending_messages() | 273 | messages = self.store.get_pending_messages() |
1357 | 274 | self.store.delete_old_messages() | 274 | self.store.delete_old_messages() |
1359 | 275 | self.assertEquals(messages, []) | 275 | self.assertEqual(messages, []) |
1360 | 276 | self.assertTrue("ValueError" in self.logfile.getvalue()) | 276 | self.assertTrue("ValueError" in self.logfile.getvalue()) |
1361 | 277 | 277 | ||
1362 | 278 | def test_atomic_message_writing(self): | 278 | def test_atomic_message_writing(self): |
1363 | @@ -296,30 +296,30 @@ | |||
1364 | 296 | self.assertRaises(IOError, self.store.add, {"type": "data", "data": 2}) | 296 | self.assertRaises(IOError, self.store.add, {"type": "data", "data": 2}) |
1365 | 297 | self.mocker.verify() | 297 | self.mocker.verify() |
1366 | 298 | self.mocker.reset() | 298 | self.mocker.reset() |
1368 | 299 | self.assertEquals(self.store.get_pending_messages(), | 299 | self.assertEqual(self.store.get_pending_messages(), |
1369 | 300 | [{"type": "data", "data": 1, "api": SERVER_API}]) | 300 | [{"type": "data", "data": 1, "api": SERVER_API}]) |
1370 | 301 | 301 | ||
1371 | 302 | def test_api_attribute(self): | 302 | def test_api_attribute(self): |
1373 | 303 | self.assertEquals(self.store.api, SERVER_API) | 303 | self.assertEqual(self.store.api, SERVER_API) |
1374 | 304 | new_api = "New API version!" | 304 | new_api = "New API version!" |
1375 | 305 | self.store.api = new_api | 305 | self.store.api = new_api |
1377 | 306 | self.assertEquals(self.store.api, new_api) | 306 | self.assertEqual(self.store.api, new_api) |
1378 | 307 | 307 | ||
1379 | 308 | def test_default_api_on_messages(self): | 308 | def test_default_api_on_messages(self): |
1380 | 309 | self.store.add({"type": "empty"}) | 309 | self.store.add({"type": "empty"}) |
1383 | 310 | self.assertEquals(self.store.get_pending_messages(), | 310 | self.assertEqual(self.store.get_pending_messages(), |
1384 | 311 | [{"type": "empty", "api": SERVER_API}]) | 311 | [{"type": "empty", "api": SERVER_API}]) |
1385 | 312 | 312 | ||
1386 | 313 | def test_custom_api_on_store(self): | 313 | def test_custom_api_on_store(self): |
1387 | 314 | self.store.api = "X.Y" | 314 | self.store.api = "X.Y" |
1388 | 315 | self.store.add({"type": "empty"}) | 315 | self.store.add({"type": "empty"}) |
1391 | 316 | self.assertEquals(self.store.get_pending_messages(), | 316 | self.assertEqual(self.store.get_pending_messages(), |
1392 | 317 | [{"type": "empty", "api": "X.Y"}]) | 317 | [{"type": "empty", "api": "X.Y"}]) |
1393 | 318 | 318 | ||
1394 | 319 | def test_custom_api_on_messages(self): | 319 | def test_custom_api_on_messages(self): |
1395 | 320 | self.store.add({"type": "empty", "api": "X.Y"}) | 320 | self.store.add({"type": "empty", "api": "X.Y"}) |
1398 | 321 | self.assertEquals(self.store.get_pending_messages(), | 321 | self.assertEqual(self.store.get_pending_messages(), |
1399 | 322 | [{"type": "empty", "api": "X.Y"}]) | 322 | [{"type": "empty", "api": "X.Y"}]) |
1400 | 323 | 323 | ||
1401 | 324 | def test_coercion(self): | 324 | def test_coercion(self): |
1402 | 325 | """ | 325 | """ |
1403 | @@ -347,17 +347,17 @@ | |||
1404 | 347 | self.store.add({"type": "data", | 347 | self.store.add({"type": "data", |
1405 | 348 | "data": u"\N{HIRAGANA LETTER A}".encode("utf-8"), | 348 | "data": u"\N{HIRAGANA LETTER A}".encode("utf-8"), |
1406 | 349 | "api": "whatever"}) | 349 | "api": "whatever"}) |
1410 | 350 | self.assertEquals(self.store.get_pending_messages(), | 350 | self.assertEqual(self.store.get_pending_messages(), |
1411 | 351 | [{"type": "data", "api": "whatever", | 351 | [{"type": "data", "api": "whatever", |
1412 | 352 | "data": u"\N{HIRAGANA LETTER A}"}]) | 352 | "data": u"\N{HIRAGANA LETTER A}"}]) |
1413 | 353 | 353 | ||
1414 | 354 | def test_count_pending_messages(self): | 354 | def test_count_pending_messages(self): |
1415 | 355 | """It is possible to get the total number of pending messages.""" | 355 | """It is possible to get the total number of pending messages.""" |
1417 | 356 | self.assertEquals(self.store.count_pending_messages(), 0) | 356 | self.assertEqual(self.store.count_pending_messages(), 0) |
1418 | 357 | self.store.add({"type": "empty"}) | 357 | self.store.add({"type": "empty"}) |
1420 | 358 | self.assertEquals(self.store.count_pending_messages(), 1) | 358 | self.assertEqual(self.store.count_pending_messages(), 1) |
1421 | 359 | self.store.add({"type": "data", "data": "yay"}) | 359 | self.store.add({"type": "data", "data": "yay"}) |
1423 | 360 | self.assertEquals(self.store.count_pending_messages(), 2) | 360 | self.assertEqual(self.store.count_pending_messages(), 2) |
1424 | 361 | 361 | ||
1425 | 362 | def test_commit(self): | 362 | def test_commit(self): |
1426 | 363 | """ | 363 | """ |
1427 | @@ -373,8 +373,8 @@ | |||
1428 | 373 | self.assertTrue(os.path.exists(filename)) | 373 | self.assertTrue(os.path.exists(filename)) |
1429 | 374 | 374 | ||
1430 | 375 | store = MessageStore(Persist(filename=filename), self.temp_dir) | 375 | store = MessageStore(Persist(filename=filename), self.temp_dir) |
1433 | 376 | self.assertEquals(set(store.get_accepted_types()), | 376 | self.assertEqual(set(store.get_accepted_types()), |
1434 | 377 | set(["foo", "bar"])) | 377 | set(["foo", "bar"])) |
1435 | 378 | 378 | ||
1436 | 379 | def test_is_pending_pre_and_post_message_delivery(self): | 379 | def test_is_pending_pre_and_post_message_delivery(self): |
1437 | 380 | self.log_helper.ignore_errors(ValueError) | 380 | self.log_helper.ignore_errors(ValueError) |
1438 | @@ -438,6 +438,6 @@ | |||
1439 | 438 | file.write("bpickle will break reading this") | 438 | file.write("bpickle will break reading this") |
1440 | 439 | file.close() | 439 | file.close() |
1441 | 440 | 440 | ||
1443 | 441 | self.assertEquals(self.store.get_pending_messages(), []) | 441 | self.assertEqual(self.store.get_pending_messages(), []) |
1444 | 442 | 442 | ||
1445 | 443 | self.assertFalse(self.store.is_pending(id)) | 443 | self.assertFalse(self.store.is_pending(id)) |
1446 | 444 | 444 | ||
1447 | === modified file 'landscape/broker/tests/test_transport.py' | |||
1448 | --- landscape/broker/tests/test_transport.py 2011-06-29 17:50:48 +0000 | |||
1449 | +++ landscape/broker/tests/test_transport.py 2011-07-06 21:14:28 +0000 | |||
1450 | @@ -53,12 +53,12 @@ | |||
1451 | 53 | def test_get_url(self): | 53 | def test_get_url(self): |
1452 | 54 | url = "http://example/ooga" | 54 | url = "http://example/ooga" |
1453 | 55 | transport = HTTPTransport(url) | 55 | transport = HTTPTransport(url) |
1455 | 56 | self.assertEquals(transport.get_url(), url) | 56 | self.assertEqual(transport.get_url(), url) |
1456 | 57 | 57 | ||
1457 | 58 | def test_set_url(self): | 58 | def test_set_url(self): |
1458 | 59 | transport = HTTPTransport("http://example/ooga") | 59 | transport = HTTPTransport("http://example/ooga") |
1459 | 60 | transport.set_url("http://example/message-system") | 60 | transport.set_url("http://example/message-system") |
1461 | 61 | self.assertEquals(transport.get_url(), "http://example/message-system") | 61 | self.assertEqual(transport.get_url(), "http://example/message-system") |
1462 | 62 | 62 | ||
1463 | 63 | def test_request_data(self): | 63 | def test_request_data(self): |
1464 | 64 | """ | 64 | """ |
1465 | @@ -76,13 +76,13 @@ | |||
1466 | 76 | message_api="X.Y") | 76 | message_api="X.Y") |
1467 | 77 | 77 | ||
1468 | 78 | def got_result(ignored): | 78 | def got_result(ignored): |
1476 | 79 | self.assertEquals(r.request.received_headers["x-computer-id"], | 79 | self.assertEqual(r.request.received_headers["x-computer-id"], |
1477 | 80 | "34") | 80 | "34") |
1478 | 81 | self.assertEquals(r.request.received_headers["user-agent"], | 81 | self.assertEqual(r.request.received_headers["user-agent"], |
1479 | 82 | "landscape-client/%s" % (VERSION,)) | 82 | "landscape-client/%s" % (VERSION,)) |
1480 | 83 | self.assertEquals(r.request.received_headers["x-message-api"], | 83 | self.assertEqual(r.request.received_headers["x-message-api"], |
1481 | 84 | "X.Y") | 84 | "X.Y") |
1482 | 85 | self.assertEquals(bpickle.loads(r.content), "HI") | 85 | self.assertEqual(bpickle.loads(r.content), "HI") |
1483 | 86 | result.addCallback(got_result) | 86 | result.addCallback(got_result) |
1484 | 87 | return result | 87 | return result |
1485 | 88 | 88 | ||
1486 | @@ -103,13 +103,13 @@ | |||
1487 | 103 | message_api="X.Y") | 103 | message_api="X.Y") |
1488 | 104 | 104 | ||
1489 | 105 | def got_result(ignored): | 105 | def got_result(ignored): |
1497 | 106 | self.assertEquals(r.request.received_headers["x-computer-id"], | 106 | self.assertEqual(r.request.received_headers["x-computer-id"], |
1498 | 107 | "34") | 107 | "34") |
1499 | 108 | self.assertEquals(r.request.received_headers["user-agent"], | 108 | self.assertEqual(r.request.received_headers["user-agent"], |
1500 | 109 | "landscape-client/%s" % (VERSION,)) | 109 | "landscape-client/%s" % (VERSION,)) |
1501 | 110 | self.assertEquals(r.request.received_headers["x-message-api"], | 110 | self.assertEqual(r.request.received_headers["x-message-api"], |
1502 | 111 | "X.Y") | 111 | "X.Y") |
1503 | 112 | self.assertEquals(bpickle.loads(r.content), "HI") | 112 | self.assertEqual(bpickle.loads(r.content), "HI") |
1504 | 113 | result.addCallback(got_result) | 113 | result.addCallback(got_result) |
1505 | 114 | return result | 114 | return result |
1506 | 115 | 115 | ||
1507 | @@ -134,8 +134,8 @@ | |||
1508 | 134 | message_api="X.Y") | 134 | message_api="X.Y") |
1509 | 135 | 135 | ||
1510 | 136 | def got_result(ignored): | 136 | def got_result(ignored): |
1513 | 137 | self.assertEquals(r.request, None) | 137 | self.assertEqual(r.request, None) |
1514 | 138 | self.assertEquals(r.content, None) | 138 | self.assertEqual(r.content, None) |
1515 | 139 | self.assertTrue("server certificate verification failed" | 139 | self.assertTrue("server certificate verification failed" |
1516 | 140 | in self.logfile.getvalue()) | 140 | in self.logfile.getvalue()) |
1517 | 141 | result.addCallback(got_result) | 141 | result.addCallback(got_result) |
1518 | @@ -167,7 +167,7 @@ | |||
1519 | 167 | transport.exchange("pay load") | 167 | transport.exchange("pay load") |
1520 | 168 | 168 | ||
1521 | 169 | file_path = os.path.join(path, static_filename()) | 169 | file_path = os.path.join(path, static_filename()) |
1523 | 170 | self.assertEquals("pay load", bpickle.loads(read_file(file_path))) | 170 | self.assertEqual("pay load", bpickle.loads(read_file(file_path))) |
1524 | 171 | 171 | ||
1525 | 172 | def test_exchange_works_without_payload_recording(self): | 172 | def test_exchange_works_without_payload_recording(self): |
1526 | 173 | """ | 173 | """ |
1527 | @@ -176,10 +176,11 @@ | |||
1528 | 176 | """ | 176 | """ |
1529 | 177 | transport = HTTPTransport("http://localhost") | 177 | transport = HTTPTransport("http://localhost") |
1530 | 178 | self.called = False | 178 | self.called = False |
1532 | 179 | 179 | ||
1533 | 180 | def fake_curl(param1, param2, param3): | 180 | def fake_curl(param1, param2, param3): |
1534 | 181 | """Stub out the curl network call.""" | 181 | """Stub out the curl network call.""" |
1535 | 182 | self.called = True | 182 | self.called = True |
1536 | 183 | |||
1537 | 183 | class Curly(object): | 184 | class Curly(object): |
1538 | 184 | def getinfo(self, param1): | 185 | def getinfo(self, param1): |
1539 | 185 | return 200 | 186 | return 200 |
1540 | @@ -190,6 +191,7 @@ | |||
1541 | 190 | 191 | ||
1542 | 191 | self.assertTrue(self.called) | 192 | self.assertTrue(self.called) |
1543 | 192 | 193 | ||
1544 | 194 | |||
1545 | 193 | class PayloadRecorderTest(MockerTestCase): | 195 | class PayloadRecorderTest(MockerTestCase): |
1546 | 194 | 196 | ||
1547 | 195 | def test_get_payload_filename(self): | 197 | def test_get_payload_filename(self): |
1548 | @@ -207,7 +209,7 @@ | |||
1549 | 207 | 209 | ||
1550 | 208 | payload_name = recorder.get_payload_filename() | 210 | payload_name = recorder.get_payload_filename() |
1551 | 209 | 211 | ||
1553 | 210 | self.assertEquals("12.346", payload_name) | 212 | self.assertEqual("12.346", payload_name) |
1554 | 211 | 213 | ||
1555 | 212 | def test_get_payload_filename_no_duplicates(self): | 214 | def test_get_payload_filename_no_duplicates(self): |
1556 | 213 | """ | 215 | """ |
1557 | @@ -228,8 +230,8 @@ | |||
1558 | 228 | payload_name_1 = recorder.get_payload_filename() | 230 | payload_name_1 = recorder.get_payload_filename() |
1559 | 229 | payload_name_2 = recorder.get_payload_filename() | 231 | payload_name_2 = recorder.get_payload_filename() |
1560 | 230 | 232 | ||
1563 | 231 | self.assertEquals("12.345", payload_name_1) | 233 | self.assertEqual("12.345", payload_name_1) |
1564 | 232 | self.assertEquals("12.346", payload_name_2) | 234 | self.assertEqual("12.346", payload_name_2) |
1565 | 233 | 235 | ||
1566 | 234 | def test_save(self): | 236 | def test_save(self): |
1567 | 235 | """L{PayloadRecorder.save} should save the payload to the filesystem. | 237 | """L{PayloadRecorder.save} should save the payload to the filesystem. |
1568 | @@ -242,7 +244,7 @@ | |||
1569 | 242 | recorder.get_payload_filename = static_filename | 244 | recorder.get_payload_filename = static_filename |
1570 | 243 | recorder.save("payload data") | 245 | recorder.save("payload data") |
1571 | 244 | file_path = os.path.join(path, static_filename()) | 246 | file_path = os.path.join(path, static_filename()) |
1573 | 245 | self.assertEquals("payload data", read_file(file_path)) | 247 | self.assertEqual("payload data", read_file(file_path)) |
1574 | 246 | 248 | ||
1575 | 247 | def test_create_destination_dir(self): | 249 | def test_create_destination_dir(self): |
1576 | 248 | """ | 250 | """ |
1577 | @@ -263,4 +265,4 @@ | |||
1578 | 263 | create_file(os.path.join(path, "one"), "one") | 265 | create_file(os.path.join(path, "one"), "one") |
1579 | 264 | create_file(os.path.join(path, "two"), "two") | 266 | create_file(os.path.join(path, "two"), "two") |
1580 | 265 | PayloadRecorder(path) | 267 | PayloadRecorder(path) |
1582 | 266 | self.assertEquals([], os.listdir(path)) | 268 | self.assertEqual([], os.listdir(path)) |
1583 | 267 | 269 | ||
1584 | === modified file 'landscape/lib/tests/test_amp.py' | |||
1585 | --- landscape/lib/tests/test_amp.py 2010-06-08 07:59:32 +0000 | |||
1586 | +++ landscape/lib/tests/test_amp.py 2011-07-06 21:14:28 +0000 | |||
1587 | @@ -2,10 +2,7 @@ | |||
1588 | 2 | from twisted.internet.defer import Deferred, DeferredList | 2 | from twisted.internet.defer import Deferred, DeferredList |
1589 | 3 | from twisted.internet.protocol import ClientCreator | 3 | from twisted.internet.protocol import ClientCreator |
1590 | 4 | from twisted.internet.error import ConnectionDone, ConnectError | 4 | from twisted.internet.error import ConnectionDone, ConnectError |
1595 | 5 | try: | 5 | from twisted.internet.task import Clock |
1592 | 6 | from twisted.internet.task import Clock | ||
1593 | 7 | except ImportError: | ||
1594 | 8 | Clock = None # Dapper doesn't have it | ||
1596 | 9 | 6 | ||
1597 | 10 | from landscape.lib.twisted_util import gather_results | 7 | from landscape.lib.twisted_util import gather_results |
1598 | 11 | from landscape.lib.amp import ( | 8 | from landscape.lib.amp import ( |
1599 | @@ -456,7 +453,7 @@ | |||
1600 | 456 | The L{MethodCallClientFactory} class has a default value of 30 seconds | 453 | The L{MethodCallClientFactory} class has a default value of 30 seconds |
1601 | 457 | for the maximum reconnection delay. | 454 | for the maximum reconnection delay. |
1602 | 458 | """ | 455 | """ |
1604 | 459 | self.assertEquals(self.factory.maxDelay, 30) | 456 | self.assertEqual(self.factory.maxDelay, 30) |
1605 | 460 | 457 | ||
1606 | 461 | def test_add_notifier(self): | 458 | def test_add_notifier(self): |
1607 | 462 | """ | 459 | """ |
1608 | @@ -494,7 +491,7 @@ | |||
1609 | 494 | self.factory.retry = self.mocker.mock() | 491 | self.factory.retry = self.mocker.mock() |
1610 | 495 | self.factory.retry(KWARGS) | 492 | self.factory.retry(KWARGS) |
1611 | 496 | self.mocker.replay() | 493 | self.mocker.replay() |
1613 | 497 | self.assertEquals(self.factory.retries, 0) | 494 | self.assertEqual(self.factory.retries, 0) |
1614 | 498 | self.factory.clientConnectionFailed(None, None) | 495 | self.factory.clientConnectionFailed(None, None) |
1615 | 499 | 496 | ||
1616 | 500 | def test_client_connection_failed_with_max_retries_reached(self): | 497 | def test_client_connection_failed_with_max_retries_reached(self): |
1617 | @@ -571,7 +568,7 @@ | |||
1618 | 571 | self.connector.disconnect() | 568 | self.connector.disconnect() |
1619 | 572 | 569 | ||
1620 | 573 | def assert_factor(ignored): | 570 | def assert_factor(ignored): |
1622 | 574 | self.assertEquals(self.connector._factory.factor, 1.0) | 571 | self.assertEqual(self.connector._factory.factor, 1.0) |
1623 | 575 | 572 | ||
1624 | 576 | result = self.connector.connect(factor=1.0) | 573 | result = self.connector.connect(factor=1.0) |
1625 | 577 | return result.addCallback(assert_factor) | 574 | return result.addCallback(assert_factor) |
1626 | @@ -650,7 +647,7 @@ | |||
1627 | 650 | self.port = reactor.listenUNIX(self.socket, self.server_factory) | 647 | self.port = reactor.listenUNIX(self.socket, self.server_factory) |
1628 | 651 | 648 | ||
1629 | 652 | def assert_failure(error): | 649 | def assert_failure(error): |
1631 | 653 | self.assertEquals(str(error), "Forbidden method 'secret'") | 650 | self.assertEqual(str(error), "Forbidden method 'secret'") |
1632 | 654 | 651 | ||
1633 | 655 | reactor.callLater(0.5, restart_listening) | 652 | reactor.callLater(0.5, restart_listening) |
1634 | 656 | result = self.words.secret() | 653 | result = self.words.secret() |
1635 | @@ -686,7 +683,7 @@ | |||
1636 | 686 | self.port = reactor.listenUNIX(self.socket, self.server_factory) | 683 | self.port = reactor.listenUNIX(self.socket, self.server_factory) |
1637 | 687 | 684 | ||
1638 | 688 | def assert_failure(error): | 685 | def assert_failure(error): |
1640 | 689 | self.assertEquals(str(error), "Forbidden method 'secret'") | 686 | self.assertEqual(str(error), "Forbidden method 'secret'") |
1641 | 690 | 687 | ||
1642 | 691 | # Use our own reconnect handler | 688 | # Use our own reconnect handler |
1643 | 692 | self.connector._factory.remove_notifier(self.words._handle_reconnect) | 689 | self.connector._factory.remove_notifier(self.words._handle_reconnect) |
1644 | @@ -710,13 +707,13 @@ | |||
1645 | 710 | self.port = reactor.listenUNIX(self.socket, self.server_factory) | 707 | self.port = reactor.listenUNIX(self.socket, self.server_factory) |
1646 | 711 | 708 | ||
1647 | 712 | def assert_guess(response): | 709 | def assert_guess(response): |
1649 | 713 | self.assertEquals(response, "Guessed!") | 710 | self.assertEqual(response, "Guessed!") |
1650 | 714 | 711 | ||
1651 | 715 | def assert_secret(failure): | 712 | def assert_secret(failure): |
1653 | 716 | self.assertEquals(str(failure.value), "Forbidden method 'secret'") | 713 | self.assertEqual(str(failure.value), "Forbidden method 'secret'") |
1654 | 717 | 714 | ||
1655 | 718 | def assert_motd(response): | 715 | def assert_motd(response): |
1657 | 719 | self.assertEquals(response, "Words are cool") | 716 | self.assertEqual(response, "Words are cool") |
1658 | 720 | 717 | ||
1659 | 721 | reactor.callLater(0.1, restart_listening) | 718 | reactor.callLater(0.1, restart_listening) |
1660 | 722 | 719 | ||
1661 | @@ -767,7 +764,7 @@ | |||
1662 | 767 | reactor.callLater(0.1, reconnected.callback, None) | 764 | reactor.callLater(0.1, reconnected.callback, None) |
1663 | 768 | 765 | ||
1664 | 769 | def assert_failure(error): | 766 | def assert_failure(error): |
1666 | 770 | self.assertEquals(str(error), "timeout") | 767 | self.assertEqual(str(error), "timeout") |
1667 | 771 | return reconnected | 768 | return reconnected |
1668 | 772 | 769 | ||
1669 | 773 | reactor.callLater(0.9, restart_listening) | 770 | reactor.callLater(0.9, restart_listening) |
1670 | 774 | 771 | ||
1671 | === modified file 'landscape/lib/tests/test_bootstrap.py' | |||
1672 | --- landscape/lib/tests/test_bootstrap.py 2008-06-10 10:56:01 +0000 | |||
1673 | +++ landscape/lib/tests/test_bootstrap.py 2011-07-06 21:14:28 +0000 | |||
1674 | @@ -117,7 +117,7 @@ | |||
1675 | 117 | filename = self.makeFile("CONTENT") | 117 | filename = self.makeFile("CONTENT") |
1676 | 118 | file = self.bootstrap_class(filename) | 118 | file = self.bootstrap_class(filename) |
1677 | 119 | file.bootstrap() | 119 | file.bootstrap() |
1679 | 120 | self.assertEquals(open(filename).read(), "CONTENT") | 120 | self.assertEqual(open(filename).read(), "CONTENT") |
1680 | 121 | 121 | ||
1681 | 122 | 122 | ||
1682 | 123 | class BootstrapDirectoryTest(BootstrapCreationTest): | 123 | class BootstrapDirectoryTest(BootstrapCreationTest): |
1683 | 124 | 124 | ||
1684 | === modified file 'landscape/lib/tests/test_bpickle.py' | |||
1685 | --- landscape/lib/tests/test_bpickle.py 2008-06-10 10:56:01 +0000 | |||
1686 | +++ landscape/lib/tests/test_bpickle.py 2011-07-06 21:14:28 +0000 | |||
1687 | @@ -6,7 +6,7 @@ | |||
1688 | 6 | class BPickleTest(unittest.TestCase): | 6 | class BPickleTest(unittest.TestCase): |
1689 | 7 | 7 | ||
1690 | 8 | def test_int(self): | 8 | def test_int(self): |
1692 | 9 | self.assertEquals(bpickle.loads(bpickle.dumps(1)), 1) | 9 | self.assertEqual(bpickle.loads(bpickle.dumps(1)), 1) |
1693 | 10 | 10 | ||
1694 | 11 | def test_float(self): | 11 | def test_float(self): |
1695 | 12 | self.assertAlmostEquals(bpickle.loads(bpickle.dumps(2.3)), 2.3) | 12 | self.assertAlmostEquals(bpickle.loads(bpickle.dumps(2.3)), 2.3) |
1696 | @@ -17,35 +17,34 @@ | |||
1697 | 17 | self.assertAlmostEquals(bpickle.loads(bpickle.dumps(number)), number) | 17 | self.assertAlmostEquals(bpickle.loads(bpickle.dumps(number)), number) |
1698 | 18 | 18 | ||
1699 | 19 | def test_string(self): | 19 | def test_string(self): |
1701 | 20 | self.assertEquals(bpickle.loads(bpickle.dumps('foo')), 'foo') | 20 | self.assertEqual(bpickle.loads(bpickle.dumps('foo')), 'foo') |
1702 | 21 | 21 | ||
1703 | 22 | def test_list(self): | 22 | def test_list(self): |
1706 | 23 | self.assertEquals(bpickle.loads(bpickle.dumps([1, 2, 'hello', 3.0])), | 23 | self.assertEqual(bpickle.loads(bpickle.dumps([1, 2, 'hello', 3.0])), |
1707 | 24 | [1, 2, 'hello', 3.0]) | 24 | [1, 2, 'hello', 3.0]) |
1708 | 25 | 25 | ||
1709 | 26 | def test_tuple(self): | 26 | def test_tuple(self): |
1710 | 27 | data = bpickle.dumps((1, [], 2, 'hello', 3.0)) | 27 | data = bpickle.dumps((1, [], 2, 'hello', 3.0)) |
1713 | 28 | self.assertEquals(bpickle.loads(data), | 28 | self.assertEqual(bpickle.loads(data), |
1714 | 29 | (1, [], 2, 'hello', 3.0)) | 29 | (1, [], 2, 'hello', 3.0)) |
1715 | 30 | 30 | ||
1716 | 31 | def test_none(self): | 31 | def test_none(self): |
1718 | 32 | self.assertEquals(bpickle.loads(bpickle.dumps(None)), None) | 32 | self.assertEqual(bpickle.loads(bpickle.dumps(None)), None) |
1719 | 33 | 33 | ||
1720 | 34 | def test_unicode(self): | 34 | def test_unicode(self): |
1722 | 35 | self.assertEquals(bpickle.loads(bpickle.dumps(u'\xc0')), u'\xc0') | 35 | self.assertEqual(bpickle.loads(bpickle.dumps(u'\xc0')), u'\xc0') |
1723 | 36 | 36 | ||
1724 | 37 | def test_bool(self): | 37 | def test_bool(self): |
1726 | 38 | self.assertEquals(bpickle.loads(bpickle.dumps(True)), True) | 38 | self.assertEqual(bpickle.loads(bpickle.dumps(True)), True) |
1727 | 39 | 39 | ||
1728 | 40 | def test_dict(self): | 40 | def test_dict(self): |
1729 | 41 | dumped_tostr = bpickle.dumps({True: "hello"}) | 41 | dumped_tostr = bpickle.dumps({True: "hello"}) |
1732 | 42 | self.assertEquals(bpickle.loads(dumped_tostr), | 42 | self.assertEqual(bpickle.loads(dumped_tostr), |
1733 | 43 | {True: "hello"}) | 43 | {True: "hello"}) |
1734 | 44 | dumped_tobool = bpickle.dumps({True: False}) | 44 | dumped_tobool = bpickle.dumps({True: False}) |
1737 | 45 | self.assertEquals(bpickle.loads(dumped_tobool), | 45 | self.assertEqual(bpickle.loads(dumped_tobool), |
1738 | 46 | {True: False}) | 46 | {True: False}) |
1739 | 47 | 47 | ||
1740 | 48 | def test_long(self): | 48 | def test_long(self): |
1741 | 49 | long = 99999999999999999999999999999 | 49 | long = 99999999999999999999999999999 |
1744 | 50 | self.assertEquals(bpickle.loads(bpickle.dumps(long)), long) | 50 | self.assertEqual(bpickle.loads(bpickle.dumps(long)), long) |
1743 | 51 | |||
1745 | 52 | 51 | ||
1746 | === modified file 'landscape/lib/tests/test_bpickle_dbus.py' | |||
1747 | --- landscape/lib/tests/test_bpickle_dbus.py 2008-06-10 10:56:01 +0000 | |||
1748 | +++ landscape/lib/tests/test_bpickle_dbus.py 2011-07-06 21:14:28 +0000 | |||
1749 | @@ -45,7 +45,7 @@ | |||
1750 | 45 | post = set(bpickle.dumps_table.iteritems()) | 45 | post = set(bpickle.dumps_table.iteritems()) |
1751 | 46 | self.assertTrue(pre.issubset(post)) | 46 | self.assertTrue(pre.issubset(post)) |
1752 | 47 | self.assertTrue(object in bpickle.dumps_table) | 47 | self.assertTrue(object in bpickle.dumps_table) |
1754 | 48 | self.assertTrue(len(original)+1, len(bpickle.dumps_table)) | 48 | self.assertTrue(len(original) + 1, len(bpickle.dumps_table)) |
1755 | 49 | 49 | ||
1756 | 50 | def test_dumps_utf8string(self): | 50 | def test_dumps_utf8string(self): |
1757 | 51 | """ | 51 | """ |
1758 | @@ -56,9 +56,9 @@ | |||
1759 | 56 | from dbus.types import UTF8String | 56 | from dbus.types import UTF8String |
1760 | 57 | 57 | ||
1761 | 58 | value = UTF8String("") | 58 | value = UTF8String("") |
1763 | 59 | self.assertEquals(dumps_utf8string(value), "u0:") | 59 | self.assertEqual(dumps_utf8string(value), "u0:") |
1764 | 60 | value = UTF8String("Charlie!") | 60 | value = UTF8String("Charlie!") |
1766 | 61 | self.assertEquals(dumps_utf8string(value), "u8:Charlie!") | 61 | self.assertEqual(dumps_utf8string(value), "u8:Charlie!") |
1767 | 62 | except ImportError: | 62 | except ImportError: |
1768 | 63 | pass | 63 | pass |
1769 | 64 | 64 | ||
1770 | 65 | 65 | ||
1771 | === modified file 'landscape/lib/tests/test_command.py' | |||
1772 | --- landscape/lib/tests/test_command.py 2009-03-18 10:13:12 +0000 | |||
1773 | +++ landscape/lib/tests/test_command.py 2011-07-06 21:14:28 +0000 | |||
1774 | @@ -9,24 +9,24 @@ | |||
1775 | 9 | super(CommandTest, self).setUp() | 9 | super(CommandTest, self).setUp() |
1776 | 10 | 10 | ||
1777 | 11 | def test_basic(self): | 11 | def test_basic(self): |
1779 | 12 | self.assertEquals(run_command("echo test"), "test") | 12 | self.assertEqual(run_command("echo test"), "test") |
1780 | 13 | 13 | ||
1781 | 14 | def test_non_0_exit_status(self): | 14 | def test_non_0_exit_status(self): |
1782 | 15 | try: | 15 | try: |
1783 | 16 | run_command("false") | 16 | run_command("false") |
1784 | 17 | except CommandError, error: | 17 | except CommandError, error: |
1788 | 18 | self.assertEquals(error.command, "false") | 18 | self.assertEqual(error.command, "false") |
1789 | 19 | self.assertEquals(error.output, "") | 19 | self.assertEqual(error.output, "") |
1790 | 20 | self.assertEquals(error.exit_status, 1) | 20 | self.assertEqual(error.exit_status, 1) |
1791 | 21 | else: | 21 | else: |
1792 | 22 | self.fail("CommandError not raised") | 22 | self.fail("CommandError not raised") |
1793 | 23 | 23 | ||
1794 | 24 | def test_error_str(self): | 24 | def test_error_str(self): |
1798 | 25 | self.assertEquals(str(CommandError("test_command", 1, "test output")), | 25 | self.assertEqual(str(CommandError("test_command", 1, "test output")), |
1799 | 26 | "'test_command' exited with status 1 " | 26 | "'test_command' exited with status 1 " |
1800 | 27 | "(test output)") | 27 | "(test output)") |
1801 | 28 | 28 | ||
1802 | 29 | def test_error_repr(self): | 29 | def test_error_repr(self): |
1806 | 30 | self.assertEquals(repr(CommandError("test_command", 1, "test output")), | 30 | self.assertEqual(repr(CommandError("test_command", 1, "test output")), |
1807 | 31 | "<CommandError command=<test_command> " | 31 | "<CommandError command=<test_command> " |
1808 | 32 | "exit_status=1 output=<test output>>") | 32 | "exit_status=1 output=<test output>>") |
1809 | 33 | 33 | ||
1810 | === modified file 'landscape/lib/tests/test_disk.py' | |||
1811 | --- landscape/lib/tests/test_disk.py 2010-06-07 17:23:44 +0000 | |||
1812 | +++ landscape/lib/tests/test_disk.py 2011-07-06 21:14:28 +0000 | |||
1813 | @@ -43,23 +43,23 @@ | |||
1814 | 43 | def test_get_filesystem_for_path(self): | 43 | def test_get_filesystem_for_path(self): |
1815 | 44 | self.set_mount_points(["/"]) | 44 | self.set_mount_points(["/"]) |
1816 | 45 | info = get_filesystem_for_path("/", self.mount_file, self.statvfs) | 45 | info = get_filesystem_for_path("/", self.mount_file, self.statvfs) |
1818 | 46 | self.assertEquals(info["mount-point"], "/") | 46 | self.assertEqual(info["mount-point"], "/") |
1819 | 47 | 47 | ||
1820 | 48 | def test_get_filesystem_subpath(self): | 48 | def test_get_filesystem_subpath(self): |
1821 | 49 | self.set_mount_points(["/"]) | 49 | self.set_mount_points(["/"]) |
1822 | 50 | self.stat_results["/"] = (4096, 0, 1000, 500, 0, 0, 0, 0, 0) | 50 | self.stat_results["/"] = (4096, 0, 1000, 500, 0, 0, 0, 0, 0) |
1823 | 51 | info = get_filesystem_for_path("/home", self.mount_file, self.statvfs) | 51 | info = get_filesystem_for_path("/home", self.mount_file, self.statvfs) |
1825 | 52 | self.assertEquals(info["mount-point"], "/") | 52 | self.assertEqual(info["mount-point"], "/") |
1826 | 53 | 53 | ||
1827 | 54 | def test_get_filesystem_subpath_closest(self): | 54 | def test_get_filesystem_subpath_closest(self): |
1828 | 55 | self.set_mount_points(["/", "/home"]) | 55 | self.set_mount_points(["/", "/home"]) |
1829 | 56 | info = get_filesystem_for_path("/home", self.mount_file, self.statvfs) | 56 | info = get_filesystem_for_path("/home", self.mount_file, self.statvfs) |
1831 | 57 | self.assertEquals(info["mount-point"], "/home") | 57 | self.assertEqual(info["mount-point"], "/home") |
1832 | 58 | 58 | ||
1833 | 59 | def test_get_filesystem_subpath_not_stupid(self): | 59 | def test_get_filesystem_subpath_not_stupid(self): |
1834 | 60 | self.set_mount_points(["/", "/ho"]) | 60 | self.set_mount_points(["/", "/ho"]) |
1835 | 61 | info = get_filesystem_for_path("/home", self.mount_file, self.statvfs) | 61 | info = get_filesystem_for_path("/home", self.mount_file, self.statvfs) |
1837 | 62 | self.assertEquals(info["mount-point"], "/") | 62 | self.assertEqual(info["mount-point"], "/") |
1838 | 63 | 63 | ||
1839 | 64 | def test_symlink_home(self): | 64 | def test_symlink_home(self): |
1840 | 65 | symlink_path = self.makeFile() | 65 | symlink_path = self.makeFile() |
1841 | @@ -68,7 +68,7 @@ | |||
1842 | 68 | self.set_mount_points(["/", "/foo"]) | 68 | self.set_mount_points(["/", "/foo"]) |
1843 | 69 | info = get_filesystem_for_path(symlink_path, | 69 | info = get_filesystem_for_path(symlink_path, |
1844 | 70 | self.mount_file, self.statvfs) | 70 | self.mount_file, self.statvfs) |
1846 | 71 | self.assertEquals(info["mount-point"], "/foo") | 71 | self.assertEqual(info["mount-point"], "/foo") |
1847 | 72 | 72 | ||
1848 | 73 | def test_whitelist(self): | 73 | def test_whitelist(self): |
1849 | 74 | self.set_mount_points(["/"]) | 74 | self.set_mount_points(["/"]) |
1850 | 75 | 75 | ||
1851 | === modified file 'landscape/lib/tests/test_fd.py' | |||
1852 | --- landscape/lib/tests/test_fd.py 2009-04-01 16:05:35 +0000 | |||
1853 | +++ landscape/lib/tests/test_fd.py 2011-07-06 21:14:28 +0000 | |||
1854 | @@ -9,7 +9,7 @@ | |||
1855 | 9 | 9 | ||
1856 | 10 | class CleanFDsTests(LandscapeTest): | 10 | class CleanFDsTests(LandscapeTest): |
1857 | 11 | """Tests for L{clean_fds}.""" | 11 | """Tests for L{clean_fds}.""" |
1859 | 12 | 12 | ||
1860 | 13 | def mock_rlimit(self, limit): | 13 | def mock_rlimit(self, limit): |
1861 | 14 | getrlimit_mock = self.mocker.replace("resource.getrlimit") | 14 | getrlimit_mock = self.mocker.replace("resource.getrlimit") |
1862 | 15 | getrlimit_mock(resource.RLIMIT_NOFILE) | 15 | getrlimit_mock(resource.RLIMIT_NOFILE) |
1863 | @@ -42,7 +42,7 @@ | |||
1864 | 42 | self.mocker.count(4093) | 42 | self.mocker.count(4093) |
1865 | 43 | self.mocker.replay() | 43 | self.mocker.replay() |
1866 | 44 | clean_fds() | 44 | clean_fds() |
1868 | 45 | self.assertEquals(closed_fds, range(3, 4096)) | 45 | self.assertEqual(closed_fds, range(3, 4096)) |
1869 | 46 | 46 | ||
1870 | 47 | def test_ignore_OSErrors(self): | 47 | def test_ignore_OSErrors(self): |
1871 | 48 | """ | 48 | """ |
1872 | @@ -53,6 +53,7 @@ | |||
1873 | 53 | self.mock_rlimit(10) | 53 | self.mock_rlimit(10) |
1874 | 54 | 54 | ||
1875 | 55 | closed_fds = [] | 55 | closed_fds = [] |
1876 | 56 | |||
1877 | 56 | def remember_and_throw(fd): | 57 | def remember_and_throw(fd): |
1878 | 57 | closed_fds.append(fd) | 58 | closed_fds.append(fd) |
1879 | 58 | raise OSError("Bad FD!") | 59 | raise OSError("Bad FD!") |
1880 | @@ -64,7 +65,7 @@ | |||
1881 | 64 | 65 | ||
1882 | 65 | self.mocker.replay() | 66 | self.mocker.replay() |
1883 | 66 | clean_fds() | 67 | clean_fds() |
1885 | 67 | self.assertEquals(closed_fds, range(3, 10)) | 68 | self.assertEqual(closed_fds, range(3, 10)) |
1886 | 68 | 69 | ||
1887 | 69 | def test_dont_ignore_other_errors(self): | 70 | def test_dont_ignore_other_errors(self): |
1888 | 70 | """ | 71 | """ |
1889 | 71 | 72 | ||
1890 | === modified file 'landscape/lib/tests/test_fetch.py' | |||
1891 | --- landscape/lib/tests/test_fetch.py 2011-01-20 19:25:15 +0000 | |||
1892 | +++ landscape/lib/tests/test_fetch.py 2011-07-06 21:14:28 +0000 | |||
1893 | @@ -84,113 +84,113 @@ | |||
1894 | 84 | def test_basic(self): | 84 | def test_basic(self): |
1895 | 85 | curl = CurlStub("result") | 85 | curl = CurlStub("result") |
1896 | 86 | result = fetch("http://example.com", curl=curl) | 86 | result = fetch("http://example.com", curl=curl) |
1909 | 87 | self.assertEquals(result, "result") | 87 | self.assertEqual(result, "result") |
1910 | 88 | self.assertEquals(curl.options, | 88 | self.assertEqual(curl.options, |
1911 | 89 | {pycurl.URL: "http://example.com", | 89 | {pycurl.URL: "http://example.com", |
1912 | 90 | pycurl.FOLLOWLOCATION: True, | 90 | pycurl.FOLLOWLOCATION: True, |
1913 | 91 | pycurl.MAXREDIRS: 5, | 91 | pycurl.MAXREDIRS: 5, |
1914 | 92 | pycurl.CONNECTTIMEOUT: 30, | 92 | pycurl.CONNECTTIMEOUT: 30, |
1915 | 93 | pycurl.LOW_SPEED_LIMIT: 1, | 93 | pycurl.LOW_SPEED_LIMIT: 1, |
1916 | 94 | pycurl.LOW_SPEED_TIME: 600, | 94 | pycurl.LOW_SPEED_TIME: 600, |
1917 | 95 | pycurl.NOSIGNAL: 1, | 95 | pycurl.NOSIGNAL: 1, |
1918 | 96 | pycurl.WRITEFUNCTION: Any(), | 96 | pycurl.WRITEFUNCTION: Any(), |
1919 | 97 | pycurl.DNS_CACHE_TIMEOUT: 0, | 97 | pycurl.DNS_CACHE_TIMEOUT: 0, |
1920 | 98 | pycurl.ENCODING: "gzip,deflate"}) | 98 | pycurl.ENCODING: "gzip,deflate"}) |
1921 | 99 | 99 | ||
1922 | 100 | def test_post(self): | 100 | def test_post(self): |
1923 | 101 | curl = CurlStub("result") | 101 | curl = CurlStub("result") |
1924 | 102 | result = fetch("http://example.com", post=True, curl=curl) | 102 | result = fetch("http://example.com", post=True, curl=curl) |
1938 | 103 | self.assertEquals(result, "result") | 103 | self.assertEqual(result, "result") |
1939 | 104 | self.assertEquals(curl.options, | 104 | self.assertEqual(curl.options, |
1940 | 105 | {pycurl.URL: "http://example.com", | 105 | {pycurl.URL: "http://example.com", |
1941 | 106 | pycurl.FOLLOWLOCATION: True, | 106 | pycurl.FOLLOWLOCATION: True, |
1942 | 107 | pycurl.MAXREDIRS: 5, | 107 | pycurl.MAXREDIRS: 5, |
1943 | 108 | pycurl.CONNECTTIMEOUT: 30, | 108 | pycurl.CONNECTTIMEOUT: 30, |
1944 | 109 | pycurl.LOW_SPEED_LIMIT: 1, | 109 | pycurl.LOW_SPEED_LIMIT: 1, |
1945 | 110 | pycurl.LOW_SPEED_TIME: 600, | 110 | pycurl.LOW_SPEED_TIME: 600, |
1946 | 111 | pycurl.NOSIGNAL: 1, | 111 | pycurl.NOSIGNAL: 1, |
1947 | 112 | pycurl.WRITEFUNCTION: Any(), | 112 | pycurl.WRITEFUNCTION: Any(), |
1948 | 113 | pycurl.POST: True, | 113 | pycurl.POST: True, |
1949 | 114 | pycurl.DNS_CACHE_TIMEOUT: 0, | 114 | pycurl.DNS_CACHE_TIMEOUT: 0, |
1950 | 115 | pycurl.ENCODING: "gzip,deflate"}) | 115 | pycurl.ENCODING: "gzip,deflate"}) |
1951 | 116 | 116 | ||
1952 | 117 | def test_post_data(self): | 117 | def test_post_data(self): |
1953 | 118 | curl = CurlStub("result") | 118 | curl = CurlStub("result") |
1954 | 119 | result = fetch("http://example.com", post=True, data="data", curl=curl) | 119 | result = fetch("http://example.com", post=True, data="data", curl=curl) |
1971 | 120 | self.assertEquals(result, "result") | 120 | self.assertEqual(result, "result") |
1972 | 121 | self.assertEquals(curl.options[pycurl.READFUNCTION](), "data") | 121 | self.assertEqual(curl.options[pycurl.READFUNCTION](), "data") |
1973 | 122 | self.assertEquals(curl.options, | 122 | self.assertEqual(curl.options, |
1974 | 123 | {pycurl.URL: "http://example.com", | 123 | {pycurl.URL: "http://example.com", |
1975 | 124 | pycurl.FOLLOWLOCATION: True, | 124 | pycurl.FOLLOWLOCATION: True, |
1976 | 125 | pycurl.MAXREDIRS: 5, | 125 | pycurl.MAXREDIRS: 5, |
1977 | 126 | pycurl.CONNECTTIMEOUT: 30, | 126 | pycurl.CONNECTTIMEOUT: 30, |
1978 | 127 | pycurl.LOW_SPEED_LIMIT: 1, | 127 | pycurl.LOW_SPEED_LIMIT: 1, |
1979 | 128 | pycurl.LOW_SPEED_TIME: 600, | 128 | pycurl.LOW_SPEED_TIME: 600, |
1980 | 129 | pycurl.NOSIGNAL: 1, | 129 | pycurl.NOSIGNAL: 1, |
1981 | 130 | pycurl.WRITEFUNCTION: Any(), | 130 | pycurl.WRITEFUNCTION: Any(), |
1982 | 131 | pycurl.POST: True, | 131 | pycurl.POST: True, |
1983 | 132 | pycurl.POSTFIELDSIZE: 4, | 132 | pycurl.POSTFIELDSIZE: 4, |
1984 | 133 | pycurl.READFUNCTION: Any(), | 133 | pycurl.READFUNCTION: Any(), |
1985 | 134 | pycurl.DNS_CACHE_TIMEOUT: 0, | 134 | pycurl.DNS_CACHE_TIMEOUT: 0, |
1986 | 135 | pycurl.ENCODING: "gzip,deflate"}) | 135 | pycurl.ENCODING: "gzip,deflate"}) |
1987 | 136 | 136 | ||
1988 | 137 | def test_cainfo(self): | 137 | def test_cainfo(self): |
1989 | 138 | curl = CurlStub("result") | 138 | curl = CurlStub("result") |
1990 | 139 | result = fetch("https://example.com", cainfo="cainfo", curl=curl) | 139 | result = fetch("https://example.com", cainfo="cainfo", curl=curl) |
2004 | 140 | self.assertEquals(result, "result") | 140 | self.assertEqual(result, "result") |
2005 | 141 | self.assertEquals(curl.options, | 141 | self.assertEqual(curl.options, |
2006 | 142 | {pycurl.URL: "https://example.com", | 142 | {pycurl.URL: "https://example.com", |
2007 | 143 | pycurl.FOLLOWLOCATION: True, | 143 | pycurl.FOLLOWLOCATION: True, |
2008 | 144 | pycurl.MAXREDIRS: 5, | 144 | pycurl.MAXREDIRS: 5, |
2009 | 145 | pycurl.CONNECTTIMEOUT: 30, | 145 | pycurl.CONNECTTIMEOUT: 30, |
2010 | 146 | pycurl.LOW_SPEED_LIMIT: 1, | 146 | pycurl.LOW_SPEED_LIMIT: 1, |
2011 | 147 | pycurl.LOW_SPEED_TIME: 600, | 147 | pycurl.LOW_SPEED_TIME: 600, |
2012 | 148 | pycurl.NOSIGNAL: 1, | 148 | pycurl.NOSIGNAL: 1, |
2013 | 149 | pycurl.WRITEFUNCTION: Any(), | 149 | pycurl.WRITEFUNCTION: Any(), |
2014 | 150 | pycurl.CAINFO: "cainfo", | 150 | pycurl.CAINFO: "cainfo", |
2015 | 151 | pycurl.DNS_CACHE_TIMEOUT: 0, | 151 | pycurl.DNS_CACHE_TIMEOUT: 0, |
2016 | 152 | pycurl.ENCODING: "gzip,deflate"}) | 152 | pycurl.ENCODING: "gzip,deflate"}) |
2017 | 153 | 153 | ||
2018 | 154 | def test_cainfo_on_http(self): | 154 | def test_cainfo_on_http(self): |
2019 | 155 | curl = CurlStub("result") | 155 | curl = CurlStub("result") |
2020 | 156 | result = fetch("http://example.com", cainfo="cainfo", curl=curl) | 156 | result = fetch("http://example.com", cainfo="cainfo", curl=curl) |
2022 | 157 | self.assertEquals(result, "result") | 157 | self.assertEqual(result, "result") |
2023 | 158 | self.assertTrue(pycurl.CAINFO not in curl.options) | 158 | self.assertTrue(pycurl.CAINFO not in curl.options) |
2024 | 159 | 159 | ||
2025 | 160 | def test_headers(self): | 160 | def test_headers(self): |
2026 | 161 | curl = CurlStub("result") | 161 | curl = CurlStub("result") |
2027 | 162 | result = fetch("http://example.com", | 162 | result = fetch("http://example.com", |
2028 | 163 | headers={"a": "1", "b": "2"}, curl=curl) | 163 | headers={"a": "1", "b": "2"}, curl=curl) |
2042 | 164 | self.assertEquals(result, "result") | 164 | self.assertEqual(result, "result") |
2043 | 165 | self.assertEquals(curl.options, | 165 | self.assertEqual(curl.options, |
2044 | 166 | {pycurl.URL: "http://example.com", | 166 | {pycurl.URL: "http://example.com", |
2045 | 167 | pycurl.FOLLOWLOCATION: True, | 167 | pycurl.FOLLOWLOCATION: True, |
2046 | 168 | pycurl.MAXREDIRS: 5, | 168 | pycurl.MAXREDIRS: 5, |
2047 | 169 | pycurl.CONNECTTIMEOUT: 30, | 169 | pycurl.CONNECTTIMEOUT: 30, |
2048 | 170 | pycurl.LOW_SPEED_LIMIT: 1, | 170 | pycurl.LOW_SPEED_LIMIT: 1, |
2049 | 171 | pycurl.LOW_SPEED_TIME: 600, | 171 | pycurl.LOW_SPEED_TIME: 600, |
2050 | 172 | pycurl.NOSIGNAL: 1, | 172 | pycurl.NOSIGNAL: 1, |
2051 | 173 | pycurl.WRITEFUNCTION: Any(), | 173 | pycurl.WRITEFUNCTION: Any(), |
2052 | 174 | pycurl.HTTPHEADER: ["a: 1", "b: 2"], | 174 | pycurl.HTTPHEADER: ["a: 1", "b: 2"], |
2053 | 175 | pycurl.DNS_CACHE_TIMEOUT: 0, | 175 | pycurl.DNS_CACHE_TIMEOUT: 0, |
2054 | 176 | pycurl.ENCODING: "gzip,deflate"}) | 176 | pycurl.ENCODING: "gzip,deflate"}) |
2055 | 177 | 177 | ||
2056 | 178 | def test_timeouts(self): | 178 | def test_timeouts(self): |
2057 | 179 | curl = CurlStub("result") | 179 | curl = CurlStub("result") |
2058 | 180 | result = fetch("http://example.com", connect_timeout=5, | 180 | result = fetch("http://example.com", connect_timeout=5, |
2059 | 181 | total_timeout=30, curl=curl) | 181 | total_timeout=30, curl=curl) |
2072 | 182 | self.assertEquals(result, "result") | 182 | self.assertEqual(result, "result") |
2073 | 183 | self.assertEquals(curl.options, | 183 | self.assertEqual(curl.options, |
2074 | 184 | {pycurl.URL: "http://example.com", | 184 | {pycurl.URL: "http://example.com", |
2075 | 185 | pycurl.FOLLOWLOCATION: True, | 185 | pycurl.FOLLOWLOCATION: True, |
2076 | 186 | pycurl.MAXREDIRS: 5, | 186 | pycurl.MAXREDIRS: 5, |
2077 | 187 | pycurl.CONNECTTIMEOUT: 5, | 187 | pycurl.CONNECTTIMEOUT: 5, |
2078 | 188 | pycurl.LOW_SPEED_LIMIT: 1, | 188 | pycurl.LOW_SPEED_LIMIT: 1, |
2079 | 189 | pycurl.LOW_SPEED_TIME: 30, | 189 | pycurl.LOW_SPEED_TIME: 30, |
2080 | 190 | pycurl.NOSIGNAL: 1, | 190 | pycurl.NOSIGNAL: 1, |
2081 | 191 | pycurl.WRITEFUNCTION: Any(), | 191 | pycurl.WRITEFUNCTION: Any(), |
2082 | 192 | pycurl.DNS_CACHE_TIMEOUT: 0, | 192 | pycurl.DNS_CACHE_TIMEOUT: 0, |
2083 | 193 | pycurl.ENCODING: "gzip,deflate"}) | 193 | pycurl.ENCODING: "gzip,deflate"}) |
2084 | 194 | 194 | ||
2085 | 195 | def test_unicode(self): | 195 | def test_unicode(self): |
2086 | 196 | """ | 196 | """ |
2087 | @@ -199,8 +199,8 @@ | |||
2088 | 199 | """ | 199 | """ |
2089 | 200 | curl = CurlStub("result") | 200 | curl = CurlStub("result") |
2090 | 201 | result = fetch(u"http://example.com", curl=curl) | 201 | result = fetch(u"http://example.com", curl=curl) |
2093 | 202 | self.assertEquals(result, "result") | 202 | self.assertEqual(result, "result") |
2094 | 203 | self.assertEquals(curl.options[pycurl.URL], "http://example.com") | 203 | self.assertEqual(curl.options[pycurl.URL], "http://example.com") |
2095 | 204 | self.assertTrue(isinstance(curl.options[pycurl.URL], str)) | 204 | self.assertTrue(isinstance(curl.options[pycurl.URL], str)) |
2096 | 205 | 205 | ||
2097 | 206 | def test_non_200_result(self): | 206 | def test_non_200_result(self): |
2098 | @@ -208,36 +208,36 @@ | |||
2099 | 208 | try: | 208 | try: |
2100 | 209 | fetch("http://example.com", curl=curl) | 209 | fetch("http://example.com", curl=curl) |
2101 | 210 | except HTTPCodeError, error: | 210 | except HTTPCodeError, error: |
2104 | 211 | self.assertEquals(error.http_code, 404) | 211 | self.assertEqual(error.http_code, 404) |
2105 | 212 | self.assertEquals(error.body, "result") | 212 | self.assertEqual(error.body, "result") |
2106 | 213 | else: | 213 | else: |
2107 | 214 | self.fail("HTTPCodeError not raised") | 214 | self.fail("HTTPCodeError not raised") |
2108 | 215 | 215 | ||
2109 | 216 | def test_http_error_str(self): | 216 | def test_http_error_str(self): |
2112 | 217 | self.assertEquals(str(HTTPCodeError(501, "")), | 217 | self.assertEqual(str(HTTPCodeError(501, "")), |
2113 | 218 | "Server returned HTTP code 501") | 218 | "Server returned HTTP code 501") |
2114 | 219 | 219 | ||
2115 | 220 | def test_http_error_repr(self): | 220 | def test_http_error_repr(self): |
2118 | 221 | self.assertEquals(repr(HTTPCodeError(501, "")), | 221 | self.assertEqual(repr(HTTPCodeError(501, "")), |
2119 | 222 | "<HTTPCodeError http_code=501>") | 222 | "<HTTPCodeError http_code=501>") |
2120 | 223 | 223 | ||
2121 | 224 | def test_pycurl_error(self): | 224 | def test_pycurl_error(self): |
2122 | 225 | curl = CurlStub(error=pycurl.error(60, "pycurl error")) | 225 | curl = CurlStub(error=pycurl.error(60, "pycurl error")) |
2123 | 226 | try: | 226 | try: |
2124 | 227 | fetch("http://example.com", curl=curl) | 227 | fetch("http://example.com", curl=curl) |
2125 | 228 | except PyCurlError, error: | 228 | except PyCurlError, error: |
2128 | 229 | self.assertEquals(error.error_code, 60) | 229 | self.assertEqual(error.error_code, 60) |
2129 | 230 | self.assertEquals(error.message, "pycurl error") | 230 | self.assertEqual(error.message, "pycurl error") |
2130 | 231 | else: | 231 | else: |
2131 | 232 | self.fail("PyCurlError not raised") | 232 | self.fail("PyCurlError not raised") |
2132 | 233 | 233 | ||
2133 | 234 | def test_pycurl_error_str(self): | 234 | def test_pycurl_error_str(self): |
2136 | 235 | self.assertEquals(str(PyCurlError(60, "pycurl error")), | 235 | self.assertEqual(str(PyCurlError(60, "pycurl error")), |
2137 | 236 | "Error 60: pycurl error") | 236 | "Error 60: pycurl error") |
2138 | 237 | 237 | ||
2139 | 238 | def test_pycurl_error_repr(self): | 238 | def test_pycurl_error_repr(self): |
2142 | 239 | self.assertEquals(repr(PyCurlError(60, "pycurl error")), | 239 | self.assertEqual(repr(PyCurlError(60, "pycurl error")), |
2143 | 240 | "<PyCurlError args=(60, 'pycurl error')>") | 240 | "<PyCurlError args=(60, 'pycurl error')>") |
2144 | 241 | 241 | ||
2145 | 242 | def test_create_curl(self): | 242 | def test_create_curl(self): |
2146 | 243 | curls = [] | 243 | curls = [] |
2147 | @@ -251,34 +251,36 @@ | |||
2148 | 251 | pycurl.Curl = pycurl_Curl | 251 | pycurl.Curl = pycurl_Curl |
2149 | 252 | result = fetch("http://example.com") | 252 | result = fetch("http://example.com") |
2150 | 253 | curl = curls[0] | 253 | curl = curls[0] |
2163 | 254 | self.assertEquals(result, "result") | 254 | self.assertEqual(result, "result") |
2164 | 255 | self.assertEquals(curl.options, | 255 | self.assertEqual(curl.options, |
2165 | 256 | {pycurl.URL: "http://example.com", | 256 | {pycurl.URL: "http://example.com", |
2166 | 257 | pycurl.FOLLOWLOCATION: True, | 257 | pycurl.FOLLOWLOCATION: True, |
2167 | 258 | pycurl.MAXREDIRS: 5, | 258 | pycurl.MAXREDIRS: 5, |
2168 | 259 | pycurl.CONNECTTIMEOUT: 30, | 259 | pycurl.CONNECTTIMEOUT: 30, |
2169 | 260 | pycurl.LOW_SPEED_LIMIT: 1, | 260 | pycurl.LOW_SPEED_LIMIT: 1, |
2170 | 261 | pycurl.LOW_SPEED_TIME: 600, | 261 | pycurl.LOW_SPEED_TIME: 600, |
2171 | 262 | pycurl.NOSIGNAL: 1, | 262 | pycurl.NOSIGNAL: 1, |
2172 | 263 | pycurl.WRITEFUNCTION: Any(), | 263 | pycurl.WRITEFUNCTION: Any(), |
2173 | 264 | pycurl.DNS_CACHE_TIMEOUT: 0, | 264 | pycurl.DNS_CACHE_TIMEOUT: 0, |
2174 | 265 | pycurl.ENCODING: "gzip,deflate"}) | 265 | pycurl.ENCODING: "gzip,deflate"}) |
2175 | 266 | finally: | 266 | finally: |
2176 | 267 | pycurl.Curl = Curl | 267 | pycurl.Curl = Curl |
2177 | 268 | 268 | ||
2178 | 269 | def test_async_fetch(self): | 269 | def test_async_fetch(self): |
2179 | 270 | curl = CurlStub("result") | 270 | curl = CurlStub("result") |
2180 | 271 | d = fetch_async("http://example.com/", curl=curl) | 271 | d = fetch_async("http://example.com/", curl=curl) |
2181 | 272 | |||
2182 | 272 | def got_result(result): | 273 | def got_result(result): |
2184 | 273 | self.assertEquals(result, "result") | 274 | self.assertEqual(result, "result") |
2185 | 274 | return d.addCallback(got_result) | 275 | return d.addCallback(got_result) |
2186 | 275 | 276 | ||
2187 | 276 | def test_async_fetch_with_error(self): | 277 | def test_async_fetch_with_error(self): |
2188 | 277 | curl = CurlStub("result", {pycurl.HTTP_CODE: 501}) | 278 | curl = CurlStub("result", {pycurl.HTTP_CODE: 501}) |
2189 | 278 | d = fetch_async("http://example.com/", curl=curl) | 279 | d = fetch_async("http://example.com/", curl=curl) |
2190 | 280 | |||
2191 | 279 | def got_error(failure): | 281 | def got_error(failure): |
2194 | 280 | self.assertEquals(failure.value.http_code, 501) | 282 | self.assertEqual(failure.value.http_code, 501) |
2195 | 281 | self.assertEquals(failure.value.body, "result") | 283 | self.assertEqual(failure.value.body, "result") |
2196 | 282 | return failure | 284 | return failure |
2197 | 283 | d.addErrback(got_error) | 285 | d.addErrback(got_error) |
2198 | 284 | self.assertFailure(d, HTTPCodeError) | 286 | self.assertFailure(d, HTTPCodeError) |
2199 | @@ -306,7 +308,7 @@ | |||
2200 | 306 | errback=errback, curl=curl) | 308 | errback=errback, curl=curl) |
2201 | 307 | 309 | ||
2202 | 308 | def completed(result): | 310 | def completed(result): |
2204 | 309 | self.assertEquals(url_results, {}) | 311 | self.assertEqual(url_results, {}) |
2205 | 310 | 312 | ||
2206 | 311 | return d.addCallback(completed) | 313 | return d.addCallback(completed) |
2207 | 312 | 314 | ||
2208 | @@ -321,8 +323,8 @@ | |||
2209 | 321 | 323 | ||
2210 | 322 | def errback(failure, url): | 324 | def errback(failure, url): |
2211 | 323 | failed_urls.append(url) | 325 | failed_urls.append(url) |
2214 | 324 | self.assertEquals(failure.value.body, "wrong") | 326 | self.assertEqual(failure.value.body, "wrong") |
2215 | 325 | self.assertEquals(failure.value.http_code, 501) | 327 | self.assertEqual(failure.value.http_code, 501) |
2216 | 326 | return failure | 328 | return failure |
2217 | 327 | 329 | ||
2218 | 328 | curl = CurlManyStub(url_results) | 330 | curl = CurlManyStub(url_results) |
2219 | @@ -332,7 +334,7 @@ | |||
2220 | 332 | def check_failure(failure): | 334 | def check_failure(failure): |
2221 | 333 | self.assertTrue(isinstance(failure.subFailure.value, | 335 | self.assertTrue(isinstance(failure.subFailure.value, |
2222 | 334 | HTTPCodeError)) | 336 | HTTPCodeError)) |
2224 | 335 | self.assertEquals(failed_urls, ["http://wrong/"]) | 337 | self.assertEqual(failed_urls, ["http://wrong/"]) |
2225 | 336 | 338 | ||
2226 | 337 | self.assertFailure(result, FirstError) | 339 | self.assertFailure(result, FirstError) |
2227 | 338 | return result.addCallback(check_failure) | 340 | return result.addCallback(check_failure) |
2228 | @@ -342,10 +344,10 @@ | |||
2229 | 342 | L{url_to_filename} extracts the filename part of an URL, optionally | 344 | L{url_to_filename} extracts the filename part of an URL, optionally |
2230 | 343 | prepending a directory path to it. | 345 | prepending a directory path to it. |
2231 | 344 | """ | 346 | """ |
2236 | 345 | self.assertEquals(url_to_filename("http://some/file"), "file") | 347 | self.assertEqual(url_to_filename("http://some/file"), "file") |
2237 | 346 | self.assertEquals(url_to_filename("http://some/file/"), "file") | 348 | self.assertEqual(url_to_filename("http://some/file/"), "file") |
2238 | 347 | self.assertEquals(url_to_filename("http://some/file", directory="dir"), | 349 | self.assertEqual(url_to_filename("http://some/file", directory="dir"), |
2239 | 348 | os.path.join("dir", "file")) | 350 | os.path.join("dir", "file")) |
2240 | 349 | 351 | ||
2241 | 350 | def test_fetch_to_files(self): | 352 | def test_fetch_to_files(self): |
2242 | 351 | """ | 353 | """ |
2243 | @@ -362,7 +364,7 @@ | |||
2244 | 362 | def check_files(ignored): | 364 | def check_files(ignored): |
2245 | 363 | for result in url_results.itervalues(): | 365 | for result in url_results.itervalues(): |
2246 | 364 | fd = open(os.path.join(directory, result)) | 366 | fd = open(os.path.join(directory, result)) |
2248 | 365 | self.assertEquals(fd.read(), result) | 367 | self.assertEqual(fd.read(), result) |
2249 | 366 | fd.close() | 368 | fd.close() |
2250 | 367 | 369 | ||
2251 | 368 | result.addCallback(check_files) | 370 | result.addCallback(check_files) |
2252 | @@ -401,14 +403,14 @@ | |||
2253 | 401 | curl=curl) | 403 | curl=curl) |
2254 | 402 | 404 | ||
2255 | 403 | def check_messages(failure): | 405 | def check_messages(failure): |
2260 | 404 | self.assertEquals(len(messages), 1) | 406 | self.assertEqual(len(messages), 1) |
2261 | 405 | self.assertEquals(messages[0], | 407 | self.assertEqual(messages[0], |
2262 | 406 | "Couldn't fetch file from http://im/wrong " | 408 | "Couldn't fetch file from http://im/wrong " |
2263 | 407 | "(Server returned HTTP code 404)") | 409 | "(Server returned HTTP code 404)") |
2264 | 408 | messages.pop() | 410 | messages.pop() |
2265 | 409 | 411 | ||
2266 | 410 | def check_files(ignored): | 412 | def check_files(ignored): |
2268 | 411 | self.assertEquals(messages, []) | 413 | self.assertEqual(messages, []) |
2269 | 412 | self.assertFalse(os.path.exists(os.path.join(directory, "wrong"))) | 414 | self.assertFalse(os.path.exists(os.path.join(directory, "wrong"))) |
2270 | 413 | 415 | ||
2271 | 414 | result.addErrback(check_messages) | 416 | result.addErrback(check_messages) |
2272 | @@ -428,7 +430,7 @@ | |||
2273 | 428 | 430 | ||
2274 | 429 | def check_error(failure): | 431 | def check_error(failure): |
2275 | 430 | error = str(failure.value.subFailure.value) | 432 | error = str(failure.value.subFailure.value) |
2277 | 431 | self.assertEquals(error, "[Errno 2] No such file or directory: " | 433 | self.assertEqual(error, "[Errno 2] No such file or directory: " |
2278 | 432 | "'i/dont/exist/right'") | 434 | "'i/dont/exist/right'") |
2279 | 433 | self.assertFalse(os.path.exists(os.path.join(directory, "right"))) | 435 | self.assertFalse(os.path.exists(os.path.join(directory, "right"))) |
2280 | 434 | 436 | ||
2281 | 435 | 437 | ||
2282 | === modified file 'landscape/lib/tests/test_fs.py' | |||
2283 | --- landscape/lib/tests/test_fs.py 2010-04-01 08:28:22 +0000 | |||
2284 | +++ landscape/lib/tests/test_fs.py 2011-07-06 21:14:28 +0000 | |||
2285 | @@ -10,7 +10,7 @@ | |||
2286 | 10 | With no options L{read_file} reads the whole file passed as argument. | 10 | With no options L{read_file} reads the whole file passed as argument. |
2287 | 11 | """ | 11 | """ |
2288 | 12 | path = self.makeFile("foo") | 12 | path = self.makeFile("foo") |
2290 | 13 | self.assertEquals(read_file(path), "foo") | 13 | self.assertEqual(read_file(path), "foo") |
2291 | 14 | 14 | ||
2292 | 15 | def test_read_file_with_limit(self): | 15 | def test_read_file_with_limit(self): |
2293 | 16 | """ | 16 | """ |
2294 | @@ -18,14 +18,14 @@ | |||
2295 | 18 | given limit. | 18 | given limit. |
2296 | 19 | """ | 19 | """ |
2297 | 20 | path = self.makeFile("foo bar") | 20 | path = self.makeFile("foo bar") |
2299 | 21 | self.assertEquals(read_file(path, limit=3), " bar") | 21 | self.assertEqual(read_file(path, limit=3), " bar") |
2300 | 22 | 22 | ||
2301 | 23 | def test_read_file_with_negative_limit(self): | 23 | def test_read_file_with_negative_limit(self): |
2302 | 24 | """ | 24 | """ |
2303 | 25 | With a negative limit L{read_file} reads only the tail of the file. | 25 | With a negative limit L{read_file} reads only the tail of the file. |
2304 | 26 | """ | 26 | """ |
2305 | 27 | path = self.makeFile("foo bar from end") | 27 | path = self.makeFile("foo bar from end") |
2307 | 28 | self.assertEquals(read_file(path, limit=-3), "end") | 28 | self.assertEqual(read_file(path, limit=-3), "end") |
2308 | 29 | 29 | ||
2309 | 30 | def test_read_file_with_limit_bigger_than_file(self): | 30 | def test_read_file_with_limit_bigger_than_file(self): |
2310 | 31 | """ | 31 | """ |
2311 | @@ -33,8 +33,8 @@ | |||
2312 | 33 | file. | 33 | file. |
2313 | 34 | """ | 34 | """ |
2314 | 35 | path = self.makeFile("foo bar from end") | 35 | path = self.makeFile("foo bar from end") |
2317 | 36 | self.assertEquals(read_file(path, limit=100), "foo bar from end") | 36 | self.assertEqual(read_file(path, limit=100), "foo bar from end") |
2318 | 37 | self.assertEquals(read_file(path, limit=-100), "foo bar from end") | 37 | self.assertEqual(read_file(path, limit=-100), "foo bar from end") |
2319 | 38 | 38 | ||
2320 | 39 | 39 | ||
2321 | 40 | class TouchFileTest(LandscapeTest): | 40 | class TouchFileTest(LandscapeTest): |
2322 | 41 | 41 | ||
2323 | === modified file 'landscape/lib/tests/test_gpg.py' | |||
2324 | --- landscape/lib/tests/test_gpg.py 2009-10-27 09:33:45 +0000 | |||
2325 | +++ landscape/lib/tests/test_gpg.py 2011-07-06 21:14:28 +0000 | |||
2326 | @@ -32,7 +32,8 @@ | |||
2327 | 32 | result = gpg_verify("/some/file", "/some/signature", gpg=gpg) | 32 | result = gpg_verify("/some/file", "/some/signature", gpg=gpg) |
2328 | 33 | 33 | ||
2329 | 34 | def check_result(ignored): | 34 | def check_result(ignored): |
2331 | 35 | self.assertEquals(open(gpg_options).read(), | 35 | self.assertEqual( |
2332 | 36 | open(gpg_options).read(), | ||
2333 | 36 | "--no-options --homedir %s --no-default-keyring " | 37 | "--no-options --homedir %s --no-default-keyring " |
2334 | 37 | "--ignore-time-conflict --keyring /etc/apt/trusted.gpg " | 38 | "--ignore-time-conflict --keyring /etc/apt/trusted.gpg " |
2335 | 38 | "--verify /some/signature /some/file" % gpg_home) | 39 | "--verify /some/signature /some/file" % gpg_home) |
2336 | @@ -64,9 +65,9 @@ | |||
2337 | 64 | result = gpg_verify("/some/file", "/some/signature", gpg=gpg) | 65 | result = gpg_verify("/some/file", "/some/signature", gpg=gpg) |
2338 | 65 | 66 | ||
2339 | 66 | def check_failure(failure): | 67 | def check_failure(failure): |
2343 | 67 | self.assertEquals(str(failure.value), | 68 | self.assertEqual(str(failure.value), |
2344 | 68 | "%s failed (out='out\n', err='err\n', " | 69 | "%s failed (out='out\n', err='err\n', " |
2345 | 69 | "code='1')" % gpg) | 70 | "code='1')" % gpg) |
2346 | 70 | self.assertFalse(os.path.exists(gpg_home)) | 71 | self.assertFalse(os.path.exists(gpg_home)) |
2347 | 71 | 72 | ||
2348 | 72 | result.addCallback(self.fail) | 73 | result.addCallback(self.fail) |
2349 | 73 | 74 | ||
2350 | === modified file 'landscape/lib/tests/test_lsb_release.py' | |||
2351 | --- landscape/lib/tests/test_lsb_release.py 2009-10-09 10:01:02 +0000 | |||
2352 | +++ landscape/lib/tests/test_lsb_release.py 2011-07-06 21:14:28 +0000 | |||
2353 | @@ -16,11 +16,11 @@ | |||
2354 | 16 | "DISTRIB_DESCRIPTION=" | 16 | "DISTRIB_DESCRIPTION=" |
2355 | 17 | "\"Ubuntu 6.06.1 LTS\"\n") | 17 | "\"Ubuntu 6.06.1 LTS\"\n") |
2356 | 18 | 18 | ||
2362 | 19 | self.assertEquals(parse_lsb_release(lsb_release_filename), | 19 | self.assertEqual(parse_lsb_release(lsb_release_filename), |
2363 | 20 | {"distributor-id": "Ubuntu", | 20 | {"distributor-id": "Ubuntu", |
2364 | 21 | "description": "Ubuntu 6.06.1 LTS", | 21 | "description": "Ubuntu 6.06.1 LTS", |
2365 | 22 | "release": "6.06", | 22 | "release": "6.06", |
2366 | 23 | "code-name": "dapper"}) | 23 | "code-name": "dapper"}) |
2367 | 24 | 24 | ||
2368 | 25 | def test_parse_lsb_release_with_missing_or_extra_fields(self): | 25 | def test_parse_lsb_release_with_missing_or_extra_fields(self): |
2369 | 26 | """ | 26 | """ |
2370 | @@ -29,5 +29,5 @@ | |||
2371 | 29 | """ | 29 | """ |
2372 | 30 | lsb_release_filename = self.makeFile("DISTRIB_ID=Ubuntu\n" | 30 | lsb_release_filename = self.makeFile("DISTRIB_ID=Ubuntu\n" |
2373 | 31 | "FOO=Bar\n") | 31 | "FOO=Bar\n") |
2376 | 32 | self.assertEquals(parse_lsb_release(lsb_release_filename), | 32 | self.assertEqual(parse_lsb_release(lsb_release_filename), |
2377 | 33 | {"distributor-id": "Ubuntu"}) | 33 | {"distributor-id": "Ubuntu"}) |
2378 | 34 | 34 | ||
2379 | === modified file 'landscape/lib/tests/test_monitor.py' | |||
2380 | --- landscape/lib/tests/test_monitor.py 2008-06-10 10:56:01 +0000 | |||
2381 | +++ landscape/lib/tests/test_monitor.py 2011-07-06 21:14:28 +0000 | |||
2382 | @@ -17,24 +17,24 @@ | |||
2383 | 17 | self.timer = Timer(create_time=self.reactor.time) | 17 | self.timer = Timer(create_time=self.reactor.time) |
2384 | 18 | 18 | ||
2385 | 19 | def test_since_start(self): | 19 | def test_since_start(self): |
2387 | 20 | self.assertEquals(self.timer.since_start(), 0.0) | 20 | self.assertEqual(self.timer.since_start(), 0.0) |
2388 | 21 | 21 | ||
2389 | 22 | self.reactor.advance(1) | 22 | self.reactor.advance(1) |
2391 | 23 | self.assertEquals(self.timer.since_start(), 1.0) | 23 | self.assertEqual(self.timer.since_start(), 1.0) |
2392 | 24 | 24 | ||
2393 | 25 | self.reactor.advance(2) | 25 | self.reactor.advance(2) |
2395 | 26 | self.assertEquals(self.timer.since_start(), 3.0) | 26 | self.assertEqual(self.timer.since_start(), 3.0) |
2396 | 27 | 27 | ||
2397 | 28 | def test_since_reset(self): | 28 | def test_since_reset(self): |
2398 | 29 | self.reactor.advance(1) | 29 | self.reactor.advance(1) |
2400 | 30 | self.assertEquals(self.timer.since_reset(), 1.0) | 30 | self.assertEqual(self.timer.since_reset(), 1.0) |
2401 | 31 | 31 | ||
2402 | 32 | self.reactor.advance(1) | 32 | self.reactor.advance(1) |
2404 | 33 | self.assertEquals(self.timer.since_start(), 2.0) | 33 | self.assertEqual(self.timer.since_start(), 2.0) |
2405 | 34 | 34 | ||
2406 | 35 | self.reactor.advance(2) | 35 | self.reactor.advance(2) |
2407 | 36 | self.timer.reset() | 36 | self.timer.reset() |
2409 | 37 | self.assertEquals(self.timer.since_start(), 4.0) | 37 | self.assertEqual(self.timer.since_start(), 4.0) |
2410 | 38 | 38 | ||
2411 | 39 | 39 | ||
2412 | 40 | class MonitorTest(ReactorHavingTest): | 40 | class MonitorTest(ReactorHavingTest): |
2413 | @@ -44,25 +44,25 @@ | |||
2414 | 44 | self.monitor = Monitor("test", create_time=self.reactor.time) | 44 | self.monitor = Monitor("test", create_time=self.reactor.time) |
2415 | 45 | 45 | ||
2416 | 46 | def test_ping(self): | 46 | def test_ping(self): |
2419 | 47 | self.assertEquals(self.monitor.count, 0) | 47 | self.assertEqual(self.monitor.count, 0) |
2420 | 48 | self.assertEquals(self.monitor.total_count, 0) | 48 | self.assertEqual(self.monitor.total_count, 0) |
2421 | 49 | 49 | ||
2422 | 50 | self.monitor.ping() | 50 | self.monitor.ping() |
2425 | 51 | self.assertEquals(self.monitor.count, 1) | 51 | self.assertEqual(self.monitor.count, 1) |
2426 | 52 | self.assertEquals(self.monitor.total_count, 1) | 52 | self.assertEqual(self.monitor.total_count, 1) |
2427 | 53 | 53 | ||
2428 | 54 | def test_reset(self): | 54 | def test_reset(self): |
2430 | 55 | self.assertEquals(self.monitor.count, 0) | 55 | self.assertEqual(self.monitor.count, 0) |
2431 | 56 | 56 | ||
2432 | 57 | self.monitor.ping() | 57 | self.monitor.ping() |
2433 | 58 | self.monitor.ping() | 58 | self.monitor.ping() |
2436 | 59 | self.assertEquals(self.monitor.count, 2) | 59 | self.assertEqual(self.monitor.count, 2) |
2437 | 60 | self.assertEquals(self.monitor.total_count, 2) | 60 | self.assertEqual(self.monitor.total_count, 2) |
2438 | 61 | 61 | ||
2439 | 62 | self.monitor.reset() | 62 | self.monitor.reset() |
2440 | 63 | self.monitor.ping() | 63 | self.monitor.ping() |
2443 | 64 | self.assertEquals(self.monitor.count, 1) | 64 | self.assertEqual(self.monitor.count, 1) |
2444 | 65 | self.assertEquals(self.monitor.total_count, 3) | 65 | self.assertEqual(self.monitor.total_count, 3) |
2445 | 66 | 66 | ||
2446 | 67 | def test_log(self): | 67 | def test_log(self): |
2447 | 68 | for i in range(100): | 68 | for i in range(100): |
2448 | @@ -169,39 +169,39 @@ | |||
2449 | 169 | If no time has passed and the monitor hasn't received any | 169 | If no time has passed and the monitor hasn't received any |
2450 | 170 | pings it should return 100%. | 170 | pings it should return 100%. |
2451 | 171 | """ | 171 | """ |
2453 | 172 | self.assertEquals(self.monitor.percent, 1.0) | 172 | self.assertEqual(self.monitor.percent, 1.0) |
2454 | 173 | 173 | ||
2455 | 174 | def test_percent(self): | 174 | def test_percent(self): |
2456 | 175 | self.reactor.advance(1) | 175 | self.reactor.advance(1) |
2458 | 176 | self.assertEquals(self.monitor.percent, 0.0) | 176 | self.assertEqual(self.monitor.percent, 0.0) |
2459 | 177 | 177 | ||
2460 | 178 | self.monitor.ping() | 178 | self.monitor.ping() |
2461 | 179 | self.reactor.advance(1) | 179 | self.reactor.advance(1) |
2463 | 180 | self.assertEquals(self.monitor.percent, 0.5) | 180 | self.assertEqual(self.monitor.percent, 0.5) |
2464 | 181 | 181 | ||
2465 | 182 | def test_percent_reset(self): | 182 | def test_percent_reset(self): |
2466 | 183 | self.reactor.advance(1) | 183 | self.reactor.advance(1) |
2468 | 184 | self.assertEquals(self.monitor.percent, 0.0) | 184 | self.assertEqual(self.monitor.percent, 0.0) |
2469 | 185 | 185 | ||
2470 | 186 | self.monitor.reset() | 186 | self.monitor.reset() |
2471 | 187 | self.monitor.ping() | 187 | self.monitor.ping() |
2472 | 188 | self.reactor.advance(1) | 188 | self.reactor.advance(1) |
2474 | 189 | self.assertEquals(self.monitor.percent, 1.0) | 189 | self.assertEqual(self.monitor.percent, 1.0) |
2475 | 190 | 190 | ||
2476 | 191 | def test_expected_count(self): | 191 | def test_expected_count(self): |
2477 | 192 | self.reactor.advance(1) | 192 | self.reactor.advance(1) |
2479 | 193 | self.assertEquals(self.monitor.expected_count, 1.0) | 193 | self.assertEqual(self.monitor.expected_count, 1.0) |
2480 | 194 | 194 | ||
2481 | 195 | self.reactor.advance(1) | 195 | self.reactor.advance(1) |
2483 | 196 | self.assertEquals(self.monitor.expected_count, 2.0) | 196 | self.assertEqual(self.monitor.expected_count, 2.0) |
2484 | 197 | 197 | ||
2485 | 198 | def test_expected_count_reset(self): | 198 | def test_expected_count_reset(self): |
2486 | 199 | self.reactor.advance(1) | 199 | self.reactor.advance(1) |
2488 | 200 | self.assertEquals(self.monitor.expected_count, 1.0) | 200 | self.assertEqual(self.monitor.expected_count, 1.0) |
2489 | 201 | 201 | ||
2490 | 202 | self.monitor.reset() | 202 | self.monitor.reset() |
2491 | 203 | self.reactor.advance(1) | 203 | self.reactor.advance(1) |
2493 | 204 | self.assertEquals(self.monitor.expected_count, 1.0) | 204 | self.assertEqual(self.monitor.expected_count, 1.0) |
2494 | 205 | 205 | ||
2495 | 206 | def test_log(self): | 206 | def test_log(self): |
2496 | 207 | for i in range(100): | 207 | for i in range(100): |
2497 | @@ -229,13 +229,13 @@ | |||
2498 | 229 | create_time=self.reactor.time) | 229 | create_time=self.reactor.time) |
2499 | 230 | 230 | ||
2500 | 231 | def test_expected_count(self): | 231 | def test_expected_count(self): |
2502 | 232 | self.assertEquals(self.monitor.expected_count, 0) | 232 | self.assertEqual(self.monitor.expected_count, 0) |
2503 | 233 | 233 | ||
2504 | 234 | self.reactor.advance(99) | 234 | self.reactor.advance(99) |
2506 | 235 | self.assertEquals(self.monitor.expected_count, 0) | 235 | self.assertEqual(self.monitor.expected_count, 0) |
2507 | 236 | 236 | ||
2508 | 237 | self.reactor.advance(1) | 237 | self.reactor.advance(1) |
2510 | 238 | self.assertEquals(self.monitor.expected_count, 1) | 238 | self.assertEqual(self.monitor.expected_count, 1) |
2511 | 239 | 239 | ||
2512 | 240 | def test_ping(self): | 240 | def test_ping(self): |
2513 | 241 | self.assertFalse(self.monitor.warn()) | 241 | self.assertFalse(self.monitor.warn()) |
2514 | 242 | 242 | ||
2515 | === modified file 'landscape/lib/tests/test_persist.py' | |||
2516 | --- landscape/lib/tests/test_persist.py 2009-11-06 13:41:30 +0000 | |||
2517 | +++ landscape/lib/tests/test_persist.py 2011-07-06 21:14:28 +0000 | |||
2518 | @@ -22,14 +22,14 @@ | |||
2519 | 22 | 22 | ||
2520 | 23 | def test_path_string_to_tuple(self): | 23 | def test_path_string_to_tuple(self): |
2521 | 24 | for path_string, path_tuple in self.paths: | 24 | for path_string, path_tuple in self.paths: |
2523 | 25 | self.assertEquals(path_string_to_tuple(path_string), path_tuple) | 25 | self.assertEqual(path_string_to_tuple(path_string), path_tuple) |
2524 | 26 | 26 | ||
2525 | 27 | def test_path_string_to_tuple_error(self): | 27 | def test_path_string_to_tuple_error(self): |
2526 | 28 | self.assertRaises(PersistError, path_string_to_tuple, "ab[0][c]") | 28 | self.assertRaises(PersistError, path_string_to_tuple, "ab[0][c]") |
2527 | 29 | 29 | ||
2528 | 30 | def test_path_tuple_to_string(self): | 30 | def test_path_tuple_to_string(self): |
2529 | 31 | for path_string, path_tuple in self.paths: | 31 | for path_string, path_tuple in self.paths: |
2531 | 32 | self.assertEquals(path_tuple_to_string(path_tuple), path_string) | 32 | self.assertEqual(path_tuple_to_string(path_tuple), path_string) |
2532 | 33 | 33 | ||
2533 | 34 | 34 | ||
2534 | 35 | class BasePersistTest(LandscapeTest): | 35 | class BasePersistTest(LandscapeTest): |
2535 | @@ -125,60 +125,60 @@ | |||
2536 | 125 | for path, value in self.set_items: | 125 | for path, value in self.set_items: |
2537 | 126 | self.persist.set(path, value) | 126 | self.persist.set(path, value) |
2538 | 127 | result = self.persist.get((), hard=True) | 127 | result = self.persist.get((), hard=True) |
2541 | 128 | self.assertEquals(result, self.set_result, | 128 | self.assertEqual(result, self.set_result, |
2542 | 129 | self.format(result, self.set_result)) | 129 | self.format(result, self.set_result)) |
2543 | 130 | 130 | ||
2544 | 131 | def test_set_tuple_paths(self): | 131 | def test_set_tuple_paths(self): |
2545 | 132 | for path, value in self.set_items: | 132 | for path, value in self.set_items: |
2546 | 133 | self.persist.set(path_string_to_tuple(path), value) | 133 | self.persist.set(path_string_to_tuple(path), value) |
2547 | 134 | result = self.persist.get((), hard=True) | 134 | result = self.persist.get((), hard=True) |
2550 | 135 | self.assertEquals(result, self.set_result, | 135 | self.assertEqual(result, self.set_result, |
2551 | 136 | self.format(result, self.set_result)) | 136 | self.format(result, self.set_result)) |
2552 | 137 | 137 | ||
2553 | 138 | def test_set_from_result(self): | 138 | def test_set_from_result(self): |
2554 | 139 | for path in self.set_result: | 139 | for path in self.set_result: |
2555 | 140 | self.persist.set(path, self.set_result[path]) | 140 | self.persist.set(path, self.set_result[path]) |
2556 | 141 | result = self.persist.get((), hard=True) | 141 | result = self.persist.get((), hard=True) |
2559 | 142 | self.assertEquals(result, self.set_result, | 142 | self.assertEqual(result, self.set_result, |
2560 | 143 | self.format(result, self.set_result)) | 143 | self.format(result, self.set_result)) |
2561 | 144 | 144 | ||
2562 | 145 | def test_get(self): | 145 | def test_get(self): |
2563 | 146 | for path in self.set_result: | 146 | for path in self.set_result: |
2564 | 147 | self.persist.set(path, self.set_result[path]) | 147 | self.persist.set(path, self.set_result[path]) |
2565 | 148 | for path, value in self.get_items: | 148 | for path, value in self.get_items: |
2567 | 149 | self.assertEquals(self.persist.get(path), value) | 149 | self.assertEqual(self.persist.get(path), value) |
2568 | 150 | 150 | ||
2569 | 151 | def test_get_tuple_paths(self): | 151 | def test_get_tuple_paths(self): |
2570 | 152 | for path in self.set_result: | 152 | for path in self.set_result: |
2571 | 153 | self.persist.set(path_string_to_tuple(path), self.set_result[path]) | 153 | self.persist.set(path_string_to_tuple(path), self.set_result[path]) |
2572 | 154 | for path, value in self.get_items: | 154 | for path, value in self.get_items: |
2574 | 155 | self.assertEquals(self.persist.get(path), value) | 155 | self.assertEqual(self.persist.get(path), value) |
2575 | 156 | 156 | ||
2576 | 157 | def test_add(self): | 157 | def test_add(self): |
2577 | 158 | for path, value in self.add_items: | 158 | for path, value in self.add_items: |
2578 | 159 | self.persist.add(path, value) | 159 | self.persist.add(path, value) |
2579 | 160 | result = self.persist.get((), hard=True) | 160 | result = self.persist.get((), hard=True) |
2582 | 161 | self.assertEquals(result, self.add_result, | 161 | self.assertEqual(result, self.add_result, |
2583 | 162 | self.format(result, self.add_result)) | 162 | self.format(result, self.add_result)) |
2584 | 163 | 163 | ||
2585 | 164 | def test_add_unique(self): | 164 | def test_add_unique(self): |
2586 | 165 | self.persist.add("a", "b") | 165 | self.persist.add("a", "b") |
2588 | 166 | self.assertEquals(self.persist.get("a"), ["b"]) | 166 | self.assertEqual(self.persist.get("a"), ["b"]) |
2589 | 167 | self.persist.add("a", "b") | 167 | self.persist.add("a", "b") |
2591 | 168 | self.assertEquals(self.persist.get("a"), ["b", "b"]) | 168 | self.assertEqual(self.persist.get("a"), ["b", "b"]) |
2592 | 169 | self.persist.add("a", "b", unique=True) | 169 | self.persist.add("a", "b", unique=True) |
2594 | 170 | self.assertEquals(self.persist.get("a"), ["b", "b"]) | 170 | self.assertEqual(self.persist.get("a"), ["b", "b"]) |
2595 | 171 | self.persist.add("a", "c", unique=True) | 171 | self.persist.add("a", "c", unique=True) |
2597 | 172 | self.assertEquals(self.persist.get("a"), ["b", "b", "c"]) | 172 | self.assertEqual(self.persist.get("a"), ["b", "b", "c"]) |
2598 | 173 | 173 | ||
2599 | 174 | def test_keys(self): | 174 | def test_keys(self): |
2600 | 175 | self.persist.set("a", {"b": 1, "c": {"d": 2}, "e": list("foo")}) | 175 | self.persist.set("a", {"b": 1, "c": {"d": 2}, "e": list("foo")}) |
2601 | 176 | keys = self.persist.keys | 176 | keys = self.persist.keys |
2607 | 177 | self.assertEquals(set(keys((), hard=True)), set(["a"])) | 177 | self.assertEqual(set(keys((), hard=True)), set(["a"])) |
2608 | 178 | self.assertEquals(set(keys("a")), set(["b", "c", "e"])) | 178 | self.assertEqual(set(keys("a")), set(["b", "c", "e"])) |
2609 | 179 | self.assertEquals(set(keys("a.d")), set([])) | 179 | self.assertEqual(set(keys("a.d")), set([])) |
2610 | 180 | self.assertEquals(set(keys("a.e")), set([0, 1, 2])) | 180 | self.assertEqual(set(keys("a.e")), set([0, 1, 2])) |
2611 | 181 | self.assertEquals(set(keys("a.f")), set([])) | 181 | self.assertEqual(set(keys("a.f")), set([])) |
2612 | 182 | self.assertRaises(PersistError, keys, "a.b") | 182 | self.assertRaises(PersistError, keys, "a.b") |
2613 | 183 | 183 | ||
2614 | 184 | def test_has(self): | 184 | def test_has(self): |
2615 | @@ -211,19 +211,19 @@ | |||
2616 | 211 | self.assertRaises(PersistError, remove, "a.c.d.e") | 211 | self.assertRaises(PersistError, remove, "a.c.d.e") |
2617 | 212 | 212 | ||
2618 | 213 | self.assertTrue(remove(("a", "e", "o"))) | 213 | self.assertTrue(remove(("a", "e", "o"))) |
2620 | 214 | self.assertEquals(get("a.e"), ["f", "t"]) | 214 | self.assertEqual(get("a.e"), ["f", "t"]) |
2621 | 215 | 215 | ||
2622 | 216 | self.assertFalse(remove("a.e[2]")) | 216 | self.assertFalse(remove("a.e[2]")) |
2624 | 217 | self.assertEquals(get("a.e"), ["f", "t"]) | 217 | self.assertEqual(get("a.e"), ["f", "t"]) |
2625 | 218 | 218 | ||
2626 | 219 | self.assertTrue(remove("a.e[1]")) | 219 | self.assertTrue(remove("a.e[1]")) |
2628 | 220 | self.assertEquals(get("a.e"), ["f"]) | 220 | self.assertEqual(get("a.e"), ["f"]) |
2629 | 221 | 221 | ||
2630 | 222 | self.assertTrue(remove("a.e", "f")) | 222 | self.assertTrue(remove("a.e", "f")) |
2631 | 223 | self.assertFalse(has("a.e")) | 223 | self.assertFalse(has("a.e")) |
2632 | 224 | 224 | ||
2633 | 225 | self.assertFalse(remove("a.b[1]")) | 225 | self.assertFalse(remove("a.b[1]")) |
2635 | 226 | self.assertEquals(get("a.b"), [1]) | 226 | self.assertEqual(get("a.b"), [1]) |
2636 | 227 | 227 | ||
2637 | 228 | self.assertTrue(remove("a.b", 1)) | 228 | self.assertTrue(remove("a.b", 1)) |
2638 | 229 | self.assertFalse(has("a.b")) | 229 | self.assertFalse(has("a.b")) |
2639 | @@ -240,43 +240,43 @@ | |||
2640 | 240 | get = self.persist.get | 240 | get = self.persist.get |
2641 | 241 | 241 | ||
2642 | 242 | self.assertTrue(move("a.b", "a.c.b")) | 242 | self.assertTrue(move("a.b", "a.c.b")) |
2644 | 243 | self.assertEquals(get("a"), {"c": {"b": [1], "d": 2}}) | 243 | self.assertEqual(get("a"), {"c": {"b": [1], "d": 2}}) |
2645 | 244 | 244 | ||
2646 | 245 | self.assertTrue(move("a.c.b[0]", "a.c.b")) | 245 | self.assertTrue(move("a.c.b[0]", "a.c.b")) |
2648 | 246 | self.assertEquals(get("a"), {"c": {"b": 1, "d": 2}}) | 246 | self.assertEqual(get("a"), {"c": {"b": 1, "d": 2}}) |
2649 | 247 | 247 | ||
2650 | 248 | self.assertTrue(move(("a", "c", "b"), ("a", "c", "b", 0))) | 248 | self.assertTrue(move(("a", "c", "b"), ("a", "c", "b", 0))) |
2652 | 249 | self.assertEquals(get("a"), {"c": {"b": [1], "d": 2}}) | 249 | self.assertEqual(get("a"), {"c": {"b": [1], "d": 2}}) |
2653 | 250 | 250 | ||
2654 | 251 | def test_copy_values_on_set(self): | 251 | def test_copy_values_on_set(self): |
2655 | 252 | d = {"b": 1} | 252 | d = {"b": 1} |
2656 | 253 | d_orig = d.copy() | 253 | d_orig = d.copy() |
2657 | 254 | self.persist.set("a", d) | 254 | self.persist.set("a", d) |
2658 | 255 | d["c"] = 2 | 255 | d["c"] = 2 |
2660 | 256 | self.assertEquals(self.persist.get("a"), d_orig) | 256 | self.assertEqual(self.persist.get("a"), d_orig) |
2661 | 257 | 257 | ||
2662 | 258 | def test_copy_values_on_add(self): | 258 | def test_copy_values_on_add(self): |
2663 | 259 | d = {"b": 1} | 259 | d = {"b": 1} |
2664 | 260 | d_orig = d.copy() | 260 | d_orig = d.copy() |
2665 | 261 | self.persist.add("a", d) | 261 | self.persist.add("a", d) |
2666 | 262 | d["c"] = 2 | 262 | d["c"] = 2 |
2668 | 263 | self.assertEquals(self.persist.get("a[0]"), d_orig) | 263 | self.assertEqual(self.persist.get("a[0]"), d_orig) |
2669 | 264 | 264 | ||
2670 | 265 | def test_copy_values_on_get(self): | 265 | def test_copy_values_on_get(self): |
2671 | 266 | self.persist.set("a", {"b": 1}) | 266 | self.persist.set("a", {"b": 1}) |
2672 | 267 | d = self.persist.get("a") | 267 | d = self.persist.get("a") |
2673 | 268 | d_orig = d.copy() | 268 | d_orig = d.copy() |
2674 | 269 | d["c"] = 2 | 269 | d["c"] = 2 |
2676 | 270 | self.assertEquals(self.persist.get("a"), d_orig) | 270 | self.assertEqual(self.persist.get("a"), d_orig) |
2677 | 271 | 271 | ||
2678 | 272 | def test_root_at(self): | 272 | def test_root_at(self): |
2679 | 273 | rooted = self.persist.root_at("my-module") | 273 | rooted = self.persist.root_at("my-module") |
2680 | 274 | rooted.set("option", 1) | 274 | rooted.set("option", 1) |
2682 | 275 | self.assertEquals(self.persist.get("my-module.option"), 1) | 275 | self.assertEqual(self.persist.get("my-module.option"), 1) |
2683 | 276 | 276 | ||
2684 | 277 | 277 | ||
2685 | 278 | class SaveLoadPersistTest(BasePersistTest): | 278 | class SaveLoadPersistTest(BasePersistTest): |
2687 | 279 | 279 | ||
2688 | 280 | def test_readonly(self): | 280 | def test_readonly(self): |
2689 | 281 | self.assertFalse(self.persist.readonly) | 281 | self.assertFalse(self.persist.readonly) |
2690 | 282 | self.persist.readonly = True | 282 | self.persist.readonly = True |
2691 | @@ -331,8 +331,8 @@ | |||
2692 | 331 | persist.load(filename) | 331 | persist.load(filename) |
2693 | 332 | 332 | ||
2694 | 333 | result = persist.get((), hard=True) | 333 | result = persist.get((), hard=True) |
2697 | 334 | self.assertEquals(result, self.set_result, | 334 | self.assertEqual(result, self.set_result, |
2698 | 335 | self.format(result, self.set_result)) | 335 | self.format(result, self.set_result)) |
2699 | 336 | 336 | ||
2700 | 337 | def test_save_on_unexistent_dir(self): | 337 | def test_save_on_unexistent_dir(self): |
2701 | 338 | dirname = self.makeFile() | 338 | dirname = self.makeFile() |
2702 | @@ -379,7 +379,7 @@ | |||
2703 | 379 | persist.save() | 379 | persist.save() |
2704 | 380 | 380 | ||
2705 | 381 | persist = self.build_persist(filename=filename) | 381 | persist = self.build_persist(filename=filename) |
2707 | 382 | self.assertEquals(persist.get("foo"), "bar") | 382 | self.assertEqual(persist.get("foo"), "bar") |
2708 | 383 | 383 | ||
2709 | 384 | def test_load_restores_backup(self): | 384 | def test_load_restores_backup(self): |
2710 | 385 | filename = self.makePersistFile("foobar") | 385 | filename = self.makePersistFile("foobar") |
2711 | @@ -391,7 +391,7 @@ | |||
2712 | 391 | persist = self.build_persist() | 391 | persist = self.build_persist() |
2713 | 392 | persist.load(filename) | 392 | persist.load(filename) |
2714 | 393 | 393 | ||
2716 | 394 | self.assertEquals(persist.get("a"), 1) | 394 | self.assertEqual(persist.get("a"), 1) |
2717 | 395 | 395 | ||
2718 | 396 | def test_load_empty_files_wont_break(self): | 396 | def test_load_empty_files_wont_break(self): |
2719 | 397 | filename = self.makeFile("") | 397 | filename = self.makeFile("") |
2720 | 398 | 398 | ||
2721 | === modified file 'landscape/lib/tests/test_process.py' | |||
2722 | --- landscape/lib/tests/test_process.py 2010-02-08 15:27:19 +0000 | |||
2723 | +++ landscape/lib/tests/test_process.py 2011-07-06 21:14:28 +0000 | |||
2724 | @@ -11,7 +11,7 @@ | |||
2725 | 11 | """ | 11 | """ |
2726 | 12 | We use os.listdir("/proc") to get the list of active processes, if a | 12 | We use os.listdir("/proc") to get the list of active processes, if a |
2727 | 13 | process ends before we attempt to read the process' information, then | 13 | process ends before we attempt to read the process' information, then |
2729 | 14 | this should not trigger an error. | 14 | this should not trigger an error. |
2730 | 15 | """ | 15 | """ |
2731 | 16 | listdir_mock = self.mocker.replace("os.listdir") | 16 | listdir_mock = self.mocker.replace("os.listdir") |
2732 | 17 | listdir_mock("/proc") | 17 | listdir_mock("/proc") |
2733 | @@ -48,7 +48,7 @@ | |||
2734 | 48 | 48 | ||
2735 | 49 | process_info = ProcessInformation("/proc") | 49 | process_info = ProcessInformation("/proc") |
2736 | 50 | processes = list(process_info.get_all_process_info()) | 50 | processes = list(process_info.get_all_process_info()) |
2738 | 51 | self.assertEquals(processes, []) | 51 | self.assertEqual(processes, []) |
2739 | 52 | self.assertTrue(fakefile1.closed) | 52 | self.assertTrue(fakefile1.closed) |
2740 | 53 | self.assertTrue(fakefile2.closed) | 53 | self.assertTrue(fakefile2.closed) |
2741 | 54 | 54 | ||
2742 | @@ -74,7 +74,7 @@ | |||
2743 | 74 | """ | 74 | """ |
2744 | 75 | 75 | ||
2745 | 76 | def test_calculate_pcpu_real_data(self): | 76 | def test_calculate_pcpu_real_data(self): |
2747 | 77 | self.assertEquals( | 77 | self.assertEqual( |
2748 | 78 | calculate_pcpu(51286, 5000, 19000.07, 9281.0, 100), 3.0) | 78 | calculate_pcpu(51286, 5000, 19000.07, 9281.0, 100), 3.0) |
2749 | 79 | 79 | ||
2750 | 80 | def test_calculate_pcpu(self): | 80 | def test_calculate_pcpu(self): |
2751 | @@ -84,8 +84,8 @@ | |||
2752 | 84 | 84 | ||
2753 | 85 | This should be cpu utilisation of 20% | 85 | This should be cpu utilisation of 20% |
2754 | 86 | """ | 86 | """ |
2757 | 87 | self.assertEquals(calculate_pcpu(8000, 2000, 1000, 50000, 100), | 87 | self.assertEqual(calculate_pcpu(8000, 2000, 1000, 50000, 100), |
2758 | 88 | 20.0) | 88 | 20.0) |
2759 | 89 | 89 | ||
2760 | 90 | def test_calculate_pcpu_capped(self): | 90 | def test_calculate_pcpu_capped(self): |
2761 | 91 | """ | 91 | """ |
2762 | @@ -95,12 +95,12 @@ | |||
2763 | 95 | This should be cpu utilisation of 200% but capped at 99% CPU | 95 | This should be cpu utilisation of 200% but capped at 99% CPU |
2764 | 96 | utilisation. | 96 | utilisation. |
2765 | 97 | """ | 97 | """ |
2768 | 98 | self.assertEquals(calculate_pcpu(98000, 2000, 1000, 50000, 100), | 98 | self.assertEqual(calculate_pcpu(98000, 2000, 1000, 50000, 100), |
2769 | 99 | 99.0) | 99 | 99.0) |
2770 | 100 | 100 | ||
2771 | 101 | def test_calculate_pcpu_floored(self): | 101 | def test_calculate_pcpu_floored(self): |
2772 | 102 | """ | 102 | """ |
2773 | 103 | This calculates the pcpu based on 1 jiffies allocated to a process | 103 | This calculates the pcpu based on 1 jiffies allocated to a process |
2774 | 104 | over 80 jiffies this should be negative, but floored to 0.0. | 104 | over 80 jiffies this should be negative, but floored to 0.0. |
2775 | 105 | """ | 105 | """ |
2777 | 106 | self.assertEquals(calculate_pcpu(1, 0, 50, 800, 10), 0.0) | 106 | self.assertEqual(calculate_pcpu(1, 0, 50, 800, 10), 0.0) |
2778 | 107 | 107 | ||
2779 | === modified file 'landscape/lib/tests/test_scriptcontent.py' | |||
2780 | --- landscape/lib/tests/test_scriptcontent.py 2008-09-18 22:09:56 +0000 | |||
2781 | +++ landscape/lib/tests/test_scriptcontent.py 2011-07-06 21:14:28 +0000 | |||
2782 | @@ -3,21 +3,22 @@ | |||
2783 | 3 | from landscape.lib.scriptcontent import (build_script, | 3 | from landscape.lib.scriptcontent import (build_script, |
2784 | 4 | generate_script_hash) | 4 | generate_script_hash) |
2785 | 5 | 5 | ||
2786 | 6 | |||
2787 | 6 | class ScriptContentTest(unittest.TestCase): | 7 | class ScriptContentTest(unittest.TestCase): |
2788 | 7 | 8 | ||
2789 | 8 | def test_concatenate(self): | 9 | def test_concatenate(self): |
2792 | 9 | self.assertEquals(build_script(u"/bin/sh", u"echo 1.0\n"), | 10 | self.assertEqual(build_script(u"/bin/sh", u"echo 1.0\n"), |
2793 | 10 | "#!/bin/sh\necho 1.0\n") | 11 | "#!/bin/sh\necho 1.0\n") |
2794 | 11 | 12 | ||
2795 | 12 | def test_concatenate_null_strings(self): | 13 | def test_concatenate_null_strings(self): |
2798 | 13 | self.assertEquals(build_script(None, None), | 14 | self.assertEqual(build_script(None, None), |
2799 | 14 | "#!\n") | 15 | "#!\n") |
2800 | 15 | 16 | ||
2801 | 16 | def test_generate_script_hash(self): | 17 | def test_generate_script_hash(self): |
2802 | 17 | hash1 = generate_script_hash("#!/bin/sh\necho 1.0\n") | 18 | hash1 = generate_script_hash("#!/bin/sh\necho 1.0\n") |
2803 | 18 | hash2 = generate_script_hash("#!/bin/sh\necho 1.0\n") | 19 | hash2 = generate_script_hash("#!/bin/sh\necho 1.0\n") |
2804 | 19 | hash3 = generate_script_hash("#!/bin/sh\necho 3.0\n") | 20 | hash3 = generate_script_hash("#!/bin/sh\necho 3.0\n") |
2805 | 20 | 21 | ||
2807 | 21 | self.assertEquals(hash1, hash2) | 22 | self.assertEqual(hash1, hash2) |
2808 | 22 | self.assertNotEqual(hash1, hash3) | 23 | self.assertNotEqual(hash1, hash3) |
2809 | 23 | self.assertTrue(isinstance(hash1, str)) | 24 | self.assertTrue(isinstance(hash1, str)) |
2810 | 24 | 25 | ||
2811 | === modified file 'landscape/lib/tests/test_sequenceranges.py' | |||
2812 | --- landscape/lib/tests/test_sequenceranges.py 2011-01-28 14:06:10 +0000 | |||
2813 | +++ landscape/lib/tests/test_sequenceranges.py 2011-07-06 21:14:28 +0000 | |||
2814 | @@ -12,35 +12,35 @@ | |||
2815 | 12 | self.sequence = [1, 2, 15, 16, 17, 19, 21, 22, 23, 24, 26, 27] | 12 | self.sequence = [1, 2, 15, 16, 17, 19, 21, 22, 23, 24, 26, 27] |
2816 | 13 | 13 | ||
2817 | 14 | def test_empty_to_sequence(self): | 14 | def test_empty_to_sequence(self): |
2819 | 15 | self.assertEquals(SequenceRanges().to_sequence(), []) | 15 | self.assertEqual(SequenceRanges().to_sequence(), []) |
2820 | 16 | 16 | ||
2821 | 17 | def test_empty_to_ranges(self): | 17 | def test_empty_to_ranges(self): |
2823 | 18 | self.assertEquals(SequenceRanges().to_ranges(), []) | 18 | self.assertEqual(SequenceRanges().to_ranges(), []) |
2824 | 19 | 19 | ||
2825 | 20 | def test_from_to_sequence(self): | 20 | def test_from_to_sequence(self): |
2826 | 21 | obj = SequenceRanges.from_sequence(self.sequence) | 21 | obj = SequenceRanges.from_sequence(self.sequence) |
2828 | 22 | self.assertEquals(obj.to_sequence(), self.sequence) | 22 | self.assertEqual(obj.to_sequence(), self.sequence) |
2829 | 23 | 23 | ||
2830 | 24 | def test_from_to_ranges(self): | 24 | def test_from_to_ranges(self): |
2831 | 25 | obj = SequenceRanges.from_ranges(self.ranges) | 25 | obj = SequenceRanges.from_ranges(self.ranges) |
2833 | 26 | self.assertEquals(obj.to_ranges(), self.ranges) | 26 | self.assertEqual(obj.to_ranges(), self.ranges) |
2834 | 27 | 27 | ||
2835 | 28 | def test_to_ranges_immutable(self): | 28 | def test_to_ranges_immutable(self): |
2836 | 29 | obj = SequenceRanges.from_ranges(self.ranges) | 29 | obj = SequenceRanges.from_ranges(self.ranges) |
2837 | 30 | obj.to_ranges().append(123) | 30 | obj.to_ranges().append(123) |
2839 | 31 | self.assertEquals(obj.to_ranges(), self.ranges) | 31 | self.assertEqual(obj.to_ranges(), self.ranges) |
2840 | 32 | 32 | ||
2841 | 33 | def test_from_sequence_to_ranges(self): | 33 | def test_from_sequence_to_ranges(self): |
2842 | 34 | obj = SequenceRanges.from_sequence(self.sequence) | 34 | obj = SequenceRanges.from_sequence(self.sequence) |
2844 | 35 | self.assertEquals(list(obj.to_ranges()), self.ranges) | 35 | self.assertEqual(list(obj.to_ranges()), self.ranges) |
2845 | 36 | 36 | ||
2846 | 37 | def test_from_ranges_to_sequence(self): | 37 | def test_from_ranges_to_sequence(self): |
2847 | 38 | obj = SequenceRanges.from_ranges(self.ranges) | 38 | obj = SequenceRanges.from_ranges(self.ranges) |
2849 | 39 | self.assertEquals(list(obj.to_sequence()), self.sequence) | 39 | self.assertEqual(list(obj.to_sequence()), self.sequence) |
2850 | 40 | 40 | ||
2851 | 41 | def test_iter(self): | 41 | def test_iter(self): |
2852 | 42 | obj = SequenceRanges.from_ranges(self.ranges) | 42 | obj = SequenceRanges.from_ranges(self.ranges) |
2854 | 43 | self.assertEquals(list(obj), self.sequence) | 43 | self.assertEqual(list(obj), self.sequence) |
2855 | 44 | 44 | ||
2856 | 45 | def test_contains(self): | 45 | def test_contains(self): |
2857 | 46 | obj = SequenceRanges.from_ranges(self.ranges) | 46 | obj = SequenceRanges.from_ranges(self.ranges) |
2858 | @@ -61,44 +61,44 @@ | |||
2859 | 61 | def test_add(self): | 61 | def test_add(self): |
2860 | 62 | obj = SequenceRanges() | 62 | obj = SequenceRanges() |
2861 | 63 | obj.add(1) | 63 | obj.add(1) |
2863 | 64 | self.assertEquals(obj.to_ranges(), [1]) | 64 | self.assertEqual(obj.to_ranges(), [1]) |
2864 | 65 | obj.add(2) | 65 | obj.add(2) |
2870 | 66 | self.assertEquals(obj.to_ranges(), [1, 2]) | 66 | self.assertEqual(obj.to_ranges(), [1, 2]) |
2871 | 67 | obj.add(3) | 67 | obj.add(3) |
2872 | 68 | self.assertEquals(obj.to_ranges(), [(1, 3)]) | 68 | self.assertEqual(obj.to_ranges(), [(1, 3)]) |
2873 | 69 | obj.add(3) | 69 | obj.add(3) |
2874 | 70 | self.assertEquals(obj.to_ranges(), [(1, 3)]) | 70 | self.assertEqual(obj.to_ranges(), [(1, 3)]) |
2875 | 71 | 71 | ||
2876 | 72 | def test_remove(self): | 72 | def test_remove(self): |
2877 | 73 | obj = SequenceRanges.from_ranges([(1, 3)]) | 73 | obj = SequenceRanges.from_ranges([(1, 3)]) |
2878 | 74 | obj.remove(2) | 74 | obj.remove(2) |
2880 | 75 | self.assertEquals(obj.to_ranges(), [1, 3]) | 75 | self.assertEqual(obj.to_ranges(), [1, 3]) |
2881 | 76 | obj.remove(1) | 76 | obj.remove(1) |
2883 | 77 | self.assertEquals(obj.to_ranges(), [3]) | 77 | self.assertEqual(obj.to_ranges(), [3]) |
2884 | 78 | obj.remove(3) | 78 | obj.remove(3) |
2886 | 79 | self.assertEquals(obj.to_ranges(), []) | 79 | self.assertEqual(obj.to_ranges(), []) |
2887 | 80 | obj.remove(4) | 80 | obj.remove(4) |
2889 | 81 | self.assertEquals(obj.to_ranges(), []) | 81 | self.assertEqual(obj.to_ranges(), []) |
2890 | 82 | 82 | ||
2891 | 83 | 83 | ||
2892 | 84 | class SequenceToRangesTest(unittest.TestCase): | 84 | class SequenceToRangesTest(unittest.TestCase): |
2893 | 85 | 85 | ||
2894 | 86 | def test_empty(self): | 86 | def test_empty(self): |
2896 | 87 | self.assertEquals(list(sequence_to_ranges([])), []) | 87 | self.assertEqual(list(sequence_to_ranges([])), []) |
2897 | 88 | 88 | ||
2898 | 89 | def test_one_element(self): | 89 | def test_one_element(self): |
2900 | 90 | self.assertEquals(list(sequence_to_ranges([1])), [1]) | 90 | self.assertEqual(list(sequence_to_ranges([1])), [1]) |
2901 | 91 | 91 | ||
2902 | 92 | def test_two_elements(self): | 92 | def test_two_elements(self): |
2904 | 93 | self.assertEquals(list(sequence_to_ranges([1, 2])), [1, 2]) | 93 | self.assertEqual(list(sequence_to_ranges([1, 2])), [1, 2]) |
2905 | 94 | 94 | ||
2906 | 95 | def test_three_elements(self): | 95 | def test_three_elements(self): |
2908 | 96 | self.assertEquals(list(sequence_to_ranges([1, 2, 3])), [(1, 3)]) | 96 | self.assertEqual(list(sequence_to_ranges([1, 2, 3])), [(1, 3)]) |
2909 | 97 | 97 | ||
2910 | 98 | def test_many_elements(self): | 98 | def test_many_elements(self): |
2911 | 99 | sequence = [1, 2, 15, 16, 17, 19, 21, 22, 23, 24, 26, 27] | 99 | sequence = [1, 2, 15, 16, 17, 19, 21, 22, 23, 24, 26, 27] |
2914 | 100 | self.assertEquals(list(sequence_to_ranges(sequence)), | 100 | self.assertEqual(list(sequence_to_ranges(sequence)), |
2915 | 101 | [1, 2, (15, 17), 19, (21, 24), 26, 27]) | 101 | [1, 2, (15, 17), 19, (21, 24), 26, 27]) |
2916 | 102 | 102 | ||
2917 | 103 | def test_out_of_order(self): | 103 | def test_out_of_order(self): |
2918 | 104 | self.assertRaises(SequenceError, sequence_to_ranges([2, 1]).next) | 104 | self.assertRaises(SequenceError, sequence_to_ranges([2, 1]).next) |
2919 | @@ -110,59 +110,59 @@ | |||
2920 | 110 | class RangesToSequenceTest(unittest.TestCase): | 110 | class RangesToSequenceTest(unittest.TestCase): |
2921 | 111 | 111 | ||
2922 | 112 | def test_empty(self): | 112 | def test_empty(self): |
2924 | 113 | self.assertEquals(list(ranges_to_sequence([])), []) | 113 | self.assertEqual(list(ranges_to_sequence([])), []) |
2925 | 114 | 114 | ||
2926 | 115 | def test_one_element(self): | 115 | def test_one_element(self): |
2928 | 116 | self.assertEquals(list(ranges_to_sequence([1])), [1]) | 116 | self.assertEqual(list(ranges_to_sequence([1])), [1]) |
2929 | 117 | 117 | ||
2930 | 118 | def test_two_elements(self): | 118 | def test_two_elements(self): |
2932 | 119 | self.assertEquals(list(ranges_to_sequence([1, 2])), [1, 2]) | 119 | self.assertEqual(list(ranges_to_sequence([1, 2])), [1, 2]) |
2933 | 120 | 120 | ||
2934 | 121 | def test_three_elements(self): | 121 | def test_three_elements(self): |
2936 | 122 | self.assertEquals(list(ranges_to_sequence([(1, 3)])), [1, 2, 3]) | 122 | self.assertEqual(list(ranges_to_sequence([(1, 3)])), [1, 2, 3]) |
2937 | 123 | 123 | ||
2938 | 124 | def test_many_elements(self): | 124 | def test_many_elements(self): |
2939 | 125 | ranges = [1, 2, (15, 17), 19, (21, 24), 26, 27] | 125 | ranges = [1, 2, (15, 17), 19, (21, 24), 26, 27] |
2942 | 126 | self.assertEquals(list(ranges_to_sequence(ranges)), | 126 | self.assertEqual(list(ranges_to_sequence(ranges)), |
2943 | 127 | [1, 2, 15, 16, 17, 19, 21, 22, 23, 24, 26, 27]) | 127 | [1, 2, 15, 16, 17, 19, 21, 22, 23, 24, 26, 27]) |
2944 | 128 | 128 | ||
2945 | 129 | 129 | ||
2946 | 130 | class FindRangesIndexTest(unittest.TestCase): | 130 | class FindRangesIndexTest(unittest.TestCase): |
2947 | 131 | 131 | ||
2948 | 132 | def test_empty(self): | 132 | def test_empty(self): |
2950 | 133 | self.assertEquals(find_ranges_index([], 2), 0) | 133 | self.assertEqual(find_ranges_index([], 2), 0) |
2951 | 134 | 134 | ||
2952 | 135 | def test_sequence(self): | 135 | def test_sequence(self): |
2960 | 136 | self.assertEquals(find_ranges_index([1, 2, 3, 4, 5], 0), 0) | 136 | self.assertEqual(find_ranges_index([1, 2, 3, 4, 5], 0), 0) |
2961 | 137 | self.assertEquals(find_ranges_index([1, 2, 3, 4, 5], 1), 0) | 137 | self.assertEqual(find_ranges_index([1, 2, 3, 4, 5], 1), 0) |
2962 | 138 | self.assertEquals(find_ranges_index([1, 2, 3, 4, 5], 2), 1) | 138 | self.assertEqual(find_ranges_index([1, 2, 3, 4, 5], 2), 1) |
2963 | 139 | self.assertEquals(find_ranges_index([1, 2, 3, 4, 5], 3), 2) | 139 | self.assertEqual(find_ranges_index([1, 2, 3, 4, 5], 3), 2) |
2964 | 140 | self.assertEquals(find_ranges_index([1, 2, 3, 4, 5], 4), 3) | 140 | self.assertEqual(find_ranges_index([1, 2, 3, 4, 5], 4), 3) |
2965 | 141 | self.assertEquals(find_ranges_index([1, 2, 3, 4, 5], 5), 4) | 141 | self.assertEqual(find_ranges_index([1, 2, 3, 4, 5], 5), 4) |
2966 | 142 | self.assertEquals(find_ranges_index([1, 2, 3, 4, 5], 6), 5) | 142 | self.assertEqual(find_ranges_index([1, 2, 3, 4, 5], 6), 5) |
2967 | 143 | 143 | ||
2968 | 144 | def test_sequence_with_missing(self): | 144 | def test_sequence_with_missing(self): |
2972 | 145 | self.assertEquals(find_ranges_index([1, 2, 4, 5], 2), 1) | 145 | self.assertEqual(find_ranges_index([1, 2, 4, 5], 2), 1) |
2973 | 146 | self.assertEquals(find_ranges_index([1, 2, 4, 5], 3), 2) | 146 | self.assertEqual(find_ranges_index([1, 2, 4, 5], 3), 2) |
2974 | 147 | self.assertEquals(find_ranges_index([1, 2, 4, 5], 4), 2) | 147 | self.assertEqual(find_ranges_index([1, 2, 4, 5], 4), 2) |
2975 | 148 | 148 | ||
2976 | 149 | def test_range(self): | 149 | def test_range(self): |
2984 | 150 | self.assertEquals(find_ranges_index([1, (2, 4), 5], 0), 0) | 150 | self.assertEqual(find_ranges_index([1, (2, 4), 5], 0), 0) |
2985 | 151 | self.assertEquals(find_ranges_index([1, (2, 4), 5], 1), 0) | 151 | self.assertEqual(find_ranges_index([1, (2, 4), 5], 1), 0) |
2986 | 152 | self.assertEquals(find_ranges_index([1, (2, 4), 5], 2), 1) | 152 | self.assertEqual(find_ranges_index([1, (2, 4), 5], 2), 1) |
2987 | 153 | self.assertEquals(find_ranges_index([1, (2, 4), 5], 3), 1) | 153 | self.assertEqual(find_ranges_index([1, (2, 4), 5], 3), 1) |
2988 | 154 | self.assertEquals(find_ranges_index([1, (2, 4), 5], 4), 1) | 154 | self.assertEqual(find_ranges_index([1, (2, 4), 5], 4), 1) |
2989 | 155 | self.assertEquals(find_ranges_index([1, (2, 4), 5], 5), 2) | 155 | self.assertEqual(find_ranges_index([1, (2, 4), 5], 5), 2) |
2990 | 156 | self.assertEquals(find_ranges_index([1, (2, 4), 5], 6), 3) | 156 | self.assertEqual(find_ranges_index([1, (2, 4), 5], 6), 3) |
2991 | 157 | 157 | ||
2992 | 158 | def test_range_with_missing(self): | 158 | def test_range_with_missing(self): |
3000 | 159 | self.assertEquals(find_ranges_index([1, (3, 4), 5], 0), 0) | 159 | self.assertEqual(find_ranges_index([1, (3, 4), 5], 0), 0) |
3001 | 160 | self.assertEquals(find_ranges_index([1, (3, 4), 5], 1), 0) | 160 | self.assertEqual(find_ranges_index([1, (3, 4), 5], 1), 0) |
3002 | 161 | self.assertEquals(find_ranges_index([1, (3, 4), 5], 2), 1) | 161 | self.assertEqual(find_ranges_index([1, (3, 4), 5], 2), 1) |
3003 | 162 | self.assertEquals(find_ranges_index([1, (3, 4), 5], 3), 1) | 162 | self.assertEqual(find_ranges_index([1, (3, 4), 5], 3), 1) |
3004 | 163 | self.assertEquals(find_ranges_index([1, (3, 4), 5], 4), 1) | 163 | self.assertEqual(find_ranges_index([1, (3, 4), 5], 4), 1) |
3005 | 164 | self.assertEquals(find_ranges_index([1, (3, 4), 5], 5), 2) | 164 | self.assertEqual(find_ranges_index([1, (3, 4), 5], 5), 2) |
3006 | 165 | self.assertEquals(find_ranges_index([1, (3, 4), 5], 6), 3) | 165 | self.assertEqual(find_ranges_index([1, (3, 4), 5], 6), 3) |
3007 | 166 | 166 | ||
3008 | 167 | 167 | ||
3009 | 168 | class AddToRangesTest(unittest.TestCase): | 168 | class AddToRangesTest(unittest.TestCase): |
3010 | @@ -170,61 +170,61 @@ | |||
3011 | 170 | def test_empty(self): | 170 | def test_empty(self): |
3012 | 171 | ranges = [] | 171 | ranges = [] |
3013 | 172 | add_to_ranges(ranges, 1) | 172 | add_to_ranges(ranges, 1) |
3015 | 173 | self.assertEquals(ranges, [1]) | 173 | self.assertEqual(ranges, [1]) |
3016 | 174 | 174 | ||
3017 | 175 | def test_append(self): | 175 | def test_append(self): |
3018 | 176 | ranges = [1] | 176 | ranges = [1] |
3019 | 177 | add_to_ranges(ranges, 2) | 177 | add_to_ranges(ranges, 2) |
3021 | 178 | self.assertEquals(ranges, [1, 2]) | 178 | self.assertEqual(ranges, [1, 2]) |
3022 | 179 | 179 | ||
3023 | 180 | def test_prepend(self): | 180 | def test_prepend(self): |
3024 | 181 | ranges = [2] | 181 | ranges = [2] |
3025 | 182 | add_to_ranges(ranges, 1) | 182 | add_to_ranges(ranges, 1) |
3027 | 183 | self.assertEquals(ranges, [1, 2]) | 183 | self.assertEqual(ranges, [1, 2]) |
3028 | 184 | 184 | ||
3029 | 185 | def test_insert(self): | 185 | def test_insert(self): |
3030 | 186 | ranges = [1, 4] | 186 | ranges = [1, 4] |
3031 | 187 | add_to_ranges(ranges, 2) | 187 | add_to_ranges(ranges, 2) |
3033 | 188 | self.assertEquals(ranges, [1, 2, 4]) | 188 | self.assertEqual(ranges, [1, 2, 4]) |
3034 | 189 | 189 | ||
3035 | 190 | def test_merge_sequence(self): | 190 | def test_merge_sequence(self): |
3036 | 191 | ranges = [1, 2, 4, 5] | 191 | ranges = [1, 2, 4, 5] |
3037 | 192 | add_to_ranges(ranges, 3) | 192 | add_to_ranges(ranges, 3) |
3039 | 193 | self.assertEquals(ranges, [(1, 5)]) | 193 | self.assertEqual(ranges, [(1, 5)]) |
3040 | 194 | 194 | ||
3041 | 195 | def test_merge_ranges(self): | 195 | def test_merge_ranges(self): |
3042 | 196 | ranges = [(1, 3), (5, 7)] | 196 | ranges = [(1, 3), (5, 7)] |
3043 | 197 | add_to_ranges(ranges, 4) | 197 | add_to_ranges(ranges, 4) |
3045 | 198 | self.assertEquals(ranges, [(1, 7)]) | 198 | self.assertEqual(ranges, [(1, 7)]) |
3046 | 199 | 199 | ||
3047 | 200 | def test_merge_sequence_and_ranges(self): | 200 | def test_merge_sequence_and_ranges(self): |
3048 | 201 | ranges = [(1, 3), 5, 6, 7] | 201 | ranges = [(1, 3), 5, 6, 7] |
3049 | 202 | add_to_ranges(ranges, 4) | 202 | add_to_ranges(ranges, 4) |
3051 | 203 | self.assertEquals(ranges, [(1, 7)]) | 203 | self.assertEqual(ranges, [(1, 7)]) |
3052 | 204 | 204 | ||
3053 | 205 | def test_merge_sequence_and_ranges_with_gaps(self): | 205 | def test_merge_sequence_and_ranges_with_gaps(self): |
3054 | 206 | ranges = [1, (3, 5), 7, 9] | 206 | ranges = [1, (3, 5), 7, 9] |
3055 | 207 | add_to_ranges(ranges, 6) | 207 | add_to_ranges(ranges, 6) |
3057 | 208 | self.assertEquals(ranges, [1, (3, 7), 9]) | 208 | self.assertEqual(ranges, [1, (3, 7), 9]) |
3058 | 209 | 209 | ||
3059 | 210 | def test_dont_merge_ranges_with_gap(self): | 210 | def test_dont_merge_ranges_with_gap(self): |
3060 | 211 | ranges = [(1, 3), (7, 9)] | 211 | ranges = [(1, 3), (7, 9)] |
3061 | 212 | add_to_ranges(ranges, 5) | 212 | add_to_ranges(ranges, 5) |
3063 | 213 | self.assertEquals(ranges, [(1, 3), 5, (7, 9)]) | 213 | self.assertEqual(ranges, [(1, 3), 5, (7, 9)]) |
3064 | 214 | 214 | ||
3065 | 215 | def test_duplicate(self): | 215 | def test_duplicate(self): |
3066 | 216 | ranges = [1] | 216 | ranges = [1] |
3067 | 217 | add_to_ranges(ranges, 1) | 217 | add_to_ranges(ranges, 1) |
3069 | 218 | self.assertEquals(ranges, [1]) | 218 | self.assertEqual(ranges, [1]) |
3070 | 219 | 219 | ||
3071 | 220 | def test_duplicate_in_range(self): | 220 | def test_duplicate_in_range(self): |
3072 | 221 | ranges = [(1, 3)] | 221 | ranges = [(1, 3)] |
3073 | 222 | add_to_ranges(ranges, 1) | 222 | add_to_ranges(ranges, 1) |
3075 | 223 | self.assertEquals(ranges, [(1, 3)]) | 223 | self.assertEqual(ranges, [(1, 3)]) |
3076 | 224 | add_to_ranges(ranges, 2) | 224 | add_to_ranges(ranges, 2) |
3078 | 225 | self.assertEquals(ranges, [(1, 3)]) | 225 | self.assertEqual(ranges, [(1, 3)]) |
3079 | 226 | add_to_ranges(ranges, 3) | 226 | add_to_ranges(ranges, 3) |
3081 | 227 | self.assertEquals(ranges, [(1, 3)]) | 227 | self.assertEqual(ranges, [(1, 3)]) |
3082 | 228 | 228 | ||
3083 | 229 | 229 | ||
3084 | 230 | class RemoveFromRangesTest(unittest.TestCase): | 230 | class RemoveFromRangesTest(unittest.TestCase): |
3085 | @@ -232,57 +232,57 @@ | |||
3086 | 232 | def test_empty(self): | 232 | def test_empty(self): |
3087 | 233 | ranges = [] | 233 | ranges = [] |
3088 | 234 | remove_from_ranges(ranges, 1) | 234 | remove_from_ranges(ranges, 1) |
3090 | 235 | self.assertEquals(ranges, []) | 235 | self.assertEqual(ranges, []) |
3091 | 236 | 236 | ||
3092 | 237 | def test_single(self): | 237 | def test_single(self): |
3093 | 238 | ranges = [1] | 238 | ranges = [1] |
3094 | 239 | remove_from_ranges(ranges, 1) | 239 | remove_from_ranges(ranges, 1) |
3096 | 240 | self.assertEquals(ranges, []) | 240 | self.assertEqual(ranges, []) |
3097 | 241 | 241 | ||
3098 | 242 | def test_remove_before(self): | 242 | def test_remove_before(self): |
3099 | 243 | ranges = [1, 2] | 243 | ranges = [1, 2] |
3100 | 244 | remove_from_ranges(ranges, 1) | 244 | remove_from_ranges(ranges, 1) |
3102 | 245 | self.assertEquals(ranges, [2]) | 245 | self.assertEqual(ranges, [2]) |
3103 | 246 | 246 | ||
3104 | 247 | def test_remove_after(self): | 247 | def test_remove_after(self): |
3105 | 248 | ranges = [1, 2] | 248 | ranges = [1, 2] |
3106 | 249 | remove_from_ranges(ranges, 2) | 249 | remove_from_ranges(ranges, 2) |
3108 | 250 | self.assertEquals(ranges, [1]) | 250 | self.assertEqual(ranges, [1]) |
3109 | 251 | 251 | ||
3110 | 252 | def test_remove_inside(self): | 252 | def test_remove_inside(self): |
3111 | 253 | ranges = [1, 2, 3] | 253 | ranges = [1, 2, 3] |
3112 | 254 | remove_from_ranges(ranges, 2) | 254 | remove_from_ranges(ranges, 2) |
3114 | 255 | self.assertEquals(ranges, [1, 3]) | 255 | self.assertEqual(ranges, [1, 3]) |
3115 | 256 | 256 | ||
3116 | 257 | def test_remove_unexistent(self): | 257 | def test_remove_unexistent(self): |
3117 | 258 | ranges = [1, 3] | 258 | ranges = [1, 3] |
3118 | 259 | remove_from_ranges(ranges, 2) | 259 | remove_from_ranges(ranges, 2) |
3120 | 260 | self.assertEquals(ranges, [1, 3]) | 260 | self.assertEqual(ranges, [1, 3]) |
3121 | 261 | 261 | ||
3122 | 262 | def test_split_range(self): | 262 | def test_split_range(self): |
3123 | 263 | ranges = [(1, 5)] | 263 | ranges = [(1, 5)] |
3124 | 264 | remove_from_ranges(ranges, 3) | 264 | remove_from_ranges(ranges, 3) |
3126 | 265 | self.assertEquals(ranges, [1, 2, 4, 5]) | 265 | self.assertEqual(ranges, [1, 2, 4, 5]) |
3127 | 266 | 266 | ||
3128 | 267 | def test_split_range_into_ranges(self): | 267 | def test_split_range_into_ranges(self): |
3129 | 268 | ranges = [(1, 7)] | 268 | ranges = [(1, 7)] |
3130 | 269 | remove_from_ranges(ranges, 4) | 269 | remove_from_ranges(ranges, 4) |
3132 | 270 | self.assertEquals(ranges, [(1, 3), (5, 7)]) | 270 | self.assertEqual(ranges, [(1, 3), (5, 7)]) |
3133 | 271 | 271 | ||
3134 | 272 | def test_decrement_left(self): | 272 | def test_decrement_left(self): |
3135 | 273 | ranges = [(1, 5)] | 273 | ranges = [(1, 5)] |
3136 | 274 | remove_from_ranges(ranges, 1) | 274 | remove_from_ranges(ranges, 1) |
3138 | 275 | self.assertEquals(ranges, [(2, 5)]) | 275 | self.assertEqual(ranges, [(2, 5)]) |
3139 | 276 | 276 | ||
3140 | 277 | def test_decrement_right(self): | 277 | def test_decrement_right(self): |
3141 | 278 | ranges = [(1, 5)] | 278 | ranges = [(1, 5)] |
3142 | 279 | remove_from_ranges(ranges, 5) | 279 | remove_from_ranges(ranges, 5) |
3144 | 280 | self.assertEquals(ranges, [(1, 4)]) | 280 | self.assertEqual(ranges, [(1, 4)]) |
3145 | 281 | 281 | ||
3146 | 282 | def test_dont_removing_unmatched_range(self): | 282 | def test_dont_removing_unmatched_range(self): |
3147 | 283 | ranges = [(1, 3), (5, 7)] | 283 | ranges = [(1, 3), (5, 7)] |
3148 | 284 | remove_from_ranges(ranges, 4) | 284 | remove_from_ranges(ranges, 4) |
3150 | 285 | self.assertEquals(ranges, [(1, 3), (5, 7)]) | 285 | self.assertEqual(ranges, [(1, 3), (5, 7)]) |
3151 | 286 | 286 | ||
3152 | 287 | 287 | ||
3153 | 288 | def test_suite(): | 288 | def test_suite(): |
3154 | 289 | 289 | ||
3155 | === modified file 'landscape/lib/tests/test_sysstats.py' | |||
3156 | --- landscape/lib/tests/test_sysstats.py 2009-08-07 22:36:33 +0000 | |||
3157 | +++ landscape/lib/tests/test_sysstats.py 2011-07-06 21:14:28 +0000 | |||
3158 | @@ -38,29 +38,29 @@ | |||
3159 | 38 | def test_get_memory_info(self): | 38 | def test_get_memory_info(self): |
3160 | 39 | filename = self.makeFile(SAMPLE_MEMORY_INFO) | 39 | filename = self.makeFile(SAMPLE_MEMORY_INFO) |
3161 | 40 | memstats = MemoryStats(filename) | 40 | memstats = MemoryStats(filename) |
3172 | 41 | self.assertEquals(memstats.total_memory, 1510) | 41 | self.assertEqual(memstats.total_memory, 1510) |
3173 | 42 | self.assertEquals(memstats.free_memory, 503) | 42 | self.assertEqual(memstats.free_memory, 503) |
3174 | 43 | self.assertEquals(memstats.used_memory, 1007) | 43 | self.assertEqual(memstats.used_memory, 1007) |
3175 | 44 | self.assertEquals(memstats.total_swap, 1584) | 44 | self.assertEqual(memstats.total_swap, 1584) |
3176 | 45 | self.assertEquals(memstats.free_swap, 1567) | 45 | self.assertEqual(memstats.free_swap, 1567) |
3177 | 46 | self.assertEquals(memstats.used_swap, 17) | 46 | self.assertEqual(memstats.used_swap, 17) |
3178 | 47 | self.assertEquals("%.2f" % memstats.free_memory_percentage, "33.31") | 47 | self.assertEqual("%.2f" % memstats.free_memory_percentage, "33.31") |
3179 | 48 | self.assertEquals("%.2f" % memstats.free_swap_percentage, "98.93") | 48 | self.assertEqual("%.2f" % memstats.free_swap_percentage, "98.93") |
3180 | 49 | self.assertEquals("%.2f" % memstats.used_memory_percentage, "66.69") | 49 | self.assertEqual("%.2f" % memstats.used_memory_percentage, "66.69") |
3181 | 50 | self.assertEquals("%.2f" % memstats.used_swap_percentage, "1.07") | 50 | self.assertEqual("%.2f" % memstats.used_swap_percentage, "1.07") |
3182 | 51 | 51 | ||
3183 | 52 | def test_get_memory_info_without_swap(self): | 52 | def test_get_memory_info_without_swap(self): |
3184 | 53 | sample = re.subn(r"Swap(Free|Total): *\d+ kB", r"Swap\1: 0", | 53 | sample = re.subn(r"Swap(Free|Total): *\d+ kB", r"Swap\1: 0", |
3185 | 54 | SAMPLE_MEMORY_INFO)[0] | 54 | SAMPLE_MEMORY_INFO)[0] |
3186 | 55 | filename = self.makeFile(sample) | 55 | filename = self.makeFile(sample) |
3187 | 56 | memstats = MemoryStats(filename) | 56 | memstats = MemoryStats(filename) |
3195 | 57 | self.assertEquals(memstats.total_swap, 0) | 57 | self.assertEqual(memstats.total_swap, 0) |
3196 | 58 | self.assertEquals(memstats.free_swap, 0) | 58 | self.assertEqual(memstats.free_swap, 0) |
3197 | 59 | self.assertEquals(memstats.used_swap, 0) | 59 | self.assertEqual(memstats.used_swap, 0) |
3198 | 60 | self.assertEquals(memstats.used_swap_percentage, 0) | 60 | self.assertEqual(memstats.used_swap_percentage, 0) |
3199 | 61 | self.assertEquals(memstats.free_swap_percentage, 0) | 61 | self.assertEqual(memstats.free_swap_percentage, 0) |
3200 | 62 | self.assertEquals(type(memstats.used_swap_percentage), float) | 62 | self.assertEqual(type(memstats.used_swap_percentage), float) |
3201 | 63 | self.assertEquals(type(memstats.free_swap_percentage), float) | 63 | self.assertEqual(type(memstats.free_swap_percentage), float) |
3202 | 64 | 64 | ||
3203 | 65 | 65 | ||
3204 | 66 | class FakeWhoQTest(LandscapeTest): | 66 | class FakeWhoQTest(LandscapeTest): |
3205 | @@ -68,7 +68,7 @@ | |||
3206 | 68 | helpers = [EnvironSaverHelper] | 68 | helpers = [EnvironSaverHelper] |
3207 | 69 | 69 | ||
3208 | 70 | def fake_who(self, users): | 70 | def fake_who(self, users): |
3210 | 71 | dirname = self.makeDir() | 71 | dirname = self.makeDir() |
3211 | 72 | os.environ["PATH"] = "%s:%s" % (dirname, os.environ["PATH"]) | 72 | os.environ["PATH"] = "%s:%s" % (dirname, os.environ["PATH"]) |
3212 | 73 | 73 | ||
3213 | 74 | self.who_path = os.path.join(dirname, "who") | 74 | self.who_path = os.path.join(dirname, "who") |
3214 | @@ -87,19 +87,19 @@ | |||
3215 | 87 | def test_one_user(self): | 87 | def test_one_user(self): |
3216 | 88 | self.fake_who("joe") | 88 | self.fake_who("joe") |
3217 | 89 | result = get_logged_in_users() | 89 | result = get_logged_in_users() |
3219 | 90 | result.addCallback(self.assertEquals, ["joe"]) | 90 | result.addCallback(self.assertEqual, ["joe"]) |
3220 | 91 | return result | 91 | return result |
3221 | 92 | 92 | ||
3222 | 93 | def test_one_user_multiple_times(self): | 93 | def test_one_user_multiple_times(self): |
3223 | 94 | self.fake_who("joe joe joe joe") | 94 | self.fake_who("joe joe joe joe") |
3224 | 95 | result = get_logged_in_users() | 95 | result = get_logged_in_users() |
3226 | 96 | result.addCallback(self.assertEquals, ["joe"]) | 96 | result.addCallback(self.assertEqual, ["joe"]) |
3227 | 97 | return result | 97 | return result |
3228 | 98 | 98 | ||
3229 | 99 | def test_many_users(self): | 99 | def test_many_users(self): |
3230 | 100 | self.fake_who("joe moe boe doe") | 100 | self.fake_who("joe moe boe doe") |
3231 | 101 | result = get_logged_in_users() | 101 | result = get_logged_in_users() |
3233 | 102 | result.addCallback(self.assertEquals, ["boe", "doe", "joe", "moe"]) | 102 | result.addCallback(self.assertEqual, ["boe", "doe", "joe", "moe"]) |
3234 | 103 | return result | 103 | return result |
3235 | 104 | 104 | ||
3236 | 105 | def test_command_error(self): | 105 | def test_command_error(self): |
3237 | @@ -108,9 +108,10 @@ | |||
3238 | 108 | who.write("#!/bin/sh\necho ERROR 1>&2\nexit 1\n") | 108 | who.write("#!/bin/sh\necho ERROR 1>&2\nexit 1\n") |
3239 | 109 | who.close() | 109 | who.close() |
3240 | 110 | result = get_logged_in_users() | 110 | result = get_logged_in_users() |
3241 | 111 | |||
3242 | 111 | def assert_failure(failure): | 112 | def assert_failure(failure): |
3243 | 112 | failure.trap(CommandError) | 113 | failure.trap(CommandError) |
3245 | 113 | self.assertEquals(str(failure.value), "ERROR\n") | 114 | self.assertEqual(str(failure.value), "ERROR\n") |
3246 | 114 | result.addErrback(assert_failure) | 115 | result.addErrback(assert_failure) |
3247 | 115 | return result | 116 | return result |
3248 | 116 | 117 | ||
3249 | @@ -137,50 +138,50 @@ | |||
3250 | 137 | 138 | ||
3251 | 138 | def test_non_existent_thermal_zone_directory(self): | 139 | def test_non_existent_thermal_zone_directory(self): |
3252 | 139 | thermal_zones = list(get_thermal_zones("/non-existent/thermal_zone")) | 140 | thermal_zones = list(get_thermal_zones("/non-existent/thermal_zone")) |
3254 | 140 | self.assertEquals(thermal_zones, []) | 141 | self.assertEqual(thermal_zones, []) |
3255 | 141 | 142 | ||
3256 | 142 | def test_empty_thermal_zone_directory(self): | 143 | def test_empty_thermal_zone_directory(self): |
3258 | 143 | self.assertEquals(self.get_thermal_zones(), []) | 144 | self.assertEqual(self.get_thermal_zones(), []) |
3259 | 144 | 145 | ||
3260 | 145 | def test_one_thermal_zone(self): | 146 | def test_one_thermal_zone(self): |
3261 | 146 | self.write_thermal_zone("THM0", "50 C") | 147 | self.write_thermal_zone("THM0", "50 C") |
3262 | 147 | thermal_zones = self.get_thermal_zones() | 148 | thermal_zones = self.get_thermal_zones() |
3264 | 148 | self.assertEquals(len(thermal_zones), 1) | 149 | self.assertEqual(len(thermal_zones), 1) |
3265 | 149 | 150 | ||
3272 | 150 | self.assertEquals(thermal_zones[0].name, "THM0") | 151 | self.assertEqual(thermal_zones[0].name, "THM0") |
3273 | 151 | self.assertEquals(thermal_zones[0].temperature, "50 C") | 152 | self.assertEqual(thermal_zones[0].temperature, "50 C") |
3274 | 152 | self.assertEquals(thermal_zones[0].temperature_value, 50) | 153 | self.assertEqual(thermal_zones[0].temperature_value, 50) |
3275 | 153 | self.assertEquals(thermal_zones[0].temperature_unit, "C") | 154 | self.assertEqual(thermal_zones[0].temperature_unit, "C") |
3276 | 154 | self.assertEquals(thermal_zones[0].path, | 155 | self.assertEqual(thermal_zones[0].path, |
3277 | 155 | os.path.join(self.thermal_zone_path, "THM0")) | 156 | os.path.join(self.thermal_zone_path, "THM0")) |
3278 | 156 | 157 | ||
3279 | 157 | def test_two_thermal_zones(self): | 158 | def test_two_thermal_zones(self): |
3280 | 158 | self.write_thermal_zone("THM0", "50 C") | 159 | self.write_thermal_zone("THM0", "50 C") |
3281 | 159 | self.write_thermal_zone("THM1", "51 C") | 160 | self.write_thermal_zone("THM1", "51 C") |
3282 | 160 | thermal_zones = self.get_thermal_zones() | 161 | thermal_zones = self.get_thermal_zones() |
3290 | 161 | self.assertEquals(len(thermal_zones), 2) | 162 | self.assertEqual(len(thermal_zones), 2) |
3291 | 162 | self.assertEquals(thermal_zones[0].temperature, "50 C") | 163 | self.assertEqual(thermal_zones[0].temperature, "50 C") |
3292 | 163 | self.assertEquals(thermal_zones[0].temperature_value, 50) | 164 | self.assertEqual(thermal_zones[0].temperature_value, 50) |
3293 | 164 | self.assertEquals(thermal_zones[0].temperature_unit, "C") | 165 | self.assertEqual(thermal_zones[0].temperature_unit, "C") |
3294 | 165 | self.assertEquals(thermal_zones[1].temperature, "51 C") | 166 | self.assertEqual(thermal_zones[1].temperature, "51 C") |
3295 | 166 | self.assertEquals(thermal_zones[1].temperature_value, 51) | 167 | self.assertEqual(thermal_zones[1].temperature_value, 51) |
3296 | 167 | self.assertEquals(thermal_zones[1].temperature_unit, "C") | 168 | self.assertEqual(thermal_zones[1].temperature_unit, "C") |
3297 | 168 | 169 | ||
3298 | 169 | def test_badly_formatted_temperature(self): | 170 | def test_badly_formatted_temperature(self): |
3299 | 170 | self.write_thermal_zone("THM0", "SOMETHING BAD") | 171 | self.write_thermal_zone("THM0", "SOMETHING BAD") |
3300 | 171 | thermal_zones = self.get_thermal_zones() | 172 | thermal_zones = self.get_thermal_zones() |
3305 | 172 | self.assertEquals(len(thermal_zones), 1) | 173 | self.assertEqual(len(thermal_zones), 1) |
3306 | 173 | self.assertEquals(thermal_zones[0].temperature, "SOMETHING BAD") | 174 | self.assertEqual(thermal_zones[0].temperature, "SOMETHING BAD") |
3307 | 174 | self.assertEquals(thermal_zones[0].temperature_value, None) | 175 | self.assertEqual(thermal_zones[0].temperature_value, None) |
3308 | 175 | self.assertEquals(thermal_zones[0].temperature_unit, None) | 176 | self.assertEqual(thermal_zones[0].temperature_unit, None) |
3309 | 176 | 177 | ||
3310 | 177 | def test_badly_formatted_with_missing_space(self): | 178 | def test_badly_formatted_with_missing_space(self): |
3311 | 178 | self.write_thermal_zone("THM0", "SOMETHINGBAD") | 179 | self.write_thermal_zone("THM0", "SOMETHINGBAD") |
3312 | 179 | thermal_zones = self.get_thermal_zones() | 180 | thermal_zones = self.get_thermal_zones() |
3317 | 180 | self.assertEquals(len(thermal_zones), 1) | 181 | self.assertEqual(len(thermal_zones), 1) |
3318 | 181 | self.assertEquals(thermal_zones[0].temperature, "SOMETHINGBAD") | 182 | self.assertEqual(thermal_zones[0].temperature, "SOMETHINGBAD") |
3319 | 182 | self.assertEquals(thermal_zones[0].temperature_value, None) | 183 | self.assertEqual(thermal_zones[0].temperature_value, None) |
3320 | 183 | self.assertEquals(thermal_zones[0].temperature_unit, None) | 184 | self.assertEqual(thermal_zones[0].temperature_unit, None) |
3321 | 184 | 185 | ||
3322 | 185 | def test_temperature_file_with_missing_label(self): | 186 | def test_temperature_file_with_missing_label(self): |
3323 | 186 | self.write_thermal_zone("THM0", "SOMETHINGBAD") | 187 | self.write_thermal_zone("THM0", "SOMETHINGBAD") |
3324 | @@ -190,7 +191,7 @@ | |||
3325 | 190 | file.write("bad-label: foo bar\n") | 191 | file.write("bad-label: foo bar\n") |
3326 | 191 | file.close() | 192 | file.close() |
3327 | 192 | thermal_zones = self.get_thermal_zones() | 193 | thermal_zones = self.get_thermal_zones() |
3332 | 193 | self.assertEquals(len(thermal_zones), 1) | 194 | self.assertEqual(len(thermal_zones), 1) |
3333 | 194 | self.assertEquals(thermal_zones[0].temperature, None) | 195 | self.assertEqual(thermal_zones[0].temperature, None) |
3334 | 195 | self.assertEquals(thermal_zones[0].temperature_value, None) | 196 | self.assertEqual(thermal_zones[0].temperature_value, None) |
3335 | 196 | self.assertEquals(thermal_zones[0].temperature_unit, None) | 197 | self.assertEqual(thermal_zones[0].temperature_unit, None) |
3336 | 197 | 198 | ||
3337 | === modified file 'landscape/lib/tests/test_timestamp.py' | |||
3338 | --- landscape/lib/tests/test_timestamp.py 2008-06-10 10:56:01 +0000 | |||
3339 | +++ landscape/lib/tests/test_timestamp.py 2011-07-06 21:14:28 +0000 | |||
3340 | @@ -12,9 +12,9 @@ | |||
3341 | 12 | date = datetime.utcfromtimestamp(1000) | 12 | date = datetime.utcfromtimestamp(1000) |
3342 | 13 | timestamp = to_timestamp(date) | 13 | timestamp = to_timestamp(date) |
3343 | 14 | self.assertTrue(isinstance(timestamp, int)) | 14 | self.assertTrue(isinstance(timestamp, int)) |
3345 | 15 | self.assertEquals(timestamp, 1000) | 15 | self.assertEqual(timestamp, 1000) |
3346 | 16 | 16 | ||
3347 | 17 | def test_before_epoch_conversion(self): | 17 | def test_before_epoch_conversion(self): |
3348 | 18 | """Test converting a date before the epoch.""" | 18 | """Test converting a date before the epoch.""" |
3349 | 19 | date = datetime.utcfromtimestamp(-1000) | 19 | date = datetime.utcfromtimestamp(-1000) |
3351 | 20 | self.assertEquals(to_timestamp(date), -1000) | 20 | self.assertEqual(to_timestamp(date), -1000) |
3352 | 21 | 21 | ||
3353 | === modified file 'landscape/lib/tests/test_warning.py' | |||
3354 | --- landscape/lib/tests/test_warning.py 2009-04-09 14:48:58 +0000 | |||
3355 | +++ landscape/lib/tests/test_warning.py 2011-07-06 21:14:28 +0000 | |||
3356 | @@ -20,8 +20,8 @@ | |||
3357 | 20 | 20 | ||
3358 | 21 | # Warning filters are processed beginning to end, and the first filter | 21 | # Warning filters are processed beginning to end, and the first filter |
3359 | 22 | # which matches a particular warning is used. | 22 | # which matches a particular warning is used. |
3362 | 23 | 23 | ||
3363 | 24 | self.assertEquals( | 24 | self.assertEqual( |
3364 | 25 | filters, | 25 | filters, |
3365 | 26 | # The frontmost should "default" (i.e. print) on UserWarnings | 26 | # The frontmost should "default" (i.e. print) on UserWarnings |
3366 | 27 | [("default", None, UserWarning, None, 0), | 27 | [("default", None, UserWarning, None, 0), |
3367 | 28 | 28 | ||
3368 | === modified file 'landscape/manager/tests/test_config.py' | |||
3369 | --- landscape/manager/tests/test_config.py 2011-04-14 09:58:34 +0000 | |||
3370 | +++ landscape/manager/tests/test_config.py 2011-07-06 21:14:28 +0000 | |||
3371 | @@ -22,7 +22,7 @@ | |||
3372 | 22 | which plugins should be active. | 22 | which plugins should be active. |
3373 | 23 | """ | 23 | """ |
3374 | 24 | self.config.load(["--manager-plugins", "ProcessKiller"]) | 24 | self.config.load(["--manager-plugins", "ProcessKiller"]) |
3376 | 25 | self.assertEquals(self.config.plugin_factories, ["ProcessKiller"]) | 25 | self.assertEqual(self.config.plugin_factories, ["ProcessKiller"]) |
3377 | 26 | 26 | ||
3378 | 27 | def test_include_script_execution(self): | 27 | def test_include_script_execution(self): |
3379 | 28 | """ | 28 | """ |
3380 | @@ -30,15 +30,15 @@ | |||
3381 | 30 | command line option. | 30 | command line option. |
3382 | 31 | """ | 31 | """ |
3383 | 32 | self.config.load(["--include-manager-plugins", "ScriptExecution"]) | 32 | self.config.load(["--include-manager-plugins", "ScriptExecution"]) |
3386 | 33 | self.assertEquals(len(self.config.plugin_factories), | 33 | self.assertEqual(len(self.config.plugin_factories), |
3387 | 34 | len(ALL_PLUGINS) + 1) | 34 | len(ALL_PLUGINS) + 1) |
3388 | 35 | self.assertTrue('ScriptExecution' in self.config.plugin_factories) | 35 | self.assertTrue('ScriptExecution' in self.config.plugin_factories) |
3389 | 36 | 36 | ||
3390 | 37 | def test_get_allowed_script_users(self): | 37 | def test_get_allowed_script_users(self): |
3391 | 38 | """ | 38 | """ |
3392 | 39 | If no script users are specified, the default is 'nobody'. | 39 | If no script users are specified, the default is 'nobody'. |
3393 | 40 | """ | 40 | """ |
3395 | 41 | self.assertEquals(self.config.get_allowed_script_users(), ["nobody"]) | 41 | self.assertEqual(self.config.get_allowed_script_users(), ["nobody"]) |
3396 | 42 | 42 | ||
3397 | 43 | def test_get_allowed_script_users_all(self): | 43 | def test_get_allowed_script_users_all(self): |
3398 | 44 | """ | 44 | """ |
3399 | @@ -54,5 +54,5 @@ | |||
3400 | 54 | as. | 54 | as. |
3401 | 55 | """ | 55 | """ |
3402 | 56 | self.config.load(["--script-users", "foo, bar,baz"]) | 56 | self.config.load(["--script-users", "foo, bar,baz"]) |
3405 | 57 | self.assertEquals(self.config.get_allowed_script_users(), | 57 | self.assertEqual(self.config.get_allowed_script_users(), |
3406 | 58 | ["foo", "bar", "baz"]) | 58 | ["foo", "bar", "baz"]) |
3407 | 59 | 59 | ||
3408 | === modified file 'landscape/manager/tests/test_customgraph.py' | |||
3409 | --- landscape/manager/tests/test_customgraph.py 2010-06-22 10:51:24 +0000 | |||
3410 | +++ landscape/manager/tests/test_customgraph.py 2011-07-06 21:14:28 +0000 | |||
3411 | @@ -49,7 +49,7 @@ | |||
3412 | 49 | "username": username, | 49 | "username": username, |
3413 | 50 | "graph-id": 123}) | 50 | "graph-id": 123}) |
3414 | 51 | 51 | ||
3416 | 52 | self.assertEquals( | 52 | self.assertEqual( |
3417 | 53 | self.store.get_graphs(), | 53 | self.store.get_graphs(), |
3418 | 54 | [(123, | 54 | [(123, |
3419 | 55 | os.path.join(self.data_path, "custom-graph-scripts", | 55 | os.path.join(self.data_path, "custom-graph-scripts", |
3420 | @@ -77,8 +77,8 @@ | |||
3421 | 77 | "username": "foo", | 77 | "username": "foo", |
3422 | 78 | "graph-id": 123}) | 78 | "graph-id": 123}) |
3423 | 79 | graph = self.store.get_graph(123) | 79 | graph = self.store.get_graph(123) |
3426 | 80 | self.assertEquals(graph[0], 123) | 80 | self.assertEqual(graph[0], 123) |
3427 | 81 | self.assertEquals(graph[2], u"foo") | 81 | self.assertEqual(graph[2], u"foo") |
3428 | 82 | self.assertTrue(error_message in self.logfile.getvalue()) | 82 | self.assertTrue(error_message in self.logfile.getvalue()) |
3429 | 83 | 83 | ||
3430 | 84 | def test_add_graph_for_user(self): | 84 | def test_add_graph_for_user(self): |
3431 | @@ -103,7 +103,7 @@ | |||
3432 | 103 | "code": "echo hi!", | 103 | "code": "echo hi!", |
3433 | 104 | "username": "bar", | 104 | "username": "bar", |
3434 | 105 | "graph-id": 123}) | 105 | "graph-id": 123}) |
3436 | 106 | self.assertEquals( | 106 | self.assertEqual( |
3437 | 107 | self.store.get_graphs(), | 107 | self.store.get_graphs(), |
3438 | 108 | [(123, os.path.join(self.data_path, "custom-graph-scripts", | 108 | [(123, os.path.join(self.data_path, "custom-graph-scripts", |
3439 | 109 | "graph-123"), | 109 | "graph-123"), |
3440 | @@ -176,7 +176,6 @@ | |||
3441 | 176 | "type": "custom-graph"}]) | 176 | "type": "custom-graph"}]) |
3442 | 177 | return self.graph_manager.run().addCallback(check) | 177 | return self.graph_manager.run().addCallback(check) |
3443 | 178 | 178 | ||
3444 | 179 | |||
3445 | 180 | def test_run_with_nonzero_exit_code(self): | 179 | def test_run_with_nonzero_exit_code(self): |
3446 | 181 | filename = self.makeFile() | 180 | filename = self.makeFile() |
3447 | 182 | tempfile = file(filename, "w") | 181 | tempfile = file(filename, "w") |
3448 | @@ -184,6 +183,7 @@ | |||
3449 | 184 | tempfile.close() | 183 | tempfile.close() |
3450 | 185 | os.chmod(filename, 0777) | 184 | os.chmod(filename, 0777) |
3451 | 186 | self.store.add_graph(123, filename, None) | 185 | self.store.add_graph(123, filename, None) |
3452 | 186 | |||
3453 | 187 | def check(ignore): | 187 | def check(ignore): |
3454 | 188 | self.graph_manager.exchange() | 188 | self.graph_manager.exchange() |
3455 | 189 | self.assertMessages( | 189 | self.assertMessages( |
3456 | @@ -204,9 +204,9 @@ | |||
3457 | 204 | self.graph_manager.process_factory = factory | 204 | self.graph_manager.process_factory = factory |
3458 | 205 | result = self.graph_manager.run() | 205 | result = self.graph_manager.run() |
3459 | 206 | 206 | ||
3461 | 207 | self.assertEquals(len(factory.spawns), 1) | 207 | self.assertEqual(len(factory.spawns), 1) |
3462 | 208 | spawn = factory.spawns[0] | 208 | spawn = factory.spawns[0] |
3464 | 209 | self.assertEquals(spawn[1], filename) | 209 | self.assertEqual(spawn[1], filename) |
3465 | 210 | 210 | ||
3466 | 211 | self._exit_process_protocol(spawn[0], "foobar") | 211 | self._exit_process_protocol(spawn[0], "foobar") |
3467 | 212 | 212 | ||
3468 | @@ -230,9 +230,9 @@ | |||
3469 | 230 | self.graph_manager.process_factory = factory | 230 | self.graph_manager.process_factory = factory |
3470 | 231 | result = self.graph_manager.run() | 231 | result = self.graph_manager.run() |
3471 | 232 | 232 | ||
3473 | 233 | self.assertEquals(len(factory.spawns), 1) | 233 | self.assertEqual(len(factory.spawns), 1) |
3474 | 234 | spawn = factory.spawns[0] | 234 | spawn = factory.spawns[0] |
3476 | 235 | self.assertEquals(spawn[1], filename) | 235 | self.assertEqual(spawn[1], filename) |
3477 | 236 | 236 | ||
3478 | 237 | self._exit_process_protocol(spawn[0], "") | 237 | self._exit_process_protocol(spawn[0], "") |
3479 | 238 | 238 | ||
3480 | @@ -257,7 +257,7 @@ | |||
3481 | 257 | self.graph_manager.process_factory = factory | 257 | self.graph_manager.process_factory = factory |
3482 | 258 | result = self.graph_manager.run() | 258 | result = self.graph_manager.run() |
3483 | 259 | 259 | ||
3485 | 260 | self.assertEquals(len(factory.spawns), 2) | 260 | self.assertEqual(len(factory.spawns), 2) |
3486 | 261 | spawn = factory.spawns[0] | 261 | spawn = factory.spawns[0] |
3487 | 262 | self._exit_process_protocol(spawn[0], "") | 262 | self._exit_process_protocol(spawn[0], "") |
3488 | 263 | spawn = factory.spawns[1] | 263 | spawn = factory.spawns[1] |
3489 | @@ -287,7 +287,7 @@ | |||
3490 | 287 | self.graph_manager.process_factory = factory | 287 | self.graph_manager.process_factory = factory |
3491 | 288 | result = self.graph_manager.run() | 288 | result = self.graph_manager.run() |
3492 | 289 | 289 | ||
3494 | 290 | self.assertEquals(len(factory.spawns), 2) | 290 | self.assertEqual(len(factory.spawns), 2) |
3495 | 291 | spawn = factory.spawns[0] | 291 | spawn = factory.spawns[0] |
3496 | 292 | self._exit_process_protocol(spawn[0], "foo") | 292 | self._exit_process_protocol(spawn[0], "foo") |
3497 | 293 | spawn = factory.spawns[1] | 293 | spawn = factory.spawns[1] |
3498 | @@ -316,6 +316,7 @@ | |||
3499 | 316 | self.graph_manager.process_factory = factory | 316 | self.graph_manager.process_factory = factory |
3500 | 317 | 317 | ||
3501 | 318 | mock_getpwnam = self.mocker.replace("pwd.getpwnam", passthrough=False) | 318 | mock_getpwnam = self.mocker.replace("pwd.getpwnam", passthrough=False) |
3502 | 319 | |||
3503 | 319 | class pwnam(object): | 320 | class pwnam(object): |
3504 | 320 | pw_uid = 1234 | 321 | pw_uid = 1234 |
3505 | 321 | pw_gid = 5678 | 322 | pw_gid = 5678 |
3506 | @@ -326,14 +327,14 @@ | |||
3507 | 326 | 327 | ||
3508 | 327 | result = self.graph_manager.run() | 328 | result = self.graph_manager.run() |
3509 | 328 | 329 | ||
3511 | 329 | self.assertEquals(len(factory.spawns), 1) | 330 | self.assertEqual(len(factory.spawns), 1) |
3512 | 330 | spawn = factory.spawns[0] | 331 | spawn = factory.spawns[0] |
3519 | 331 | self.assertEquals(spawn[1], filename) | 332 | self.assertEqual(spawn[1], filename) |
3520 | 332 | self.assertEquals(spawn[2], ()) | 333 | self.assertEqual(spawn[2], ()) |
3521 | 333 | self.assertEquals(spawn[3], {}) | 334 | self.assertEqual(spawn[3], {}) |
3522 | 334 | self.assertEquals(spawn[4], "/") | 335 | self.assertEqual(spawn[4], "/") |
3523 | 335 | self.assertEquals(spawn[5], 1234) | 336 | self.assertEqual(spawn[5], 1234) |
3524 | 336 | self.assertEquals(spawn[6], 5678) | 337 | self.assertEqual(spawn[6], 5678) |
3525 | 337 | 338 | ||
3526 | 338 | self._exit_process_protocol(spawn[0], "spam") | 339 | self._exit_process_protocol(spawn[0], "spam") |
3527 | 339 | 340 | ||
3528 | @@ -350,7 +351,7 @@ | |||
3529 | 350 | self.graph_manager.process_factory = factory | 351 | self.graph_manager.process_factory = factory |
3530 | 351 | result = self.graph_manager.run() | 352 | result = self.graph_manager.run() |
3531 | 352 | 353 | ||
3533 | 353 | self.assertEquals(len(factory.spawns), 0) | 354 | self.assertEqual(len(factory.spawns), 0) |
3534 | 354 | 355 | ||
3535 | 355 | def check(ignore): | 356 | def check(ignore): |
3536 | 356 | self.graph_manager.exchange() | 357 | self.graph_manager.exchange() |
3537 | @@ -379,7 +380,7 @@ | |||
3538 | 379 | self.graph_manager.process_factory = factory | 380 | self.graph_manager.process_factory = factory |
3539 | 380 | result = self.graph_manager.run() | 381 | result = self.graph_manager.run() |
3540 | 381 | 382 | ||
3542 | 382 | self.assertEquals(len(factory.spawns), 0) | 383 | self.assertEqual(len(factory.spawns), 0) |
3543 | 383 | 384 | ||
3544 | 384 | def check(ignore): | 385 | def check(ignore): |
3545 | 385 | self.graph_manager.exchange() | 386 | self.graph_manager.exchange() |
3546 | @@ -400,11 +401,11 @@ | |||
3547 | 400 | self.graph_manager.process_factory = factory | 401 | self.graph_manager.process_factory = factory |
3548 | 401 | result = self.graph_manager.run() | 402 | result = self.graph_manager.run() |
3549 | 402 | 403 | ||
3551 | 403 | self.assertEquals(len(factory.spawns), 1) | 404 | self.assertEqual(len(factory.spawns), 1) |
3552 | 404 | spawn = factory.spawns[0] | 405 | spawn = factory.spawns[0] |
3553 | 405 | protocol = spawn[0] | 406 | protocol = spawn[0] |
3554 | 406 | protocol.makeConnection(DummyProcess()) | 407 | protocol.makeConnection(DummyProcess()) |
3556 | 407 | self.assertEquals(spawn[1], filename) | 408 | self.assertEqual(spawn[1], filename) |
3557 | 408 | 409 | ||
3558 | 409 | self.manager.reactor.advance(110) | 410 | self.manager.reactor.advance(110) |
3559 | 410 | protocol.processEnded(Failure(ProcessDone(0))) | 411 | protocol.processEnded(Failure(ProcessDone(0))) |
3560 | @@ -432,7 +433,7 @@ | |||
3561 | 432 | self.graph_manager.process_factory = factory | 433 | self.graph_manager.process_factory = factory |
3562 | 433 | self.graph_manager.run() | 434 | self.graph_manager.run() |
3563 | 434 | 435 | ||
3565 | 435 | self.assertEquals(len(factory.spawns), 0) | 436 | self.assertEqual(len(factory.spawns), 0) |
3566 | 436 | 437 | ||
3567 | 437 | self.graph_manager.exchange() | 438 | self.graph_manager.exchange() |
3568 | 438 | self.assertMessages( | 439 | self.assertMessages( |
3569 | @@ -500,7 +501,7 @@ | |||
3570 | 500 | "username": username, | 501 | "username": username, |
3571 | 501 | "graph-id": 123}) | 502 | "graph-id": 123}) |
3572 | 502 | self.graph_manager.exchange() | 503 | self.graph_manager.exchange() |
3574 | 503 | self.graph_manager._get_script_hash = lambda x: 1/0 | 504 | self.graph_manager._get_script_hash = lambda x: 1 / 0 |
3575 | 504 | self.graph_manager.do_send = True | 505 | self.graph_manager.do_send = True |
3576 | 505 | self.graph_manager.exchange() | 506 | self.graph_manager.exchange() |
3577 | 506 | self.assertMessages( | 507 | self.assertMessages( |
3578 | @@ -572,7 +573,7 @@ | |||
3579 | 572 | self.graph_manager.process_factory = factory | 573 | self.graph_manager.process_factory = factory |
3580 | 573 | result = self.graph_manager.run() | 574 | result = self.graph_manager.run() |
3581 | 574 | 575 | ||
3583 | 575 | self.assertEquals(len(factory.spawns), 1) | 576 | self.assertEqual(len(factory.spawns), 1) |
3584 | 576 | spawn = factory.spawns[0] | 577 | spawn = factory.spawns[0] |
3585 | 577 | 578 | ||
3586 | 578 | self.manager.dispatch_message( | 579 | self.manager.dispatch_message( |
3587 | @@ -617,7 +618,7 @@ | |||
3588 | 617 | self.graph_manager.process_factory = factory | 618 | self.graph_manager.process_factory = factory |
3589 | 618 | result = self.graph_manager.run() | 619 | result = self.graph_manager.run() |
3590 | 619 | 620 | ||
3592 | 620 | self.assertEquals(len(factory.spawns), 1) | 621 | self.assertEqual(len(factory.spawns), 1) |
3593 | 621 | spawn = factory.spawns[0] | 622 | spawn = factory.spawns[0] |
3594 | 622 | 623 | ||
3595 | 623 | self.manager.dispatch_message( | 624 | self.manager.dispatch_message( |
3596 | @@ -655,7 +656,7 @@ | |||
3597 | 655 | self.graph_manager.process_factory = factory | 656 | self.graph_manager.process_factory = factory |
3598 | 656 | result = self.graph_manager.run() | 657 | result = self.graph_manager.run() |
3599 | 657 | 658 | ||
3601 | 658 | self.assertEquals(len(factory.spawns), 0) | 659 | self.assertEqual(len(factory.spawns), 0) |
3602 | 659 | 660 | ||
3603 | 660 | return result.addCallback(self.assertIdentical, None) | 661 | return result.addCallback(self.assertIdentical, None) |
3604 | 661 | 662 | ||
3605 | @@ -666,14 +667,14 @@ | |||
3606 | 666 | of results. | 667 | of results. |
3607 | 667 | """ | 668 | """ |
3608 | 668 | self.graph_manager.registry.broker.call_if_accepted = ( | 669 | self.graph_manager.registry.broker.call_if_accepted = ( |
3610 | 669 | lambda *args: 1/0) | 670 | lambda *args: 1 / 0) |
3611 | 670 | factory = StubProcessFactory() | 671 | factory = StubProcessFactory() |
3612 | 671 | self.graph_manager.process_factory = factory | 672 | self.graph_manager.process_factory = factory |
3613 | 672 | result = self.graph_manager.run() | 673 | result = self.graph_manager.run() |
3614 | 673 | 674 | ||
3616 | 674 | self.assertEquals(len(factory.spawns), 0) | 675 | self.assertEqual(len(factory.spawns), 0) |
3617 | 675 | 676 | ||
3619 | 676 | return result.addCallback(self.assertEquals, []) | 677 | return result.addCallback(self.assertEqual, []) |
3620 | 677 | 678 | ||
3621 | 678 | def test_run_unknown_user_with_unicode(self): | 679 | def test_run_unknown_user_with_unicode(self): |
3622 | 679 | """ | 680 | """ |
3623 | @@ -690,7 +691,7 @@ | |||
3624 | 690 | self.graph_manager.process_factory = factory | 691 | self.graph_manager.process_factory = factory |
3625 | 691 | result = self.graph_manager.run() | 692 | result = self.graph_manager.run() |
3626 | 692 | 693 | ||
3628 | 693 | self.assertEquals(len(factory.spawns), 0) | 694 | self.assertEqual(len(factory.spawns), 0) |
3629 | 694 | 695 | ||
3630 | 695 | def check(ignore): | 696 | def check(ignore): |
3631 | 696 | self.graph_manager.exchange() | 697 | self.graph_manager.exchange() |
3632 | 697 | 698 | ||
3633 | === modified file 'landscape/manager/tests/test_packagemanager.py' | |||
3634 | --- landscape/manager/tests/test_packagemanager.py 2010-04-26 07:38:03 +0000 | |||
3635 | +++ landscape/manager/tests/test_packagemanager.py 2011-07-06 21:14:28 +0000 | |||
3636 | @@ -104,7 +104,7 @@ | |||
3637 | 104 | 104 | ||
3638 | 105 | package_manager_mock = self.mocker.patch(self.package_manager) | 105 | package_manager_mock = self.mocker.patch(self.package_manager) |
3639 | 106 | package_manager_mock.spawn_handler(PackageChanger) | 106 | package_manager_mock.spawn_handler(PackageChanger) |
3641 | 107 | self.mocker.count(2) # Once for registration, then again explicitly. | 107 | self.mocker.count(2) # Once for registration, then again explicitly. |
3642 | 108 | self.mocker.replay() | 108 | self.mocker.replay() |
3643 | 109 | 109 | ||
3644 | 110 | self.manager.add(self.package_manager) | 110 | self.manager.add(self.package_manager) |
3645 | @@ -121,7 +121,7 @@ | |||
3646 | 121 | 121 | ||
3647 | 122 | package_manager_mock = self.mocker.patch(self.package_manager) | 122 | package_manager_mock = self.mocker.patch(self.package_manager) |
3648 | 123 | package_manager_mock.spawn_handler(PackageChanger) | 123 | package_manager_mock.spawn_handler(PackageChanger) |
3650 | 124 | self.mocker.count(2) # Once for registration, then again explicitly. | 124 | self.mocker.count(2) # Once for registration, then again explicitly. |
3651 | 125 | self.mocker.replay() | 125 | self.mocker.replay() |
3652 | 126 | 126 | ||
3653 | 127 | self.manager.add(self.package_manager) | 127 | self.manager.add(self.package_manager) |
3654 | @@ -137,7 +137,7 @@ | |||
3655 | 137 | 137 | ||
3656 | 138 | package_manager_mock = self.mocker.patch(self.package_manager) | 138 | package_manager_mock = self.mocker.patch(self.package_manager) |
3657 | 139 | package_manager_mock.spawn_handler(ReleaseUpgrader) | 139 | package_manager_mock.spawn_handler(ReleaseUpgrader) |
3659 | 140 | self.mocker.count(2) # Once for registration, then again explicitly. | 140 | self.mocker.count(2) # Once for registration, then again explicitly. |
3660 | 141 | self.mocker.replay() | 141 | self.mocker.replay() |
3661 | 142 | 142 | ||
3662 | 143 | self.manager.add(self.package_manager) | 143 | self.manager.add(self.package_manager) |
3663 | @@ -154,7 +154,7 @@ | |||
3664 | 154 | self.manager.dispatch_message(message) | 154 | self.manager.dispatch_message(message) |
3665 | 155 | task = self.package_store.get_next_task("changer") | 155 | task = self.package_store.get_next_task("changer") |
3666 | 156 | self.assertTrue(task) | 156 | self.assertTrue(task) |
3668 | 157 | self.assertEquals(task.data, message) | 157 | self.assertEqual(task.data, message) |
3669 | 158 | 158 | ||
3670 | 159 | def test_release_upgrade_handling(self): | 159 | def test_release_upgrade_handling(self): |
3671 | 160 | """ | 160 | """ |
3672 | @@ -172,7 +172,7 @@ | |||
3673 | 172 | self.manager.dispatch_message(message) | 172 | self.manager.dispatch_message(message) |
3674 | 173 | task = self.package_store.get_next_task("release-upgrader") | 173 | task = self.package_store.get_next_task("release-upgrader") |
3675 | 174 | self.assertTrue(task) | 174 | self.assertTrue(task) |
3677 | 175 | self.assertEquals(task.data, message) | 175 | self.assertEqual(task.data, message) |
3678 | 176 | 176 | ||
3679 | 177 | def test_spawn_changer(self): | 177 | def test_spawn_changer(self): |
3680 | 178 | """ | 178 | """ |
3681 | @@ -341,4 +341,4 @@ | |||
3682 | 341 | self.manager.dispatch_message(message) | 341 | self.manager.dispatch_message(message) |
3683 | 342 | task = self.package_store.get_next_task("changer") | 342 | task = self.package_store.get_next_task("changer") |
3684 | 343 | self.assertTrue(task) | 343 | self.assertTrue(task) |
3686 | 344 | self.assertEquals(task.data, message) | 344 | self.assertEqual(task.data, message) |
3687 | 345 | 345 | ||
3688 | === modified file 'landscape/manager/tests/test_processkiller.py' | |||
3689 | --- landscape/manager/tests/test_processkiller.py 2010-04-26 15:19:55 +0000 | |||
3690 | +++ landscape/manager/tests/test_processkiller.py 2011-07-06 21:14:28 +0000 | |||
3691 | @@ -100,7 +100,7 @@ | |||
3692 | 100 | # a signal. | 100 | # a signal. |
3693 | 101 | self.assertTrue(return_code < 0) | 101 | self.assertTrue(return_code < 0) |
3694 | 102 | process_info = process_info_factory.get_process_info(popen.pid) | 102 | process_info = process_info_factory.get_process_info(popen.pid) |
3696 | 103 | self.assertEquals(process_info, None) | 103 | self.assertEqual(process_info, None) |
3697 | 104 | 104 | ||
3698 | 105 | service = self.broker_service | 105 | service = self.broker_service |
3699 | 106 | self.assertMessages(service.message_store.get_pending_messages(), | 106 | self.assertMessages(service.message_store.get_pending_messages(), |
3700 | 107 | 107 | ||
3701 | === modified file 'landscape/manager/tests/test_scriptexecution.py' | |||
3702 | --- landscape/manager/tests/test_scriptexecution.py 2010-04-26 14:10:43 +0000 | |||
3703 | +++ landscape/manager/tests/test_scriptexecution.py 2011-07-06 21:14:28 +0000 | |||
3704 | @@ -42,13 +42,13 @@ | |||
3705 | 42 | commands. | 42 | commands. |
3706 | 43 | """ | 43 | """ |
3707 | 44 | result = self.plugin.run_script("/bin/sh", "echo hi") | 44 | result = self.plugin.run_script("/bin/sh", "echo hi") |
3709 | 45 | result.addCallback(self.assertEquals, "hi\n") | 45 | result.addCallback(self.assertEqual, "hi\n") |
3710 | 46 | return result | 46 | return result |
3711 | 47 | 47 | ||
3712 | 48 | def test_other_interpreter(self): | 48 | def test_other_interpreter(self): |
3713 | 49 | """Non-shell interpreters can be specified.""" | 49 | """Non-shell interpreters can be specified.""" |
3714 | 50 | result = self.plugin.run_script("/usr/bin/python", "print 'hi'") | 50 | result = self.plugin.run_script("/usr/bin/python", "print 'hi'") |
3716 | 51 | result.addCallback(self.assertEquals, "hi\n") | 51 | result.addCallback(self.assertEqual, "hi\n") |
3717 | 52 | return result | 52 | return result |
3718 | 53 | 53 | ||
3719 | 54 | def test_other_interpreter_env(self): | 54 | def test_other_interpreter_env(self): |
3720 | @@ -78,8 +78,8 @@ | |||
3721 | 78 | # run_script is truly async | 78 | # run_script is truly async |
3722 | 79 | d1 = self.plugin.run_script("/bin/sh", "cat " + fifo) | 79 | d1 = self.plugin.run_script("/bin/sh", "cat " + fifo) |
3723 | 80 | d2 = self.plugin.run_script("/bin/sh", "echo hi > " + fifo) | 80 | d2 = self.plugin.run_script("/bin/sh", "echo hi > " + fifo) |
3726 | 81 | d1.addCallback(self.assertEquals, "hi\n") | 81 | d1.addCallback(self.assertEqual, "hi\n") |
3727 | 82 | d2.addCallback(self.assertEquals, "") | 82 | d2.addCallback(self.assertEqual, "") |
3728 | 83 | return gatherResults([d1, d2]) | 83 | return gatherResults([d1, d2]) |
3729 | 84 | 84 | ||
3730 | 85 | def test_accented_run_in_code(self): | 85 | def test_accented_run_in_code(self): |
3731 | @@ -91,7 +91,7 @@ | |||
3732 | 91 | result = self.plugin.run_script( | 91 | result = self.plugin.run_script( |
3733 | 92 | u"/bin/sh", u"echo %s" % (accented_content,)) | 92 | u"/bin/sh", u"echo %s" % (accented_content,)) |
3734 | 93 | result.addCallback( | 93 | result.addCallback( |
3736 | 94 | self.assertEquals, "%s\n" % (accented_content.encode("utf-8"),)) | 94 | self.assertEqual, "%s\n" % (accented_content.encode("utf-8"),)) |
3737 | 95 | return result | 95 | return result |
3738 | 96 | 96 | ||
3739 | 97 | def test_accented_run_in_interpreter(self): | 97 | def test_accented_run_in_interpreter(self): |
3740 | @@ -119,7 +119,7 @@ | |||
3741 | 119 | mock_umask(0077) | 119 | mock_umask(0077) |
3742 | 120 | self.mocker.replay() | 120 | self.mocker.replay() |
3743 | 121 | result = self.plugin.run_script("/bin/sh", "umask") | 121 | result = self.plugin.run_script("/bin/sh", "umask") |
3745 | 122 | result.addCallback(self.assertEquals, "0022\n") | 122 | result.addCallback(self.assertEqual, "0022\n") |
3746 | 123 | return result | 123 | return result |
3747 | 124 | 124 | ||
3748 | 125 | def test_restore_umask_in_event_of_error(self): | 125 | def test_restore_umask_in_event_of_error(self): |
3749 | @@ -147,7 +147,7 @@ | |||
3750 | 147 | attachments={u"file1": "some data"}) | 147 | attachments={u"file1": "some data"}) |
3751 | 148 | 148 | ||
3752 | 149 | def check(result): | 149 | def check(result): |
3754 | 150 | self.assertEquals(result, "file1\nsome data") | 150 | self.assertEqual(result, "file1\nsome data") |
3755 | 151 | result.addCallback(check) | 151 | result.addCallback(check) |
3756 | 152 | return result | 152 | return result |
3757 | 153 | 153 | ||
3758 | @@ -157,7 +157,7 @@ | |||
3759 | 157 | execution plugin tries to remove the script file. | 157 | execution plugin tries to remove the script file. |
3760 | 158 | """ | 158 | """ |
3761 | 159 | result = self.plugin.run_script("/bin/sh", "echo hi && rm $0") | 159 | result = self.plugin.run_script("/bin/sh", "echo hi && rm $0") |
3763 | 160 | result.addCallback(self.assertEquals, "hi\n") | 160 | result.addCallback(self.assertEqual, "hi\n") |
3764 | 161 | return result | 161 | return result |
3765 | 162 | 162 | ||
3766 | 163 | def test_self_remove_attachments(self): | 163 | def test_self_remove_attachments(self): |
3767 | @@ -171,7 +171,7 @@ | |||
3768 | 171 | attachments={u"file1": "some data"}) | 171 | attachments={u"file1": "some data"}) |
3769 | 172 | 172 | ||
3770 | 173 | def check(result): | 173 | def check(result): |
3772 | 174 | self.assertEquals(result, "file1\n") | 174 | self.assertEqual(result, "file1\n") |
3773 | 175 | result.addCallback(check) | 175 | result.addCallback(check) |
3774 | 176 | return result | 176 | return result |
3775 | 177 | 177 | ||
3776 | @@ -187,12 +187,12 @@ | |||
3777 | 187 | 187 | ||
3778 | 188 | result = self.plugin.run_script("/bin/sh", "echo hi", user=username) | 188 | result = self.plugin.run_script("/bin/sh", "echo hi", user=username) |
3779 | 189 | 189 | ||
3781 | 190 | self.assertEquals(len(factory.spawns), 1) | 190 | self.assertEqual(len(factory.spawns), 1) |
3782 | 191 | spawn = factory.spawns[0] | 191 | spawn = factory.spawns[0] |
3787 | 192 | self.assertEquals(spawn[4], path) | 192 | self.assertEqual(spawn[4], path) |
3788 | 193 | self.assertEquals(spawn[5], uid) | 193 | self.assertEqual(spawn[5], uid) |
3789 | 194 | self.assertEquals(spawn[6], gid) | 194 | self.assertEqual(spawn[6], gid) |
3790 | 195 | result.addCallback(self.assertEquals, "foobar") | 195 | result.addCallback(self.assertEqual, "foobar") |
3791 | 196 | 196 | ||
3792 | 197 | protocol = spawn[0] | 197 | protocol = spawn[0] |
3793 | 198 | protocol.childDataReceived(1, "foobar") | 198 | protocol.childDataReceived(1, "foobar") |
3794 | @@ -250,13 +250,13 @@ | |||
3795 | 250 | result = self.plugin.run_script("/bin/sh", "echo hi", user=username, | 250 | result = self.plugin.run_script("/bin/sh", "echo hi", user=username, |
3796 | 251 | attachments={u"file 1": "some data"}) | 251 | attachments={u"file 1": "some data"}) |
3797 | 252 | 252 | ||
3799 | 253 | self.assertEquals(len(factory.spawns), 1) | 253 | self.assertEqual(len(factory.spawns), 1) |
3800 | 254 | spawn = factory.spawns[0] | 254 | spawn = factory.spawns[0] |
3801 | 255 | self.assertIn("LANDSCAPE_ATTACHMENTS", spawn[3].keys()) | 255 | self.assertIn("LANDSCAPE_ATTACHMENTS", spawn[3].keys()) |
3802 | 256 | attachment_dir = spawn[3]["LANDSCAPE_ATTACHMENTS"] | 256 | attachment_dir = spawn[3]["LANDSCAPE_ATTACHMENTS"] |
3804 | 257 | self.assertEquals(stat.S_IMODE(os.stat(attachment_dir).st_mode), 0700) | 257 | self.assertEqual(stat.S_IMODE(os.stat(attachment_dir).st_mode), 0700) |
3805 | 258 | filename = os.path.join(attachment_dir, "file 1") | 258 | filename = os.path.join(attachment_dir, "file 1") |
3807 | 259 | self.assertEquals(stat.S_IMODE(os.stat(filename).st_mode), 0600) | 259 | self.assertEqual(stat.S_IMODE(os.stat(filename).st_mode), 0600) |
3808 | 260 | 260 | ||
3809 | 261 | protocol = spawn[0] | 261 | protocol = spawn[0] |
3810 | 262 | protocol.childDataReceived(1, "foobar") | 262 | protocol.childDataReceived(1, "foobar") |
3811 | @@ -265,7 +265,7 @@ | |||
3812 | 265 | protocol.processEnded(Failure(ProcessDone(0))) | 265 | protocol.processEnded(Failure(ProcessDone(0))) |
3813 | 266 | 266 | ||
3814 | 267 | def check(data): | 267 | def check(data): |
3816 | 268 | self.assertEquals(data, "foobar") | 268 | self.assertEqual(data, "foobar") |
3817 | 269 | self.assertFalse(os.path.exists(attachment_dir)) | 269 | self.assertFalse(os.path.exists(attachment_dir)) |
3818 | 270 | return result.addCallback(check) | 270 | return result.addCallback(check) |
3819 | 271 | 271 | ||
3820 | @@ -275,7 +275,7 @@ | |||
3821 | 275 | self.plugin.process_factory = factory | 275 | self.plugin.process_factory = factory |
3822 | 276 | self.plugin.size_limit = 100 | 276 | self.plugin.size_limit = 100 |
3823 | 277 | result = self.plugin.run_script("/bin/sh", "") | 277 | result = self.plugin.run_script("/bin/sh", "") |
3825 | 278 | result.addCallback(self.assertEquals, "x" * 100) | 278 | result.addCallback(self.assertEqual, "x" * 100) |
3826 | 279 | 279 | ||
3827 | 280 | protocol = factory.spawns[0][0] | 280 | protocol = factory.spawns[0][0] |
3828 | 281 | protocol.childDataReceived(1, "x" * 200) | 281 | protocol.childDataReceived(1, "x" * 200) |
3829 | @@ -310,7 +310,7 @@ | |||
3830 | 310 | 310 | ||
3831 | 311 | def got_error(f): | 311 | def got_error(f): |
3832 | 312 | self.assertTrue(f.check(ProcessTimeLimitReachedError)) | 312 | self.assertTrue(f.check(ProcessTimeLimitReachedError)) |
3834 | 313 | self.assertEquals(f.value.data, "hi\n") | 313 | self.assertEqual(f.value.data, "hi\n") |
3835 | 314 | result.addErrback(got_error) | 314 | result.addErrback(got_error) |
3836 | 315 | return result | 315 | return result |
3837 | 316 | 316 | ||
3838 | @@ -327,7 +327,7 @@ | |||
3839 | 327 | protocol.childDataReceived(1, "hi\n") | 327 | protocol.childDataReceived(1, "hi\n") |
3840 | 328 | protocol.processEnded(Failure(ProcessDone(0))) | 328 | protocol.processEnded(Failure(ProcessDone(0))) |
3841 | 329 | self.manager.reactor.advance(501) | 329 | self.manager.reactor.advance(501) |
3843 | 330 | self.assertEquals(transport.signals, []) | 330 | self.assertEqual(transport.signals, []) |
3844 | 331 | 331 | ||
3845 | 332 | def test_cancel_doesnt_blow_after_success(self): | 332 | def test_cancel_doesnt_blow_after_success(self): |
3846 | 333 | """ | 333 | """ |
3847 | @@ -346,7 +346,7 @@ | |||
3848 | 346 | self.manager.reactor.advance(501) | 346 | self.manager.reactor.advance(501) |
3849 | 347 | 347 | ||
3850 | 348 | def got_result(output): | 348 | def got_result(output): |
3852 | 349 | self.assertEquals(output, "hi") | 349 | self.assertEqual(output, "hi") |
3853 | 350 | result.addCallback(got_result) | 350 | result.addCallback(got_result) |
3854 | 351 | return result | 351 | return result |
3855 | 352 | 352 | ||
3856 | @@ -412,7 +412,7 @@ | |||
3857 | 412 | 412 | ||
3858 | 413 | def eb(failure): | 413 | def eb(failure): |
3859 | 414 | failure.trap(UnknownInterpreterError) | 414 | failure.trap(UnknownInterpreterError) |
3861 | 415 | self.assertEquals( | 415 | self.assertEqual( |
3862 | 416 | failure.value.interpreter, | 416 | failure.value.interpreter, |
3863 | 417 | "/bin/cantpossiblyexist") | 417 | "/bin/cantpossiblyexist") |
3864 | 418 | return d.addCallback(cb).addErrback(eb) | 418 | return d.addCallback(cb).addErrback(eb) |
3865 | @@ -433,7 +433,7 @@ | |||
3866 | 433 | script has the correct content. | 433 | script has the correct content. |
3867 | 434 | """ | 434 | """ |
3868 | 435 | data = open(executable, "r").read() | 435 | data = open(executable, "r").read() |
3870 | 436 | self.assertEquals(data, "#!%s\n%s" % (interp, code)) | 436 | self.assertEqual(data, "#!%s\n%s" % (interp, code)) |
3871 | 437 | 437 | ||
3872 | 438 | def _send_script(self, interpreter, code, operation_id=123, | 438 | def _send_script(self, interpreter, code, operation_id=123, |
3873 | 439 | user=pwd.getpwuid(os.getuid())[0], | 439 | user=pwd.getpwuid(os.getuid())[0], |
3874 | @@ -652,7 +652,7 @@ | |||
3875 | 652 | self.assertTrue(self.broker_service.exchanger.is_urgent()) | 652 | self.assertTrue(self.broker_service.exchanger.is_urgent()) |
3876 | 653 | [message] = ( | 653 | [message] = ( |
3877 | 654 | self.broker_service.message_store.get_pending_messages()) | 654 | self.broker_service.message_store.get_pending_messages()) |
3879 | 655 | self.assertEquals( | 655 | self.assertEqual( |
3880 | 656 | message["result-text"], | 656 | message["result-text"], |
3881 | 657 | u"\x7fELF\x01\x01\x01\x00\x00\x00\ufffd\x01") | 657 | u"\x7fELF\x01\x01\x01\x00\x00\x00\ufffd\x01") |
3882 | 658 | 658 | ||
3883 | 659 | 659 | ||
3884 | === modified file 'landscape/manager/tests/test_service.py' | |||
3885 | --- landscape/manager/tests/test_service.py 2010-08-11 11:56:29 +0000 | |||
3886 | +++ landscape/manager/tests/test_service.py 2011-07-06 21:14:28 +0000 | |||
3887 | @@ -26,7 +26,7 @@ | |||
3888 | 26 | By default the L{ManagerService.plugins} list holds an instance of | 26 | By default the L{ManagerService.plugins} list holds an instance of |
3889 | 27 | every enabled manager plugin. | 27 | every enabled manager plugin. |
3890 | 28 | """ | 28 | """ |
3892 | 29 | self.assertEquals(len(self.service.plugins), len(ALL_PLUGINS)) | 29 | self.assertEqual(len(self.service.plugins), len(ALL_PLUGINS)) |
3893 | 30 | 30 | ||
3894 | 31 | def test_get_plugins(self): | 31 | def test_get_plugins(self): |
3895 | 32 | """ | 32 | """ |
3896 | @@ -59,7 +59,7 @@ | |||
3897 | 59 | self.broker_service.port.stopListening() | 59 | self.broker_service.port.stopListening() |
3898 | 60 | 60 | ||
3899 | 61 | def assert_broker_connection(ignored): | 61 | def assert_broker_connection(ignored): |
3901 | 62 | self.assertEquals(len(self.broker_service.broker.get_clients()), 1) | 62 | self.assertEqual(len(self.broker_service.broker.get_clients()), 1) |
3902 | 63 | self.assertIs(self.service.broker, self.service.manager.broker) | 63 | self.assertIs(self.service.broker, self.service.manager.broker) |
3903 | 64 | result = self.service.broker.ping() | 64 | result = self.service.broker.ping() |
3904 | 65 | return result.addCallback(stop_service) | 65 | return result.addCallback(stop_service) |
3905 | 66 | 66 | ||
3906 | === modified file 'landscape/manager/tests/test_shutdownmanager.py' | |||
3907 | --- landscape/manager/tests/test_shutdownmanager.py 2010-04-23 13:39:22 +0000 | |||
3908 | +++ landscape/manager/tests/test_shutdownmanager.py 2011-07-06 21:14:28 +0000 | |||
3909 | @@ -34,14 +34,14 @@ | |||
3910 | 34 | [arguments] = self.process_factory.spawns | 34 | [arguments] = self.process_factory.spawns |
3911 | 35 | protocol = arguments[0] | 35 | protocol = arguments[0] |
3912 | 36 | self.assertTrue(isinstance(protocol, ShutdownProcessProtocol)) | 36 | self.assertTrue(isinstance(protocol, ShutdownProcessProtocol)) |
3914 | 37 | self.assertEquals( | 37 | self.assertEqual( |
3915 | 38 | arguments[1:3], | 38 | arguments[1:3], |
3916 | 39 | ("/sbin/shutdown", ["/sbin/shutdown", "-r", "+4", | 39 | ("/sbin/shutdown", ["/sbin/shutdown", "-r", "+4", |
3917 | 40 | "Landscape is rebooting the system"])) | 40 | "Landscape is rebooting the system"])) |
3918 | 41 | 41 | ||
3919 | 42 | def restart_performed(ignore): | 42 | def restart_performed(ignore): |
3920 | 43 | self.assertTrue(self.broker_service.exchanger.is_urgent()) | 43 | self.assertTrue(self.broker_service.exchanger.is_urgent()) |
3922 | 44 | self.assertEquals( | 44 | self.assertEqual( |
3923 | 45 | self.broker_service.message_store.get_pending_messages(), | 45 | self.broker_service.message_store.get_pending_messages(), |
3924 | 46 | [{"type": "operation-result", "api": SERVER_API, | 46 | [{"type": "operation-result", "api": SERVER_API, |
3925 | 47 | "operation-id": 100, "timestamp": 10, "status": SUCCEEDED, | 47 | "operation-id": 100, "timestamp": 10, "status": SUCCEEDED, |
3926 | @@ -65,7 +65,7 @@ | |||
3927 | 65 | message = {"type": "shutdown", "reboot": False, "operation-id": 100} | 65 | message = {"type": "shutdown", "reboot": False, "operation-id": 100} |
3928 | 66 | self.plugin.perform_shutdown(message) | 66 | self.plugin.perform_shutdown(message) |
3929 | 67 | [arguments] = self.process_factory.spawns | 67 | [arguments] = self.process_factory.spawns |
3931 | 68 | self.assertEquals( | 68 | self.assertEqual( |
3932 | 69 | arguments[1:3], | 69 | arguments[1:3], |
3933 | 70 | ("/sbin/shutdown", ["/sbin/shutdown", "-h", "+4", | 70 | ("/sbin/shutdown", ["/sbin/shutdown", "-h", "+4", |
3934 | 71 | "Landscape is shutting down the system"])) | 71 | "Landscape is shutting down the system"])) |
3935 | @@ -81,7 +81,7 @@ | |||
3936 | 81 | 81 | ||
3937 | 82 | def restart_failed(message_id): | 82 | def restart_failed(message_id): |
3938 | 83 | self.assertTrue(self.broker_service.exchanger.is_urgent()) | 83 | self.assertTrue(self.broker_service.exchanger.is_urgent()) |
3940 | 84 | self.assertEquals( | 84 | self.assertEqual( |
3941 | 85 | self.broker_service.message_store.get_pending_messages(), | 85 | self.broker_service.message_store.get_pending_messages(), |
3942 | 86 | [{"type": "operation-result", "api": SERVER_API, | 86 | [{"type": "operation-result", "api": SERVER_API, |
3943 | 87 | "operation-id": 100, "timestamp": 0, "status": FAILED, | 87 | "operation-id": 100, "timestamp": 0, "status": FAILED, |
3944 | @@ -105,7 +105,7 @@ | |||
3945 | 105 | stash = [] | 105 | stash = [] |
3946 | 106 | 106 | ||
3947 | 107 | def restart_performed(ignore): | 107 | def restart_performed(ignore): |
3949 | 108 | self.assertEquals(stash, []) | 108 | self.assertEqual(stash, []) |
3950 | 109 | stash.append(True) | 109 | stash.append(True) |
3951 | 110 | 110 | ||
3952 | 111 | [arguments] = self.process_factory.spawns | 111 | [arguments] = self.process_factory.spawns |
3953 | @@ -128,6 +128,6 @@ | |||
3954 | 128 | protocol.childDataReceived(0, "Data may arrive ") | 128 | protocol.childDataReceived(0, "Data may arrive ") |
3955 | 129 | protocol.childDataReceived(0, "in batches.") | 129 | protocol.childDataReceived(0, "in batches.") |
3956 | 130 | self.manager.reactor.advance(10) | 130 | self.manager.reactor.advance(10) |
3958 | 131 | self.assertEquals(protocol.get_data(), "Data may arrive in batches.") | 131 | self.assertEqual(protocol.get_data(), "Data may arrive in batches.") |
3959 | 132 | protocol.childDataReceived(0, "Even when you least expect it.") | 132 | protocol.childDataReceived(0, "Even when you least expect it.") |
3961 | 133 | self.assertEquals(protocol.get_data(), "Data may arrive in batches.") | 133 | self.assertEqual(protocol.get_data(), "Data may arrive in batches.") |
3962 | 134 | 134 | ||
3963 | === modified file 'landscape/manager/tests/test_store.py' | |||
3964 | --- landscape/manager/tests/test_store.py 2008-10-22 16:54:38 +0000 | |||
3965 | +++ landscape/manager/tests/test_store.py 2011-07-06 21:14:28 +0000 | |||
3966 | @@ -18,36 +18,36 @@ | |||
3967 | 18 | 18 | ||
3968 | 19 | def test_get_graph(self): | 19 | def test_get_graph(self): |
3969 | 20 | graph = self.store.get_graph(1) | 20 | graph = self.store.get_graph(1) |
3971 | 21 | self.assertEquals(graph, (1, u"file 1", u"user1")) | 21 | self.assertEqual(graph, (1, u"file 1", u"user1")) |
3972 | 22 | 22 | ||
3973 | 23 | def test_get_graphs(self): | 23 | def test_get_graphs(self): |
3974 | 24 | graphs = self.store.get_graphs() | 24 | graphs = self.store.get_graphs() |
3976 | 25 | self.assertEquals(graphs, [(1, u"file 1", u"user1")]) | 25 | self.assertEqual(graphs, [(1, u"file 1", u"user1")]) |
3977 | 26 | 26 | ||
3978 | 27 | def test_get_no_graphs(self): | 27 | def test_get_no_graphs(self): |
3979 | 28 | self.store.remove_graph(1) | 28 | self.store.remove_graph(1) |
3980 | 29 | graphs = self.store.get_graphs() | 29 | graphs = self.store.get_graphs() |
3982 | 30 | self.assertEquals(graphs, []) | 30 | self.assertEqual(graphs, []) |
3983 | 31 | 31 | ||
3984 | 32 | def test_add_graph(self): | 32 | def test_add_graph(self): |
3985 | 33 | self.store.add_graph(2, u"file 2", u"user2") | 33 | self.store.add_graph(2, u"file 2", u"user2") |
3986 | 34 | graph = self.store.get_graph(2) | 34 | graph = self.store.get_graph(2) |
3988 | 35 | self.assertEquals(graph, (2, u"file 2", u"user2")) | 35 | self.assertEqual(graph, (2, u"file 2", u"user2")) |
3989 | 36 | 36 | ||
3990 | 37 | def test_add_update_graph(self): | 37 | def test_add_update_graph(self): |
3991 | 38 | self.store.add_graph(1, u"file 2", u"user2") | 38 | self.store.add_graph(1, u"file 2", u"user2") |
3992 | 39 | graph = self.store.get_graph(1) | 39 | graph = self.store.get_graph(1) |
3994 | 40 | self.assertEquals(graph, (1, u"file 2", u"user2")) | 40 | self.assertEqual(graph, (1, u"file 2", u"user2")) |
3995 | 41 | 41 | ||
3996 | 42 | def test_remove_graph(self): | 42 | def test_remove_graph(self): |
3997 | 43 | self.store.remove_graph(1) | 43 | self.store.remove_graph(1) |
3998 | 44 | graphs = self.store.get_graphs() | 44 | graphs = self.store.get_graphs() |
4000 | 45 | self.assertEquals(graphs, []) | 45 | self.assertEqual(graphs, []) |
4001 | 46 | 46 | ||
4002 | 47 | def test_remove_unknown_graph(self): | 47 | def test_remove_unknown_graph(self): |
4003 | 48 | self.store.remove_graph(2) | 48 | self.store.remove_graph(2) |
4004 | 49 | graphs = self.store.get_graphs() | 49 | graphs = self.store.get_graphs() |
4006 | 50 | self.assertEquals(graphs, [(1, u"file 1", u"user1")]) | 50 | self.assertEqual(graphs, [(1, u"file 1", u"user1")]) |
4007 | 51 | 51 | ||
4008 | 52 | def test_get_accumulate_unknown_graph(self): | 52 | def test_get_accumulate_unknown_graph(self): |
4009 | 53 | accumulate = self.store.get_graph_accumulate(2) | 53 | accumulate = self.store.get_graph_accumulate(2) |
4010 | @@ -56,9 +56,9 @@ | |||
4011 | 56 | def test_set_accumulate_graph(self): | 56 | def test_set_accumulate_graph(self): |
4012 | 57 | self.store.set_graph_accumulate(2, 1234, 2.0) | 57 | self.store.set_graph_accumulate(2, 1234, 2.0) |
4013 | 58 | accumulate = self.store.get_graph_accumulate(2) | 58 | accumulate = self.store.get_graph_accumulate(2) |
4015 | 59 | self.assertEquals(accumulate, (2, 1234, 2.0)) | 59 | self.assertEqual(accumulate, (2, 1234, 2.0)) |
4016 | 60 | 60 | ||
4017 | 61 | def test_update_accumulate_graph(self): | 61 | def test_update_accumulate_graph(self): |
4018 | 62 | self.store.set_graph_accumulate(1, 4567, 2.0) | 62 | self.store.set_graph_accumulate(1, 4567, 2.0) |
4019 | 63 | accumulate = self.store.get_graph_accumulate(1) | 63 | accumulate = self.store.get_graph_accumulate(1) |
4021 | 64 | self.assertEquals(accumulate, (1, 4567, 2.0)) | 64 | self.assertEqual(accumulate, (1, 4567, 2.0)) |
4022 | 65 | 65 | ||
4023 | === modified file 'landscape/manager/tests/test_usermanager.py' | |||
4024 | --- landscape/manager/tests/test_usermanager.py 2010-09-09 17:01:02 +0000 | |||
4025 | +++ landscape/manager/tests/test_usermanager.py 2011-07-06 21:14:28 +0000 | |||
4026 | @@ -125,7 +125,7 @@ | |||
4027 | 125 | def handle_callback2(result, messages): | 125 | def handle_callback2(result, messages): |
4028 | 126 | message_store = self.broker_service.message_store | 126 | message_store = self.broker_service.message_store |
4029 | 127 | new_messages = message_store.get_pending_messages() | 127 | new_messages = message_store.get_pending_messages() |
4031 | 128 | self.assertEquals(messages, new_messages) | 128 | self.assertEqual(messages, new_messages) |
4032 | 129 | return result | 129 | return result |
4033 | 130 | 130 | ||
4034 | 131 | plugin = self.setup_environment([], [], None) | 131 | plugin = self.setup_environment([], [], None) |
4035 | @@ -148,7 +148,7 @@ | |||
4036 | 148 | 148 | ||
4037 | 149 | def handle_callback(result): | 149 | def handle_callback(result): |
4038 | 150 | messages = self.broker_service.message_store.get_pending_messages() | 150 | messages = self.broker_service.message_store.get_pending_messages() |
4040 | 151 | self.assertEquals(len(messages), 3) | 151 | self.assertEqual(len(messages), 3) |
4041 | 152 | messages = [messages[0], messages[2]] | 152 | messages = [messages[0], messages[2]] |
4042 | 153 | self.assertMessages(messages, | 153 | self.assertMessages(messages, |
4043 | 154 | [{"type": "users", | 154 | [{"type": "users", |
4044 | @@ -190,7 +190,7 @@ | |||
4045 | 190 | 190 | ||
4046 | 191 | def handle_callback(result): | 191 | def handle_callback(result): |
4047 | 192 | messages = self.broker_service.message_store.get_pending_messages() | 192 | messages = self.broker_service.message_store.get_pending_messages() |
4049 | 193 | self.assertEquals(len(messages), 3) | 193 | self.assertEqual(len(messages), 3) |
4050 | 194 | # Ignore the message created by plugin.run. | 194 | # Ignore the message created by plugin.run. |
4051 | 195 | self.assertMessages(messages[1:], | 195 | self.assertMessages(messages[1:], |
4052 | 196 | [{"type": "operation-result", | 196 | [{"type": "operation-result", |
4053 | @@ -238,7 +238,7 @@ | |||
4054 | 238 | def handle_callback2(result, messages): | 238 | def handle_callback2(result, messages): |
4055 | 239 | mstore = self.broker_service.message_store | 239 | mstore = self.broker_service.message_store |
4056 | 240 | new_messages = mstore.get_pending_messages() | 240 | new_messages = mstore.get_pending_messages() |
4058 | 241 | self.assertEquals(messages, new_messages) | 241 | self.assertEqual(messages, new_messages) |
4059 | 242 | return result | 242 | return result |
4060 | 243 | 243 | ||
4061 | 244 | users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", | 244 | users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", |
4062 | @@ -262,7 +262,7 @@ | |||
4063 | 262 | 262 | ||
4064 | 263 | def handle_callback(result): | 263 | def handle_callback(result): |
4065 | 264 | messages = self.broker_service.message_store.get_pending_messages() | 264 | messages = self.broker_service.message_store.get_pending_messages() |
4067 | 265 | self.assertEquals(len(messages), 3) | 265 | self.assertEqual(len(messages), 3) |
4068 | 266 | self.assertMessages([messages[0], messages[2]], | 266 | self.assertMessages([messages[0], messages[2]], |
4069 | 267 | [{"type": "users", | 267 | [{"type": "users", |
4070 | 268 | "create-group-members": {u"users": | 268 | "create-group-members": {u"users": |
4071 | @@ -311,7 +311,7 @@ | |||
4072 | 311 | 311 | ||
4073 | 312 | def handle_callback(result): | 312 | def handle_callback(result): |
4074 | 313 | messages = self.broker_service.message_store.get_pending_messages() | 313 | messages = self.broker_service.message_store.get_pending_messages() |
4076 | 314 | self.assertEquals(len(messages), 3) | 314 | self.assertEqual(len(messages), 3) |
4077 | 315 | # Ignore the message created by plugin.run. | 315 | # Ignore the message created by plugin.run. |
4078 | 316 | self.assertMessages([messages[2], messages[1]], | 316 | self.assertMessages([messages[2], messages[1]], |
4079 | 317 | [{"timestamp": 0, "delete-users": ["jdoe"], | 317 | [{"timestamp": 0, "delete-users": ["jdoe"], |
4080 | @@ -321,7 +321,6 @@ | |||
4081 | 321 | "operation-id": 39, "timestamp": 0, | 321 | "operation-id": 39, "timestamp": 0, |
4082 | 322 | "result-text": "remove_user succeeded"}]) | 322 | "result-text": "remove_user succeeded"}]) |
4083 | 323 | 323 | ||
4084 | 324 | |||
4085 | 325 | users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/home/bo", | 324 | users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/home/bo", |
4086 | 326 | "/bin/zsh")] | 325 | "/bin/zsh")] |
4087 | 327 | self.setup_environment(users, [], None) | 326 | self.setup_environment(users, [], None) |
4088 | @@ -357,7 +356,6 @@ | |||
4089 | 357 | "operation-id": 40, "timestamp": 0, | 356 | "operation-id": 40, "timestamp": 0, |
4090 | 358 | "result-text": "remove_user succeeded"}]) | 357 | "result-text": "remove_user succeeded"}]) |
4091 | 359 | 358 | ||
4092 | 360 | |||
4093 | 361 | results = [] | 359 | results = [] |
4094 | 362 | results.append(self.manager.dispatch_message({"username": "foo", | 360 | results.append(self.manager.dispatch_message({"username": "foo", |
4095 | 363 | "delete-home": True, | 361 | "delete-home": True, |
4096 | @@ -378,7 +376,7 @@ | |||
4097 | 378 | 376 | ||
4098 | 379 | def handle_callback(result): | 377 | def handle_callback(result): |
4099 | 380 | messages = self.broker_service.message_store.get_pending_messages() | 378 | messages = self.broker_service.message_store.get_pending_messages() |
4101 | 381 | self.assertEquals(len(messages), 1) | 379 | self.assertEqual(len(messages), 1) |
4102 | 382 | failure_string = "UserManagementError: remove_user failed" | 380 | failure_string = "UserManagementError: remove_user failed" |
4103 | 383 | self.assertMessages(messages, | 381 | self.assertMessages(messages, |
4104 | 384 | [{"type": "operation-result", "status": FAILED, | 382 | [{"type": "operation-result", "status": FAILED, |
4105 | @@ -407,7 +405,7 @@ | |||
4106 | 407 | def handle_callback(result): | 405 | def handle_callback(result): |
4107 | 408 | messages = ( | 406 | messages = ( |
4108 | 409 | self.broker_service.message_store.get_pending_messages()) | 407 | self.broker_service.message_store.get_pending_messages()) |
4110 | 410 | self.assertEquals(len(messages), 3) | 408 | self.assertEqual(len(messages), 3) |
4111 | 411 | # Ignore the message created by plugin.run. | 409 | # Ignore the message created by plugin.run. |
4112 | 412 | self.assertMessages([messages[2], messages[1]], | 410 | self.assertMessages([messages[2], messages[1]], |
4113 | 413 | [{"timestamp": 0, "delete-users": ["jdoe"], | 411 | [{"timestamp": 0, "delete-users": ["jdoe"], |
4114 | @@ -446,7 +444,7 @@ | |||
4115 | 446 | def handle_callback2(result, messages): | 444 | def handle_callback2(result, messages): |
4116 | 447 | message_store = self.broker_service.message_store | 445 | message_store = self.broker_service.message_store |
4117 | 448 | new_messages = message_store.get_pending_messages() | 446 | new_messages = message_store.get_pending_messages() |
4119 | 449 | self.assertEquals(messages, new_messages) | 447 | self.assertEqual(messages, new_messages) |
4120 | 450 | 448 | ||
4121 | 451 | users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/home/bo", | 449 | users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/home/bo", |
4122 | 452 | "/bin/zsh")] | 450 | "/bin/zsh")] |
4123 | @@ -470,7 +468,7 @@ | |||
4124 | 470 | 468 | ||
4125 | 471 | def handle_callback(result): | 469 | def handle_callback(result): |
4126 | 472 | messages = self.broker_service.message_store.get_pending_messages() | 470 | messages = self.broker_service.message_store.get_pending_messages() |
4128 | 473 | self.assertEquals(len(messages), 3) | 471 | self.assertEqual(len(messages), 3) |
4129 | 474 | self.assertMessages([messages[0], messages[2]], | 472 | self.assertMessages([messages[0], messages[2]], |
4130 | 475 | [{"type": "users", | 473 | [{"type": "users", |
4131 | 476 | "create-users": [{"home-phone": None, | 474 | "create-users": [{"home-phone": None, |
4132 | @@ -507,10 +505,11 @@ | |||
4133 | 507 | 505 | ||
4134 | 508 | def handle_callback(result): | 506 | def handle_callback(result): |
4135 | 509 | messages = self.broker_service.message_store.get_pending_messages() | 507 | messages = self.broker_service.message_store.get_pending_messages() |
4137 | 510 | self.assertEquals(len(messages), 3, messages) | 508 | self.assertEqual(len(messages), 3, messages) |
4138 | 511 | # Ignore the message created by plugin.run. | 509 | # Ignore the message created by plugin.run. |
4139 | 512 | self.assertMessages([messages[2], messages[1]], | 510 | self.assertMessages([messages[2], messages[1]], |
4141 | 513 | [{"timestamp": 0, "type": "users", "operation-id": 99, | 511 | [{"timestamp": 0, "type": "users", |
4142 | 512 | "operation-id": 99, | ||
4143 | 514 | "update-users": [{"home-phone": None, | 513 | "update-users": [{"home-phone": None, |
4144 | 515 | "username": "jdoe", | 514 | "username": "jdoe", |
4145 | 516 | "uid": 1000, | 515 | "uid": 1000, |
4146 | @@ -524,7 +523,8 @@ | |||
4147 | 524 | "operation-id": 99, "timestamp": 0, | 523 | "operation-id": 99, "timestamp": 0, |
4148 | 525 | "result-text": "lock_user succeeded"}]) | 524 | "result-text": "lock_user succeeded"}]) |
4149 | 526 | 525 | ||
4151 | 527 | users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/home/bo", "/bin/zsh")] | 526 | users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/home/bo", |
4152 | 527 | "/bin/zsh")] | ||
4153 | 528 | self.setup_environment(users, [], self.shadow_file) | 528 | self.setup_environment(users, [], self.shadow_file) |
4154 | 529 | result = self.manager.dispatch_message( | 529 | result = self.manager.dispatch_message( |
4155 | 530 | {"username": "jdoe", | 530 | {"username": "jdoe", |
4156 | @@ -543,7 +543,7 @@ | |||
4157 | 543 | 543 | ||
4158 | 544 | def handle_callback(result): | 544 | def handle_callback(result): |
4159 | 545 | messages = self.broker_service.message_store.get_pending_messages() | 545 | messages = self.broker_service.message_store.get_pending_messages() |
4161 | 546 | self.assertEquals(len(messages), 1) | 546 | self.assertEqual(len(messages), 1) |
4162 | 547 | failure_string = "UserManagementError: lock_user failed" | 547 | failure_string = "UserManagementError: lock_user failed" |
4163 | 548 | self.assertMessages(messages, | 548 | self.assertMessages(messages, |
4164 | 549 | [{"type": "operation-result", | 549 | [{"type": "operation-result", |
4165 | @@ -577,7 +577,7 @@ | |||
4166 | 577 | def handle_callback2(result, messages): | 577 | def handle_callback2(result, messages): |
4167 | 578 | message_store = self.broker_service.message_store | 578 | message_store = self.broker_service.message_store |
4168 | 579 | new_messages = message_store.get_pending_messages() | 579 | new_messages = message_store.get_pending_messages() |
4170 | 580 | self.assertEquals(messages, new_messages) | 580 | self.assertEqual(messages, new_messages) |
4171 | 581 | 581 | ||
4172 | 582 | users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/home/bo", | 582 | users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/home/bo", |
4173 | 583 | "/bin/zsh")] | 583 | "/bin/zsh")] |
4174 | @@ -598,7 +598,7 @@ | |||
4175 | 598 | """ | 598 | """ |
4176 | 599 | def handle_callback(result): | 599 | def handle_callback(result): |
4177 | 600 | messages = self.broker_service.message_store.get_pending_messages() | 600 | messages = self.broker_service.message_store.get_pending_messages() |
4179 | 601 | self.assertEquals(len(messages), 3) | 601 | self.assertEqual(len(messages), 3) |
4180 | 602 | self.assertMessages([messages[0], messages[2]], | 602 | self.assertMessages([messages[0], messages[2]], |
4181 | 603 | [{"type": "users", | 603 | [{"type": "users", |
4182 | 604 | "create-users": [{"home-phone": None, | 604 | "create-users": [{"home-phone": None, |
4183 | @@ -639,10 +639,11 @@ | |||
4184 | 639 | 639 | ||
4185 | 640 | def handle_callback(result): | 640 | def handle_callback(result): |
4186 | 641 | messages = self.broker_service.message_store.get_pending_messages() | 641 | messages = self.broker_service.message_store.get_pending_messages() |
4188 | 642 | self.assertEquals(len(messages), 3) | 642 | self.assertEqual(len(messages), 3) |
4189 | 643 | # Ignore the message created by plugin.run. | 643 | # Ignore the message created by plugin.run. |
4190 | 644 | self.assertMessages([messages[2], messages[1]], | 644 | self.assertMessages([messages[2], messages[1]], |
4192 | 645 | [{"timestamp": 0, "type": "users", "operation-id": 99, | 645 | [{"timestamp": 0, "type": "users", |
4193 | 646 | "operation-id": 99, | ||
4194 | 646 | "update-users": [{"home-phone": None, | 647 | "update-users": [{"home-phone": None, |
4195 | 647 | "username": "psmith", | 648 | "username": "psmith", |
4196 | 648 | "uid": 1000, | 649 | "uid": 1000, |
4197 | @@ -677,7 +678,7 @@ | |||
4198 | 677 | 678 | ||
4199 | 678 | def handle_callback(result): | 679 | def handle_callback(result): |
4200 | 679 | messages = self.broker_service.message_store.get_pending_messages() | 680 | messages = self.broker_service.message_store.get_pending_messages() |
4202 | 680 | self.assertEquals(len(messages), 1) | 681 | self.assertEqual(len(messages), 1) |
4203 | 681 | failure_string = "UserManagementError: unlock_user failed" | 682 | failure_string = "UserManagementError: unlock_user failed" |
4204 | 682 | self.assertMessages(messages, | 683 | self.assertMessages(messages, |
4205 | 683 | [{"type": "operation-result", | 684 | [{"type": "operation-result", |
4206 | @@ -712,7 +713,7 @@ | |||
4207 | 712 | def handle_callback2(result, messages): | 713 | def handle_callback2(result, messages): |
4208 | 713 | message_store = self.broker_service.message_store | 714 | message_store = self.broker_service.message_store |
4209 | 714 | new_messages = message_store.get_pending_messages() | 715 | new_messages = message_store.get_pending_messages() |
4211 | 715 | self.assertEquals(messages, new_messages) | 716 | self.assertEqual(messages, new_messages) |
4212 | 716 | 717 | ||
4213 | 717 | users = [("psmith", "x", 1000, 1000, "Paul Smith,,,,", "/home/psmith", | 718 | users = [("psmith", "x", 1000, 1000, "Paul Smith,,,,", "/home/psmith", |
4214 | 718 | "/bin/zsh")] | 719 | "/bin/zsh")] |
4215 | @@ -736,7 +737,7 @@ | |||
4216 | 736 | 737 | ||
4217 | 737 | def handle_callback(result): | 738 | def handle_callback(result): |
4218 | 738 | messages = self.broker_service.message_store.get_pending_messages() | 739 | messages = self.broker_service.message_store.get_pending_messages() |
4220 | 739 | self.assertEquals(len(messages), 3) | 740 | self.assertEqual(len(messages), 3) |
4221 | 740 | self.assertMessages([messages[0], messages[2]], | 741 | self.assertMessages([messages[0], messages[2]], |
4222 | 741 | [{"type": "users", | 742 | [{"type": "users", |
4223 | 742 | "create-users": [{"home-phone": None, | 743 | "create-users": [{"home-phone": None, |
4224 | @@ -781,7 +782,7 @@ | |||
4225 | 781 | 782 | ||
4226 | 782 | def handle_callback(result): | 783 | def handle_callback(result): |
4227 | 783 | messages = self.broker_service.message_store.get_pending_messages() | 784 | messages = self.broker_service.message_store.get_pending_messages() |
4229 | 784 | self.assertEquals(len(messages), 2) | 785 | self.assertEqual(len(messages), 2) |
4230 | 785 | # Ignore the message created by plugin.run. | 786 | # Ignore the message created by plugin.run. |
4231 | 786 | self.assertMessages([messages[1], messages[0]], | 787 | self.assertMessages([messages[1], messages[0]], |
4232 | 787 | [{"type": "users", "timestamp": 0, | 788 | [{"type": "users", "timestamp": 0, |
4233 | @@ -819,7 +820,7 @@ | |||
4234 | 819 | def handle_callback2(result, messages): | 820 | def handle_callback2(result, messages): |
4235 | 820 | message_store = self.broker_service.message_store | 821 | message_store = self.broker_service.message_store |
4236 | 821 | new_messages = message_store.get_pending_messages() | 822 | new_messages = message_store.get_pending_messages() |
4238 | 822 | self.assertEquals(messages, new_messages) | 823 | self.assertEqual(messages, new_messages) |
4239 | 823 | 824 | ||
4240 | 824 | plugin = self.setup_environment([], [], None) | 825 | plugin = self.setup_environment([], [], None) |
4241 | 825 | result = self.manager.dispatch_message( | 826 | result = self.manager.dispatch_message( |
4242 | @@ -829,7 +830,6 @@ | |||
4243 | 829 | result.addCallback(handle_callback1) | 830 | result.addCallback(handle_callback1) |
4244 | 830 | return result | 831 | return result |
4245 | 831 | 832 | ||
4246 | 832 | |||
4247 | 833 | def test_add_group_event_with_external_changes(self): | 833 | def test_add_group_event_with_external_changes(self): |
4248 | 834 | """ | 834 | """ |
4249 | 835 | If external user changes have been made but not detected by | 835 | If external user changes have been made but not detected by |
4250 | @@ -840,7 +840,7 @@ | |||
4251 | 840 | 840 | ||
4252 | 841 | def handle_callback(result): | 841 | def handle_callback(result): |
4253 | 842 | messages = self.broker_service.message_store.get_pending_messages() | 842 | messages = self.broker_service.message_store.get_pending_messages() |
4255 | 843 | self.assertEquals(len(messages), 3) | 843 | self.assertEqual(len(messages), 3) |
4256 | 844 | # We skip the operation-result message. | 844 | # We skip the operation-result message. |
4257 | 845 | self.assertMessages([messages[0], messages[2]], | 845 | self.assertMessages([messages[0], messages[2]], |
4258 | 846 | [{"type": "users", | 846 | [{"type": "users", |
4259 | @@ -859,7 +859,6 @@ | |||
4260 | 859 | result.addCallback(handle_callback) | 859 | result.addCallback(handle_callback) |
4261 | 860 | return result | 860 | return result |
4262 | 861 | 861 | ||
4263 | 862 | |||
4264 | 863 | def test_edit_group_event(self): | 862 | def test_edit_group_event(self): |
4265 | 864 | """ | 863 | """ |
4266 | 865 | When an C{edit-group} message is received the specified group | 864 | When an C{edit-group} message is received the specified group |
4267 | @@ -872,25 +871,25 @@ | |||
4268 | 872 | 871 | ||
4269 | 873 | def handle_callback(result): | 872 | def handle_callback(result): |
4270 | 874 | messages = self.broker_service.message_store.get_pending_messages() | 873 | messages = self.broker_service.message_store.get_pending_messages() |
4272 | 875 | self.assertEquals(len(messages), 3) | 874 | self.assertEqual(len(messages), 3) |
4273 | 876 | # Ignore the message created when the initial snapshot was | 875 | # Ignore the message created when the initial snapshot was |
4274 | 877 | # taken before the operation was performed. | 876 | # taken before the operation was performed. |
4291 | 878 | self.assertMessages(messages, | 877 | expected = [{"create-groups": [{"gid": 50, |
4292 | 879 | [{"create-groups": [{"gid": 50, | 878 | "name": "sales"}], |
4293 | 880 | "name": "sales"}], | 879 | "timestamp": 0, |
4294 | 881 | "timestamp": 0, | 880 | "type": "users"}, |
4295 | 882 | "type": "users"}, | 881 | {"type": "operation-result", |
4296 | 883 | {"type": "operation-result", | 882 | "status": SUCCEEDED, |
4297 | 884 | "status": SUCCEEDED, | 883 | "operation-id": 123, "timestamp": 0, |
4298 | 885 | "operation-id": 123, "timestamp": 0, | 884 | "result-text": "set_group_details succeeded"}, |
4299 | 886 | "result-text": "set_group_details succeeded"}, | 885 | {"delete-groups": ["sales"], |
4300 | 887 | {"delete-groups": ["sales"], | 886 | "create-groups": [{"gid": 50, |
4301 | 888 | "create-groups": [{"gid": 50, | 887 | "name": "bizdev"}], |
4302 | 889 | "name": "bizdev"}], | 888 | "timestamp": 0, |
4303 | 890 | "timestamp": 0, | 889 | "operation-id": 123, |
4304 | 891 | "operation-id": 123, | 890 | "type": "users"}, |
4305 | 892 | "type": "users"},]) | 891 | ] |
4306 | 893 | 892 | self.assertMessages(messages, expected) | |
4307 | 894 | 893 | ||
4308 | 895 | groups = [("sales", "x", 50, [])] | 894 | groups = [("sales", "x", 50, [])] |
4309 | 896 | self.setup_environment([], groups, None) | 895 | self.setup_environment([], groups, None) |
4310 | @@ -920,7 +919,7 @@ | |||
4311 | 920 | def handle_callback2(result, messages): | 919 | def handle_callback2(result, messages): |
4312 | 921 | message_store = self.broker_service.message_store | 920 | message_store = self.broker_service.message_store |
4313 | 922 | new_messages = message_store.get_pending_messages() | 921 | new_messages = message_store.get_pending_messages() |
4315 | 923 | self.assertEquals(messages, new_messages) | 922 | self.assertEqual(messages, new_messages) |
4316 | 924 | 923 | ||
4317 | 925 | groups = [("sales", "x", 50, [])] | 924 | groups = [("sales", "x", 50, [])] |
4318 | 926 | plugin = self.setup_environment([], groups, None) | 925 | plugin = self.setup_environment([], groups, None) |
4319 | @@ -953,7 +952,7 @@ | |||
4320 | 953 | def handle_callback2(result): | 952 | def handle_callback2(result): |
4321 | 954 | message_store = self.broker_service.message_store | 953 | message_store = self.broker_service.message_store |
4322 | 955 | messages = message_store.get_pending_messages() | 954 | messages = message_store.get_pending_messages() |
4324 | 956 | self.assertEquals(len(messages), 3) | 955 | self.assertEqual(len(messages), 3) |
4325 | 957 | self.assertMessages([messages[0], messages[2]], | 956 | self.assertMessages([messages[0], messages[2]], |
4326 | 958 | [{"type": "users", | 957 | [{"type": "users", |
4327 | 959 | "create-groups": [{"gid": 1001, | 958 | "create-groups": [{"gid": 1001, |
4328 | @@ -964,14 +963,12 @@ | |||
4329 | 964 | "create-groups": [{"gid": 1001, | 963 | "create-groups": [{"gid": 1001, |
4330 | 965 | "name": "webdev"}]}]) | 964 | "name": "webdev"}]}]) |
4331 | 966 | 965 | ||
4332 | 967 | |||
4333 | 968 | groups = [("sales", "x", 1001, [])] | 966 | groups = [("sales", "x", 1001, [])] |
4334 | 969 | plugin = self.setup_environment([], groups, None) | 967 | plugin = self.setup_environment([], groups, None) |
4335 | 970 | result = plugin.run() | 968 | result = plugin.run() |
4336 | 971 | result.addCallback(handle_callback1) | 969 | result.addCallback(handle_callback1) |
4337 | 972 | return result | 970 | return result |
4338 | 973 | 971 | ||
4339 | 974 | |||
4340 | 975 | def test_add_group_member_event(self): | 972 | def test_add_group_member_event(self): |
4341 | 976 | """ | 973 | """ |
4342 | 977 | When an C{add-group-member} message is received the new user | 974 | When an C{add-group-member} message is received the new user |
4343 | @@ -983,19 +980,18 @@ | |||
4344 | 983 | 980 | ||
4345 | 984 | def handle_callback(result): | 981 | def handle_callback(result): |
4346 | 985 | messages = self.broker_service.message_store.get_pending_messages() | 982 | messages = self.broker_service.message_store.get_pending_messages() |
4348 | 986 | self.assertEquals(len(messages), 3) | 983 | self.assertEqual(len(messages), 3) |
4349 | 987 | # Ignore the message created when the initial snapshot was | 984 | # Ignore the message created when the initial snapshot was |
4350 | 988 | # taken before the operation was performed. | 985 | # taken before the operation was performed. |
4361 | 989 | self.assertMessages([messages[2], messages[1]], | 986 | expected = [{"type": "users", "timestamp": 0, |
4362 | 990 | [{"type": "users", "timestamp": 0, | 987 | "operation-id": 123, |
4363 | 991 | "operation-id": 123, | 988 | "create-group-members": {"bizdev": ["jdoe"]}}, |
4364 | 992 | "create-group-members": {"bizdev": ["jdoe"]}}, | 989 | {"type": "operation-result", |
4365 | 993 | {"type": "operation-result", | 990 | "timestamp": 0, |
4366 | 994 | "timestamp": 0, | 991 | "status": SUCCEEDED, |
4367 | 995 | "status": SUCCEEDED, | 992 | "operation-id": 123, |
4368 | 996 | "operation-id": 123, | 993 | "result-text": "add_group_member succeeded"}] |
4369 | 997 | "result-text": "add_group_member succeeded"}]) | 994 | self.assertMessages([messages[2], messages[1]], expected) |
4360 | 998 | |||
4370 | 999 | 995 | ||
4371 | 1000 | users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/bin/sh", | 996 | users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/bin/sh", |
4372 | 1001 | "/home/jdoe")] | 997 | "/home/jdoe")] |
4373 | @@ -1009,7 +1005,6 @@ | |||
4374 | 1009 | result.addCallback(handle_callback) | 1005 | result.addCallback(handle_callback) |
4375 | 1010 | return result | 1006 | return result |
4376 | 1011 | 1007 | ||
4377 | 1012 | |||
4378 | 1013 | def test_add_group_member_with_username_and_groupname_event(self): | 1008 | def test_add_group_member_with_username_and_groupname_event(self): |
4379 | 1014 | """ | 1009 | """ |
4380 | 1015 | When an C{add-group-member} message is received with a | 1010 | When an C{add-group-member} message is received with a |
4381 | @@ -1022,17 +1017,16 @@ | |||
4382 | 1022 | 1017 | ||
4383 | 1023 | def handle_callback(result): | 1018 | def handle_callback(result): |
4384 | 1024 | messages = self.broker_service.message_store.get_pending_messages() | 1019 | messages = self.broker_service.message_store.get_pending_messages() |
4386 | 1025 | self.assertEquals(len(messages), 3) | 1020 | self.assertEqual(len(messages), 3) |
4387 | 1026 | # Ignore the message created when the initial snapshot was | 1021 | # Ignore the message created when the initial snapshot was |
4388 | 1027 | # taken before the operation was performed. | 1022 | # taken before the operation was performed. |
4397 | 1028 | self.assertMessages([messages[2], messages[1]], | 1023 | expected = [{"type": "users", "timestamp": 0, |
4398 | 1029 | [{"type": "users", "timestamp": 0, | 1024 | "operation-id": 123, |
4399 | 1030 | "operation-id": 123, | 1025 | "create-group-members": {"bizdev": ["jdoe"]}}, |
4400 | 1031 | "create-group-members": {"bizdev": ["jdoe"]}}, | 1026 | {"type": "operation-result", "timestamp": 0, |
4401 | 1032 | {"type": "operation-result", "timestamp": 0, | 1027 | "status": SUCCEEDED, "operation-id": 123, |
4402 | 1033 | "status": SUCCEEDED, "operation-id": 123, | 1028 | "result-text": "add_group_member succeeded"}] |
4403 | 1034 | "result-text": "add_group_member succeeded"}]) | 1029 | self.assertMessages([messages[2], messages[1]], expected) |
4396 | 1035 | |||
4404 | 1036 | 1030 | ||
4405 | 1037 | users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/bin/sh", | 1031 | users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/bin/sh", |
4406 | 1038 | "/home/jdoe")] | 1032 | "/home/jdoe")] |
4407 | @@ -1065,7 +1059,7 @@ | |||
4408 | 1065 | def handle_callback2(result, messages): | 1059 | def handle_callback2(result, messages): |
4409 | 1066 | message_store = self.broker_service.message_store | 1060 | message_store = self.broker_service.message_store |
4410 | 1067 | new_messages = message_store.get_pending_messages() | 1061 | new_messages = message_store.get_pending_messages() |
4412 | 1068 | self.assertEquals(messages, new_messages) | 1062 | self.assertEqual(messages, new_messages) |
4413 | 1069 | 1063 | ||
4414 | 1070 | users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/bin/sh", | 1064 | users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/bin/sh", |
4415 | 1071 | "/home/jdoe")] | 1065 | "/home/jdoe")] |
4416 | @@ -1090,21 +1084,21 @@ | |||
4417 | 1090 | 1084 | ||
4418 | 1091 | def handle_callback(result): | 1085 | def handle_callback(result): |
4419 | 1092 | messages = self.broker_service.message_store.get_pending_messages() | 1086 | messages = self.broker_service.message_store.get_pending_messages() |
4435 | 1093 | self.assertEquals(len(messages), 3) | 1087 | self.assertEqual(len(messages), 3) |
4436 | 1094 | self.assertMessages([messages[0], messages[2]], | 1088 | expected = [{"type": "users", |
4437 | 1095 | [{"type": "users", | 1089 | "create-users": [{"home-phone": None, |
4438 | 1096 | "create-users": [{"home-phone": None, | 1090 | "username": "jdoe", |
4439 | 1097 | "username": "jdoe", | 1091 | "uid": 1000, |
4440 | 1098 | "uid": 1000, | 1092 | "enabled": True, |
4441 | 1099 | "enabled": True, | 1093 | "location": None, |
4442 | 1100 | "location": None, | 1094 | "work-phone": None, |
4443 | 1101 | "work-phone": None, | 1095 | "primary-gid": 1000, |
4444 | 1102 | "primary-gid": 1000, | 1096 | "name": "John Doe"}], |
4445 | 1103 | "name": "John Doe"}], | 1097 | "create-groups": [{"gid": 1001, |
4446 | 1104 | "create-groups": [{"gid": 1001, | 1098 | "name": "bizdev"}]}, |
4447 | 1105 | "name": "bizdev"}]}, | 1099 | {"type": "users", "operation-id": 123, |
4448 | 1106 | {"type": "users", "operation-id": 123, | 1100 | "create-group-members": {"bizdev": ["jdoe"]}}] |
4449 | 1107 | "create-group-members": {"bizdev": ["jdoe"]}}]) | 1101 | self.assertMessages([messages[0], messages[2]], expected) |
4450 | 1108 | 1102 | ||
4451 | 1109 | users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/bin/sh", | 1103 | users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/bin/sh", |
4452 | 1110 | "/home/jdoe")] | 1104 | "/home/jdoe")] |
4453 | @@ -1129,9 +1123,10 @@ | |||
4454 | 1129 | 1123 | ||
4455 | 1130 | def handle_callback(result): | 1124 | def handle_callback(result): |
4456 | 1131 | messages = self.broker_service.message_store.get_pending_messages() | 1125 | messages = self.broker_service.message_store.get_pending_messages() |
4458 | 1132 | self.assertEquals(len(messages), 3) | 1126 | self.assertEqual(len(messages), 3) |
4459 | 1133 | # Ignore the message created by plugin.run. | 1127 | # Ignore the message created by plugin.run. |
4461 | 1134 | self.assertMessages([messages[2], messages[1]], | 1128 | self.assertMessages( |
4462 | 1129 | [messages[2], messages[1]], | ||
4463 | 1135 | [{"type": "users", "timestamp": 0, | 1130 | [{"type": "users", "timestamp": 0, |
4464 | 1136 | "operation-id": 123, | 1131 | "operation-id": 123, |
4465 | 1137 | "delete-group-members": {"bizdev": ["jdoe"]}}, | 1132 | "delete-group-members": {"bizdev": ["jdoe"]}}, |
4466 | @@ -1140,7 +1135,6 @@ | |||
4467 | 1140 | "operation-id": 123, "timestamp": 0, | 1135 | "operation-id": 123, "timestamp": 0, |
4468 | 1141 | "result-text": "remove_group_member succeeded"}]) | 1136 | "result-text": "remove_group_member succeeded"}]) |
4469 | 1142 | 1137 | ||
4470 | 1143 | |||
4471 | 1144 | users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/bin/sh", | 1138 | users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/bin/sh", |
4472 | 1145 | "/home/jdoe")] | 1139 | "/home/jdoe")] |
4473 | 1146 | groups = [("bizdev", "x", 1001, ["jdoe"])] | 1140 | groups = [("bizdev", "x", 1001, ["jdoe"])] |
4474 | @@ -1169,7 +1163,7 @@ | |||
4475 | 1169 | def handle_callback2(result, messages): | 1163 | def handle_callback2(result, messages): |
4476 | 1170 | message_store = self.broker_service.message_store | 1164 | message_store = self.broker_service.message_store |
4477 | 1171 | new_messages = message_store.get_pending_messages() | 1165 | new_messages = message_store.get_pending_messages() |
4479 | 1172 | self.assertEquals(messages, new_messages) | 1166 | self.assertEqual(messages, new_messages) |
4480 | 1173 | 1167 | ||
4481 | 1174 | users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/bin/sh", | 1168 | users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/bin/sh", |
4482 | 1175 | "/home/jdoe")] | 1169 | "/home/jdoe")] |
4483 | @@ -1193,22 +1187,22 @@ | |||
4484 | 1193 | 1187 | ||
4485 | 1194 | def handle_callback(result): | 1188 | def handle_callback(result): |
4486 | 1195 | messages = self.broker_service.message_store.get_pending_messages() | 1189 | messages = self.broker_service.message_store.get_pending_messages() |
4503 | 1196 | self.assertEquals(len(messages), 3) | 1190 | self.assertEqual(len(messages), 3) |
4504 | 1197 | self.assertMessages([messages[0], messages[2]], | 1191 | expected = [{"timestamp": 0, "type": "users", |
4505 | 1198 | [{"timestamp": 0, "type": "users", | 1192 | "create-users": [{"home-phone": None, |
4506 | 1199 | "create-users": [{"home-phone": None, | 1193 | "username": "jdoe", |
4507 | 1200 | "username": "jdoe", | 1194 | "uid": 1000, |
4508 | 1201 | "uid": 1000, | 1195 | "enabled": True, |
4509 | 1202 | "enabled": True, | 1196 | "location": None, |
4510 | 1203 | "location": None, | 1197 | "work-phone": None, |
4511 | 1204 | "work-phone": None, | 1198 | "primary-gid": 1000, |
4512 | 1205 | "primary-gid": 1000, | 1199 | "name": "John Doe"}], |
4513 | 1206 | "name": "John Doe"}], | 1200 | "create-groups": [{"gid": 1001, |
4514 | 1207 | "create-groups": [{"gid": 1001, | 1201 | "name": "bizdev"}], |
4515 | 1208 | "name": "bizdev"}], | 1202 | "create-group-members": {"bizdev": ["jdoe"]}}, |
4516 | 1209 | "create-group-members": {"bizdev": ["jdoe"]}}, | 1203 | {"type": "users", "operation-id": 123, |
4517 | 1210 | {"type": "users", "operation-id": 123, | 1204 | "delete-group-members": {"bizdev": ["jdoe"]}}] |
4518 | 1211 | "delete-group-members": {"bizdev": ["jdoe"]}}]) | 1205 | self.assertMessages([messages[0], messages[2]], expected) |
4519 | 1212 | 1206 | ||
4520 | 1213 | users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/bin/sh", | 1207 | users = [("jdoe", "x", 1000, 1000, "John Doe,,,,", "/bin/sh", |
4521 | 1214 | "/home/jdoe")] | 1208 | "/home/jdoe")] |
4522 | @@ -1232,7 +1226,6 @@ | |||
4523 | 1232 | """ | 1226 | """ |
4524 | 1233 | 1227 | ||
4525 | 1234 | def handle_callback1(result): | 1228 | def handle_callback1(result): |
4526 | 1235 | |||
4527 | 1236 | result = self.manager.dispatch_message( | 1229 | result = self.manager.dispatch_message( |
4528 | 1237 | {"groupname": "sales", "type": "remove-group", | 1230 | {"groupname": "sales", "type": "remove-group", |
4529 | 1238 | "operation-id": 123}) | 1231 | "operation-id": 123}) |
4530 | @@ -1243,7 +1236,7 @@ | |||
4531 | 1243 | def handle_callback2(result): | 1236 | def handle_callback2(result): |
4532 | 1244 | message_store = self.broker_service.message_store | 1237 | message_store = self.broker_service.message_store |
4533 | 1245 | messages = message_store.get_pending_messages() | 1238 | messages = message_store.get_pending_messages() |
4535 | 1246 | self.assertEquals(len(messages), 3) | 1239 | self.assertEqual(len(messages), 3) |
4536 | 1247 | # Ignore the message created when the initial snapshot was | 1240 | # Ignore the message created when the initial snapshot was |
4537 | 1248 | # taken before the operation was performed. | 1241 | # taken before the operation was performed. |
4538 | 1249 | self.assertMessages([messages[2], messages[1]], | 1242 | self.assertMessages([messages[2], messages[1]], |
4539 | @@ -1280,7 +1273,7 @@ | |||
4540 | 1280 | def handle_callback2(result, messages): | 1273 | def handle_callback2(result, messages): |
4541 | 1281 | message_store = self.broker_service.message_store | 1274 | message_store = self.broker_service.message_store |
4542 | 1282 | new_messages = message_store.get_pending_messages() | 1275 | new_messages = message_store.get_pending_messages() |
4544 | 1283 | self.assertEquals(messages, new_messages) | 1276 | self.assertEqual(messages, new_messages) |
4545 | 1284 | 1277 | ||
4546 | 1285 | groups = [("sales", "x", 50, [])] | 1278 | groups = [("sales", "x", 50, [])] |
4547 | 1286 | plugin = self.setup_environment([], groups, None) | 1279 | plugin = self.setup_environment([], groups, None) |
4548 | @@ -1310,7 +1303,7 @@ | |||
4549 | 1310 | def handle_callback2(result): | 1303 | def handle_callback2(result): |
4550 | 1311 | message_store = self.broker_service.message_store | 1304 | message_store = self.broker_service.message_store |
4551 | 1312 | messages = message_store.get_pending_messages() | 1305 | messages = message_store.get_pending_messages() |
4553 | 1313 | self.assertEquals(len(messages), 3) | 1306 | self.assertEqual(len(messages), 3) |
4554 | 1314 | self.assertMessages([messages[0], messages[2]], | 1307 | self.assertMessages([messages[0], messages[2]], |
4555 | 1315 | [{"type": "users", | 1308 | [{"type": "users", |
4556 | 1316 | "create-groups": [{"gid": 1001, | 1309 | "create-groups": [{"gid": 1001, |
4557 | @@ -1343,7 +1336,7 @@ | |||
4558 | 1343 | "psmith:!:13348:0:99999:7:::\n" | 1336 | "psmith:!:13348:0:99999:7:::\n" |
4559 | 1344 | "yo:$1$q7sz09uw$q.A3526M/SHu8vUb.Jo1A/:13349:0:99999:7:::\n") | 1337 | "yo:$1$q7sz09uw$q.A3526M/SHu8vUb.Jo1A/:13349:0:99999:7:::\n") |
4560 | 1345 | fd.close() | 1338 | fd.close() |
4562 | 1346 | self.assertEquals(self.user_manager.get_locked_usernames(), ["psmith"]) | 1339 | self.assertEqual(self.user_manager.get_locked_usernames(), ["psmith"]) |
4563 | 1347 | 1340 | ||
4564 | 1348 | def test_get_locked_usernames_with_empty_shadow_file(self): | 1341 | def test_get_locked_usernames_with_empty_shadow_file(self): |
4565 | 1349 | """ | 1342 | """ |
4566 | @@ -1353,7 +1346,7 @@ | |||
4567 | 1353 | fd = open(self.shadow_file, "w") | 1346 | fd = open(self.shadow_file, "w") |
4568 | 1354 | fd.write("\n") | 1347 | fd.write("\n") |
4569 | 1355 | fd.close() | 1348 | fd.close() |
4571 | 1356 | self.assertEquals(self.user_manager.get_locked_usernames(), []) | 1349 | self.assertEqual(self.user_manager.get_locked_usernames(), []) |
4572 | 1357 | 1350 | ||
4573 | 1358 | def test_get_locked_usernames_with_non_existing_shadow_file(self): | 1351 | def test_get_locked_usernames_with_non_existing_shadow_file(self): |
4574 | 1359 | """ | 1352 | """ |
4575 | @@ -1362,7 +1355,7 @@ | |||
4576 | 1362 | """ | 1355 | """ |
4577 | 1363 | self.log_helper.ignore_errors("Error reading shadow file.*") | 1356 | self.log_helper.ignore_errors("Error reading shadow file.*") |
4578 | 1364 | self.assertFalse(os.path.exists(self.shadow_file)) | 1357 | self.assertFalse(os.path.exists(self.shadow_file)) |
4580 | 1365 | self.assertEquals(self.user_manager.get_locked_usernames(), []) | 1358 | self.assertEqual(self.user_manager.get_locked_usernames(), []) |
4581 | 1366 | self.assertIn("Error reading shadow file. [Errno 2] No such file or " | 1359 | self.assertIn("Error reading shadow file. [Errno 2] No such file or " |
4582 | 1367 | "directory", self.logfile.getvalue()) | 1360 | "directory", self.logfile.getvalue()) |
4583 | 1368 | 1361 | ||
4584 | 1369 | 1362 | ||
4585 | === modified file 'landscape/monitor/tests/test_activeprocessinfo.py' | |||
4586 | --- landscape/monitor/tests/test_activeprocessinfo.py 2010-04-09 14:43:09 +0000 | |||
4587 | +++ landscape/monitor/tests/test_activeprocessinfo.py 2011-07-06 21:14:28 +0000 | |||
4588 | @@ -36,9 +36,9 @@ | |||
4589 | 36 | self.monitor.add(plugin) | 36 | self.monitor.add(plugin) |
4590 | 37 | plugin.exchange() | 37 | plugin.exchange() |
4591 | 38 | message = self.mstore.get_pending_messages()[0] | 38 | message = self.mstore.get_pending_messages()[0] |
4593 | 39 | self.assertEquals(message["type"], "active-process-info") | 39 | self.assertEqual(message["type"], "active-process-info") |
4594 | 40 | self.assertTrue("kill-all-processes" in message) | 40 | self.assertTrue("kill-all-processes" in message) |
4596 | 41 | self.assertEquals(message["kill-all-processes"], True) | 41 | self.assertEqual(message["kill-all-processes"], True) |
4597 | 42 | self.assertTrue("add-processes" in message) | 42 | self.assertTrue("add-processes" in message) |
4598 | 43 | 43 | ||
4599 | 44 | def test_only_first_run_includes_kill_message(self): | 44 | def test_only_first_run_includes_kill_message(self): |
4600 | @@ -56,14 +56,14 @@ | |||
4601 | 56 | process_name="blargh") | 56 | process_name="blargh") |
4602 | 57 | self.monitor.exchange() | 57 | self.monitor.exchange() |
4603 | 58 | messages = self.mstore.get_pending_messages() | 58 | messages = self.mstore.get_pending_messages() |
4605 | 59 | self.assertEquals(len(messages), 2) | 59 | self.assertEqual(len(messages), 2) |
4606 | 60 | message = messages[0] | 60 | message = messages[0] |
4608 | 61 | self.assertEquals(message["type"], "active-process-info") | 61 | self.assertEqual(message["type"], "active-process-info") |
4609 | 62 | self.assertTrue("kill-all-processes" in message) | 62 | self.assertTrue("kill-all-processes" in message) |
4610 | 63 | self.assertTrue("add-processes" in message) | 63 | self.assertTrue("add-processes" in message) |
4611 | 64 | 64 | ||
4612 | 65 | message = messages[1] | 65 | message = messages[1] |
4614 | 66 | self.assertEquals(message["type"], "active-process-info") | 66 | self.assertEqual(message["type"], "active-process-info") |
4615 | 67 | self.assertTrue("add-processes" in message) | 67 | self.assertTrue("add-processes" in message) |
4616 | 68 | 68 | ||
4617 | 69 | def test_terminating_process_race(self): | 69 | def test_terminating_process_race(self): |
4618 | @@ -113,7 +113,7 @@ | |||
4619 | 113 | self.monitor.add(plugin) | 113 | self.monitor.add(plugin) |
4620 | 114 | plugin.exchange() | 114 | plugin.exchange() |
4621 | 115 | message = self.mstore.get_pending_messages()[0] | 115 | message = self.mstore.get_pending_messages()[0] |
4623 | 116 | self.assertEquals(message["type"], "active-process-info") | 116 | self.assertEqual(message["type"], "active-process-info") |
4624 | 117 | self.assertTrue("kill-all-processes" in message) | 117 | self.assertTrue("kill-all-processes" in message) |
4625 | 118 | self.assertTrue("add-processes" in message) | 118 | self.assertTrue("add-processes" in message) |
4626 | 119 | expected_process_0 = {"state": "R", "gid": 0, "pid": 1, | 119 | expected_process_0 = {"state": "R", "gid": 0, "pid": 1, |
4627 | @@ -127,8 +127,8 @@ | |||
4628 | 127 | "start-time": 112, "percent-cpu": 0.0} | 127 | "start-time": 112, "percent-cpu": 0.0} |
4629 | 128 | processes = message["add-processes"] | 128 | processes = message["add-processes"] |
4630 | 129 | processes.sort(key=operator.itemgetter("pid")) | 129 | processes.sort(key=operator.itemgetter("pid")) |
4633 | 130 | self.assertEquals(processes, [expected_process_0, expected_process_1, | 130 | self.assertEqual(processes, [expected_process_0, expected_process_1, |
4634 | 131 | expected_process_2]) | 131 | expected_process_2]) |
4635 | 132 | 132 | ||
4636 | 133 | def test_skip_non_numeric_subdirs(self): | 133 | def test_skip_non_numeric_subdirs(self): |
4637 | 134 | """Test ensures the plugin doesn't touch non-process dirs in /proc.""" | 134 | """Test ensures the plugin doesn't touch non-process dirs in /proc.""" |
4638 | @@ -144,14 +144,14 @@ | |||
4639 | 144 | self.monitor.add(plugin) | 144 | self.monitor.add(plugin) |
4640 | 145 | plugin.exchange() | 145 | plugin.exchange() |
4641 | 146 | message = self.mstore.get_pending_messages()[0] | 146 | message = self.mstore.get_pending_messages()[0] |
4643 | 147 | self.assertEquals(message["type"], "active-process-info") | 147 | self.assertEqual(message["type"], "active-process-info") |
4644 | 148 | self.assertTrue("kill-all-processes" in message) | 148 | self.assertTrue("kill-all-processes" in message) |
4645 | 149 | self.assertTrue("add-processes" in message) | 149 | self.assertTrue("add-processes" in message) |
4646 | 150 | 150 | ||
4647 | 151 | expected_process = {"pid": 1, "state": "R", "name": "init", | 151 | expected_process = {"pid": 1, "state": "R", "name": "init", |
4648 | 152 | "vm-size": 11676, "uid": 0, "gid": 0, | 152 | "vm-size": 11676, "uid": 0, "gid": 0, |
4649 | 153 | "start-time": 112, "percent-cpu": 0.0} | 153 | "start-time": 112, "percent-cpu": 0.0} |
4651 | 154 | self.assertEquals(message["add-processes"], [expected_process]) | 154 | self.assertEqual(message["add-processes"], [expected_process]) |
4652 | 155 | 155 | ||
4653 | 156 | def test_plugin_manager(self): | 156 | def test_plugin_manager(self): |
4654 | 157 | """Test plugin manager integration.""" | 157 | """Test plugin manager integration.""" |
4655 | @@ -196,48 +196,48 @@ | |||
4656 | 196 | 196 | ||
4657 | 197 | plugin.exchange() | 197 | plugin.exchange() |
4658 | 198 | messages = self.mstore.get_pending_messages() | 198 | messages = self.mstore.get_pending_messages() |
4660 | 199 | self.assertEquals(len(messages), 2) | 199 | self.assertEqual(len(messages), 2) |
4661 | 200 | 200 | ||
4662 | 201 | # The first time the plugin runs we expect all known processes | 201 | # The first time the plugin runs we expect all known processes |
4663 | 202 | # to be killed. | 202 | # to be killed. |
4664 | 203 | message = messages[0] | 203 | message = messages[0] |
4666 | 204 | self.assertEquals(message["type"], "active-process-info") | 204 | self.assertEqual(message["type"], "active-process-info") |
4667 | 205 | self.assertTrue("kill-all-processes" in message) | 205 | self.assertTrue("kill-all-processes" in message) |
4669 | 206 | self.assertEquals(message["kill-all-processes"], True) | 206 | self.assertEqual(message["kill-all-processes"], True) |
4670 | 207 | self.assertTrue("add-processes" in message) | 207 | self.assertTrue("add-processes" in message) |
4671 | 208 | expected_process_0 = {"state": "R", "gid": 0, "pid": 1, | 208 | expected_process_0 = {"state": "R", "gid": 0, "pid": 1, |
4673 | 209 | "vm-size": 11676, "name": "init", | 209 | "vm-size": 11676, "name": "init", |
4674 | 210 | "uid": 0, "start-time": 101, | 210 | "uid": 0, "start-time": 101, |
4675 | 211 | "percent-cpu": 0.0} | 211 | "percent-cpu": 0.0} |
4676 | 212 | expected_process_1 = {"state": "T", "gid": 1000, "pid": 671, | 212 | expected_process_1 = {"state": "T", "gid": 1000, "pid": 671, |
4678 | 213 | "vm-size": 11676, "name": "blargh", | 213 | "vm-size": 11676, "name": "blargh", |
4679 | 214 | "uid": 1000, "start-time": 102, | 214 | "uid": 1000, "start-time": 102, |
4680 | 215 | "percent-cpu": 0.0} | 215 | "percent-cpu": 0.0} |
4681 | 216 | expected_process_2 = {"state": "I", "gid": 1000, "pid": 672, | 216 | expected_process_2 = {"state": "I", "gid": 1000, "pid": 672, |
4683 | 217 | "vm-size": 11676, "name": "blarpy", | 217 | "vm-size": 11676, "name": "blarpy", |
4684 | 218 | "uid": 1000, "start-time": 104, | 218 | "uid": 1000, "start-time": 104, |
4685 | 219 | "percent-cpu": 0.0} | 219 | "percent-cpu": 0.0} |
4686 | 220 | processes = message["add-processes"] | 220 | processes = message["add-processes"] |
4687 | 221 | processes.sort(key=operator.itemgetter("pid")) | 221 | processes.sort(key=operator.itemgetter("pid")) |
4690 | 222 | self.assertEquals(processes, [expected_process_0, expected_process_1, | 222 | self.assertEqual(processes, [expected_process_0, expected_process_1, |
4691 | 223 | expected_process_2]) | 223 | expected_process_2]) |
4692 | 224 | 224 | ||
4693 | 225 | # Report diff-like changes to processes, such as terminated | 225 | # Report diff-like changes to processes, such as terminated |
4694 | 226 | # processes and new processes. | 226 | # processes and new processes. |
4695 | 227 | message = messages[1] | 227 | message = messages[1] |
4697 | 228 | self.assertEquals(message["type"], "active-process-info") | 228 | self.assertEqual(message["type"], "active-process-info") |
4698 | 229 | 229 | ||
4699 | 230 | self.assertTrue("add-processes" in message) | 230 | self.assertTrue("add-processes" in message) |
4701 | 231 | self.assertEquals(len(message["add-processes"]), 1) | 231 | self.assertEqual(len(message["add-processes"]), 1) |
4702 | 232 | expected_process = {"state": "R", "gid": 0, "pid": 12753, | 232 | expected_process = {"state": "R", "gid": 0, "pid": 12753, |
4703 | 233 | "vm-size": 11676, "name": "wubble", | 233 | "vm-size": 11676, "name": "wubble", |
4704 | 234 | "uid": 0, "start-time": 107, | 234 | "uid": 0, "start-time": 107, |
4705 | 235 | "percent-cpu": 0.0} | 235 | "percent-cpu": 0.0} |
4707 | 236 | self.assertEquals(message["add-processes"], [expected_process]) | 236 | self.assertEqual(message["add-processes"], [expected_process]) |
4708 | 237 | 237 | ||
4709 | 238 | self.assertTrue("kill-processes" in message) | 238 | self.assertTrue("kill-processes" in message) |
4712 | 239 | self.assertEquals(len(message["kill-processes"]), 1) | 239 | self.assertEqual(len(message["kill-processes"]), 1) |
4713 | 240 | self.assertEquals(message["kill-processes"], [671]) | 240 | self.assertEqual(message["kill-processes"], [671]) |
4714 | 241 | 241 | ||
4715 | 242 | def test_only_queue_message_when_process_data_is_available(self): | 242 | def test_only_queue_message_when_process_data_is_available(self): |
4716 | 243 | """Test ensures that messages are only queued when data changes.""" | 243 | """Test ensures that messages are only queued when data changes.""" |
4717 | @@ -249,10 +249,10 @@ | |||
4718 | 249 | self.monitor.add(plugin) | 249 | self.monitor.add(plugin) |
4719 | 250 | 250 | ||
4720 | 251 | plugin.exchange() | 251 | plugin.exchange() |
4722 | 252 | self.assertEquals(len(self.mstore.get_pending_messages()), 1) | 252 | self.assertEqual(len(self.mstore.get_pending_messages()), 1) |
4723 | 253 | 253 | ||
4724 | 254 | plugin.exchange() | 254 | plugin.exchange() |
4726 | 255 | self.assertEquals(len(self.mstore.get_pending_messages()), 1) | 255 | self.assertEqual(len(self.mstore.get_pending_messages()), 1) |
4727 | 256 | 256 | ||
4728 | 257 | def test_only_report_active_processes(self): | 257 | def test_only_report_active_processes(self): |
4729 | 258 | """Test ensures the plugin only reports active processes.""" | 258 | """Test ensures the plugin only reports active processes.""" |
4730 | @@ -283,7 +283,7 @@ | |||
4731 | 283 | 283 | ||
4732 | 284 | plugin.exchange() | 284 | plugin.exchange() |
4733 | 285 | messages = self.mstore.get_pending_messages() | 285 | messages = self.mstore.get_pending_messages() |
4735 | 286 | self.assertEquals(len(messages), 1) | 286 | self.assertEqual(len(messages), 1) |
4736 | 287 | 287 | ||
4737 | 288 | message = messages[0] | 288 | message = messages[0] |
4738 | 289 | self.assertTrue("kill-all-processes" in message) | 289 | self.assertTrue("kill-all-processes" in message) |
4739 | @@ -292,7 +292,7 @@ | |||
4740 | 292 | 292 | ||
4741 | 293 | pids = [process["pid"] for process in message["add-processes"]] | 293 | pids = [process["pid"] for process in message["add-processes"]] |
4742 | 294 | pids.sort() | 294 | pids.sort() |
4744 | 295 | self.assertEquals(pids, [673, 674, 675, 676, 677, 678]) | 295 | self.assertEqual(pids, [673, 674, 675, 676, 677, 678]) |
4745 | 296 | 296 | ||
4746 | 297 | def test_report_interesting_state_changes(self): | 297 | def test_report_interesting_state_changes(self): |
4747 | 298 | """Test ensures that interesting state changes are reported.""" | 298 | """Test ensures that interesting state changes are reported.""" |
4748 | @@ -307,14 +307,14 @@ | |||
4749 | 307 | plugin.exchange() | 307 | plugin.exchange() |
4750 | 308 | 308 | ||
4751 | 309 | messages = self.mstore.get_pending_messages() | 309 | messages = self.mstore.get_pending_messages() |
4753 | 310 | self.assertEquals(len(messages), 1) | 310 | self.assertEqual(len(messages), 1) |
4754 | 311 | message = messages[0] | 311 | message = messages[0] |
4755 | 312 | 312 | ||
4756 | 313 | self.assertTrue("kill-all-processes" in message) | 313 | self.assertTrue("kill-all-processes" in message) |
4757 | 314 | self.assertTrue("kill-processes" not in message) | 314 | self.assertTrue("kill-processes" not in message) |
4758 | 315 | self.assertTrue("add-processes" in message) | 315 | self.assertTrue("add-processes" in message) |
4761 | 316 | self.assertEquals(message["add-processes"][0]["pid"], 672) | 316 | self.assertEqual(message["add-processes"][0]["pid"], 672) |
4762 | 317 | self.assertEquals(message["add-processes"][0]["state"], u"R") | 317 | self.assertEqual(message["add-processes"][0]["state"], u"R") |
4763 | 318 | 318 | ||
4764 | 319 | # Convert the process to a zombie and ensure it gets reported. | 319 | # Convert the process to a zombie and ensure it gets reported. |
4765 | 320 | self.builder.remove_data(672) | 320 | self.builder.remove_data(672) |
4766 | @@ -325,12 +325,12 @@ | |||
4767 | 325 | plugin.exchange() | 325 | plugin.exchange() |
4768 | 326 | 326 | ||
4769 | 327 | messages = self.mstore.get_pending_messages() | 327 | messages = self.mstore.get_pending_messages() |
4771 | 328 | self.assertEquals(len(messages), 2) | 328 | self.assertEqual(len(messages), 2) |
4772 | 329 | message = messages[1] | 329 | message = messages[1] |
4773 | 330 | 330 | ||
4774 | 331 | self.assertTrue("kill-all-processes" not in message) | 331 | self.assertTrue("kill-all-processes" not in message) |
4775 | 332 | self.assertTrue("update-processes" in message) | 332 | self.assertTrue("update-processes" in message) |
4777 | 333 | self.assertEquals(message["update-processes"][0]["state"], u"Z") | 333 | self.assertEqual(message["update-processes"][0]["state"], u"Z") |
4778 | 334 | 334 | ||
4779 | 335 | def test_call_on_accepted(self): | 335 | def test_call_on_accepted(self): |
4780 | 336 | """ | 336 | """ |
4781 | @@ -340,12 +340,12 @@ | |||
4782 | 340 | plugin = ActiveProcessInfo(proc_dir=self.sample_dir, uptime=100, | 340 | plugin = ActiveProcessInfo(proc_dir=self.sample_dir, uptime=100, |
4783 | 341 | jiffies=10) | 341 | jiffies=10) |
4784 | 342 | self.monitor.add(plugin) | 342 | self.monitor.add(plugin) |
4786 | 343 | self.assertEquals(len(self.mstore.get_pending_messages()), 0) | 343 | self.assertEqual(len(self.mstore.get_pending_messages()), 0) |
4787 | 344 | result = self.monitor.fire_event( | 344 | result = self.monitor.fire_event( |
4788 | 345 | "message-type-acceptance-changed", "active-process-info", True) | 345 | "message-type-acceptance-changed", "active-process-info", True) |
4789 | 346 | 346 | ||
4790 | 347 | def assert_messages(ignored): | 347 | def assert_messages(ignored): |
4792 | 348 | self.assertEquals(len(self.mstore.get_pending_messages()), 1) | 348 | self.assertEqual(len(self.mstore.get_pending_messages()), 1) |
4793 | 349 | 349 | ||
4794 | 350 | result.addCallback(assert_messages) | 350 | result.addCallback(assert_messages) |
4795 | 351 | return result | 351 | return result |
4796 | @@ -441,7 +441,7 @@ | |||
4797 | 441 | message = plugin.get_message() | 441 | message = plugin.get_message() |
4798 | 442 | 442 | ||
4799 | 443 | def assert_message(message_id): | 443 | def assert_message(message_id): |
4801 | 444 | self.assertEquals(message, plugin.get_message()) | 444 | self.assertEqual(message, plugin.get_message()) |
4802 | 445 | 445 | ||
4803 | 446 | result = plugin.exchange() | 446 | result = plugin.exchange() |
4804 | 447 | result.addCallback(assert_message) | 447 | result.addCallback(assert_message) |
4805 | @@ -465,7 +465,7 @@ | |||
4806 | 465 | plugin.exchange() | 465 | plugin.exchange() |
4807 | 466 | 466 | ||
4808 | 467 | messages = self.mstore.get_pending_messages() | 467 | messages = self.mstore.get_pending_messages() |
4810 | 468 | self.assertEquals(len(messages), 1) | 468 | self.assertEqual(len(messages), 1) |
4811 | 469 | 469 | ||
4812 | 470 | self.builder.remove_data(1) | 470 | self.builder.remove_data(1) |
4813 | 471 | self.builder.create_data(1, self.builder.RUNNING, uid=0, gid=0, | 471 | self.builder.create_data(1, self.builder.RUNNING, uid=0, gid=0, |
4814 | @@ -474,7 +474,7 @@ | |||
4815 | 474 | plugin.exchange() | 474 | plugin.exchange() |
4816 | 475 | 475 | ||
4817 | 476 | messages = self.mstore.get_pending_messages() | 476 | messages = self.mstore.get_pending_messages() |
4819 | 477 | self.assertEquals(len(messages), 2) | 477 | self.assertEqual(len(messages), 2) |
4820 | 478 | self.assertMessages(messages, [{"timestamp": 0, | 478 | self.assertMessages(messages, [{"timestamp": 0, |
4821 | 479 | "api": SERVER_API, | 479 | "api": SERVER_API, |
4822 | 480 | "type": "active-process-info", | 480 | "type": "active-process-info", |
4823 | @@ -534,14 +534,14 @@ | |||
4824 | 534 | self.monitor.add(plugin) | 534 | self.monitor.add(plugin) |
4825 | 535 | plugin.exchange() | 535 | plugin.exchange() |
4826 | 536 | message = self.mstore.get_pending_messages()[0] | 536 | message = self.mstore.get_pending_messages()[0] |
4828 | 537 | self.assertEquals(message["type"], "active-process-info") | 537 | self.assertEqual(message["type"], "active-process-info") |
4829 | 538 | self.assertTrue("kill-all-processes" in message) | 538 | self.assertTrue("kill-all-processes" in message) |
4830 | 539 | self.assertTrue("add-processes" in message) | 539 | self.assertTrue("add-processes" in message) |
4831 | 540 | expected_process_0 = {"state": "R", "gid": 0, "pid": 1, | 540 | expected_process_0 = {"state": "R", "gid": 0, "pid": 1, |
4832 | 541 | "vm-size": 11676, "name": "NetworkManagerDaemon", | 541 | "vm-size": 11676, "name": "NetworkManagerDaemon", |
4833 | 542 | "uid": 0, "start-time": 103, "percent-cpu": 0.0} | 542 | "uid": 0, "start-time": 103, "percent-cpu": 0.0} |
4834 | 543 | processes = message["add-processes"] | 543 | processes = message["add-processes"] |
4836 | 544 | self.assertEquals(processes, [expected_process_0]) | 544 | self.assertEqual(processes, [expected_process_0]) |
4837 | 545 | 545 | ||
4838 | 546 | def test_strip_command_line_name_whitespace(self): | 546 | def test_strip_command_line_name_whitespace(self): |
4839 | 547 | """Whitespace should be stripped from command-line names.""" | 547 | """Whitespace should be stripped from command-line names.""" |
4840 | @@ -553,8 +553,8 @@ | |||
4841 | 553 | self.monitor.add(plugin) | 553 | self.monitor.add(plugin) |
4842 | 554 | plugin.exchange() | 554 | plugin.exchange() |
4843 | 555 | message = self.mstore.get_pending_messages()[0] | 555 | message = self.mstore.get_pending_messages()[0] |
4846 | 556 | self.assertEquals(message["add-processes"][0]["name"], | 556 | self.assertEqual(message["add-processes"][0]["name"], |
4847 | 557 | u"postgres: writer process") | 557 | u"postgres: writer process") |
4848 | 558 | 558 | ||
4849 | 559 | def test_read_process_with_no_cmdline(self): | 559 | def test_read_process_with_no_cmdline(self): |
4850 | 560 | """Test reading a process without a cmdline file.""" | 560 | """Test reading a process without a cmdline file.""" |
4851 | @@ -568,14 +568,14 @@ | |||
4852 | 568 | self.monitor.add(plugin) | 568 | self.monitor.add(plugin) |
4853 | 569 | plugin.exchange() | 569 | plugin.exchange() |
4854 | 570 | message = self.mstore.get_pending_messages()[0] | 570 | message = self.mstore.get_pending_messages()[0] |
4856 | 571 | self.assertEquals(message["type"], "active-process-info") | 571 | self.assertEqual(message["type"], "active-process-info") |
4857 | 572 | self.assertTrue("kill-all-processes" in message) | 572 | self.assertTrue("kill-all-processes" in message) |
4858 | 573 | self.assertTrue("add-processes" in message) | 573 | self.assertTrue("add-processes" in message) |
4859 | 574 | expected_process_0 = {"state": "R", "gid": 0, "pid": 1, | 574 | expected_process_0 = {"state": "R", "gid": 0, "pid": 1, |
4860 | 575 | "vm-size": 11676, "name": "ProcessWithLong", | 575 | "vm-size": 11676, "name": "ProcessWithLong", |
4861 | 576 | "uid": 0, "start-time": 103, "percent-cpu": 0.0} | 576 | "uid": 0, "start-time": 103, "percent-cpu": 0.0} |
4862 | 577 | processes = message["add-processes"] | 577 | processes = message["add-processes"] |
4864 | 578 | self.assertEquals(processes, [expected_process_0]) | 578 | self.assertEqual(processes, [expected_process_0]) |
4865 | 579 | 579 | ||
4866 | 580 | def test_generate_cpu_usage(self): | 580 | def test_generate_cpu_usage(self): |
4867 | 581 | """ | 581 | """ |
4868 | @@ -596,7 +596,7 @@ | |||
4869 | 596 | self.monitor.add(plugin) | 596 | self.monitor.add(plugin) |
4870 | 597 | plugin.exchange() | 597 | plugin.exchange() |
4871 | 598 | message = self.mstore.get_pending_messages()[0] | 598 | message = self.mstore.get_pending_messages()[0] |
4873 | 599 | self.assertEquals(message["type"], "active-process-info") | 599 | self.assertEqual(message["type"], "active-process-info") |
4874 | 600 | self.assertTrue("kill-all-processes" in message) | 600 | self.assertTrue("kill-all-processes" in message) |
4875 | 601 | self.assertTrue("add-processes" in message) | 601 | self.assertTrue("add-processes" in message) |
4876 | 602 | processes = message["add-processes"] | 602 | processes = message["add-processes"] |
4877 | @@ -605,7 +605,7 @@ | |||
4878 | 605 | "uid": 0, "start-time": 300, | 605 | "uid": 0, "start-time": 300, |
4879 | 606 | "percent-cpu": 4.00} | 606 | "percent-cpu": 4.00} |
4880 | 607 | processes = message["add-processes"] | 607 | processes = message["add-processes"] |
4882 | 608 | self.assertEquals(processes, [expected_process_0]) | 608 | self.assertEqual(processes, [expected_process_0]) |
4883 | 609 | 609 | ||
4884 | 610 | def test_generate_cpu_usage_capped(self): | 610 | def test_generate_cpu_usage_capped(self): |
4885 | 611 | """ | 611 | """ |
4886 | @@ -627,7 +627,7 @@ | |||
4887 | 627 | self.monitor.add(plugin) | 627 | self.monitor.add(plugin) |
4888 | 628 | plugin.exchange() | 628 | plugin.exchange() |
4889 | 629 | message = self.mstore.get_pending_messages()[0] | 629 | message = self.mstore.get_pending_messages()[0] |
4891 | 630 | self.assertEquals(message["type"], "active-process-info") | 630 | self.assertEqual(message["type"], "active-process-info") |
4892 | 631 | self.assertTrue("kill-all-processes" in message) | 631 | self.assertTrue("kill-all-processes" in message) |
4893 | 632 | self.assertTrue("add-processes" in message) | 632 | self.assertTrue("add-processes" in message) |
4894 | 633 | processes = message["add-processes"] | 633 | processes = message["add-processes"] |
4895 | @@ -636,4 +636,4 @@ | |||
4896 | 636 | "uid": 0, "start-time": 300, | 636 | "uid": 0, "start-time": 300, |
4897 | 637 | "percent-cpu": 99.00} | 637 | "percent-cpu": 99.00} |
4898 | 638 | processes = message["add-processes"] | 638 | processes = message["add-processes"] |
4900 | 639 | self.assertEquals(processes, [expected_process_0]) | 639 | self.assertEqual(processes, [expected_process_0]) |
4901 | 640 | 640 | ||
4902 | === modified file 'landscape/monitor/tests/test_aptpreferences.py' | |||
4903 | --- landscape/monitor/tests/test_aptpreferences.py 2010-12-10 13:49:46 +0000 | |||
4904 | +++ landscape/monitor/tests/test_aptpreferences.py 2011-07-06 21:14:28 +0000 | |||
4905 | @@ -33,8 +33,8 @@ | |||
4906 | 33 | preferences_filename = os.path.join(self.etc_apt_directory, | 33 | preferences_filename = os.path.join(self.etc_apt_directory, |
4907 | 34 | "preferences") | 34 | "preferences") |
4908 | 35 | self.makeFile(path=preferences_filename, content="crap") | 35 | self.makeFile(path=preferences_filename, content="crap") |
4911 | 36 | self.assertEquals(self.plugin.get_data(), | 36 | self.assertEqual(self.plugin.get_data(), |
4912 | 37 | {preferences_filename: "crap"}) | 37 | {preferences_filename: "crap"}) |
4913 | 38 | 38 | ||
4914 | 39 | def test_get_data_with_empty_preferences_directory(self): | 39 | def test_get_data_with_empty_preferences_directory(self): |
4915 | 40 | """ | 40 | """ |
4916 | @@ -56,8 +56,8 @@ | |||
4917 | 56 | self.makeDir(path=preferences_directory) | 56 | self.makeDir(path=preferences_directory) |
4918 | 57 | filename1 = self.makeFile(dirname=preferences_directory, content="foo") | 57 | filename1 = self.makeFile(dirname=preferences_directory, content="foo") |
4919 | 58 | filename2 = self.makeFile(dirname=preferences_directory, content="bar") | 58 | filename2 = self.makeFile(dirname=preferences_directory, content="bar") |
4922 | 59 | self.assertEquals(self.plugin.get_data(), {filename1: "foo", | 59 | self.assertEqual(self.plugin.get_data(), {filename1: "foo", |
4923 | 60 | filename2: "bar"}) | 60 | filename2: "bar"}) |
4924 | 61 | 61 | ||
4925 | 62 | def test_get_data_with_one_big_file(self): | 62 | def test_get_data_with_one_big_file(self): |
4926 | 63 | """ | 63 | """ |
4927 | @@ -68,7 +68,7 @@ | |||
4928 | 68 | "preferences") | 68 | "preferences") |
4929 | 69 | limit = self.plugin.size_limit | 69 | limit = self.plugin.size_limit |
4930 | 70 | self.makeFile(path=preferences_filename, content="a" * (limit + 1)) | 70 | self.makeFile(path=preferences_filename, content="a" * (limit + 1)) |
4932 | 71 | self.assertEquals(self.plugin.get_data(), { | 71 | self.assertEqual(self.plugin.get_data(), { |
4933 | 72 | preferences_filename: "a" * (limit - len(preferences_filename))}) | 72 | preferences_filename: "a" * (limit - len(preferences_filename))}) |
4934 | 73 | 73 | ||
4935 | 74 | def test_get_data_with_many_big_files(self): | 74 | def test_get_data_with_many_big_files(self): |
4936 | @@ -84,9 +84,9 @@ | |||
4937 | 84 | content="a" * (limit / 2)) | 84 | content="a" * (limit / 2)) |
4938 | 85 | filename2 = self.makeFile(dirname=preferences_directory, | 85 | filename2 = self.makeFile(dirname=preferences_directory, |
4939 | 86 | content="b" * (limit / 2)) | 86 | content="b" * (limit / 2)) |
4943 | 87 | self.assertEquals(self.plugin.get_data(), | 87 | self.assertEqual(self.plugin.get_data(), |
4944 | 88 | {filename1: "a" * (limit / 2 - len(filename1)), | 88 | {filename1: "a" * (limit / 2 - len(filename1)), |
4945 | 89 | filename2: "b" * (limit / 2 - len(filename2))}) | 89 | filename2: "b" * (limit / 2 - len(filename2))}) |
4946 | 90 | 90 | ||
4947 | 91 | def test_exchange_without_apt_preferences_data(self): | 91 | def test_exchange_without_apt_preferences_data(self): |
4948 | 92 | """ | 92 | """ |
4949 | @@ -94,7 +94,7 @@ | |||
4950 | 94 | """ | 94 | """ |
4951 | 95 | self.mstore.set_accepted_types(["apt-preferences"]) | 95 | self.mstore.set_accepted_types(["apt-preferences"]) |
4952 | 96 | self.plugin.exchange() | 96 | self.plugin.exchange() |
4954 | 97 | self.assertEquals(self.mstore.get_pending_messages(), []) | 97 | self.assertEqual(self.mstore.get_pending_messages(), []) |
4955 | 98 | 98 | ||
4956 | 99 | def test_exchange(self): | 99 | def test_exchange(self): |
4957 | 100 | """ | 100 | """ |
4958 | @@ -113,10 +113,10 @@ | |||
4959 | 113 | content="foo") | 113 | content="foo") |
4960 | 114 | self.plugin.exchange() | 114 | self.plugin.exchange() |
4961 | 115 | messages = self.mstore.get_pending_messages() | 115 | messages = self.mstore.get_pending_messages() |
4966 | 116 | self.assertEquals(messages[0]["type"], "apt-preferences") | 116 | self.assertEqual(messages[0]["type"], "apt-preferences") |
4967 | 117 | self.assertEquals(messages[0]["data"], | 117 | self.assertEqual(messages[0]["data"], |
4968 | 118 | {main_preferences_filename: u"crap", | 118 | {main_preferences_filename: u"crap", |
4969 | 119 | sub_preferences_filename: u"foo"}) | 119 | sub_preferences_filename: u"foo"}) |
4970 | 120 | for filename in messages[0]["data"]: | 120 | for filename in messages[0]["data"]: |
4971 | 121 | self.assertTrue(isinstance(filename, unicode)) | 121 | self.assertTrue(isinstance(filename, unicode)) |
4972 | 122 | 122 | ||
4973 | @@ -125,7 +125,7 @@ | |||
4974 | 125 | os.remove(sub_preferences_filename) | 125 | os.remove(sub_preferences_filename) |
4975 | 126 | self.plugin.exchange() | 126 | self.plugin.exchange() |
4976 | 127 | messages = self.mstore.get_pending_messages() | 127 | messages = self.mstore.get_pending_messages() |
4978 | 128 | self.assertEquals(messages[1]["type"], "apt-preferences") | 128 | self.assertEqual(messages[1]["type"], "apt-preferences") |
4979 | 129 | self.assertIdentical(messages[1]["data"], None) | 129 | self.assertIdentical(messages[1]["data"], None) |
4980 | 130 | 130 | ||
4981 | 131 | def test_exchange_only_once(self): | 131 | def test_exchange_only_once(self): |
4982 | @@ -140,9 +140,9 @@ | |||
4983 | 140 | self.makeFile(path=preferences_filename, content="crap") | 140 | self.makeFile(path=preferences_filename, content="crap") |
4984 | 141 | self.plugin.exchange() | 141 | self.plugin.exchange() |
4985 | 142 | messages = self.mstore.get_pending_messages() | 142 | messages = self.mstore.get_pending_messages() |
4987 | 143 | self.assertEquals(len(messages), 1) | 143 | self.assertEqual(len(messages), 1) |
4988 | 144 | messages = self.mstore.get_pending_messages() | 144 | messages = self.mstore.get_pending_messages() |
4990 | 145 | self.assertEquals(len(messages), 1) | 145 | self.assertEqual(len(messages), 1) |
4991 | 146 | 146 | ||
4992 | 147 | def test_run(self): | 147 | def test_run(self): |
4993 | 148 | """ | 148 | """ |
4994 | @@ -174,4 +174,4 @@ | |||
4995 | 174 | self.reactor.fire("resynchronize") | 174 | self.reactor.fire("resynchronize") |
4996 | 175 | self.plugin.run() | 175 | self.plugin.run() |
4997 | 176 | messages = self.mstore.get_pending_messages() | 176 | messages = self.mstore.get_pending_messages() |
4999 | 177 | self.assertEquals(len(messages), 2) | 177 | self.assertEqual(len(messages), 2) |
5000 | 178 | 178 |
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.