python/lib/python-gflags/tests/gflags_validators_test.py

   1 #!/usr/bin/env python
   2
   3 # Copyright (c) 2010, Google Inc.
   4 # All rights reserved.
   5 #
   6 # Redistribution and use in source and binary forms, with or without
   7 # modification, are permitted provided that the following conditions are
   8 # met:
   9 #
  10 #     * Redistributions of source code must retain the above copyright
  11 # notice, this list of conditions and the following disclaimer.
  12 #     * Redistributions in binary form must reproduce the above
  13 # copyright notice, this list of conditions and the following disclaimer
  14 # in the documentation and/or other materials provided with the
  15 # distribution.
  16 #     * Neither the name of Google Inc. nor the names of its
  17 # contributors may be used to endorse or promote products derived from
  18 # this software without specific prior written permission.
  19 #
  20 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31
  32 """Testing that flags validators framework does work.
  33
  34 This file tests that each flag validator called when it should be, and that
  35 failed validator will throw an exception, etc.
  36 """
  37
  38 __author__ = 'olexiy@google.com (Olexiy Oryeshko)'
  39
  40 import gflags_googletest as googletest
  41 import gflags
  42 import gflags_validators
  43
  44
  45 class SimpleValidatorTest(googletest.TestCase):
  46   """Testing gflags.RegisterValidator() method."""
  47
  48   def setUp(self):
  49     super(SimpleValidatorTest, self).setUp()
  50     self.flag_values = gflags.FlagValues()
  51     self.call_args = []
  52
  53   def testSuccess(self):
  54     def Checker(x):
  55       self.call_args.append(x)
  56       return True
  57     gflags.DEFINE_integer('test_flag', None, 'Usual integer flag',
  58                          flag_values=self.flag_values)
  59     gflags.RegisterValidator('test_flag',
  60                             Checker,
  61                             message='Errors happen',
  62                             flag_values=self.flag_values)
  63
  64     argv = ('./program')
  65     self.flag_values(argv)
  66     self.assertEquals(None, self.flag_values.test_flag)
  67     self.flag_values.test_flag = 2
  68     self.assertEquals(2, self.flag_values.test_flag)
  69     self.assertEquals([None, 2], self.call_args)
  70
  71   def testDefaultValueNotUsedSuccess(self):
  72     def Checker(x):
  73       self.call_args.append(x)
  74       return True
  75     gflags.DEFINE_integer('test_flag', None, 'Usual integer flag',
  76                          flag_values=self.flag_values)
  77     gflags.RegisterValidator('test_flag',
  78                             Checker,
  79                             message='Errors happen',
  80                             flag_values=self.flag_values)
  81
  82     argv = ('./program', '--test_flag=1')
  83     self.flag_values(argv)
  84     self.assertEquals(1, self.flag_values.test_flag)
  85     self.assertEquals([1], self.call_args)
  86
  87   def testValidatorNotCalledWhenOtherFlagIsChanged(self):
  88     def Checker(x):
  89       self.call_args.append(x)
  90       return True
  91     gflags.DEFINE_integer('test_flag', 1, 'Usual integer flag',
  92                          flag_values=self.flag_values)
  93     gflags.DEFINE_integer('other_flag', 2, 'Other integer flag',
  94                          flag_values=self.flag_values)
  95     gflags.RegisterValidator('test_flag',
  96                             Checker,
  97                             message='Errors happen',
  98                             flag_values=self.flag_values)
  99
 100     argv = ('./program')
 101     self.flag_values(argv)
 102     self.assertEquals(1, self.flag_values.test_flag)
 103     self.flag_values.other_flag = 3
 104     self.assertEquals([1], self.call_args)
 105
 106   def testExceptionRaisedIfCheckerFails(self):
 107     def Checker(x):
 108       self.call_args.append(x)
 109       return x == 1
 110     gflags.DEFINE_integer('test_flag', None, 'Usual integer flag',
 111                          flag_values=self.flag_values)
 112     gflags.RegisterValidator('test_flag',
 113                             Checker,
 114                             message='Errors happen',
 115                             flag_values=self.flag_values)
 116
 117     argv = ('./program', '--test_flag=1')
 118     self.flag_values(argv)
 119     try:
 120       self.flag_values.test_flag = 2
 121       raise AssertionError('gflags.IllegalFlagValue expected')
 122     except gflags.IllegalFlagValue, e:
 123       self.assertEquals('flag --test_flag=2: Errors happen', str(e))
 124     self.assertEquals([1, 2], self.call_args)
 125
 126   def testExceptionRaisedIfCheckerRaisesException(self):
 127     def Checker(x):
 128       self.call_args.append(x)
 129       if x == 1:
 130         return True
 131       raise gflags_validators.Error('Specific message')
 132     gflags.DEFINE_integer('test_flag', None, 'Usual integer flag',
 133                          flag_values=self.flag_values)
 134     gflags.RegisterValidator('test_flag',
 135                             Checker,
 136                             message='Errors happen',
 137                             flag_values=self.flag_values)
 138
 139     argv = ('./program', '--test_flag=1')
 140     self.flag_values(argv)
 141     try:
 142       self.flag_values.test_flag = 2
 143       raise AssertionError('gflags.IllegalFlagValue expected')
 144     except gflags.IllegalFlagValue, e:
 145       self.assertEquals('flag --test_flag=2: Specific message', str(e))
 146     self.assertEquals([1, 2], self.call_args)
 147
 148   def testErrorMessageWhenCheckerReturnsFalseOnStart(self):
 149     def Checker(x):
 150       self.call_args.append(x)
 151       return False
 152     gflags.DEFINE_integer('test_flag', None, 'Usual integer flag',
 153                          flag_values=self.flag_values)
 154     gflags.RegisterValidator('test_flag',
 155                             Checker,
 156                             message='Errors happen',
 157                             flag_values=self.flag_values)
 158
 159     argv = ('./program', '--test_flag=1')
 160     try:
 161       self.flag_values(argv)
 162       raise AssertionError('gflags.IllegalFlagValue expected')
 163     except gflags.IllegalFlagValue, e:
 164       self.assertEquals('flag --test_flag=1: Errors happen', str(e))
 165     self.assertEquals([1], self.call_args)
 166
 167   def testErrorMessageWhenCheckerRaisesExceptionOnStart(self):
 168     def Checker(x):
 169       self.call_args.append(x)
 170       raise gflags_validators.Error('Specific message')
 171     gflags.DEFINE_integer('test_flag', None, 'Usual integer flag',
 172                          flag_values=self.flag_values)
 173     gflags.RegisterValidator('test_flag',
 174                             Checker,
 175                             message='Errors happen',
 176                             flag_values=self.flag_values)
 177
 178     argv = ('./program', '--test_flag=1')
 179     try:
 180       self.flag_values(argv)
 181       raise AssertionError('IllegalFlagValue expected')
 182     except gflags.IllegalFlagValue, e:
 183       self.assertEquals('flag --test_flag=1: Specific message', str(e))
 184     self.assertEquals([1], self.call_args)
 185
 186   def testValidatorsCheckedInOrder(self):
 187
 188     def Required(x):
 189       self.calls.append('Required')
 190       return x is not None
 191
 192     def Even(x):
 193       self.calls.append('Even')
 194       return x % 2 == 0
 195
 196     self.calls = []
 197     self._DefineFlagAndValidators(Required, Even)
 198     self.assertEquals(['Required', 'Even'], self.calls)
 199
 200     self.calls = []
 201     self._DefineFlagAndValidators(Even, Required)
 202     self.assertEquals(['Even', 'Required'], self.calls)
 203
 204   def _DefineFlagAndValidators(self, first_validator, second_validator):
 205     local_flags = gflags.FlagValues()
 206     gflags.DEFINE_integer('test_flag', 2, 'test flag', flag_values=local_flags)
 207     gflags.RegisterValidator('test_flag',
 208                             first_validator,
 209                             message='',
 210                             flag_values=local_flags)
 211     gflags.RegisterValidator('test_flag',
 212                             second_validator,
 213                             message='',
 214                             flag_values=local_flags)
 215     argv = ('./program')
 216     local_flags(argv)
 217
 218
 219 if __name__ == '__main__':
 220   googletest.main()