Debian Codegraph @

Lib/test/test_sqlite3/test_factory.py

raw
1 # pysqlite2/test/factory.py: tests for the various factories in pysqlite
2 #
3 # Copyright (C) 2005-2007 Gerhard Häring <[email protected]>
4 #
5 # This file is part of pysqlite.
6 #
7 # This software is provided 'as-is', without any express or implied
8 # warranty. In no event will the authors be held liable for any damages
9 # arising from the use of this software.
10 #
11 # Permission is granted to anyone to use this software for any purpose,
12 # including commercial applications, and to alter it and redistribute it
13 # freely, subject to the following restrictions:
14 #
15 # 1. The origin of this software must not be misrepresented; you must not
16 # claim that you wrote the original software. If you use this software
17 # in a product, an acknowledgment in the product documentation would be
18 # appreciated but is not required.
19 # 2. Altered source versions must be plainly marked as such, and must not be
20 # misrepresented as being the original software.
21 # 3. This notice may not be removed or altered from any source distribution.
22
23 import unittest
24 import sqlite3 as sqlite
25 from collections.abc import Sequence
26
27 from .util import memory_database
28 from .util import MemoryDatabaseMixin
29
30
31 def dict_factory(cursor, row):
32 d = {}
33 for idx, col in enumerate(cursor.description):
34 d[col[0]] = row[idx]
35 return d
36
37 class MyCursor(sqlite.Cursor):
38 def __init__(self, *args, **kwargs):
39 sqlite.Cursor.__init__(self, *args, **kwargs)
40 self.row_factory = dict_factory
41
42 class ConnectionFactoryTests(unittest.TestCase):
43 def test_connection_factories(self):
44 class DefectFactory(sqlite.Connection):
45 def __init__(self, *args, **kwargs):
46 return None
47 class OkFactory(sqlite.Connection):
48 def __init__(self, *args, **kwargs):
49 sqlite.Connection.__init__(self, *args, **kwargs)
50
51 with memory_database(factory=OkFactory) as con:
52 self.assertIsInstance(con, OkFactory)
53 regex = "Base Connection.__init__ not called."
54 with self.assertRaisesRegex(sqlite.ProgrammingError, regex):
55 with memory_database(factory=DefectFactory) as con:
56 self.assertIsInstance(con, DefectFactory)
57
58 def test_connection_factory_relayed_call(self):
59 # gh-95132: keyword args must not be passed as positional args
60 class Factory(sqlite.Connection):
61 def __init__(self, *args, **kwargs):
62 kwargs["isolation_level"] = None
63 super(Factory, self).__init__(*args, **kwargs)
64
65 with memory_database(factory=Factory) as con:
66 self.assertIsNone(con.isolation_level)
67 self.assertIsInstance(con, Factory)
68
69 def test_connection_factory_as_positional_arg(self):
70 class Factory(sqlite.Connection):
71 def __init__(self, *args, **kwargs):
72 super(Factory, self).__init__(*args, **kwargs)
73
74 regex = (
75 r"Passing more than 1 positional argument to _sqlite3.Connection\(\) "
76 r"is deprecated. Parameters 'timeout', 'detect_types', "
77 r"'isolation_level', 'check_same_thread', 'factory', "
78 r"'cached_statements' and 'uri' will become keyword-only "
79 r"parameters in Python 3.15."
80 )
81 with self.assertWarnsRegex(DeprecationWarning, regex) as cm:
82 with memory_database(5.0, 0, None, True, Factory) as con:
83 self.assertIsNone(con.isolation_level)
84 self.assertIsInstance(con, Factory)
85 self.assertEqual(cm.filename, __file__)
86
87
88 class CursorFactoryTests(MemoryDatabaseMixin, unittest.TestCase):
89
90 def test_is_instance(self):
91 cur = self.con.cursor()
92 self.assertIsInstance(cur, sqlite.Cursor)
93 cur = self.con.cursor(MyCursor)
94 self.assertIsInstance(cur, MyCursor)
95 cur = self.con.cursor(factory=lambda con: MyCursor(con))
96 self.assertIsInstance(cur, MyCursor)
97
98 def test_invalid_factory(self):
99 # not a callable at all
100 self.assertRaises(TypeError, self.con.cursor, None)
101 # invalid callable with not exact one argument
102 self.assertRaises(TypeError, self.con.cursor, lambda: None)
103 # invalid callable returning non-cursor
104 self.assertRaises(TypeError, self.con.cursor, lambda con: None)
105
106
107 class RowFactoryTestsBackwardsCompat(MemoryDatabaseMixin, unittest.TestCase):
108
109 def test_is_produced_by_factory(self):
110 cur = self.con.cursor(factory=MyCursor)
111 cur.execute("select 4+5 as foo")
112 row = cur.fetchone()
113 self.assertIsInstance(row, dict)
114 cur.close()
115
116
117 class RowFactoryTests(MemoryDatabaseMixin, unittest.TestCase):
118
119 def setUp(self):
120 super().setUp()
121 self.con.row_factory = sqlite.Row
122
123 def test_custom_factory(self):
124 self.con.row_factory = lambda cur, row: list(row)
125 row = self.con.execute("select 1, 2").fetchone()
126 self.assertIsInstance(row, list)
127
128 def test_sqlite_row_index(self):
129 row = self.con.execute("select 1 as a_1, 2 as b").fetchone()
130 self.assertIsInstance(row, sqlite.Row)
131
132 self.assertEqual(row["a_1"], 1, "by name: wrong result for column 'a_1'")
133 self.assertEqual(row["b"], 2, "by name: wrong result for column 'b'")
134
135 self.assertEqual(row["A_1"], 1, "by name: wrong result for column 'A_1'")
136 self.assertEqual(row["B"], 2, "by name: wrong result for column 'B'")
137
138 self.assertEqual(row[0], 1, "by index: wrong result for column 0")
139 self.assertEqual(row[1], 2, "by index: wrong result for column 1")
140 self.assertEqual(row[-1], 2, "by index: wrong result for column -1")
141 self.assertEqual(row[-2], 1, "by index: wrong result for column -2")
142
143 with self.assertRaises(IndexError):
144 row['c']
145 with self.assertRaises(IndexError):
146 row['a_\x11']
147 with self.assertRaises(IndexError):
148 row['a\x7f1']
149 with self.assertRaises(IndexError):
150 row[2]
151 with self.assertRaises(IndexError):
152 row[-3]
153 with self.assertRaises(IndexError):
154 row[2**1000]
155 with self.assertRaises(IndexError):
156 row[complex()] # index must be int or string
157
158 def test_delete_connection_row_factory(self):
159 # gh-149738: deleting row_factory should raise an exception
160 with self.assertRaises(AttributeError):
161 del self.con.row_factory
162
163 def test_delete_connection_text_factory(self):
164 # gh-149738: deleting text_factory should raise an exception
165 with self.assertRaises(AttributeError):
166 del self.con.text_factory
167
168 def test_sqlite_row_index_unicode(self):
169 row = self.con.execute("select 1 as \xff").fetchone()
170 self.assertEqual(row["\xff"], 1)
171 with self.assertRaises(IndexError):
172 row['\u0178']
173 with self.assertRaises(IndexError):
174 row['\xdf']
175
176 def test_sqlite_row_slice(self):
177 # A sqlite.Row can be sliced like a list.
178 row = self.con.execute("select 1, 2, 3, 4").fetchone()
179 self.assertEqual(row[0:0], ())
180 self.assertEqual(row[0:1], (1,))
181 self.assertEqual(row[1:3], (2, 3))
182 self.assertEqual(row[3:1], ())
183 # Explicit bounds are optional.
184 self.assertEqual(row[1:], (2, 3, 4))
185 self.assertEqual(row[:3], (1, 2, 3))
186 # Slices can use negative indices.
187 self.assertEqual(row[-2:-1], (3,))
188 self.assertEqual(row[-2:], (3, 4))
189 # Slicing supports steps.
190 self.assertEqual(row[0:4:2], (1, 3))
191 self.assertEqual(row[3:0:-2], (4, 2))
192
193 def test_sqlite_row_iter(self):
194 # Checks if the row object is iterable.
195 row = self.con.execute("select 1 as a, 2 as b").fetchone()
196
197 # Is iterable in correct order and produces valid results:
198 items = [col for col in row]
199 self.assertEqual(items, [1, 2])
200
201 # Is iterable the second time:
202 items = [col for col in row]
203 self.assertEqual(items, [1, 2])
204
205 def test_sqlite_row_as_tuple(self):
206 # Checks if the row object can be converted to a tuple.
207 row = self.con.execute("select 1 as a, 2 as b").fetchone()
208 t = tuple(row)
209 self.assertEqual(t, (row['a'], row['b']))
210
211 def test_sqlite_row_as_dict(self):
212 # Checks if the row object can be correctly converted to a dictionary.
213 row = self.con.execute("select 1 as a, 2 as b").fetchone()
214 d = dict(row)
215 self.assertEqual(d["a"], row["a"])
216 self.assertEqual(d["b"], row["b"])
217
218 def test_sqlite_row_hash_cmp(self):
219 # Checks if the row object compares and hashes correctly.
220 row_1 = self.con.execute("select 1 as a, 2 as b").fetchone()
221 row_2 = self.con.execute("select 1 as a, 2 as b").fetchone()
222 row_3 = self.con.execute("select 1 as a, 3 as b").fetchone()
223 row_4 = self.con.execute("select 1 as b, 2 as a").fetchone()
224 row_5 = self.con.execute("select 2 as b, 1 as a").fetchone()
225
226 self.assertTrue(row_1 == row_1)
227 self.assertTrue(row_1 == row_2)
228 self.assertFalse(row_1 == row_3)
229 self.assertFalse(row_1 == row_4)
230 self.assertFalse(row_1 == row_5)
231 self.assertFalse(row_1 == object())
232
233 self.assertFalse(row_1 != row_1)
234 self.assertFalse(row_1 != row_2)
235 self.assertTrue(row_1 != row_3)
236 self.assertTrue(row_1 != row_4)
237 self.assertTrue(row_1 != row_5)
238 self.assertTrue(row_1 != object())
239
240 with self.assertRaises(TypeError):
241 row_1 > row_2
242 with self.assertRaises(TypeError):
243 row_1 < row_2
244 with self.assertRaises(TypeError):
245 row_1 >= row_2
246 with self.assertRaises(TypeError):
247 row_1 <= row_2
248
249 self.assertEqual(hash(row_1), hash(row_2))
250
251 def test_sqlite_row_hash_unhashable(self):
252 # An unhashable value must raise TypeError, not SystemError.
253 sqlite.register_converter("LST", lambda b: [1, 2, 3])
254 self.addCleanup(sqlite.converters.pop, "LST", None)
255 with memory_database(detect_types=sqlite.PARSE_DECLTYPES) as con:
256 con.row_factory = sqlite.Row
257 con.execute("create table t(x LST)")
258 con.execute("insert into t values(?)", (b"x",))
259 row = con.execute("select x from t").fetchone()
260 self.assertRaisesRegex(TypeError, "unhashable", hash, row)
261
262 def test_sqlite_row_as_sequence(self):
263 # Checks if the row object can act like a sequence.
264 row = self.con.execute("select 1 as a, 2 as b").fetchone()
265
266 as_tuple = tuple(row)
267 self.assertEqual(list(reversed(row)), list(reversed(as_tuple)))
268 self.assertIsInstance(row, Sequence)
269
270 def test_sqlite_row_keys(self):
271 # Checks if the row object can return a list of columns as strings.
272 row = self.con.execute("select 1 as a, 2 as b").fetchone()
273 self.assertEqual(row.keys(), ['a', 'b'])
274
275 def test_fake_cursor_class(self):
276 # Issue #24257: Incorrect use of PyObject_IsInstance() caused
277 # segmentation fault.
278 # Issue #27861: Also applies for cursor factory.
279 class FakeCursor(str):
280 __class__ = sqlite.Cursor
281 self.assertRaises(TypeError, self.con.cursor, FakeCursor)
282 self.assertRaises(TypeError, sqlite.Row, FakeCursor(), ())
283
284
285 class TextFactoryTests(MemoryDatabaseMixin, unittest.TestCase):
286
287 def test_unicode(self):
288 austria = "Österreich"
289 row = self.con.execute("select ?", (austria,)).fetchone()
290 self.assertEqual(type(row[0]), str, "type of row[0] must be unicode")
291
292 def test_string(self):
293 self.con.text_factory = bytes
294 austria = "Österreich"
295 row = self.con.execute("select ?", (austria,)).fetchone()
296 self.assertEqual(type(row[0]), bytes, "type of row[0] must be bytes")
297 self.assertEqual(row[0], austria.encode("utf-8"), "column must equal original data in UTF-8")
298
299 def test_custom(self):
300 self.con.text_factory = lambda x: str(x, "utf-8", "ignore")
301 austria = "Österreich"
302 row = self.con.execute("select ?", (austria,)).fetchone()
303 self.assertEqual(type(row[0]), str, "type of row[0] must be unicode")
304 self.assertEndsWith(row[0], "reich", "column must contain original data")
305
306
307 class TextFactoryTestsWithEmbeddedZeroBytes(unittest.TestCase):
308
309 def setUp(self):
310 self.con = sqlite.connect(":memory:")
311 self.con.execute("create table test (value text)")
312 self.con.execute("insert into test (value) values (?)", ("a\x00b",))
313
314 def tearDown(self):
315 self.con.close()
316
317 def test_string(self):
318 # text_factory defaults to str
319 row = self.con.execute("select value from test").fetchone()
320 self.assertIs(type(row[0]), str)
321 self.assertEqual(row[0], "a\x00b")
322
323 def test_bytes(self):
324 self.con.text_factory = bytes
325 row = self.con.execute("select value from test").fetchone()
326 self.assertIs(type(row[0]), bytes)
327 self.assertEqual(row[0], b"a\x00b")
328
329 def test_bytearray(self):
330 self.con.text_factory = bytearray
331 row = self.con.execute("select value from test").fetchone()
332 self.assertIs(type(row[0]), bytearray)
333 self.assertEqual(row[0], b"a\x00b")
334
335 def test_custom(self):
336 # A custom factory should receive a bytes argument
337 self.con.text_factory = lambda x: x
338 row = self.con.execute("select value from test").fetchone()
339 self.assertIs(type(row[0]), bytes)
340 self.assertEqual(row[0], b"a\x00b")
341
342
343 if __name__ == "__main__":
344 unittest.main()