Esempio n. 1
0
    def setUp(self):
        CatchLogs.setUp(self)
        self.store = _memstore.MemoryStore()

        self.consumer = self.consumer_class(self.store)

        self.fetcher = MockFetcher()
        fetchers.setDefaultFetcher(self.fetcher)
Esempio n. 2
0
    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)
Esempio n. 3
0
    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')
Esempio n. 4
0
    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')
Esempio n. 5
0
 def tearDown(self):
     fetchers.setDefaultFetcher(self.oldfetcher)
Esempio n. 6
0
 def setUp(self):
     self.oldfetcher = fetchers.getDefaultFetcher()
     fetchers.setDefaultFetcher(self.MockFetcher())
Esempio n. 7
0
 def tearDown(self):
     fetchers.setDefaultFetcher(None)
Esempio n. 8
0
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
Esempio n. 9
0
 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)
Esempio n. 10
0
 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)
Esempio n. 11
0
 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)
Esempio n. 12
0
 def tearDown(self):
     """reset the default fetcher to None"""
     fetchers.setDefaultFetcher(None)
Esempio n. 13
0
 def setUp(self):
     """reset the default fetcher to None"""
     fetchers.setDefaultFetcher(None)
Esempio n. 14
0
 def setUp(self):
     fetcher = ErrorRaisingFetcher(self.exc)
     fetchers.setDefaultFetcher(fetcher, wrap_exceptions=False)
Esempio n. 15
0
 def setUp(self):
     fetcher = SimpleMockFetcher(self.responses)
     fetchers.setDefaultFetcher(fetcher)
Esempio n. 16
0
 def setUp(self):
     self.documents = self.documents.copy()
     self.fetcher = self.fetcherClass(self.documents)
     fetchers.setDefaultFetcher(self.fetcher)