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_as_sequence(self):
252 # Checks if the row object can act like a sequence.
253 row = self.con.execute("select 1 as a, 2 as b").fetchone()
254
255 as_tuple = tuple(row)
256 self.assertEqual(list(reversed(row)), list(reversed(as_tuple)))
257 self.assertIsInstance(row, Sequence)
258
259 def test_sqlite_row_keys(self):
260 # Checks if the row object can return a list of columns as strings.
261 row = self.con.execute("select 1 as a, 2 as b").fetchone()
262 self.assertEqual(row.keys(), ['a', 'b'])
263
264 def test_fake_cursor_class(self):
265 # Issue #24257: Incorrect use of PyObject_IsInstance() caused
266 # segmentation fault.
267 # Issue #27861: Also applies for cursor factory.
268 class FakeCursor(str):
269 __class__ = sqlite.Cursor
270 self.assertRaises(TypeError, self.con.cursor, FakeCursor)
271 self.assertRaises(TypeError, sqlite.Row, FakeCursor(), ())
272
273
274 class TextFactoryTests(MemoryDatabaseMixin, unittest.TestCase):
275
276 def test_unicode(self):
277 austria = "Österreich"
278 row = self.con.execute("select ?", (austria,)).fetchone()
279 self.assertEqual(type(row[0]), str, "type of row[0] must be unicode")
280
281 def test_string(self):
282 self.con.text_factory = bytes
283 austria = "Österreich"
284 row = self.con.execute("select ?", (austria,)).fetchone()
285 self.assertEqual(type(row[0]), bytes, "type of row[0] must be bytes")
286 self.assertEqual(row[0], austria.encode("utf-8"), "column must equal original data in UTF-8")
287
288 def test_custom(self):
289 self.con.text_factory = lambda x: str(x, "utf-8", "ignore")
290 austria = "Österreich"
291 row = self.con.execute("select ?", (austria,)).fetchone()
292 self.assertEqual(type(row[0]), str, "type of row[0] must be unicode")
293 self.assertEndsWith(row[0], "reich", "column must contain original data")
294
295
296 class TextFactoryTestsWithEmbeddedZeroBytes(unittest.TestCase):
297
298 def setUp(self):
299 self.con = sqlite.connect(":memory:")
300 self.con.execute("create table test (value text)")
301 self.con.execute("insert into test (value) values (?)", ("a\x00b",))
302
303 def tearDown(self):
304 self.con.close()
305
306 def test_string(self):
307 # text_factory defaults to str
308 row = self.con.execute("select value from test").fetchone()
309 self.assertIs(type(row[0]), str)
310 self.assertEqual(row[0], "a\x00b")
311
312 def test_bytes(self):
313 self.con.text_factory = bytes
314 row = self.con.execute("select value from test").fetchone()
315 self.assertIs(type(row[0]), bytes)
316 self.assertEqual(row[0], b"a\x00b")
317
318 def test_bytearray(self):
319 self.con.text_factory = bytearray
320 row = self.con.execute("select value from test").fetchone()
321 self.assertIs(type(row[0]), bytearray)
322 self.assertEqual(row[0], b"a\x00b")
323
324 def test_custom(self):
325 # A custom factory should receive a bytes argument
326 self.con.text_factory = lambda x: x
327 row = self.con.execute("select value from test").fetchone()
328 self.assertIs(type(row[0]), bytes)
329 self.assertEqual(row[0], b"a\x00b")
330
331
332 if __name__ == "__main__":
333 unittest.main()