test: add comprehensive vitest test suite with 100% coverage

Add vitest with v8 coverage provider and 95% threshold enforcement.
75 tests across 10 test files covering all source modules:
HttpError, FetchAdapter, AuthenticatedAdapter, EQP, and all 6 services.

Author: CybotTM

.github/workflows/lint.and.build.yml

@@ -35,6 +35,22 @@ jobs:
             - name: 🔨 Build
               run: yarn build:lib
 
+    test:
+        name: 🧪 Test
+        runs-on: ubuntu-24.04
+        steps:
+            - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+            - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
+              with:
+                  node-version: 24
+                  cache: yarn
+
+            - name: ⚡ Install dependencies
+              run: yarn install --frozen-lockfile
+
+            - name: 🧪 Test
+              run: yarn test:coverage
+
     lint:
         name: 🔎 Lint
         runs-on: ubuntu-24.04

package.json

@@ -12,24 +12,28 @@
 	"license": "MIT",
 	"scripts": {
 		"build": "yarn build:lib && yarn build:docs",
-		"build:lib": "tsc",
+		"build:lib": "tsc -p tsconfig.build.json",
 		"build:lib:dev": "tsc -w",
 		"build:docs": "typedoc --out docs --entryPoints src/index.ts",
+		"test": "vitest run",
+		"test:coverage": "vitest run --coverage",
 		"lint": "eslint src",
 		"prepack": "yarn build:lib",
 		"prepare": "husky"
 	},
 	"devDependencies": {
 		"@eslint/js": "^10.0.0",
 		"@types/node": "^24.0.0",
+		"@vitest/coverage-v8": "^4.0.18",
 		"eslint": "^10.0.0",
 		"eslint-config-prettier": "^10.0.0",
 		"husky": "^9.1.7",
 		"lint-staged": "^16.2.7",
 		"prettier": "^3.0.0",
 		"typedoc": "^0.28.0",
 		"typescript": "^5.1.6",
-		"typescript-eslint": "^8.0.0"
+		"typescript-eslint": "^8.0.0",
+		"vitest": "^4.0.18"
 	},
 	"dependencies": {
 		"tslib": "^2.6.0"

src/__tests__/AuthenticatedAdapter.test.ts

@@ -0,0 +1,150 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { AuthenticatedAdapter } from '../AuthenticatedAdapter';
+import { Adapter } from '../types/adapters';
+
+describe('AuthenticatedAdapter', () => {
+	let mockBaseAdapter: Adapter;
+	let adapter: AuthenticatedAdapter;
+	const credentials = { appId: 'test-app-id', appSecret: 'test-app-secret' };
+
+	beforeEach(() => {
+		mockBaseAdapter = {
+			setHeader: vi.fn(),
+			get: vi.fn().mockResolvedValue({}),
+			post: vi.fn().mockResolvedValue({
+				mage_id: 'MAG123',
+				ust: 'test-token-xyz',
+				expires_in: 360
+			}),
+			put: vi.fn().mockResolvedValue({}),
+			delete: vi.fn().mockResolvedValue({})
+		};
+		adapter = new AuthenticatedAdapter(mockBaseAdapter, credentials);
+	});
+
+	describe('authenticate', () => {
+		it('should POST to /app/session/token with Basic auth', async () => {
+			await adapter.get('/test');
+
+			expect(mockBaseAdapter.post).toHaveBeenCalledWith(
+				'/app/session/token',
+				{ grant_type: 'session', expires_in: 360 },
+				{
+					auth: {
+						username: 'test-app-id',
+						password: 'test-app-secret'
+					}
+				}
+			);
+		});
+	});
+
+	describe('Bearer token', () => {
+		it('should pass Bearer token in authorization header', async () => {
+			await adapter.get('/test');
+
+			expect(mockBaseAdapter.get).toHaveBeenCalledWith('/test', { headers: { authorization: 'Bearer test-token-xyz' } });
+		});
+	});
+
+	describe('|MAGE_ID| replacement', () => {
+		it('should replace |MAGE_ID| in URLs', async () => {
+			await adapter.get('/users/|MAGE_ID|/profile');
+
+			expect(mockBaseAdapter.get).toHaveBeenCalledWith('/users/MAG123/profile', expect.any(Object));
+		});
+
+		it('should replace |MAGE_ID| for POST requests', async () => {
+			await adapter.post('/users/|MAGE_ID|', { data: 'test' });
+
+			expect(mockBaseAdapter.post).toHaveBeenCalledTimes(2); // 1 auth + 1 actual
+			const actualCall = (mockBaseAdapter.post as ReturnType<typeof vi.fn>).mock.calls[1];
+			expect(actualCall[0]).toBe('/users/MAG123');
+		});
+
+		it('should replace |MAGE_ID| for PUT requests', async () => {
+			await adapter.put('/users/|MAGE_ID|', { data: 'test' });
+
+			expect(mockBaseAdapter.put).toHaveBeenCalledWith('/users/MAG123', { data: 'test' }, expect.any(Object));
+		});
+
+		it('should replace |MAGE_ID| for DELETE requests', async () => {
+			await adapter.delete('/users/|MAGE_ID|/key');
+
+			expect(mockBaseAdapter.delete).toHaveBeenCalledWith('/users/MAG123/key', expect.any(Object));
+		});
+	});
+
+	describe('addHeaders', () => {
+		it('should merge auth headers with existing config headers', async () => {
+			await adapter.get('/test', { headers: { 'x-custom': 'value' } });
+
+			expect(mockBaseAdapter.get).toHaveBeenCalledWith('/test', {
+				headers: {
+					'x-custom': 'value',
+					authorization: 'Bearer test-token-xyz'
+				}
+			});
+		});
+
+		it('should work when config is undefined', async () => {
+			await adapter.get('/test');
+
+			expect(mockBaseAdapter.get).toHaveBeenCalledWith('/test', { headers: { authorization: 'Bearer test-token-xyz' } });
+		});
+	});
+
+	describe('HTTP method delegation', () => {
+		it('should delegate get', async () => {
+			await adapter.get('/path', { params: { a: '1' } });
+
+			expect(mockBaseAdapter.get).toHaveBeenCalledWith(
+				'/path',
+				expect.objectContaining({
+					params: { a: '1' },
+					headers: expect.objectContaining({ authorization: 'Bearer test-token-xyz' })
+				})
+			);
+		});
+
+		it('should delegate post', async () => {
+			await adapter.post('/path', { body: true });
+
+			const calls = (mockBaseAdapter.post as ReturnType<typeof vi.fn>).mock.calls;
+			const actualCall = calls[calls.length - 1];
+			expect(actualCall[0]).toBe('/path');
+			expect(actualCall[1]).toEqual({ body: true });
+		});
+
+		it('should delegate put', async () => {
+			await adapter.put('/path', { body: true });
+
+			expect(mockBaseAdapter.put).toHaveBeenCalledWith(
+				'/path',
+				{ body: true },
+				expect.objectContaining({
+					headers: expect.objectContaining({ authorization: 'Bearer test-token-xyz' })
+				})
+			);
+		});
+
+		it('should delegate delete', async () => {
+			await adapter.delete('/path');
+
+			expect(mockBaseAdapter.delete).toHaveBeenCalledWith(
+				'/path',
+				expect.objectContaining({
+					headers: expect.objectContaining({ authorization: 'Bearer test-token-xyz' })
+				})
+			);
+		});
+	});
+
+	describe('getMageId', () => {
+		it('should return the mage_id from authentication', async () => {
+			const mageId = await adapter.getMageId();
+
+			expect(mageId).toBe('MAG123');
+		});
+	});
+});

src/__tests__/EQP.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { EQP } from '../index';
+import { FileService } from '../services/FileService';
+import { UserService } from '../services/UserService';
+import { KeyService } from '../services/KeyService';
+import { CallbackService } from '../services/CallbackService';
+import { ReportService } from '../services/ReportService';
+import { PackageService } from '../services/PackageService';
+
+// Mock global fetch to prevent real requests during EQP construction
+vi.stubGlobal('fetch', vi.fn());
+
+describe('EQP', () => {
+	const defaultOptions = {
+		appId: 'test-app-id',
+		appSecret: 'test-app-secret'
+	};
+
+	describe('environment URLs', () => {
+		it('should use production URL by default', () => {
+			const eqp = new EQP(defaultOptions);
+
+			expect(eqp).toBeDefined();
+		});
+
+		it('should use production URL when environment is "production"', () => {
+			const eqp = new EQP({ ...defaultOptions, environment: 'production' });
+
+			expect(eqp).toBeDefined();
+		});
+
+		it('should use sandbox URL when environment is "sandbox"', () => {
+			const eqp = new EQP({ ...defaultOptions, environment: 'sandbox' });
+
+			expect(eqp).toBeDefined();
+		});
+	});
+
+	describe('custom adapter', () => {
+		it('should use provided adapter instead of creating FetchAdapter', () => {
+			const customAdapter = {
+				setHeader: vi.fn(),
+				get: vi.fn(),
+				post: vi.fn(),
+				put: vi.fn(),
+				delete: vi.fn()
+			};
+
+			const eqp = new EQP({ ...defaultOptions, adapter: customAdapter });
+
+			expect(eqp).toBeDefined();
+		});
+	});
+
+	describe('services', () => {
+		let eqp: EQP;
+
+		beforeEach(() => {
+			eqp = new EQP(defaultOptions);
+		});
+
+		it('should initialize fileService', () => {
+			expect(eqp.fileService).toBeInstanceOf(FileService);
+		});
+
+		it('should initialize userService', () => {
+			expect(eqp.userService).toBeInstanceOf(UserService);
+		});
+
+		it('should initialize keyService', () => {
+			expect(eqp.keyService).toBeInstanceOf(KeyService);
+		});
+
+		it('should initialize callbackService', () => {
+			expect(eqp.callbackService).toBeInstanceOf(CallbackService);
+		});
+
+		it('should initialize reportService', () => {
+			expect(eqp.reportService).toBeInstanceOf(ReportService);
+		});
+
+		it('should initialize packageService', () => {
+			expect(eqp.packageService).toBeInstanceOf(PackageService);
+		});
+	});
+
+	describe('getMageId', () => {
+		it('should delegate to adapter.getMageId()', async () => {
+			const customAdapter = {
+				setHeader: vi.fn(),
+				get: vi.fn(),
+				post: vi.fn().mockResolvedValue({ mage_id: 'MAG456', ust: 'token', expires_in: 360 }),
+				put: vi.fn(),
+				delete: vi.fn()
+			};
+
+			const eqp = new EQP({ ...defaultOptions, adapter: customAdapter });
+			const mageId = await eqp.getMageId();
+
+			expect(mageId).toBe('MAG456');
+		});
+	});
+});