Changeset 6603


Ignore:
Timestamp:
22/02/10 13:51:08 (9 years ago)
Author:
pjkersha
Message:

Completed pickle support for AuthzDecision?* types.

Location:
TI12-security/trunk/ndg_security_saml/saml
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/ndg_security_saml/saml/common/__init__.py

    r6602 r6603  
    142142    def __eq__(self, version): 
    143143        """Test for equality against an input version string, tuple or list""" 
    144                  
    145         if isinstance(version, basestring): 
     144        if isinstance(version, SAMLVersion): 
     145            return str(self) == str(version) 
     146           
     147        elif isinstance(version, basestring): 
    146148            return self.__version == SAMLVersion.valueOf(version) 
     149         
    147150        elif isinstance(version, (tuple, list)): 
    148151            return self.__version == tuple(version) 
  • TI12-security/trunk/ndg_security_saml/saml/saml2/core.py

    r6602 r6603  
    385385             
    386386        return _dict 
    387  
     387   
     388    def __setstate__(self, attrDict): 
     389        '''Enable pickling''' 
     390        for attrName, val in attrDict.items(): 
     391            setattr(self, attrName, val) 
     392             
    388393    def _setValue(self, value): 
    389394        if isinstance(value, DecisionType): 
     
    414419class PermitDecisionType(DecisionType): 
    415420    """Permit authorisation Decision""" 
     421    __slots__ = () 
     422 
    416423    def __init__(self): 
    417424        super(PermitDecisionType, self).__init__(DecisionType.PERMIT_STR) 
     
    423430class DenyDecisionType(DecisionType): 
    424431    """Deny authorisation Decision""" 
     432    __slots__ = () 
     433     
    425434    def __init__(self): 
    426435        super(DenyDecisionType, self).__init__(DecisionType.DENY_STR) 
     
    432441class IndeterminateDecisionType(DecisionType): 
    433442    """Indeterminate authorisation Decision""" 
     443    __slots__ = () 
     444     
    434445    def __init__(self): 
    435446        super(IndeterminateDecisionType, self).__init__( 
     
    11051116                      SAMLConstants.SAML20_PREFIX) 
    11061117 
     1118    __slots__ = () 
     1119     
    11071120    def _getChildren(self, typeOrName=None): 
    11081121        ''' 
     
    18841897    } 
    18851898     
     1899    __slots__ = ('__namespace', '__value', '__actionTypes') 
     1900     
    18861901    def __init__(self, **kw): 
    18871902        '''Create an authorization action type 
     
    18931908        self.__namespace = Action.RWEDC_NEGATION_NS_URI 
    18941909 
    1895         #Value value 
    1896         self.__action = None        
     1910        # Action value 
     1911        self.__value = None        
    18971912     
    18981913        self.__actionTypes = Action.ACTION_TYPES 
     
    23472362        self.__assertionURI = None    
    23482363 
     2364    def __getstate__(self): 
     2365        '''Enable pickling''' 
     2366        _dict = super(AssertionURIRef, self).__getstate__() 
     2367        for attrName in AssertionURIRef.__slots__: 
     2368            # Ugly hack to allow for derived classes setting private member 
     2369            # variables 
     2370            if attrName.startswith('__'): 
     2371                attrName = "_AssertionURIRef" + attrName 
     2372                 
     2373            _dict[attrName] = getattr(self, attrName) 
     2374             
     2375        return _dict 
     2376     
    23492377    def _getAssertionURI(self): 
    23502378        return self.__assertionURI 
     
    23872415                                             namespacePrefix) 
    23882416        self.__assertionID = None 
    2389      
     2417 
     2418    def __getstate__(self): 
     2419        '''Enable pickling''' 
     2420        _dict = super(AssertionIDRef, self).__getstate__() 
     2421        for attrName in AssertionIDRef.__slots__: 
     2422            # Ugly hack to allow for derived classes setting private member 
     2423            # variables 
     2424            if attrName.startswith('__'): 
     2425                attrName = "_AssertionIDRef" + attrName 
     2426                 
     2427            _dict[attrName] = getattr(self, attrName) 
     2428             
     2429        return _dict 
     2430         
    23902431    def _getAssertionID(self): 
    23912432        '''Gets the ID of the assertion this references. 
     
    24832524        # Assertion of the Evidence.  
    24842525        self.__values = TypedList(Evidentiary)  
    2485          
     2526 
     2527    def __getstate__(self): 
     2528        '''Enable pickling''' 
     2529        _dict = super(Evidence, self).__getstate__() 
     2530        for attrName in Evidence.__slots__: 
     2531            # Ugly hack to allow for derived classes setting private member 
     2532            # variables 
     2533            if attrName.startswith('__'): 
     2534                attrName = "_Evidence" + attrName 
     2535                 
     2536            _dict[attrName] = getattr(self, attrName) 
     2537             
     2538        return _dict    
     2539          
    24862540    @property 
    24872541    def assertionIDReferences(self): 
     
    25932647            # variables 
    25942648            if attrName.startswith('__'): 
    2595                 attrName = "_AuthzDecisionQueryy" + attrName 
     2649                attrName = "_AuthzDecisionQuery" + attrName 
    25962650                 
    25972651            _dict[attrName] = getattr(self, attrName) 
  • TI12-security/trunk/ndg_security_saml/saml/test/test_saml.py

    r6602 r6603  
    2626                             Response, Issuer, Subject, NameID, StatusCode,  
    2727                             StatusMessage, Status, Conditions, DecisionType, 
    28                              XSStringAttributeValue, Action, 
     28                             XSStringAttributeValue, Action,  
    2929                             AuthzDecisionQuery) 
    3030 
     
    385385        print("_"*80) 
    386386         
    387     def test06CreateAuthzDecisionQuery(self): 
     387    def _createAuthzDecisionQuery(self): 
    388388        authzDecisionQuery = AuthzDecisionQuery() 
    389389 
     
    402402         
    403403        authzDecisionQuery.resource = "http://LOCALHOST:80/My Secured URI" 
     404         
     405        return authzDecisionQuery 
     406     
     407    def test06CreateAuthzDecisionQuery(self): 
     408        samlUtil = SAMLUtil() 
     409        authzDecisionQuery = samlUtil.buildAuthzDecisionQuery() 
     410         
    404411        self.assert_(":80" not in authzDecisionQuery.resource) 
    405412        self.assert_("localhost" in authzDecisionQuery.resource) 
     
    492499            authzDecisionQuery2.actions[0].namespace == Action.GHPP_NS_URI) 
    493500        self.assert_(authzDecisionQuery2.evidence is None) 
    494  
    495501 
    496502    def _createAuthzDecisionQueryResponse(self): 
     
    676682                                    ].attributes[1].attributeValues[0].value) 
    677683              
     684    def test15PickleAuthzDecisionQuery(self): 
     685        samlUtil = SAMLUtil() 
     686        query = samlUtil.buildAuthzDecisionQuery() 
    678687              
     688        jar = pickle.dumps(query) 
     689        query2 = pickle.loads(jar) 
     690         
     691        self.assert_(isinstance(query2, AuthzDecisionQuery)) 
     692        self.assert_(query.resource == query2.resource) 
     693        self.assert_(query.version == query2.version) 
     694        self.assert_(len(query2.actions) == 1) 
     695        self.assert_(query2.actions[0].value == Action.HTTP_GET_ACTION) 
     696        self.assert_(query2.actions[0].namespace == Action.GHPP_NS_URI) 
     697 
     698 
     699         
     700    def test16PickleAuthzDecisionResponse(self): 
     701        response = self._createAuthzDecisionQueryResponse() 
     702         
     703        jar = pickle.dumps(response) 
     704        response2 = pickle.loads(jar) 
     705         
     706        self.assert_(isinstance(response2, Response)) 
     707         
     708        self.assert_(len(response.assertions) == 1) 
     709        self.assert_(len(response.assertions[0].authzDecisionStatements) == 1) 
     710          
     711        self.assert_(response.assertions[0].authzDecisionStatements[0 
     712                        ].resource == response2.assertions[0 
     713                                        ].authzDecisionStatements[0].resource) 
     714         
     715        self.assert_(len(response.assertions[0].authzDecisionStatements[0 
     716                        ].actions) == 1) 
     717        self.assert_(response.assertions[0].authzDecisionStatements[0 
     718                        ].actions[0].value == response2.assertions[0 
     719                                        ].authzDecisionStatements[0 
     720                                                ].actions[0].value) 
     721         
     722        self.assert_(response2.assertions[0].authzDecisionStatements[0 
     723                        ].actions[0].namespace == Action.GHPP_NS_URI)         
     724 
     725        self.assert_(response2.assertions[0].authzDecisionStatements[0 
     726                        ].decision == DecisionType.PERMIT)         
     727         
    679728if __name__ == "__main__": 
    680729    unittest.main()         
Note: See TracChangeset for help on using the changeset viewer.