Source Code for Module ndg.xacml.test.functions.test_string_functions

  1  """NDG XACML tests for string functions 
  2   
  3  NERC DataGrid 
  4  """ 
  5  __author__ = "R B Wilkinson" 
  6  __date__ = "14/03/12" 
  7  __copyright__ = "" 
  8  __license__ = "BSD - see LICENSE file in top-level directory" 
  9  __contact__ = "Philip.Kershaw@stfc.ac.uk" 
 10  __revision__ = '$Id$' 
 11   
 12  import logging 
 13  from os import path 
 14  import unittest 
 15   
 16  from ndg.xacml.parsers.etree.factory import ReaderFactory 
 17  from ndg.xacml.core.context.pdp import PDP 
 18  from ndg.xacml.core.context.result import Decision 
 19  from ndg.xacml.test.context import XacmlContextBaseTestCase 
 20   
 21  logging.basicConfig(level=logging.DEBUG) 
 22   
 23  THIS_DIR = path.dirname(__file__) 
 24  XACML_CONCATENATE_TEST_FILEPATH = path.join(THIS_DIR, "policy_concatenate.xml") 
 25   
 26 -class Test(XacmlContextBaseTestCase): 
 27   
 28      RESOURCE1_ID = 'http://localhost/resource1' 
 29      RESOURCE2_ID = 'http://localhost/resource2' 
 30      RESOURCE3_ID = 'http://localhost/resource3' 
 31      RESOURCE4_ID = 'http://localhost/resource4' 
 32      RESOURCE5_ID = 'http://localhost/resource5' 
 33      RESOURCE6_ID = 'http://localhost/resource6' 
 34      RESOURCE7_ID = 'http://localhost/resource7' 
 35      RESOURCE8_ID = 'http://localhost/resource8' 
 36   
 37   
 38 -    def test01_01StringConcatenate2Values(self): 
 39          """Test concatenation of 2 string values resulting in permit decision. 
 40          """ 
 41          self.pdp = PDP.fromPolicySource(XACML_CONCATENATE_TEST_FILEPATH, 
 42                                          ReaderFactory) 
 43          request = self._createRequestCtx(self.__class__.RESOURCE1_ID, 
 44                                           subjectRoles=('role1',)) 
 45          response = self.pdp.evaluate(request) 
 46          self.failIf(response is None, "Null response") 
 47          for result in response.results: 
 48              self.failIf(result.decision != Decision.PERMIT, 
 49                          "Expecting Permit decision") 
 50   
 51 -    def test01_02StringConcatenate2Values(self): 
 52          """Test concatenation of 2 string values resulting in deny decision. 
 53          """ 
 54          self.pdp = PDP.fromPolicySource(XACML_CONCATENATE_TEST_FILEPATH, 
 55                                          ReaderFactory) 
 56          request = self._createRequestCtx(self.__class__.RESOURCE2_ID, 
 57                                           subjectRoles=('role1',)) 
 58          response = self.pdp.evaluate(request) 
 59          self.failIf(response is None, "Null response") 
 60          for result in response.results: 
 61              self.failIf(result.decision != Decision.DENY, 
 62                          "Expecting Deny decision") 
 63   
 64 -    def test01_03StringConcatenate4Values(self): 
 65          """Test concatenation of 4 string values resulting in permit decision. 
 66          """ 
 67          self.pdp = PDP.fromPolicySource(XACML_CONCATENATE_TEST_FILEPATH, 
 68                                          ReaderFactory) 
 69          request = self._createRequestCtx(self.__class__.RESOURCE3_ID, 
 70                                           subjectRoles=('role1',)) 
 71          response = self.pdp.evaluate(request) 
 72          self.failIf(response is None, "Null response") 
 73          for result in response.results: 
 74              self.failIf(result.decision != Decision.PERMIT, 
 75                          "Expecting Permit decision") 
 76   
 77 -    def test01_04StringConcatenate4Values(self): 
 78          """Test concatenation of 4 string values resulting in deny decision. 
 79          """ 
 80          self.pdp = PDP.fromPolicySource(XACML_CONCATENATE_TEST_FILEPATH, 
 81                                          ReaderFactory) 
 82          request = self._createRequestCtx(self.__class__.RESOURCE4_ID, 
 83                                           subjectRoles=('role1',)) 
 84          response = self.pdp.evaluate(request) 
 85          self.failIf(response is None, "Null response") 
 86          for result in response.results: 
 87              self.failIf(result.decision != Decision.DENY, 
 88                          "Expecting Deny decision") 
 89   
 90   
 91 -    def test02_01UrlStringConcatenate2Values(self): 
 92          """Test concatenation of URI and 1 string value resulting in permit 
 93          decision. 
 94          """ 
 95          self.pdp = PDP.fromPolicySource(XACML_CONCATENATE_TEST_FILEPATH, 
 96                                          ReaderFactory) 
 97          request = self._createRequestCtx(self.__class__.RESOURCE5_ID, 
 98                                           subjectRoles=('role1',)) 
 99          response = self.pdp.evaluate(request) 
100          self.failIf(response is None, "Null response") 
101          for result in response.results: 
102              self.failIf(result.decision != Decision.PERMIT, 
103                          "Expecting Permit decision") 
104   
105 -    def test02_02UrlStringConcatenate2Values(self): 
106          """Test concatenation of URI and 1 string value resulting in deny 
107          decision. 
108          """ 
109          self.pdp = PDP.fromPolicySource(XACML_CONCATENATE_TEST_FILEPATH, 
110                                          ReaderFactory) 
111          request = self._createRequestCtx(self.__class__.RESOURCE6_ID, 
112                                           subjectRoles=('role1',)) 
113          response = self.pdp.evaluate(request) 
114          self.failIf(response is None, "Null response") 
115          for result in response.results: 
116              self.failIf(result.decision != Decision.DENY, 
117                          "Expecting Deny decision") 
118   
119 -    def test02_03UrlStringConcatenate3Values(self): 
120          """Test concatenation of URI and 2 string values resulting in permit 
121          decision. 
122          """ 
123          self.pdp = PDP.fromPolicySource(XACML_CONCATENATE_TEST_FILEPATH, 
124                                          ReaderFactory) 
125          request = self._createRequestCtx(self.__class__.RESOURCE7_ID, 
126                                           subjectId='testuser1', 
127                                           subjectRoles=('role1',)) 
128          response = self.pdp.evaluate(request) 
129          self.failIf(response is None, "Null response") 
130          for result in response.results: 
131              self.failIf(result.decision != Decision.PERMIT, 
132                          "Expecting Permit decision") 
133   
134 -    def test02_04UrlStringConcatenate3Values(self): 
135          """Test concatenation of URI and 2 string values resulting in deny 
136          decision. 
137          """ 
138          self.pdp = PDP.fromPolicySource(XACML_CONCATENATE_TEST_FILEPATH, 
139                                          ReaderFactory) 
140          request = self._createRequestCtx(self.__class__.RESOURCE8_ID, 
141                                           subjectId='testuser1', 
142                                           subjectRoles=('role1',)) 
143          response = self.pdp.evaluate(request) 
144          self.failIf(response is None, "Null response") 
145          for result in response.results: 
146              self.failIf(result.decision != Decision.DENY, 
147                          "Expecting Deny decision") 
148   
149  if __name__ == "__main__": 
150      unittest.main() 
151