Skip to content

Commit 6da81dd

Browse files
araujoguiaraujogui
committed
sqlite: create options test cases
1 parent 387000f commit 6da81dd

File tree

2 files changed

+345
-0
lines changed

2 files changed

+345
-0
lines changed

‎test/parallel/test-sqlite-named-parameters.js‎

Lines changed: 100 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -119,3 +119,103 @@ suite('StatementSync.prototype.setAllowUnknownNamedParameters()', () => {
119119
});
120120
});
121121
});
122+
123+
suite('options.allowUnknownNamedParameters', () => {
124+
test('unknown named parameters are allowed when input is true', (t) => {
125+
const db = new DatabaseSync(':memory:');
126+
t.after(() => { db.close(); });
127+
const setup = db.exec(
128+
'CREATE TABLE data(key INTEGER, val INTEGER) STRICT;'
129+
);
130+
t.assert.strictEqual(setup, undefined);
131+
const stmt = db.prepare(
132+
'INSERT INTO data (key, val) VALUES ($k, $v)',
133+
{ allowUnknownNamedParameters: true }
134+
);
135+
const params = { $a: 1, $b: 2, $k: 42, $y: 25, $v: 84, $z: 99 };
136+
t.assert.deepStrictEqual(
137+
stmt.run(params),
138+
{ changes: 1, lastInsertRowid: 1 },
139+
);
140+
});
141+
142+
test('unknown named parameters throw when input is false', (t) => {
143+
const db = new DatabaseSync(':memory:');
144+
t.after(() => { db.close(); });
145+
const setup = db.exec(
146+
'CREATE TABLE data(key INTEGER, val INTEGER) STRICT;'
147+
);
148+
t.assert.strictEqual(setup, undefined);
149+
const stmt = db.prepare(
150+
'INSERT INTO data (key, val) VALUES ($k, $v)',
151+
{ allowUnknownNamedParameters: false }
152+
);
153+
const params = { $a: 1, $b: 2, $k: 42, $y: 25, $v: 84, $z: 99 };
154+
t.assert.throws(() => {
155+
stmt.run(params);
156+
}, {
157+
code: 'ERR_INVALID_STATE',
158+
message: /Unknown named parameter '\$a'/,
159+
});
160+
});
161+
162+
test('unknown named parameters throws error by default', (t) => {
163+
const db = new DatabaseSync(':memory:');
164+
t.after(() => { db.close(); });
165+
const setup = db.exec(
166+
'CREATE TABLE data(key INTEGER, val INTEGER) STRICT;'
167+
);
168+
t.assert.strictEqual(setup, undefined);
169+
const stmt = db.prepare('INSERT INTO data (key, val) VALUES ($k, $v)');
170+
const params = { $a: 1, $b: 2, $k: 42, $y: 25, $v: 84, $z: 99 };
171+
t.assert.throws(() => {
172+
stmt.run(params);
173+
}, {
174+
code: 'ERR_INVALID_STATE',
175+
message: /Unknown named parameter '\$a'/,
176+
});
177+
});
178+
179+
test('throws when option is not a boolean', (t) => {
180+
const db = new DatabaseSync(':memory:');
181+
t.after(() => { db.close(); });
182+
const setup = db.exec(
183+
'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
184+
);
185+
t.assert.strictEqual(setup, undefined);
186+
t.assert.throws(() => {
187+
db.prepare(
188+
'INSERT INTO data (key, val) VALUES ($k, $v)',
189+
{ allowUnknownNamedParameters: 'true' }
190+
);
191+
}, {
192+
code: 'ERR_INVALID_ARG_TYPE',
193+
message: /The "options\.allowUnknownNamedParameters" argument must be a boolean/,
194+
});
195+
});
196+
197+
test('setAllowUnknownNamedParameters can override prepare option', (t) => {
198+
const db = new DatabaseSync(':memory:');
199+
t.after(() => { db.close(); });
200+
const setup = db.exec(
201+
'CREATE TABLE data(key INTEGER, val INTEGER) STRICT;'
202+
);
203+
t.assert.strictEqual(setup, undefined);
204+
const stmt = db.prepare(
205+
'INSERT INTO data (key, val) VALUES ($k, $v)',
206+
{ allowUnknownNamedParameters: true }
207+
);
208+
const params = { $a: 1, $b: 2, $k: 42, $y: 25, $v: 84, $z: 99 };
209+
t.assert.deepStrictEqual(
210+
stmt.run(params),
211+
{ changes: 1, lastInsertRowid: 1 },
212+
);
213+
t.assert.strictEqual(stmt.setAllowUnknownNamedParameters(false), undefined);
214+
t.assert.throws(() => {
215+
stmt.run(params);
216+
}, {
217+
code: 'ERR_INVALID_STATE',
218+
message: /Unknown named parameter '\$a'/,
219+
});
220+
});
221+
});

‎test/parallel/test-sqlite-statement-sync.js‎

Lines changed: 245 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -609,3 +609,248 @@ suite('StatementSync.prototype.setAllowBareNamedParameters()', () => {
609609
});
610610
});
611611
});
612+
613+
suite('options.readBigInts', () => {
614+
test('BigInts are returned when input is true', (t) => {
615+
const db = new DatabaseSync(nextDb());
616+
t.after(() => { db.close(); });
617+
const setup = db.exec(`
618+
CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;
619+
INSERT INTO data (key, val) VALUES (1, 42);
620+
`);
621+
t.assert.strictEqual(setup, undefined);
622+
623+
const query = db.prepare('SELECT val FROM data', { readBigInts: true });
624+
t.assert.deepStrictEqual(query.get(), { __proto__: null, val: 42n });
625+
});
626+
627+
test('numbers are returned when input is false', (t) => {
628+
const db = new DatabaseSync(nextDb());
629+
t.after(() => { db.close(); });
630+
const setup = db.exec(`
631+
CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;
632+
INSERT INTO data (key, val) VALUES (1, 42);
633+
`);
634+
t.assert.strictEqual(setup, undefined);
635+
636+
const query = db.prepare('SELECT val FROM data', { readBigInts: false });
637+
t.assert.deepStrictEqual(query.get(), { __proto__: null, val: 42 });
638+
});
639+
640+
test('throws when input is not a boolean', (t) => {
641+
const db = new DatabaseSync(nextDb());
642+
t.after(() => { db.close(); });
643+
const setup = db.exec(
644+
'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
645+
);
646+
t.assert.strictEqual(setup, undefined);
647+
t.assert.throws(() => {
648+
db.prepare('SELECT val FROM data', { readBigInts: 'true' });
649+
}, {
650+
code: 'ERR_INVALID_ARG_TYPE',
651+
message: /The "options\.readBigInts" argument must be a boolean/,
652+
});
653+
});
654+
655+
test('setReadBigInts can override prepare option', (t) => {
656+
const db = new DatabaseSync(nextDb());
657+
t.after(() => { db.close(); });
658+
const setup = db.exec(`
659+
CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;
660+
INSERT INTO data (key, val) VALUES (1, 42);
661+
`);
662+
t.assert.strictEqual(setup, undefined);
663+
664+
const query = db.prepare('SELECT val FROM data', { readBigInts: true });
665+
t.assert.deepStrictEqual(query.get(), { __proto__: null, val: 42n });
666+
t.assert.strictEqual(query.setReadBigInts(false), undefined);
667+
t.assert.deepStrictEqual(query.get(), { __proto__: null, val: 42 });
668+
});
669+
});
670+
671+
suite('options.returnArrays', () => {
672+
test('arrays are returned when input is true', (t) => {
673+
const db = new DatabaseSync(nextDb());
674+
t.after(() => { db.close(); });
675+
const setup = db.exec(`
676+
CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;
677+
INSERT INTO data (key, val) VALUES (1, 'one');
678+
`);
679+
t.assert.strictEqual(setup, undefined);
680+
681+
const query = db.prepare(
682+
'SELECT key, val FROM data WHERE key = 1',
683+
{ returnArrays: true }
684+
);
685+
t.assert.deepStrictEqual(query.get(), [1, 'one']);
686+
});
687+
688+
test('objects are returned when input is false', (t) => {
689+
const db = new DatabaseSync(nextDb());
690+
t.after(() => { db.close(); });
691+
const setup = db.exec(`
692+
CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;
693+
INSERT INTO data (key, val) VALUES (1, 'one');
694+
`);
695+
t.assert.strictEqual(setup, undefined);
696+
697+
const query = db.prepare(
698+
'SELECT key, val FROM data WHERE key = 1',
699+
{ returnArrays: false }
700+
);
701+
t.assert.deepStrictEqual(query.get(), { __proto__: null, key: 1, val: 'one' });
702+
});
703+
704+
test('throws when input is not a boolean', (t) => {
705+
const db = new DatabaseSync(nextDb());
706+
t.after(() => { db.close(); });
707+
const setup = db.exec(
708+
'CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;'
709+
);
710+
t.assert.strictEqual(setup, undefined);
711+
t.assert.throws(() => {
712+
db.prepare('SELECT key, val FROM data', { returnArrays: 'true' });
713+
}, {
714+
code: 'ERR_INVALID_ARG_TYPE',
715+
message: /The "options\.returnArrays" argument must be a boolean/,
716+
});
717+
});
718+
719+
test('setReturnArrays can override prepare option', (t) => {
720+
const db = new DatabaseSync(nextDb());
721+
t.after(() => { db.close(); });
722+
const setup = db.exec(`
723+
CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;
724+
INSERT INTO data (key, val) VALUES (1, 'one');
725+
`);
726+
t.assert.strictEqual(setup, undefined);
727+
728+
const query = db.prepare(
729+
'SELECT key, val FROM data WHERE key = 1',
730+
{ returnArrays: true }
731+
);
732+
t.assert.deepStrictEqual(query.get(), [1, 'one']);
733+
t.assert.strictEqual(query.setReturnArrays(false), undefined);
734+
t.assert.deepStrictEqual(query.get(), { __proto__: null, key: 1, val: 'one' });
735+
});
736+
737+
test('all() returns arrays when input is true', (t) => {
738+
const db = new DatabaseSync(nextDb());
739+
t.after(() => { db.close(); });
740+
const setup = db.exec(`
741+
CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;
742+
INSERT INTO data (key, val) VALUES (1, 'one');
743+
INSERT INTO data (key, val) VALUES (2, 'two');
744+
`);
745+
t.assert.strictEqual(setup, undefined);
746+
747+
const query = db.prepare(
748+
'SELECT key, val FROM data ORDER BY key',
749+
{ returnArrays: true }
750+
);
751+
t.assert.deepStrictEqual(query.all(), [
752+
[1, 'one'],
753+
[2, 'two'],
754+
]);
755+
});
756+
757+
test('iterate() returns arrays when input is true', (t) => {
758+
const db = new DatabaseSync(nextDb());
759+
t.after(() => { db.close(); });
760+
const setup = db.exec(`
761+
CREATE TABLE data(key INTEGER PRIMARY KEY, val TEXT) STRICT;
762+
INSERT INTO data (key, val) VALUES (1, 'one');
763+
INSERT INTO data (key, val) VALUES (2, 'two');
764+
`);
765+
t.assert.strictEqual(setup, undefined);
766+
767+
const query = db.prepare(
768+
'SELECT key, val FROM data ORDER BY key',
769+
{ returnArrays: true }
770+
);
771+
t.assert.deepStrictEqual(query.iterate().toArray(), [
772+
[1, 'one'],
773+
[2, 'two'],
774+
]);
775+
});
776+
});
777+
778+
suite('options.allowBareNamedParameters', () => {
779+
test('bare named parameters are allowed when input is true', (t) => {
780+
const db = new DatabaseSync(nextDb());
781+
t.after(() => { db.close(); });
782+
const setup = db.exec(
783+
'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
784+
);
785+
t.assert.strictEqual(setup, undefined);
786+
const stmt = db.prepare(
787+
'INSERT INTO data (key, val) VALUES ($k, $v)',
788+
{ allowBareNamedParameters: true }
789+
);
790+
t.assert.deepStrictEqual(
791+
stmt.run({ k: 1, v: 2 }),
792+
{ changes: 1, lastInsertRowid: 1 },
793+
);
794+
});
795+
796+
test('bare named parameters throw when input is false', (t) => {
797+
const db = new DatabaseSync(nextDb());
798+
t.after(() => { db.close(); });
799+
const setup = db.exec(
800+
'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
801+
);
802+
t.assert.strictEqual(setup, undefined);
803+
const stmt = db.prepare(
804+
'INSERT INTO data (key, val) VALUES ($k, $v)',
805+
{ allowBareNamedParameters: false }
806+
);
807+
t.assert.throws(() => {
808+
stmt.run({ k: 1, v: 2 });
809+
}, {
810+
code: 'ERR_INVALID_STATE',
811+
message: /Unknown named parameter 'k'/,
812+
});
813+
});
814+
815+
test('throws when input is not a boolean', (t) => {
816+
const db = new DatabaseSync(nextDb());
817+
t.after(() => { db.close(); });
818+
const setup = db.exec(
819+
'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
820+
);
821+
t.assert.strictEqual(setup, undefined);
822+
t.assert.throws(() => {
823+
db.prepare(
824+
'INSERT INTO data (key, val) VALUES ($k, $v)',
825+
{ allowBareNamedParameters: 'true' }
826+
);
827+
}, {
828+
code: 'ERR_INVALID_ARG_TYPE',
829+
message: /The "options\.allowBareNamedParameters" argument must be a boolean/,
830+
});
831+
});
832+
833+
test('setAllowBareNamedParameters can override prepare option', (t) => {
834+
const db = new DatabaseSync(nextDb());
835+
t.after(() => { db.close(); });
836+
const setup = db.exec(
837+
'CREATE TABLE data(key INTEGER PRIMARY KEY, val INTEGER) STRICT;'
838+
);
839+
t.assert.strictEqual(setup, undefined);
840+
const stmt = db.prepare(
841+
'INSERT INTO data (key, val) VALUES ($k, $v)',
842+
{ allowBareNamedParameters: false }
843+
);
844+
t.assert.throws(() => {
845+
stmt.run({ k: 1, v: 2 });
846+
}, {
847+
code: 'ERR_INVALID_STATE',
848+
message: /Unknown named parameter 'k'/,
849+
});
850+
t.assert.strictEqual(stmt.setAllowBareNamedParameters(true), undefined);
851+
t.assert.deepStrictEqual(
852+
stmt.run({ k: 2, v: 4 }),
853+
{ changes: 1, lastInsertRowid: 2 },
854+
);
855+
});
856+
});

0 commit comments

Comments
 (0)