Changeset 643 for branches/4.x


Ignore:
Timestamp:
Nov 27, 2015, 7:56:09 AM (4 years ago)
Author:
cito
Message:

Fix and backport some issues in the config tests

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/4.x/module/tests/test_classic_connection.py

    r642 r643  
    932932    def testGetDecimalPoint(self):
    933933        point = pg.get_decimal_point()
     934        # error if a parameter is passed
     935        self.assertRaises(TypeError, pg.get_decimal_point, point)
    934936        self.assertIsInstance(point, str)
    935         self.assertEqual(point, '.')
     937        self.assertEqual(point, '.')  # the default setting
     938        pg.set_decimal_point(',')
     939        try:
     940            r = pg.get_decimal_point()
     941        finally:
     942            pg.set_decimal_point(point)
     943        self.assertIsInstance(r, str)
     944        self.assertEqual(r, ',')
     945        pg.set_decimal_point("'")
     946        try:
     947            r = pg.get_decimal_point()
     948        finally:
     949            pg.set_decimal_point(point)
     950        self.assertIsInstance(r, str)
     951        self.assertEqual(r, "'")
     952        pg.set_decimal_point('')
     953        try:
     954            r = pg.get_decimal_point()
     955        finally:
     956            pg.set_decimal_point(point)
     957        self.assertIsNone(r)
     958        pg.set_decimal_point(None)
     959        try:
     960            r = pg.get_decimal_point()
     961        finally:
     962            pg.set_decimal_point(point)
     963        self.assertIsNone(r)
    936964
    937965    def testSetDecimalPoint(self):
    938966        d = pg.Decimal
    939967        point = pg.get_decimal_point()
     968        self.assertRaises(TypeError, pg.set_decimal_point)
     969        # error if decimal point is not a string
     970        self.assertRaises(TypeError, pg.set_decimal_point, 0)
     971        # error if more than one decimal point passed
     972        self.assertRaises(TypeError, pg.set_decimal_point, '.', ',')
     973        self.assertRaises(TypeError, pg.set_decimal_point, '.,')
     974        # error if decimal point is not a punctuation character
     975        self.assertRaises(TypeError, pg.set_decimal_point, '0')
    940976        query = self.c.query
    941         # check that money values can be interpreted correctly
    942         # if and only if the decimal point is set appropriately
    943         # for the current lc_monetary setting
    944         try:
    945             query("set lc_monetary='en_US.UTF-8'")
     977        # check that money values are interpreted as decimal values
     978        # only if decimal_point is set, and that the result is correct
     979        # only if it is set suitable for the current lc_monetary setting
     980        select_money = "select '34.25'::money"
     981        proper_money = d(34.25)
     982        bad_money = d(3425)
     983        en_locales = 'en', 'en_US', 'en_US.utf8', 'en_US.UTF-8'
     984        en_money = '$34.25', '$ 34.25', '34.25$', '34.25 $', '34.25 Dollar'
     985        de_locales = 'de', 'de_DE', 'de_DE.utf8', 'de_DE.UTF-8'
     986        de_money = ('34,25€', '34,25 €', '€34,25' '€ 34,25',
     987            '34,25 EUR', '34,25 Euro', '34,25 DM')
     988        # first try with English localization (using the point)
     989        for lc in en_locales:
     990            try:
     991                query("set lc_monetary='%s'" % lc)
     992            except pg.ProgrammingError:
     993                pass
     994            else:
     995                break
     996        else:
     997            self.skipTest("cannot set English money locale")
     998        try:
     999            r = query(select_money)
    9461000        except pg.ProgrammingError:
    947             self.skipTest("cannot set English money locale")
     1001            # this can happen if the currency signs cannot be
     1002            # converted using the encoding of the test database
     1003            self.skipTest("database does not support English money")
    9481004        pg.set_decimal_point(None)
    9491005        try:
    950             r = query("select '34.25'::money").getresult()[0][0]
     1006            r = r.getresult()[0][0]
    9511007        finally:
    9521008            pg.set_decimal_point(point)
    9531009        self.assertIsInstance(r, str)
    954         self.assertIn(r, (
    955             '$34.25', '$ 34.25', '34.25$', '34.25 $', '34.25 Dollar'))
     1010        self.assertIn(r, en_money)
     1011        r = query(select_money)
     1012        pg.set_decimal_point('')
     1013        try:
     1014            r = r.getresult()[0][0]
     1015        finally:
     1016            pg.set_decimal_point(point)
     1017        self.assertIsInstance(r, str)
     1018        self.assertIn(r, en_money)
     1019        r = query(select_money)
    9561020        pg.set_decimal_point('.')
    9571021        try:
    958             r = query("select '34.25'::money").getresult()[0][0]
     1022            r = r.getresult()[0][0]
    9591023        finally:
    9601024            pg.set_decimal_point(point)
    9611025        self.assertIsInstance(r, d)
    962         self.assertEqual(r, d('34.25'))
     1026        self.assertEqual(r, proper_money)
     1027        r = query(select_money)
    9631028        pg.set_decimal_point(',')
    9641029        try:
    965             r = query("select '34.25'::money").getresult()[0][0]
    966         finally:
    967             pg.set_decimal_point(point)
    968         self.assertNotEqual(r, d('34.25'))
    969         try:
    970             query("set lc_monetary='de_DE.UTF-8'")
     1030            r = r.getresult()[0][0]
     1031        finally:
     1032            pg.set_decimal_point(point)
     1033        self.assertIsInstance(r, d)
     1034        self.assertEqual(r, bad_money)
     1035        r = query(select_money)
     1036        pg.set_decimal_point("'")
     1037        try:
     1038            r = r.getresult()[0][0]
     1039        finally:
     1040            pg.set_decimal_point(point)
     1041        self.assertIsInstance(r, d)
     1042        self.assertEqual(r, bad_money)
     1043        # then try with German localization (using the comma)
     1044        for lc in de_locales:
     1045            try:
     1046                query("set lc_monetary='%s'" % lc)
     1047            except pg.ProgrammingError:
     1048                pass
     1049            else:
     1050                break
     1051        else:
     1052            self.skipTest("cannot set German money locale")
     1053        select_money = select_money.replace('.', ',')
     1054        try:
     1055            r = query(select_money)
    9711056        except pg.ProgrammingError:
    972             self.skipTest("cannot set German money locale")
     1057            self.skipTest("database does not support English money")
    9731058        pg.set_decimal_point(None)
    9741059        try:
    975             r = query("select '34,25'::money").getresult()[0][0]
     1060            r = r.getresult()[0][0]
    9761061        finally:
    9771062            pg.set_decimal_point(point)
    9781063        self.assertIsInstance(r, str)
    979         self.assertIn(r, ('34,25€', '34,25 €', '€34,25' '€ 34,25',
    980             '34,25 EUR', '34,25 Euro', '34,25 DM'))
     1064        self.assertIn(r, de_money)
     1065        r = query(select_money)
     1066        pg.set_decimal_point('')
     1067        try:
     1068            r = r.getresult()[0][0]
     1069        finally:
     1070            pg.set_decimal_point(point)
     1071        self.assertIsInstance(r, str)
     1072        self.assertIn(r, de_money)
     1073        r = query(select_money)
    9811074        pg.set_decimal_point(',')
    9821075        try:
    983             r = query("select '34,25'::money").getresult()[0][0]
     1076            r = r.getresult()[0][0]
    9841077        finally:
    9851078            pg.set_decimal_point(point)
    9861079        self.assertIsInstance(r, d)
    987         self.assertEqual(r, d('34.25'))
    988         try:
    989             pg.set_decimal_point('.')
    990         finally:
    991             pg.set_decimal_point(point)
    992         r = query("select '34,25'::money").getresult()[0][0]
    993         self.assertNotEqual(r, d('34.25'))
     1080        self.assertEqual(r, proper_money)
     1081        r = query(select_money)
     1082        pg.set_decimal_point('.')
     1083        try:
     1084            r = r.getresult()[0][0]
     1085        finally:
     1086            pg.set_decimal_point(point)
     1087        self.assertEqual(r, bad_money)
     1088        r = query(select_money)
     1089        pg.set_decimal_point("'")
     1090        try:
     1091            r = r.getresult()[0][0]
     1092        finally:
     1093            pg.set_decimal_point(point)
     1094        self.assertEqual(r, bad_money)
     1095
     1096    def testGetDecimal(self):
     1097        decimal_class = pg.get_decimal()
     1098        # error if a parameter is passed
     1099        self.assertRaises(TypeError, pg.get_decimal, decimal_class)
     1100        self.assertIs(decimal_class, pg.Decimal)  # the default setting
     1101        pg.set_decimal(int)
     1102        try:
     1103            r = pg.get_decimal()
     1104        finally:
     1105            pg.set_decimal(decimal_class)
     1106        self.assertIs(r, int)
     1107        r = pg.get_decimal()
     1108        self.assertIs(r, decimal_class)
    9941109
    9951110    def testSetDecimal(self):
    996         d = pg.Decimal
     1111        decimal_class = pg.get_decimal()
     1112        # error if no parameter is passed
     1113        self.assertRaises(TypeError, pg.set_decimal)
    9971114        query = self.c.query
    998         r = query("select 3425::numeric").getresult()[0][0]
    999         self.assertIsInstance(r, d)
    1000         self.assertEqual(r, d('3425'))
    1001         pg.set_decimal(long)
    1002         try:
    1003             r = query("select 3425::numeric").getresult()[0][0]
    1004         finally:
    1005             pg.set_decimal(d)
    1006         self.assertNotIsInstance(r, d)
    1007         self.assertIsInstance(r, long)
    1008         self.assertEqual(r, 3425L)
     1115        try:
     1116            r = query("select 3425::numeric")
     1117        except pg.ProgrammingError:
     1118            self.skipTest('database does not support numeric')
     1119        r = r.getresult()[0][0]
     1120        self.assertIsInstance(r, decimal_class)
     1121        self.assertEqual(r, decimal_class('3425'))
     1122        r = query("select 3425::numeric")
     1123        pg.set_decimal(int)
     1124        try:
     1125            r = r.getresult()[0][0]
     1126        finally:
     1127            pg.set_decimal(decimal_class)
     1128        self.assertNotIsInstance(r, decimal_class)
     1129        self.assertIsInstance(r, int)
     1130        self.assertEqual(r, int(3425))
     1131
     1132    def testGetBool(self):
     1133        use_bool = pg.get_bool()
     1134        # error if a parameter is passed
     1135        self.assertRaises(TypeError, pg.get_bool, use_bool)
     1136        self.assertIsInstance(use_bool, bool)
     1137        self.assertIs(use_bool, False)  # the default setting
     1138        pg.set_bool(True)
     1139        try:
     1140            r = pg.get_bool()
     1141        finally:
     1142            pg.set_bool(use_bool)
     1143        self.assertIsInstance(r, bool)
     1144        self.assertIs(r, True)
     1145        pg.set_bool(False)
     1146        try:
     1147            r = pg.get_bool()
     1148        finally:
     1149            pg.set_bool(use_bool)
     1150        self.assertIsInstance(r, bool)
     1151        self.assertIs(r, False)
     1152        pg.set_bool(1)
     1153        try:
     1154            r = pg.get_bool()
     1155        finally:
     1156            pg.set_bool(use_bool)
     1157        self.assertIsInstance(r, bool)
     1158        self.assertIs(r, True)
     1159        pg.set_bool(0)
     1160        try:
     1161            r = pg.get_bool()
     1162        finally:
     1163            pg.set_bool(use_bool)
     1164        self.assertIsInstance(r, bool)
     1165        self.assertIs(r, False)
     1166
     1167    def testSetBool(self):
     1168        use_bool = pg.get_bool()
     1169        # error if no parameter is passed
     1170        self.assertRaises(TypeError, pg.set_bool)
     1171        query = self.c.query
     1172        try:
     1173            r = query("select true::bool")
     1174        except pg.ProgrammingError:
     1175            self.skipTest('database does not support bool')
     1176        r = r.getresult()[0][0]
     1177        self.assertIsInstance(r, str)
     1178        self.assertEqual(r, 't')
     1179        r = query("select true::bool")
     1180        pg.set_bool(True)
     1181        try:
     1182            r = r.getresult()[0][0]
     1183        finally:
     1184            pg.set_bool(use_bool)
     1185        self.assertIsInstance(r, bool)
     1186        self.assertIs(r, True)
     1187        r = query("select true::bool")
     1188        pg.set_bool(False)
     1189        try:
     1190            r = r.getresult()[0][0]
     1191        finally:
     1192            pg.set_bool(use_bool)
     1193        self.assertIsInstance(r, str)
     1194        self.assertIs(r, 't')
     1195
     1196    def testGetNamedresult(self):
     1197        namedresult = pg.get_namedresult()
     1198        # error if a parameter is passed
     1199        self.assertRaises(TypeError, pg.get_namedresult, namedresult)
     1200        self.assertIs(namedresult, pg._namedresult)  # the default setting
    10091201
    10101202    @unittest.skipUnless(namedtuple, 'Named tuples not available')
    10111203    def testSetNamedresult(self):
     1204        namedresult = pg.get_namedresult()
     1205        self.assertTrue(callable(namedresult))
     1206
    10121207        query = self.c.query
    10131208
     
    10201215        self.assertEqual(r.__class__.__name__, 'Row')
    10211216
    1022         _namedresult = pg._namedresult
    1023         self.assertTrue(callable(_namedresult))
    1024         pg.set_namedresult(_namedresult)
    1025 
    1026         r = query("select 1 as x, 2 as y").namedresult()[0]
    1027         self.assertIsInstance(r, tuple)
    1028         self.assertEqual(r, (1, 2))
    1029         self.assertIsNot(type(r), tuple)
    1030         self.assertEqual(r._fields, ('x', 'y'))
    1031         self.assertEqual(r._asdict(), {'x': 1, 'y': 2})
    1032         self.assertEqual(r.__class__.__name__, 'Row')
    1033 
    1034         def _listresult(q):
    1035             return map(list, q.getresult())
    1036 
    1037         pg.set_namedresult(_listresult)
    1038 
    1039         try:
     1217        def listresult(q):
     1218            return [list(row) for row in q.getresult()]
     1219
     1220        pg.set_namedresult(listresult)
     1221        try:
     1222            r = pg.get_namedresult()
     1223            self.assertIs(r, listresult)
    10401224            r = query("select 1 as x, 2 as y").namedresult()[0]
    10411225            self.assertIsInstance(r, list)
     
    10451229            self.assertNotEqual(r.__class__.__name__, 'Row')
    10461230        finally:
    1047             pg.set_namedresult(_namedresult)
     1231            pg.set_namedresult(namedresult)
     1232
     1233        r = pg.get_namedresult()
     1234        self.assertIs(r, namedresult)
    10481235
    10491236
Note: See TracChangeset for help on using the changeset viewer.