Warning: Can't synchronize with repository "(default)" (Unsupported version control system "svn": No module named svn). Look in the Trac log for more information.

Ticket #2114: repozewho-tg-2114.diff

File repozewho-tg-2114.diff, 15.7 KB (added by Gustavo, 3 years ago)

Patch to repoze.who v1.0.10

  • repoze/who/plugins/form.py

     
    7272class FormPlugin(FormPluginBase): 
    7373 
    7474    implements(IChallenger, IIdentifier) 
    75      
     75 
    7676    def __init__(self, login_form_qs, rememberer_name, formbody=None, 
    7777                 formcallable=None): 
    7878        self.login_form_qs = login_form_qs 
    … …  
    8888        query = parse_dict_querystring(environ) 
    8989        # If the extractor finds a special query string on any request, 
    9090        # it will attempt to find the values in the input body. 
    91         if query.get(self.login_form_qs):  
     91        if query.get(self.login_form_qs): 
    9292            form = parse_formvars(environ) 
    9393            from StringIO import StringIO 
    9494            # XXX we need to replace wsgi.input because we've read it 
    … …  
    115115            if location: 
    116116                headers = list(app_headers) + list(forget_headers) 
    117117                return HTTPFound(headers = headers) 
    118                  
     118 
    119119        form = self.formbody or _DEFAULT_FORM 
    120120        if self.formcallable is not None: 
    121121            form = self.formcallable(environ) 
    … …  
    131131class RedirectingFormPlugin(FormPluginBase): 
    132132 
    133133    implements(IChallenger, IIdentifier) 
    134      
     134 
    135135    def __init__(self, login_form_url, login_handler_path, logout_handler_path, 
    136136                 rememberer_name, reason_param='reason'): 
    137137        self.login_form_url = login_form_url 
    … …  
    146146    # IIdentifier 
    147147    def identify(self, environ): 
    148148        path_info = environ['PATH_INFO'] 
     149        script_path = environ.get('SCRIPT_PATH') or '/' 
    149150        query = parse_dict_querystring(environ) 
    150151 
    151152        if path_info == self.logout_handler_path: 
    152153            # we've been asked to perform a logout 
    153154            form = parse_formvars(environ) 
    154155            form.update(query) 
    155             referer = environ.get('HTTP_REFERER', '/') 
     156            referer = environ.get('HTTP_REFERER', script_path) 
    156157            came_from = form.get('came_from', referer) 
    157158            # set in environ for self.challenge() to find later 
    158159            environ['came_from'] = came_from 
    … …  
    172173                    } 
    173174            except KeyError: 
    174175                credentials = None 
    175             referer = environ.get('HTTP_REFERER', '/') 
     176            referer = environ.get('HTTP_REFERER', script_path) 
    176177            came_from = form.get('came_from', referer) 
    177178            environ['repoze.who.application'] = HTTPFound(came_from) 
    178179            return credentials 
    … …  
    189190            query_elements[self.reason_param] = reason 
    190191        url_parts[4] = urllib.urlencode(query_elements, doseq=True) 
    191192        login_form_url = urlparse.urlunparse(url_parts) 
     193        login_form_url = self._get_full_path(login_form_url, environ) 
    192194        headers = [ ('Location', login_form_url) ] 
    193195        cookies = [(h,v) for (h,v) in app_headers if h.lower() == 'set-cookie'] 
    194196        headers = headers + forget_headers + cookies 
    195197        return HTTPFound(headers=headers) 
    196198 
     199    def _get_full_path(self, path, environ): 
     200        """ 
     201        Return the full path to ``path`` by prepending the SCRIPT_PATH. 
     202 
     203        If ``path`` is a URL, do nothing. 
     204 
     205        """ 
     206        if path.startswith('/'): 
     207            path = environ.get('SCRIPT_PATH', '') + path 
     208        return path 
     209 
    197210def make_plugin(login_form_qs='__do_login', rememberer_name=None, 
    198211                form=None): 
    199212    if rememberer_name is None: 

  • repoze/who/tests.py

     
    2121                 authenticators=None, 
    2222                 challengers=None, 
    2323                 classifier=None, 
    24                  mdproviders=None,                  
     24                 mdproviders=None, 
    2525                 challenge_decider=None, 
    2626                 log_stream=None, 
    2727                 log_level=None, 
    … …  
    5353                                    log_stream, 
    5454                                    log_level=logging.DEBUG) 
    5555        return mw 
    56      
     56 
    5757    def test_accepts_logger(self): 
    5858        import logging 
    5959        logger = logging.Logger('something') 
    … …  
    437437        self.assertEqual(environ['challenged'], app2) 
    438438        self.assertEqual(identifier.forgotten, identity) 
    439439 
    440     def test_add_metadata(self):  
     440    def test_add_metadata(self): 
    441441        environ = self._makeEnviron() 
    442442        plugin1 = DummyMDProvider({'foo':'bar'}) 
    443443        plugin2 = DummyMDProvider({'fuz':'baz'}) 
    … …  
    449449        self.assertEqual(identity['foo'], 'bar') 
    450450        self.assertEqual(identity['fuz'], 'baz') 
    451451 
    452     def test_add_metadata_w_classification(self):  
     452    def test_add_metadata_w_classification(self): 
    453453        environ = self._makeEnviron() 
    454454        plugin1 = DummyMDProvider({'foo':'bar'}) 
    455455        plugin2 = DummyMDProvider({'fuz':'baz'}) 
    … …  
    461461        identity = {} 
    462462        mw.add_metadata(environ, classification, identity) 
    463463        self.assertEqual(identity['foo'], 'bar') 
    464         self.assertEqual(identity.get('fuz'), None)        
     464        self.assertEqual(identity.get('fuz'), None) 
    465465 
    466466    def test_call_remoteuser_already_set(self): 
    467467        environ = self._makeEnviron({'REMOTE_USER':'admin'}) 
    … …  
    504504        self.assertEqual(result, ['body']) 
    505505        self.assertEqual(start_response.status, '200 OK') 
    506506        self.assertEqual(start_response.headers, headers) 
    507          
     507 
    508508    def test_call_401_no_identifiers(self): 
    509509        environ = self._makeEnviron() 
    510510        headers = [('a', '1')] 
    … …  
    724724        self.assertEqual(wrapper.start_response, None) 
    725725        self.assertEqual(wrapper.headers, []) 
    726726        self.failUnless(wrapper.buffer) 
    727      
     727 
    728728    def test_finish_response(self): 
    729729        statuses = [] 
    730730        headerses = [] 
    … …  
    736736        def close(): 
    737737            closededs.append(True) 
    738738        write.close = close 
    739              
     739 
    740740        def start_response(status, headers, exc_info=None): 
    741741            statuses.append(status) 
    742742            headerses.append(headers) 
    743743            return write 
    744              
     744 
    745745        wrapper = self._makeOne(start_response) 
    746746        wrapper.status = '401 Unauthorized' 
    747747        wrapper.headers = [('a', '1')] 
    … …  
    782782            items.append(item) 
    783783        response = ''.join(items) 
    784784        self.failUnless(response.startswith('401 Unauthorized')) 
    785          
     785 
    786786    def test_identify_noauthinfo(self): 
    787787        plugin = self._makeOne('realm') 
    788788        environ = self._makeEnviron() 
    … …  
    836836        forget = plugin._get_wwwauth() 
    837837        result = plugin.challenge(environ, '401 Unauthorized', [], forget) 
    838838        self.assertEqual(result.headers, forget) 
    839          
     839 
    840840    def test_challenge_forgetheaders_omits(self): 
    841841        plugin = self._makeOne('realm') 
    842842        creds = {'login':'foo', 'password':'password'} 
    … …  
    874874        creds = {} 
    875875        result = plugin.authenticate(environ, creds) 
    876876        self.assertEqual(result, None) 
    877          
     877 
    878878    def test_authenticate_nolines(self): 
    879879        from StringIO import StringIO 
    880880        io = StringIO() 
    … …  
    883883        creds = {'login':'chrism', 'password':'pass'} 
    884884        result = plugin.authenticate(environ, creds) 
    885885        self.assertEqual(result, None) 
    886          
     886 
    887887    def test_authenticate_nousermatch(self): 
    888888        from StringIO import StringIO 
    889889        io = StringIO('nobody:foo') 
    … …  
    987987        environ = self._makeEnviron() 
    988988        result = plugin.identify(environ) 
    989989        self.assertEqual(result, None) 
    990          
     990 
    991991    def test_identify_badcookies(self): 
    992992        plugin = self._makeOne('oatmeal') 
    993993        environ = self._makeEnviron({'HTTP_COOKIE':'oatmeal=a'}) 
    … …  
    10721072            extra['QUERY_STRING'] = '__do_login=true' 
    10731073        environ = self._makeEnviron(extra) 
    10741074        return environ 
    1075      
     1075 
    10761076    def test_implements(self): 
    10771077        from zope.interface.verify import verifyClass 
    10781078        from repoze.who.interfaces import IIdentifier 
    … …  
    10861086        environ = self._makeFormEnviron() 
    10871087        result = plugin.identify(environ) 
    10881088        self.assertEqual(result, None) 
    1089          
     1089 
    10901090    def test_identify_qs_no_values(self): 
    10911091        plugin = self._makeOne() 
    10921092        environ = self._makeFormEnviron(do_login=True) 
    … …  
    10981098        environ = self._makeFormEnviron(do_login=True, login='chris') 
    10991099        result = plugin.identify(environ) 
    11001100        self.assertEqual(result, None) 
    1101      
     1101 
    11021102    def test_identify_nopassword(self): 
    11031103        plugin = self._makeOne() 
    11041104        environ = self._makeFormEnviron(do_login=True, password='password') 
    … …  
    12171217        return plugin 
    12181218 
    12191219    def _makeFormEnviron(self, login=None, password=None, came_from=None, 
    1220                          path_info='/', identifier=None): 
     1220                         path_info='/', identifier=None, script_path=''): 
    12211221        from StringIO import StringIO 
    12221222        fields = [] 
    12231223        if login: 
    … …  
    12401240                 'repoze.who.plugins': {'cookie':identifier}, 
    12411241                 'QUERY_STRING':'default=1', 
    12421242                 'PATH_INFO':path_info, 
     1243                 'SCRIPT_PATH':script_path 
    12431244                 } 
    12441245        environ = self._makeEnviron(extra) 
    12451246        return environ 
    1246      
     1247 
    12471248    def test_implements(self): 
    12481249        from zope.interface.verify import verifyClass 
    12491250        from repoze.who.interfaces import IIdentifier 
    … …  
    12581259        result = plugin.identify(environ) 
    12591260        self.assertEqual(result, None) 
    12601261        self.failIf(environ.get('repoze.who.application')) 
    1261          
     1262 
    12621263    def test_identify_via_login_handler(self): 
    12631264        plugin = self._makeOne() 
    12641265        environ = self._makeFormEnviron(path_info='/login_handler', 
    … …  
    13151316        self.assertEqual(value, 'http://foo.bar') 
    13161317        self.assertEqual(app.code, 302) 
    13171318 
     1319    def test_identify_via_login_handler_no_came_from_no_referer_spath(self): 
     1320        plugin = self._makeOne() 
     1321        environ = self._makeFormEnviron(path_info='/login_handler', 
     1322                                        script_path='/my-app', 
     1323                                        login='chris', 
     1324                                        password='password') 
     1325        plugin.identify(environ) 
     1326        app = environ['repoze.who.application'] 
     1327        self.assertEqual(app.location(), '/my-app') 
     1328 
    13181329    def test_identify_via_logout_handler(self): 
    13191330        plugin = self._makeOne() 
    13201331        environ = self._makeFormEnviron(path_info='/logout_handler', 
    … …  
    13401351        self.assertEqual(app.code, 401) 
    13411352        self.assertEqual(environ['came_from'], '/') 
    13421353 
     1354    def test_identify_via_logout_handler_no_came_from_no_referer_spath(self): 
     1355        plugin = self._makeOne() 
     1356        environ = self._makeFormEnviron(path_info='/logout_handler', 
     1357                                        script_path='/my-app', 
     1358                                        login='chris', 
     1359                                        password='password') 
     1360        plugin.identify(environ) 
     1361        app = environ['repoze.who.application'] 
     1362        self.assertEqual(environ['came_from'], '/my-app') 
     1363 
    13431364    def test_identify_via_logout_handler_no_came_from(self): 
    13441365        plugin = self._makeOne() 
    13451366        environ = self._makeFormEnviron(path_info='/logout_handler', 
    … …  
    15061527        self.assertEqual(sr.headers[2][0], 'set-cookie') 
    15071528        self.assertEqual(sr.headers[2][1], 'b') 
    15081529 
     1530    def test_challenge_with_non_root_script_path(self): 
     1531        """The script path must be taken into account while redirecting.""" 
     1532        plugin = self._makeOne(login_form_url='/login') 
     1533        environ = self._makeFormEnviron(script_path='/app', 
     1534                                        path_info='/admin') 
     1535        came_from = 'http://www.example.com/app/admin?default=1' 
     1536        environ['came_from'] = came_from 
     1537        app = plugin.challenge(environ, '401 Unauthorized', [('app', '1')], 
     1538                               [('forget', '1')]) 
     1539        from urllib import quote 
     1540        login_url = '/app/login?came_from=%s' % quote(came_from, '') 
     1541        self.assertEqual(app.location(), login_url) 
     1542 
    15091543class TestAuthTktCookiePlugin(Base): 
    15101544    def _getTargetClass(self): 
    15111545        from repoze.who.plugins.auth_tkt import AuthTktCookiePlugin 
    … …  
    15461580        environ = self._makeEnviron() 
    15471581        result = plugin.identify(environ) 
    15481582        self.assertEqual(result, None) 
    1549          
     1583 
    15501584    def test_identify_good_cookie_include_ip(self): 
    15511585        plugin = self._makeOne('secret', include_ip=True) 
    15521586        val = self._makeTicket(remote_addr='1.1.1.1') 
    … …  
    16081642        environ = self._makeEnviron({'HTTP_COOKIE':'auth_tkt=bogus'}) 
    16091643        result = plugin.identify(environ) 
    16101644        self.assertEqual(result, None) 
    1611      
     1645 
    16121646    def test_remember_creds_same(self): 
    16131647        plugin = self._makeOne('secret') 
    16141648        val = self._makeTicket(userid='userid') 
    … …  
    16421676        new_val = self._makeTicket(userid='1', userdata='userid_type:int') 
    16431677        result = plugin.remember(environ, {'repoze.who.userid':1, 
    16441678                                           'userdata':''}) 
    1645          
     1679 
    16461680        self.assertEqual(len(result), 3) 
    16471681        self.assertEqual(result[0], 
    16481682                         ('Set-Cookie', 
    … …  
    17171751        environ = self._makeEnviron({'HTTP_USER_AGENT':'WebDrive'}) 
    17181752        result = classifier(environ) 
    17191753        self.assertEqual(result, 'dav') 
    1720          
     1754 
    17211755    def test_classify_xmlpost(self): 
    17221756        classifier = self._getFUT() 
    17231757        environ = self._makeEnviron({'CONTENT_TYPE':'text/xml', 
    … …  
    17421776        iface_reg, name_reg = fn([], [], [], []) 
    17431777        self.assertEqual(iface_reg, {}) 
    17441778        self.assertEqual(name_reg, {}) 
    1745          
     1779 
    17461780    def test_brokenimpl(self): 
    17471781        fn = self._getFUT() 
    17481782        self.assertRaises(ValueError, fn, [(None, DummyApp())], [], [], []) 
    … …  
    22402274 
    22412275IDENTIFIERS_ONLY = """\ 
    22422276[identifiers] 
    2243 plugins =  
     2277plugins = 
    22442278    repoze.who.tests:DummyPlugin;klass1 
    22452279    repoze.who.tests:DummyPlugin 
    22462280""" 
    22472281 
    22482282IDENTIFIERS_WITH_PLUGINS = """\ 
    22492283[identifiers] 
    2250 plugins =  
     2284plugins = 
    22512285    foo;klass1 
    22522286    bar 
    22532287 
    … …  
    22602294 
    22612295AUTHENTICATORS_ONLY = """\ 
    22622296[authenticators] 
    2263 plugins =  
     2297plugins = 
    22642298    repoze.who.tests:DummyPlugin;klass1 
    22652299    repoze.who.tests:DummyPlugin 
    22662300""" 
    22672301 
    22682302AUTHENTICATORS_WITH_PLUGINS = """\ 
    22692303[authenticators] 
    2270 plugins =  
     2304plugins = 
    22712305    foo;klass1 
    22722306    bar 
    22732307 
    … …  
    22802314 
    22812315CHALLENGERS_ONLY = """\ 
    22822316[challengers] 
    2283 plugins =  
     2317plugins = 
    22842318    repoze.who.tests:DummyPlugin;klass1 
    22852319    repoze.who.tests:DummyPlugin 
    22862320""" 
    22872321 
    22882322CHALLENGERS_WITH_PLUGINS = """\ 
    22892323[challengers] 
    2290 plugins =  
     2324plugins = 
    22912325    foo;klass1 
    22922326    bar 
    22932327 
    … …  
    23002334 
    23012335MDPROVIDERS_ONLY = """\ 
    23022336[mdproviders] 
    2303 plugins =  
     2337plugins = 
    23042338    repoze.who.tests:DummyPlugin;klass1 
    23052339    repoze.who.tests:DummyPlugin 
    23062340""" 
    23072341 
    23082342MDPROVIDERS_WITH_PLUGINS = """\ 
    23092343[mdproviders] 
    2310 plugins =  
     2344plugins = 
    23112345    foo;klass1 
    23122346    bar 
    23132347 
    … …  
    23832417challenge_decider = repoze.who.classifiers:default_challenge_decider 
    23842418 
    23852419[identifiers] 
    2386 plugins =  
     2420plugins = 
    23872421    form;browser 
    23882422    auth_tkt 
    23892423    basicauth 
    … …  
    26062640        environ['repoze.who.identity']['password'] = 'schooled' 
    26072641        start_response(self.status, self.headers) 
    26082642        return ['body'] 
    2609      
     2643 
    26102644class DummyRequestClassifier: 
    26112645    def __call__(self, environ): 
    26122646        return 'browser' 
    … …  
    26482682class DummyAuthenticator: 
    26492683    def __init__(self, userid=None): 
    26502684        self.userid = userid 
    2651          
     2685 
    26522686    def authenticate(self, environ, credentials): 
    26532687        if self.userid is None: 
    26542688            return credentials['login'] 
    … …  
    26722706class DummyMDProvider: 
    26732707    def __init__(self, metadata=None): 
    26742708        self._metadata = metadata 
    2675          
     2709 
    26762710    def add_metadata(self, environ, identity): 
    26772711        return identity.update(self._metadata) 
    26782712