upping coverage

Author: cblanquera

packages/inquire/tests/Delete.test.ts

@@ -65,4 +65,34 @@ describe('Delete Builder Tests', () => {
     expect(build.filters).to.deep.equal([['', []]]);
   });
 
-});
+  it('Should store JSON filters and custom selector settings', () => {
+    //Configure the builder to use a custom JSON path notation.
+    const del = new Delete('table');
+    del.selector = '->';
+    del.separator = '/';
+
+    //Add both equality and contains-style JSON filters.
+    del.whereJson('__json__ = ?', [ 'meta->status', '__json__' ], 'active');
+    del.whereJsonContains('meta->roles', [ 'admin', 'owner' ]);
+
+    //Confirm the builder preserved the JSON metadata for the dialect.
+    const build = del.build();
+    expect(build.selector).to.equal('->');
+    expect(build.separator).to.equal('/');
+    expect(build.json).to.deep.equal([
+      {
+        selector: 'meta->status',
+        query: '__json__ = ?',
+        replace: '__json__',
+        values: [ 'active' ]
+      },
+      {
+        selector: 'meta->roles',
+        query: 'contains',
+        replace: '',
+        values: [ 'admin', 'owner' ]
+      }
+    ]);
+  });
+
+});

packages/inquire/tests/Engine.test.ts

@@ -335,11 +335,63 @@ describe('Engine Tests', () => {
     expect(result).to.be.an('array').that.is.empty;
   });
 
+  it('Should allow the before hook to short-circuit the database query', async () => {
+    //Use a resource that records whether the connection layer ran.
+    const resource = new MockConnection();
+    const engine = new Engine(resource);
+    const rows = [ { id: 7 } ];
+
+    //Install a before hook that returns rows immediately.
+    engine.before = async request => {
+      expect(request.query).to.equal('SELECT 1');
+      return rows;
+    };
+
+    //Run the query through the public engine method.
+    const result = await engine.query('SELECT 1');
+
+    //Confirm the hook result is returned and the connection is skipped.
+    expect(engine.before).to.be.a('function');
+    expect(result).to.equal(rows);
+    expect(resource.queries).to.have.lengthOf(0);
+  });
+
+  it('Should format template string queries with the dialect quote character', async () => {
+    //Use the mock resource so the test can inspect the emitted request.
+    const resource = new MockConnection();
+    const engine = new Engine(resource);
+
+    //Run the tagged template API with backtick-quoted identifiers.
+    await engine.sql`SELECT \`id\` FROM \`users\` WHERE id = ${1}`;
+
+    //Confirm the template was flattened into the final query object.
+    expect(resource.queries[0]).to.deep.equal({
+      query: 'SELECT "id" FROM "users" WHERE id = ?',
+      values: [ 1 ]
+    });
+  });
+
+  it('Should pass the cascade flag through truncate queries', async () => {
+    //Use the resource recorder to inspect the generated truncate request.
+    const resource = new MockConnection();
+    const engine = new Engine(resource);
+
+    //Run the public truncate helper with cascade enabled.
+    await engine.truncate('sessions', true);
+
+    //Confirm the dialect-generated query preserved the cascade suffix.
+    expect(resource.queries[0]).to.deep.equal({
+      query: 'TRUNCATE TABLE "sessions" CASCADE',
+      values: []
+    });
+  });
+
 });
 
 class MockConnection implements Connection {
   public dialect = Pgsql;
   public resource = {} as any;
+  public queries: QueryObject[] = [];
 
   lastId: string | number | undefined;
 
@@ -382,6 +434,7 @@ class MockConnection implements Connection {
    * library should not care about the kind of database.
    */
   public async query<R = unknown>(request: QueryObject) {
+    this.queries.push(request);
     return [];
   }
 
@@ -391,4 +444,4 @@ class MockConnection implements Connection {
   public async transaction<R = unknown>(callback: Transaction<R>) {
     return [] as R;
   }
-}
+}

packages/inquire/tests/Helpers.test.ts

@@ -0,0 +1,58 @@
+import { describe, it } from 'mocha';
+import { expect } from 'chai';
+//NOTE: no extensions in tests because it's excluded in tsconfig.json and
+//we are testing in a typescript environment via `ts-mocha -r tsx` (esm)
+import Exception from '../src/Exception';
+import {
+  backSlashes,
+  doubleQuotes,
+  escapeBackSlashes,
+  escapeDoubleQuotes,
+  isIndex,
+  joinTypes,
+  jsonCompare,
+  safeJsonValue
+} from '../src/helpers';
+
+describe('Helper Tests', () => {
+  it('Should escape JSON-sensitive string values', () => {
+    //Use simple inputs so each escaping rule is easy to verify.
+    const slashValue = 'C:\\path';
+    const quoteValue = '"quoted"';
+    const safeValue = 'C:\\path "quoted"';
+
+    //Run each helper directly so the coverage reflects the exported API.
+    const withSlashes = escapeBackSlashes(slashValue);
+    const withQuotes = escapeDoubleQuotes(quoteValue);
+    const safeJson = safeJsonValue(safeValue);
+
+    //Confirm each helper only applies the escaping it owns.
+    expect(withSlashes).to.equal('C:\\\\path');
+    expect(withQuotes).to.equal('\\"quoted\\"');
+    expect(safeJson).to.equal('C:\\\\path \\"quoted\\"');
+  });
+
+  it('Should expose the shared helper constants and compare JSON values', () => {
+    //Exercise the exported regex helpers and join mapping directly.
+    expect(joinTypes.full_outer).to.equal('FULL OUTER');
+    expect(isIndex.test('12')).to.equal(true);
+    expect(isIndex.test('id')).to.equal(false);
+    expect('a\\b'.replace(backSlashes, '/')).to.equal('a/b');
+    expect('"a"'.replace(doubleQuotes, '\'')).to.equal('\'a\'');
+
+    //Cover both the equal and not-equal comparison branches.
+    expect(jsonCompare({ id: 1, tags: [ 'a' ] }, { id: 1, tags: [ 'a' ] }))
+      .to.equal(true);
+    expect(jsonCompare({ id: 1 }, { id: 2 })).to.equal(false);
+  });
+
+  it('Should expose the custom exception class', () => {
+    //Instantiate the package-specific error directly.
+    const error = new Exception('Coverage error');
+
+    //Confirm callers receive the package-specific exception type.
+    expect(error).to.be.instanceOf(Exception);
+    expect(error).to.be.instanceOf(Error);
+    expect(error.message).to.equal('Coverage error');
+  });
+});

packages/inquire/tests/Mysql.test.ts

@@ -8,7 +8,7 @@ import Delete from '../src/builder/Delete';
 import Insert from '../src/builder/Insert';
 import Select from '../src/builder/Select';
 import Update from '../src/builder/Update';
-import Mysql from '../src/dialect/Mysql';
+import Mysql, { MysqlDialect } from '../src/dialect/Mysql';
 
 describe('Mysql Dialect Tests', () => {
   it('Should translate alter', async () => {
@@ -399,4 +399,64 @@ describe('Mysql Dialect Tests', () => {
 
     expect(query[0].values).to.be.empty;
   });
-});
+
+  it('Should translate JSON selectors in select queries', () => {
+    //Use a fresh dialect instance so selector mutations stay local.
+    const dialect = new MysqlDialect();
+    const select = new Select([
+      { column: 'profile.data:info.name', alias: 'displayName' },
+      { column: 'profile.data:tags.0' }
+    ]);
+
+    //Build a query that touches selector, where, JSON where, contains, and sort.
+    select.from({ name: 'users', alias: 'u' });
+    select.where('profile.data:info.name = ?', [ 'Ada' ]);
+    select.whereJson(
+      '__json__ = ?',
+      [ 'profile.data:info.name', '__json__' ],
+      'Ada'
+    );
+    select.whereJsonContains('profile.data:tags', [ 'admin', 'owner' ]);
+    select.order({ name: 'profile.data:info.name' }, 'desc');
+
+    //Confirm the dialect rewrote JSON selectors consistently.
+    const query = dialect.select(select);
+    expect(query.query).to.contain('JSON_UNQUOTE(JSON_EXTRACT(`profile`.`data`,');
+    expect(query.query).to.contain('$."info"."name"');
+    expect(query.query).to.contain('$."tags"[0]');
+    expect(query.query).to.contain(
+      "JSON_CONTAINS(`profile`.`data`, '$.\"tags\"')"
+    );
+    expect(query.query).to.contain('ORDER BY');
+    expect(query.values).to.deep.equal([
+      'Ada',
+      'Ada',
+      '"admin"',
+      '"owner"'
+    ]);
+  });
+
+  it('Should expose configurable JSON dialect helpers', () => {
+    //Read and write the shared JsonTrait configuration through Mysql.
+    const dialect = new MysqlDialect();
+    dialect.separator = '/';
+    dialect.splitter = '->';
+
+    //Create helpers through both overloads so parse branches are covered.
+    const parsed = dialect.json('profile.data->info/name', '->', '/');
+    const direct = dialect.json('profile.data', [ 'tags', '0' ]);
+
+    //Confirm the helper metadata matches the expected MySQL JSON syntax.
+    expect(dialect.separator).to.equal('/');
+    expect(dialect.splitter).to.equal('->');
+    expect(parsed.extract).to.equal(
+      "JSON_UNQUOTE(JSON_EXTRACT(`profile`.`data`, '$.\"info\".\"name\"'))"
+    );
+    expect(parsed.where('__json__ = ?', '__json__')).to.equal(
+      "JSON_UNQUOTE(JSON_EXTRACT(`profile`.`data`, '$.\"info\".\"name\"')) = ?"
+    );
+    expect(direct.contains).to.equal(
+      "JSON_CONTAINS(`profile`.`data`, '$.\"tags\"[0]')"
+    );
+  });
+});

packages/inquire/tests/Pgsql.test.ts

@@ -8,7 +8,7 @@ import Delete from '../src/builder/Delete';
 import Insert from '../src/builder/Insert';
 import Select from '../src/builder/Select';
 import Update from '../src/builder/Update';
-import Pgsql from '../src/dialect/Pgsql';
+import Pgsql, { PgsqlDialect } from '../src/dialect/Pgsql';
 
 describe('Pgsql Dialect Tests', () => {
   it('Should translate alter', async () => {
@@ -436,4 +436,51 @@ describe('Pgsql Dialect Tests', () => {
 
     expect(query[0].values).to.be.empty;
   });
-});
+
+  it('Should translate JSON selectors in select queries', () => {
+    //Keep JSON trait mutations isolated to this test instance.
+    const dialect = new PgsqlDialect();
+    const select = new Select([
+      { column: 'profile.data:info.name', alias: 'displayName' },
+      { column: 'profile.data:tags.0' }
+    ]);
+
+    //Exercise raw where clauses, JSON equality filters, contains filters, and sort.
+    select.from({ name: 'users', alias: 'u' });
+    select.where('profile.data:info.name = ?', [ 'Ada' ]);
+    select.whereJson(
+      '__json__ = ?',
+      [ 'profile.data:info.name', '__json__' ],
+      'Ada'
+    );
+    select.whereJsonContains('profile.data:tags', [ 'admin', 'owner' ]);
+    select.order({ name: 'profile.data:info.name' }, 'desc');
+
+    //Confirm the PostgreSQL dialect rewrote the JSON selectors.
+    const query = dialect.select(select);
+    expect(query.query).to.contain('"profile"."data"->$$info$$->>$$name$$');
+    expect(query.query).to.contain('"profile"."data"->$$tags$$->>0');
+    expect(query.query).to.contain('"profile"."data"->$$tags$$ ?? ?');
+    expect(query.query).to.contain('ORDER BY');
+    expect(query.values).to.deep.equal([ 'Ada', 'Ada', 'admin', 'owner' ]);
+  });
+
+  it('Should expose configurable JSON dialect helpers', () => {
+    //Change both JsonTrait delimiters and resolve helper objects through both overloads.
+    const dialect = new PgsqlDialect();
+    dialect.separator = '/';
+    dialect.splitter = '->';
+
+    const parsed = dialect.json('profile.data->info/name', '->', '/');
+    const direct = dialect.json('profile.data', [ 'tags', '0' ]);
+
+    //Confirm the helper API produces the PostgreSQL-specific expressions.
+    expect(dialect.separator).to.equal('/');
+    expect(dialect.splitter).to.equal('->');
+    expect(parsed.extract).to.equal('"profile"."data"->$$info$$->>$$name$$');
+    expect(parsed.where('__json__ = ?', '__json__')).to.equal(
+      '"profile"."data"->$$info$$->>$$name$$ = ?'
+    );
+    expect(direct.contains).to.equal('"profile"."data"->$$tags$$->0 ?? ?');
+  });
+});

packages/inquire/tests/Select.test.ts

@@ -104,7 +104,37 @@ describe('Select Builder Tests', () => {
     expect(filters[0].clause).to.equal('');
     expect(filters[0].values).to.deep.equal([]);
   });
- 
 
+  it('Should split comma-separated selectors and preserve JSON filter metadata', () => {
+    //Start with a raw selector string so the split-and-trim branch runs.
+    const select = new Select(' id, profile.data:info.name , , count(*) ');
 
-});
+    //Add JSON filters to exercise the builder-only storage logic.
+    select.whereJson('__json__ = ?', [ 'profile.data:info.name', '__json__' ], 'Ada');
+    select.whereJsonContains('profile.data:tags', 'admin');
+
+    //Confirm blank selectors were removed and JSON filters were stored.
+    const build = select.build();
+    expect(build.selectors).to.deep.equal([
+      'id',
+      'profile.data:info.name',
+      'count(*)'
+    ]);
+    expect(build.json).to.deep.equal([
+      {
+        selector: 'profile.data:info.name',
+        query: '__json__ = ?',
+        replace: '__json__',
+        values: [ 'Ada' ]
+      },
+      {
+        selector: 'profile.data:tags',
+        query: 'contains',
+        replace: '',
+        values: [ 'admin' ]
+      }
+    ]);
+  });
+
+
+});