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

  1  """NDG XACML tests for logical functions 
  2   
  3  NERC DataGrid 
  4  """ 
  5  __author__ = "R B Wilkinson" 
  6  __date__ = "13/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_NOTTEST_FILEPATH = path.join(THIS_DIR, "policy_not.xml") 
 25  XACML_ANDTEST_FILEPATH = path.join(THIS_DIR, "policy_and.xml") 
 26   
 27 -class Test(XacmlContextBaseTestCase): 
 28   
 29      RESOURCE1_ID = 'http://localhost/resource1' 
 30      RESOURCE2_ID = 'http://localhost/resource2' 
 31      RESOURCE3_ID = 'http://localhost/resource3' 
 32      RESOURCE4_ID = 'http://localhost/resource4' 
 33      RESOURCE5_ID = 'http://localhost/resource5' 
 34      RESOURCE6_ID = 'http://localhost/resource6' 
 35      RESOURCE7_ID = 'http://localhost/resource7' 
 36   
 37   
 38 -    def test01_01NotTrue(self): 
 39          self.pdp = PDP.fromPolicySource(XACML_NOTTEST_FILEPATH, ReaderFactory) 
 40          request = self._createRequestCtx( 
 41                              self.__class__.RESOURCE1_ID, 
 42                              subjectRoles=('role1',)) 
 43          response = self.pdp.evaluate(request) 
 44          self.failIf(response is None, "Null response") 
 45          for result in response.results: 
 46              self.failIf(result.decision != Decision.DENY, 
 47                          "Expecting Deny decision") 
 48   
 49 -    def test01_02NotFalse(self): 
 50          self.pdp = PDP.fromPolicySource(XACML_NOTTEST_FILEPATH, ReaderFactory) 
 51          request = self._createRequestCtx( 
 52                              self.__class__.RESOURCE2_ID, 
 53                              subjectRoles=('role1',)) 
 54          response = self.pdp.evaluate(request) 
 55          self.failIf(response is None, "Null response") 
 56          for result in response.results: 
 57              self.failIf(result.decision != Decision.PERMIT, 
 58                          "Expecting Permit decision") 
 59   
 60 -    def test02_01And0Args(self): 
 61          self.pdp = PDP.fromPolicySource(XACML_ANDTEST_FILEPATH, ReaderFactory) 
 62          request = self._createRequestCtx( 
 63                              self.__class__.RESOURCE1_ID, 
 64                              subjectRoles=('role1',)) 
 65          response = self.pdp.evaluate(request) 
 66          self.failIf(response is None, "Null response") 
 67          for result in response.results: 
 68              self.failIf(result.decision != Decision.PERMIT, 
 69                          "Expecting Permit decision") 
 70   
 71 -    def test02_02And1ArgTrue(self): 
 72          self.pdp = PDP.fromPolicySource(XACML_ANDTEST_FILEPATH, ReaderFactory) 
 73          request = self._createRequestCtx( 
 74                              self.__class__.RESOURCE2_ID, 
 75                              subjectRoles=('role1',)) 
 76          response = self.pdp.evaluate(request) 
 77          self.failIf(response is None, "Null response") 
 78          for result in response.results: 
 79              self.failIf(result.decision != Decision.PERMIT, 
 80                          "Expecting Permit decision") 
 81   
 82 -    def test02_03And1ArgFalse(self): 
 83          self.pdp = PDP.fromPolicySource(XACML_ANDTEST_FILEPATH, ReaderFactory) 
 84          request = self._createRequestCtx( 
 85                              self.__class__.RESOURCE3_ID, 
 86                              subjectRoles=('role1',)) 
 87          response = self.pdp.evaluate(request) 
 88          self.failIf(response is None, "Null response") 
 89          for result in response.results: 
 90              self.failIf(result.decision != Decision.DENY, 
 91                          "Expecting Deny decision") 
 92   
 93 -    def test02_04And2ArgsTrue(self): 
 94          self.pdp = PDP.fromPolicySource(XACML_ANDTEST_FILEPATH, ReaderFactory) 
 95          request = self._createRequestCtx( 
 96                              self.__class__.RESOURCE4_ID, 
 97                              subjectRoles=('role1', 'role2')) 
 98          response = self.pdp.evaluate(request) 
 99          self.failIf(response is None, "Null response") 
100          for result in response.results: 
101              self.failIf(result.decision != Decision.PERMIT, 
102                          "Expecting Permit decision") 
103   
104 -    def test02_05And2ArgsFalse(self): 
105          self.pdp = PDP.fromPolicySource(XACML_ANDTEST_FILEPATH, ReaderFactory) 
106          request = self._createRequestCtx( 
107                              self.__class__.RESOURCE5_ID, 
108                              subjectRoles=('role1', 'role2')) 
109          response = self.pdp.evaluate(request) 
110          self.failIf(response is None, "Null response") 
111          for result in response.results: 
112              self.failIf(result.decision != Decision.DENY, 
113                          "Expecting Deny decision") 
114   
115 -    def test02_06And3ArgsTrue(self): 
116          self.pdp = PDP.fromPolicySource(XACML_ANDTEST_FILEPATH, ReaderFactory) 
117          request = self._createRequestCtx( 
118                              self.__class__.RESOURCE6_ID, 
119                              subjectRoles=('role1', 'role2', 'role3')) 
120          response = self.pdp.evaluate(request) 
121          self.failIf(response is None, "Null response") 
122          for result in response.results: 
123              self.failIf(result.decision != Decision.PERMIT, 
124                          "Expecting Permit decision") 
125   
126 -    def test02_07And3ArgsFalse(self): 
127          self.pdp = PDP.fromPolicySource(XACML_ANDTEST_FILEPATH, ReaderFactory) 
128          request = self._createRequestCtx( 
129                              self.__class__.RESOURCE7_ID, 
130                              subjectRoles=('role1', 'role2', 'role3')) 
131          response = self.pdp.evaluate(request) 
132          self.failIf(response is None, "Null response") 
133          for result in response.results: 
134              self.failIf(result.decision != Decision.DENY, 
135                          "Expecting Deny decision") 
136   
137  if __name__ == "__main__": 
138      unittest.main() 
139