test: increase test coverage for ConnectionString

Author: dhensby

package.json

@@ -17,7 +17,7 @@
     "build": "tsc",
     "lint": "eslint ./src ./test",
     "test": "tsx --test test/**/*.test.ts",
-    "test:coverage": "c8 --reporter=cobertura -- tsx --test test/**/*.test.ts",
+    "test:coverage": "c8 --reporter=cobertura -- tsx --test test/**/*.test.ts test/*.test.ts",
     "test:workflow": "npm run test --silent"
   },
   "keywords": [

src/connection-string.ts

@@ -44,7 +44,7 @@ export class ConnectionString implements ReadonlyMap<string, string> {
     // it would be really nice to be able to make this a generice (eg: get<string>) and that would then coerce the value
     // see typia library for an example of something similar
     get<T extends CoerceType = 'string'>(key: string, coerceType?: T): CoerceTypeMap[T] | undefined {
-        const val = this.#parsed.get(key);
+        const val = this.#parsed.get(key.toLowerCase());
         const actualType = coerceType ?? 'string';
         if (typeof val === 'undefined' || actualType === 'string') {
             return val as CoerceTypeMap[T];
@@ -96,7 +96,7 @@ export class ConnectionString implements ReadonlyMap<string, string> {
             // try to find the property
             const prop = [key, ...aliases ?? []].find((k) => this.has(k));
             if (prop || includeMissing) {
-                props.push([key, prop ? this.get(prop, type) : defaultValue] as [keyof T, CoerceType]);
+                props.push([key, prop ? this.get(prop.toLowerCase(), type) : defaultValue] as [keyof T, CoerceType]);
             }
             return props;
         }, [] as [keyof T, CoerceType][])) as InferSchema<T>;

test/connection-string.test.ts

@@ -0,0 +1,107 @@
+import * as assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { ConnectionString } from '../src/connection-string';
+
+describe('connection-string', () => {
+    const connectionString = 'keyword=value;isTrue=true;isYes=yes;isFalse=false;isNo=no;is0=0;is1=1';
+    describe('.has()', () => {
+        it('returns true for existing keys', () => {
+            const parsed = new ConnectionString(connectionString);
+            assert.equal(parsed.has('keyword'), true);
+            assert.equal(parsed.has('isTrue'), true);
+            assert.equal(parsed.has('isYes'), true);
+            assert.equal(parsed.has('isFalse'), true);
+            assert.equal(parsed.has('isNo'), true);
+            assert.equal(parsed.has('is0'), true);
+            assert.equal(parsed.has('is1'), true);
+        });
+        it('returns false for missing keys', () => {
+            const parsed = new ConnectionString(connectionString);
+            assert.equal(parsed.has('missing'), false);
+        });
+    });
+    describe('.get()', () => {
+        it('coerces a string', () => {
+            const parsed = new ConnectionString(connectionString);
+            assert.equal(parsed.get('keyword'), 'value');
+            assert.equal(parsed.get('keyword', 'string'), 'value');
+        });
+        it('coerces a string to a number', () => {
+            const parsed = new ConnectionString(connectionString);
+            assert.equal(parsed.get('keyword', 'number'), Number.NaN);
+            assert.equal(parsed.get('is0', 'number'), 0);
+            assert.equal(parsed.get('is1', 'number'), 1);
+        });
+        it('coerces a string to a boolean', () => {
+            const parsed = new ConnectionString(connectionString);
+            assert.equal(parsed.get('keyword', 'boolean'), true);
+        });
+        it('coerces a boolean', () => {
+            const parsed = new ConnectionString(connectionString);
+            assert.equal(parsed.get('isTrue', 'boolean'), true);
+            assert.equal(parsed.get('isFalse', 'boolean'), false);
+            assert.equal(parsed.get('isYes', 'boolean'), true);
+            assert.equal(parsed.get('isNo', 'boolean'), false);
+            assert.equal(parsed.get('is0', 'boolean'), false);
+            assert.equal(parsed.get('is1', 'boolean'), true);
+        });
+        it('returns undefined for missing value', () => {
+            const parsed = new ConnectionString(connectionString);
+            assert.equal(parsed.get('missing'), undefined);
+        });
+    });
+    describe('.size', () => {
+        it('returns the number of properties', () => {
+            const parsed = new ConnectionString(connectionString);
+            assert.equal(parsed.size, 7);
+        });
+    });
+    describe('.keys()', () => {
+        it('returns the keys', () => {
+            const parsed = new ConnectionString(connectionString);
+            assert.deepEqual(Array.from(parsed.keys()), [
+                'keyword',
+                'istrue',
+                'isyes',
+                'isfalse',
+                'isno',
+                'is0',
+                'is1',
+            ]);
+        });
+    });
+    describe('.values()', () => {
+        it('returns the values', () => {
+            const parsed = new ConnectionString(connectionString);
+            assert.deepEqual(Array.from(parsed.values()), [
+                'value',
+                'true',
+                'yes',
+                'false',
+                'no',
+                '0',
+                '1',
+            ]);
+        });
+    });
+    describe('.entries()', () => {
+        it('returns the entries', () => {
+            const parsed = new ConnectionString(connectionString);
+            assert.deepEqual(Array.from(parsed.entries()), [
+                ['keyword', 'value'],
+                ['istrue', 'true'],
+                ['isyes', 'yes'],
+                ['isfalse', 'false'],
+                ['isno', 'no'],
+                ['is0', '0'],
+                ['is1', '1'],
+            ]);
+        });
+    });
+    describe('.toString()', () => {
+        it('returns the connection string', () => {
+            const parsed = new ConnectionString(connectionString);
+            assert.equal(parsed.toString(), connectionString);
+        });
+    });
+});