1 from twisted.trial import unittest

     2 from mock import Mock

     3 

     4 from iro.validate import vBool, vInteger, vHash, validate

     5 from iro.error import ValidateException

     6 

     7 class testValidators(unittest.TestCase):

     8     '''test for simple validators'''

     9 

    10     def testBool(self):

    11         self.assertEqual(vBool(True,None),True)

    12         self.assertEqual(vBool(1,None),True)

    13         self.assertEqual(vBool("true",None),True)

    14         self.assertEqual(vBool("True",None),True)

    15         self.assertEqual(vBool("TRUE",None),True)

    16 

    17         self.assertEqual(vBool(False,None),False)

    18         self.assertEqual(vBool(0,None),False)

    19         self.assertEqual(vBool("false",None),False)

    20         self.assertEqual(vBool("False",None),False)

    21         self.assertEqual(vBool("FALSE",None),False)

    22 

    23         e = self.assertRaises(ValidateException, vBool, "TRue","test")

    24         self.assertEqual(e.msg,"test is not boolean")

    25 

    26     def testInteger(self):

    27         self.assertEqual(vInteger(123,None),123)

    28         self.assertEqual(vInteger("123",None),123)

    29         self.assertEqual(vInteger("-123",None),-123)

    30 

    31         self.assertRaises(ValidateException, vInteger, "a123",None)

    32 

    33     def testIntegerLimits(self):

    34         self.assertEqual(vInteger(10,None,maxv=10),10)

    35         self.assertRaises(ValidateException, vInteger, 11, None, maxv=10)

    36 

    37         self.assertEqual(vInteger(4,None,minv=4),4)

    38         self.assertRaises(ValidateException, vInteger, 3, None, minv=4)

    39 

    40         self.assertRaises(ValidateException, vInteger, -1, None, minv=0)

    41         self.assertRaises(ValidateException, vInteger, 1, None, maxv=0)

    42 

    43     def testIntegerNoneAllowed(self):

    44         self.assertEqual(vInteger(None,None,none_allowed=True),None)

    45         self.assertEqual(vInteger('',None,none_allowed=True),None)

    46 

    47         self.assertRaises(ValidateException, vInteger, "", None)

    48         self.assertRaises(ValidateException, vInteger, None, None)

    49 

    50     def testHash(self):

    51         self.assertEqual(vHash("0123456789abcdef",None),"0123456789abcdef")

    52         self.assertEqual(vHash("0123456789ABCDEF",None),"0123456789abcdef")

    53         self.assertEqual(vHash("F",None),"f")

    54         self.assertEqual(vHash("",None),'')

    55 

    56         self.assertRaises(ValidateException, vHash, "GHIJKL", None)

    57         

    58     def testHashLimits(self):

    59         self.assertEqual(vHash("F",None,minlength=1),"f")

    60         self.assertRaises(ValidateException, vHash, "", None, minlength=1)

    61 

    62         self.assertEqual(vHash("Fa",None,maxlength=2),"fa")

    63         self.assertRaises(ValidateException, vHash, "123", None, maxlength=1)

    64 

    65     

    66     def testValidate(self):

    67         f = Mock()

    68         f.return_value = "valid"

    69         @validate("t",f,True,1,2,3,4,k=5)

    70         def g(u=False, t="bla"):

    71             return t

    72         d = g(t="uhuhu")

    73         def r(t):

    74             f.called_once_with("uhuhu","t",1,2,3,4,k=5)

    75             self.assertEqual(t,"valid")

    76         d.addCallback(r)

    77         return d

    78 

    79     def testValidateMissingNeed(self):

    80         f = Mock()

    81         @validate("t",f,True,1,2,3,4,k=5)

    82         def g(u, t="buuh"):

    83             return t

    84         e = self.assertRaises(ValidateException, g, u="uhuhu", t = None)

    85         self.assertEqual(str(e),'700: t is nessasary')

    86 

    87     def testValidateMissingNeedNonExplicit(self):

    88         f = Mock()

    89         @validate("t",f,True,1,2,3,4,k=5)

    90         def g(u, **k):

    91             return k["t"]

    92         e = self.assertRaises(ValidateException, g, u="uhuhu")

    93         self.assertEqual(str(e),'700: t is nessasary')

    94 

    95 

    96     def testValidateMissingNeed2(self):

    97         f = Mock()

    98         f.return_value = "valid"

    99         @validate("t",f,True,1,2,3,4,k=5)

   100         def g(u, t="buuh"):

   101             return t

   102 

   103         d = g(True)

   104 

   105         def r(t):

   106             f.called_once_with("buuh","t",1,2,3,4,k=5)

   107             self.assertEqual(t,"valid")

   108         d.addCallback(r)

   109         return d

   110 

   111     def testvalidateNoNeed(self):

   112         f = Mock()

   113         f.return_value = "valid"

   114         @validate("t",f,False,1,2,3,4,k=5)

   115         def g(u, t="buuh"):

   116             return t

   117         d = g("uhu")

   118         def r(t):

   119             self.assertEqual(f.called,True)

   120             self.assertEqual(t,"valid")

   121         d.addCallback(r)

   122         return d

   123 

   124     def testvalidateNoNeed2(self):

   125         f = Mock()

   126         f.return_value = "valid"

   127         @validate("t",f,False,1,2,3,4,k=5)

   128         def g(u, **k):

   129             return k["t"]

   130         d = g("uhu")

   131         def r(t):

   132             self.assertEqual(f.called,False)

   133             self.assertEqual(t,None)

   134         d.addCallback(r)

   135         return d