def setUp(self): CatchLogs.setUp(self) self.store = _memstore.MemoryStore() self.consumer = self.consumer_class(self.store) self.fetcher = MockFetcher() fetchers.setDefaultFetcher(self.fetcher)
def setUp(self): fetchers.setDefaultFetcher(TestFetcher(self.base_url), wrap_exceptions=False) self.input_url, self.expected = discoverdata.generateResult( self.base_url, self.input_name, self.id_name, self.result_name, self.success)
def test_error_exception(self): self.fetcher = ExceptionRaisingMockFetcher() fetchers.setDefaultFetcher(self.fetcher) self.failUnlessRaises(fetchers.HTTPFetchingError, self.consumer._makeKVPost, {'openid.mode':'associate'}, "http://server_url") # exception fetching returns no association self.failUnless(self.consumer._getAssociation('some://url') is None) self.failUnlessRaises(fetchers.HTTPFetchingError, self.consumer._checkAuth, {'openid.signed':''}, 'some://url')
def test_notWrapped(self): """Make sure that if we set a non-wrapped fetcher as default, it will not wrap exceptions.""" # A fetcher that will raise an exception when it encounters a # host that will not resolve fetcher = fetchers.Urllib2Fetcher() fetchers.setDefaultFetcher(fetcher, wrap_exceptions=False) self.failIf(isinstance(fetchers.getDefaultFetcher(), fetchers.ExceptionWrappingFetcher)) try: fetchers.fetch('http://invalid.janrain.com/') except fetchers.HTTPFetchingError: self.fail('Should not be wrapping exception') except: exc = sys.exc_info()[1] self.failUnless(isinstance(exc, urllib2.URLError), exc) pass else: self.fail('Should have raised an exception')
def tearDown(self): fetchers.setDefaultFetcher(self.oldfetcher)
def setUp(self): self.oldfetcher = fetchers.getDefaultFetcher() fetchers.setDefaultFetcher(self.MockFetcher())
def tearDown(self): fetchers.setDefaultFetcher(None)
def _test_success(server_url, user_url, delegate_url, links, immediate=False): store = _memstore.MemoryStore() if immediate: mode = 'checkid_immediate' else: mode = 'checkid_setup' endpoint = OpenIDServiceEndpoint() endpoint.identity_url = user_url endpoint.server_url = server_url endpoint.delegate = delegate_url fetcher = TestFetcher(None, None, assocs[0]) fetchers.setDefaultFetcher(fetcher, wrap_exceptions=False) def run(): trust_root = consumer_url consumer = GenericConsumer(store) request = consumer.begin(endpoint) return_to = consumer_url redirect_url = request.redirectURL(trust_root, return_to, immediate) parsed = urlparse.urlparse(redirect_url) qs = parsed[4] q = parseQuery(qs) new_return_to = q['openid.return_to'] del q['openid.return_to'] assert q == { 'openid.mode':mode, 'openid.identity':delegate_url, 'openid.trust_root':trust_root, 'openid.assoc_handle':fetcher.assoc_handle, }, (q, user_url, delegate_url, mode) assert new_return_to.startswith(return_to) assert redirect_url.startswith(server_url) query = { 'nonce':request.return_to_args['nonce'], 'openid.mode':'id_res', 'openid.return_to':new_return_to, 'openid.identity':delegate_url, 'openid.assoc_handle':fetcher.assoc_handle, } assoc = store.getAssociation(server_url, fetcher.assoc_handle) assoc.addSignature(['mode', 'return_to', 'identity'], query) info = consumer.complete(query, request.endpoint) assert info.status == SUCCESS, info.message assert info.identity_url == user_url assert fetcher.num_assocs == 0 run() assert fetcher.num_assocs == 1 # Test that doing it again uses the existing association run() assert fetcher.num_assocs == 1 # Another association is created if we remove the existing one store.removeAssociation(server_url, fetcher.assoc_handle) run() assert fetcher.num_assocs == 2 # Test that doing it again uses the existing association run() assert fetcher.num_assocs == 2
def test_callFetch(self): """Make sure that fetchers.fetch() uses the default fetcher instance that was set.""" fetchers.setDefaultFetcher(FakeFetcher()) actual = fetchers.fetch('bad://url') self.failUnless(actual is FakeFetcher.sentinel)
def test_getDefaultNotNone(self): """Make sure that None is never returned as a default fetcher""" self.failUnless(fetchers.getDefaultFetcher() is not None) fetchers.setDefaultFetcher(None) self.failUnless(fetchers.getDefaultFetcher() is not None)
def test_setDefault(self): """Make sure the getDefaultFetcher returns the object set for setDefaultFetcher""" sentinel = object() fetchers.setDefaultFetcher(sentinel, wrap_exceptions=False) self.failUnless(fetchers.getDefaultFetcher() is sentinel)
def tearDown(self): """reset the default fetcher to None""" fetchers.setDefaultFetcher(None)
def setUp(self): """reset the default fetcher to None""" fetchers.setDefaultFetcher(None)
def setUp(self): fetcher = ErrorRaisingFetcher(self.exc) fetchers.setDefaultFetcher(fetcher, wrap_exceptions=False)
def setUp(self): fetcher = SimpleMockFetcher(self.responses) fetchers.setDefaultFetcher(fetcher)
def setUp(self): self.documents = self.documents.copy() self.fetcher = self.fetcherClass(self.documents) fetchers.setDefaultFetcher(self.fetcher)