← Back to branch summary

~nataliabidart/ubuntuone-client/login-email-password-for-everyone

« back to all changes in this revision

Viewing changes to ubuntuone/platform/credentials/__init__.py

  • Committer: Natalia B. Bidart
  • Date: 2011-08-22 20:56:10 UTC
  • Revision ID: natalia.bidart@canonical.com-20110822205610-sjqs44tghpl1ds3k
Improvements to tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ubuntuone/platform/credentials/__init__.py
83
83
 
84
84
    def __init__(self):
85
85
        self._cleanup_signals = []
 
86
        self.done = None
 
87
 
 
88
    def callback_done(self):
 
89
        """Fire self.done with success."""
 
90
        self.done.callback(None)
 
91
 
 
92
    def errback_done(self, result):
 
93
        """Fire self.done with error."""
 
94
        self.done.errback(CredentialsError(result))
86
95
 
87
96
    def cleanup(self, _):
88
97
        """Disconnect all the DBus signals."""
128
137
 
129
138
        proxy = yield self.get_creds_proxy()
130
139
 
131
 
        sig = proxy.register_to_credentials_found(d.callback)
132
 
        self._cleanup_signals.append(sig)
133
 
 
134
 
        sig = proxy.register_to_credentials_not_found(lambda: d.callback({}))
135
 
        self._cleanup_signals.append(sig)
136
 
 
137
 
        sig = proxy.register_to_credentials_error(
 
140
        sig = proxy.connect_to_signal('CredentialsFound', d.callback)
 
141
        self._cleanup_signals.append(sig)
 
142
 
 
143
        sig = proxy.connect_to_signal('CredentialsNotFound',
 
144
                                      lambda: d.callback({}))
 
145
        self._cleanup_signals.append(sig)
 
146
 
 
147
        sig = proxy.connect_to_signal('CredentialsError',
138
148
            lambda error_dict: d.errback(CredentialsError(error_dict)))
139
149
        self._cleanup_signals.append(sig)
140
150
 
141
 
        done = defer.Deferred()
142
 
        proxy.find_credentials(reply_handler=lambda: done.callback(None),
143
 
            error_handler=lambda *a: done.errback(a))
 
151
        self.done = defer.Deferred()
 
152
        proxy.find_credentials(reply_handler=self.callback_done,
 
153
                               error_handler=self.errback_done)
144
154
 
145
 
        yield done
 
155
        yield self.done
146
156
 
147
157
        result = yield d
148
158
        defer.returnValue(result)
161
171
        d.addBoth(self.cleanup)
162
172
 
163
173
        proxy = yield self.get_creds_proxy()
164
 
        sig = proxy.register_to_credentials_cleared(lambda: d.callback(None))
 
174
 
 
175
        sig = proxy.connect_to_signal('CredentialsCleared',
 
176
                                      lambda: d.callback(None))
165
177
        self._cleanup_signals.append(sig)
166
178
 
167
 
        sig = proxy.register_to_credentials_error(
 
179
        sig = proxy.connect_to_signal('CredentialsError',
168
180
            lambda error_dict: d.errback(CredentialsError(error_dict)))
169
181
        self._cleanup_signals.append(sig)
170
182
 
171
 
        done = defer.Deferred()
172
 
        proxy.clear_credentials(reply_handler=lambda: done.callback(None),
173
 
            error_handler=lambda *a: done.errback(a))
 
183
        self.done = defer.Deferred()
 
184
        proxy.clear_credentials(reply_handler=self.callback_done,
 
185
                                error_handler=self.errback_done)
174
186
 
175
 
        yield done
 
187
        yield self.done
176
188
 
177
189
        yield d
178
190
 
193
205
        d.addBoth(self.cleanup)
194
206
 
195
207
        proxy = yield self.get_creds_proxy()
196
 
        sig = proxy.register_to_credentials_stored(lambda: d.callback(None))
 
208
 
 
209
        sig = proxy.connect_to_signal('CredentialsStored',
 
210
                                      lambda: d.callback(None))
197
211
        self._cleanup_signals.append(sig)
198
212
 
199
 
        sig = proxy.register_to_credentials_error(
 
213
        sig = proxy.connect_to_signal('CredentialsError',
200
214
            lambda error_dict: d.errback(CredentialsError(error_dict)))
201
215
        self._cleanup_signals.append(sig)
202
216
 
203
 
        done = defer.Deferred()
 
217
        self.done = defer.Deferred()
204
218
        proxy.store_credentials(token,
205
 
            reply_handler=lambda: done.callback(None),
206
 
            error_handler=lambda *a: done.errback(a))
 
219
            reply_handler=self.callback_done, error_handler=self.errback_done)
207
220
 
208
 
        yield done
 
221
        yield self.done
209
222
 
210
223
        yield d
211
224
 
235
248
 
236
249
        proxy = yield self.get_creds_proxy()
237
250
 
238
 
        sig = proxy.register_to_credentials_found(d.callback)
239
 
        self._cleanup_signals.append(sig)
240
 
 
241
 
        sig = proxy.register_to_authorization_denied(lambda: d.callback(None))
242
 
        self._cleanup_signals.append(sig)
243
 
 
244
 
        sig = proxy.register_to_credentials_error(
 
251
        sig = proxy.connect_to_signal('CredentialsFound', d.callback)
 
252
        self._cleanup_signals.append(sig)
 
253
 
 
254
        sig = proxy.connect_to_signal('AuthorizationDenied',
 
255
                                      lambda: d.callback(None))
 
256
        self._cleanup_signals.append(sig)
 
257
 
 
258
        sig = proxy.connect_to_signal('CredentialsError',
245
259
            lambda error_dict: d.errback(CredentialsError(error_dict)))
246
260
        self._cleanup_signals.append(sig)
247
261
 
248
 
        done = defer.Deferred()
 
262
        self.done = defer.Deferred()
249
263
        proxy.register({'window_id': str(window_id)},
250
 
            reply_handler=lambda: done.callback(None),
251
 
            error_handler=lambda *a: done.errback(a))
 
264
            reply_handler=self.callback_done, error_handler=self.errback_done)
252
265
 
253
 
        yield done
 
266
        yield self.done
254
267
 
255
268
        result = yield d
256
269
        defer.returnValue(result)
282
295
 
283
296
        proxy = yield self.get_creds_proxy()
284
297
 
285
 
        sig = proxy.register_to_credentials_found(d.callback)
286
 
        self._cleanup_signals.append(sig)
287
 
 
288
 
        sig = proxy.register_to_authorization_denied(lambda: d.callback(None))
289
 
        self._cleanup_signals.append(sig)
290
 
 
291
 
        sig = proxy.register_to_credentials_error(
 
298
        sig = proxy.connect_to_signal('CredentialsFound', d.callback)
 
299
        self._cleanup_signals.append(sig)
 
300
 
 
301
        sig = proxy.connect_to_signal('AuthorizationDenied',
 
302
                                       lambda: d.callback(None))
 
303
        self._cleanup_signals.append(sig)
 
304
 
 
305
        sig = proxy.connect_to_signal('CredentialsError',
292
306
            lambda error_dict: d.errback(CredentialsError(error_dict)))
293
307
        self._cleanup_signals.append(sig)
294
308
 
295
 
        done = defer.Deferred()
 
309
        self.done = defer.Deferred()
296
310
        proxy.login({'window_id': str(window_id)},
297
 
            reply_handler=lambda: done.callback(None),
298
 
            error_handler=lambda *a: done.errback(a))
 
311
            reply_handler=self.callback_done, error_handler=self.errback_done)
299
312
 
300
 
        yield done
 
313
        yield self.done
301
314
 
302
315
        result = yield d
303
316
        defer.returnValue(result)
320
333
 
321
334
        proxy = yield self.get_creds_proxy()
322
335
 
323
 
        sig = proxy.register_to_credentials_found(d.callback)
324
 
        self._cleanup_signals.append(sig)
325
 
 
326
 
        sig = proxy.register_to_credentials_error(
327
 
            lambda x, error_dict: d.errback(CredentialsError(error_dict)))
328
 
        self._cleanup_signals.append(sig)
329
 
 
330
 
        done = defer.Deferred()
 
336
        sig = proxy.connect_to_signal('CredentialsFound', d.callback)
 
337
        self._cleanup_signals.append(sig)
 
338
 
 
339
        sig = proxy.connect_to_signal('CredentialsError',
 
340
            lambda error_dict: d.errback(CredentialsError(error_dict)))
 
341
        self._cleanup_signals.append(sig)
 
342
 
 
343
        self.done = defer.Deferred()
331
344
        proxy.login_email_password({'email': email, 'password': password},
332
 
            reply_handler=lambda: done.callback(None),
333
 
            error_handler=lambda *a: done.errback(a))
 
345
            reply_handler=self.callback_done, error_handler=self.errback_done)
334
346
 
335
 
        yield done
 
347
        yield self.done
336
348
 
337
349
        result = yield d
338
350
        defer.returnValue(result)