@anonympins/fingerprint 0.5.1 → 0.5.4

package/src/js/redis-store.js

@@ -1,43 +1,115 @@
-/**
- * @file Creates a store adapter for ioredis.
- * This adapter handles the serialization and deserialization of complex objects,
- * including the conversion of Set objects to arrays for storage in Redis.
- */
-
-/**
- * Creates a store adapter for an ioredis client.
- * @param {import('ioredis').Redis} redisClient - An instance of the ioredis client.
- * @returns {import('./fingerprint.js').IStore} An object that complies with the IStore interface.
- */
-export function createRedisStore(redisClient) {
-  return {
-    async get(key) {
-      const value = await redisClient.get(key);
-      if (!value) return null;
-      // Use a reviver to convert arrays back to Sets for specific keys like 'ips'.
-      return JSON.parse(value, (k, v) => {
-        if (k === 'ips' && Array.isArray(v)) {
-          return new Set(v);
-        }
-        return v;
-      });
-    },
-    async set(key, value, ttl) {
-      // Use a replacer to convert Set objects into arrays before serialization.
-      const stringValue = JSON.stringify(value, (k, v) => {
-        if (v instanceof Set) {
-          return Array.from(v);
-        }
-        return v;
-      });
-
-      if (ttl && ttl > 0) {
-        await redisClient.set(key, stringValue, 'EX', ttl);
-      } else {
-        await redisClient.set(key, stringValue);
-      }
-    },
-    async has(key) { return (await redisClient.exists(key)) === 1; },
-    async delete(key) { await redisClient.del(key); },
-  };
+/**
+ * @file Creates a store adapter for ioredis.
+ * This adapter handles the serialization and deserialization of complex objects,
+ * including the conversion of Set objects to arrays for storage in Redis.
+ */
+
+/**
+ * Creates a store adapter for an ioredis client.
+ * @param {import('ioredis').Redis} redisClient - An instance of the ioredis client.
+ * @returns {import('./fingerprint.js').IStore} An object that complies with the IStore interface.
+ */
+export function createRedisStore(redisClient) {
+  const replacer = (k, v) => (v instanceof Set ? Array.from(v) : v);
+  const reviver = (k, v) => (k === 'ips' && Array.isArray(v) ? new Set(v) : v);
+
+  const localStore = new Map();
+  const localTimeouts = new Map();
+  let isDown = false;
+  let reconnecting = false;
+
+  const triggerFallback = () => {
+    if (!isDown) {
+      isDown = true;
+      attemptReconnection();
+    }
+  };
+
+  const attemptReconnection = () => {
+    if (reconnecting) return;
+    reconnecting = true;
+    const interval = setInterval(async () => {
+      try {
+        await redisClient.ping();
+        isDown = false;
+        reconnecting = false;
+        clearInterval(interval);
+      } catch (err) {
+        // Continue de tenter la reconnexion toutes les 5 secondes
+      }
+    }, 5000);
+    if (interval.unref) interval.unref();
+  };
+
+  const setLocal = (key, value, ttl) => {
+    localStore.set(key, value);
+    if (localTimeouts.has(key)) {
+      clearTimeout(localTimeouts.get(key));
+    }
+    if (ttl && ttl > 0) {
+      const timeout = setTimeout(() => {
+        localStore.delete(key);
+        localTimeouts.delete(key);
+      }, ttl * 1000);
+      if (timeout.unref) timeout.unref();
+      localTimeouts.set(key, timeout);
+    }
+  };
+
+  return {
+    async get(key) {
+      if (isDown) {
+        return localStore.get(key) || null;
+      }
+      try {
+        const value = await redisClient.get(key);
+        if (!value) return null;
+        return JSON.parse(value, reviver);
+      } catch (e) {
+        triggerFallback();
+        return localStore.get(key) || null;
+      }
+    },
+    async set(key, value, ttl) {
+      if (isDown) {
+        setLocal(key, value, ttl);
+        return;
+      }
+      try {
+        const stringValue = JSON.stringify(value, replacer);
+        if (ttl && ttl > 0) {
+          await redisClient.set(key, stringValue, 'EX', ttl);
+        } else {
+          await redisClient.set(key, stringValue);
+        }
+      } catch (e) {
+        triggerFallback();
+        setLocal(key, value, ttl);
+      }
+    },
+    async has(key) {
+      if (isDown) {
+        return localStore.has(key);
+      }
+      try {
+        return (await redisClient.exists(key)) === 1;
+      } catch (e) {
+        triggerFallback();
+        return localStore.has(key);
+      }
+    },
+    async delete(key) {
+      if (localTimeouts.has(key)) {
+        clearTimeout(localTimeouts.get(key));
+        localTimeouts.delete(key);
+      }
+      localStore.delete(key);
+      if (isDown) return;
+      try {
+        await redisClient.del(key);
+      } catch (e) {
+        triggerFallback();
+      }
+    },
+  };
 }

package/src/js/tests/dns-circuit-breaker.test.js

@@ -0,0 +1,55 @@
+import { describe, expect, it, beforeEach } from 'vitest';
+import { __internal } from '../fingerprint.js';
+
+const { dnsCircuitBreaker, recordDnsSuccess, recordDnsFailure, canAttemptDns } = __internal;
+
+describe('DNS Circuit Breaker', () => {
+    beforeEach(() => {
+        dnsCircuitBreaker.state = 'CLOSED';
+        dnsCircuitBreaker.failureCount = 0;
+        dnsCircuitBreaker.lastStateChange = 0;
+        dnsCircuitBreaker.threshold = 5;
+        dnsCircuitBreaker.cooldownMs = 1000; // 1s de cooldown pour accélérer le test unitaire
+    });
+
+    it('devrait démarrer à l\'état CLOSED et autoriser les résolutions', () => {
+        expect(canAttemptDns()).toBe(true);
+        expect(dnsCircuitBreaker.state).toBe('CLOSED');
+    });
+
+    it('devrait s\'ouvrir après avoir atteint le seuil d\'échecs (5)', () => {
+        for (let i = 0; i < 4; i++) {
+            recordDnsFailure();
+            expect(canAttemptDns()).toBe(true);
+            expect(dnsCircuitBreaker.state).toBe('CLOSED');
+        }
+
+        recordDnsFailure();
+        expect(canAttemptDns()).toBe(false);
+        expect(dnsCircuitBreaker.state).toBe('OPEN');
+    });
+
+    it('devrait passer en HALF-OPEN après expiration du cooldown', async () => {
+        for (let i = 0; i < 5; i++) {
+            recordDnsFailure();
+        }
+        expect(canAttemptDns()).toBe(false);
+
+        await new Promise((resolve) => setTimeout(resolve, 1100));
+
+        expect(canAttemptDns()).toBe(true);
+        expect(dnsCircuitBreaker.state).toBe('HALF-OPEN');
+    });
+
+    it('devrait se refermer (CLOSED) après un succès en HALF-OPEN', async () => {
+        for (let i = 0; i < 5; i++) {
+            recordDnsFailure();
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1100));
+        expect(canAttemptDns()).toBe(true); // Passage en HALF-OPEN
+
+        recordDnsSuccess();
+        expect(dnsCircuitBreaker.state).toBe('CLOSED');
+        expect(dnsCircuitBreaker.failureCount).toBe(0);
+    });
+});

package/src/js/tests/fingerprint.client.init.test.js

@@ -1,144 +1,144 @@
-import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest';
-import {JSDOM} from 'jsdom';
-import ClientLibrary from '../fingerprint.client.js';
-
-// --- Setup JSDOM Environment ---
-// Vitest peut être configuré pour le faire automatiquement, mais le faire manuellement
-// ici rend le test explicite et portable.
-const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>', {
-    url: 'http://localhost',
-});
-
-// In recent Node.js versions, some global properties like 'navigator', 'performance',
-// and 'screen' are read-only. To ensure our JSDOM environment works correctly across
-// all versions, we use Object.defineProperty to make these properties writable.
-Object.defineProperty(global, 'window', { value: dom.window, writable: true });
-Object.defineProperty(global, 'document', { value: dom.window.document, writable: true });
-Object.defineProperty(global, 'navigator', { value: dom.window.navigator, writable: true });
-Object.defineProperty(global, 'screen', { value: dom.window.screen, writable: true });
-Object.defineProperty(global, 'performance', { value: dom.window.performance, writable: true });
-
-global.fetch = vi.fn(); // Mock global fetch
-global.Headers = dom.window.Headers;
-global.Request = dom.window.Request;
-global.URL = dom.window.URL;
-global.TextEncoder = dom.window.TextEncoder;
-
-
-describe('ClientLibrary.initializeClient', () => {
-
-    // On utilise des espions (spies) pour vérifier si les méthodes internes sont appelées.
-    let startMouseSpy, startKeystrokeSpy, startClickSpy, startTouchSpy, startRenderingSpy, initWasmSpy, initHoneypotsSpy, injectTrapsSpy, initFetchSpy, injectPhantomTrapsSpy;
-
-    beforeEach(() => {
-        // Réinitialiser l'état du client avant chaque test
-        ClientLibrary._resetCache();
-
-        // Créer les espions sur les méthodes internes
-        startMouseSpy = vi.spyOn(ClientLibrary, 'startMouseEntropyTracker');
-        startKeystrokeSpy = vi.spyOn(ClientLibrary, 'startKeystrokeDynamicsTracker');
-        startClickSpy = vi.spyOn(ClientLibrary, 'startClickTracker');
-        startTouchSpy = vi.spyOn(ClientLibrary, 'startTouchEventTracker');
-        startRenderingSpy = vi.spyOn(ClientLibrary, 'startRenderingTracker');
-        initWasmSpy = vi.spyOn(ClientLibrary, 'initializeWasm').mockResolvedValue(undefined);
-        initHoneypotsSpy = vi.spyOn(ClientLibrary, 'initializeHoneypots');
-        injectTrapsSpy = vi.spyOn(ClientLibrary, 'injectTrapLinks');
-        initFetchSpy = vi.spyOn(ClientLibrary, 'initializeFetch');
-        injectPhantomTrapsSpy = vi.spyOn(ClientLibrary, 'injectPhantomTraps');
-    });
-
-    afterEach(() => {
-        // Restaurer les espions après chaque test pour ne pas affecter les autres tests
-        vi.restoreAllMocks();
-    });
-
-    it('should enable all trackers by default', () => {
-        ClientLibrary.initializeClient();
-
-        expect(startMouseSpy).toHaveBeenCalled();
-        expect(startKeystrokeSpy).toHaveBeenCalled();
-        expect(startClickSpy).toHaveBeenCalled();
-        expect(startTouchSpy).toHaveBeenCalled();
-        expect(startRenderingSpy).toHaveBeenCalled();
-        expect(injectPhantomTrapsSpy).toHaveBeenCalled();
-    });
-
-    it('should disable trackers when configured', () => {
-        ClientLibrary.initializeClient({ mouse: false, keystrokes: false, clicks: false, touches: false, rendering: false });
-
-        expect(startMouseSpy).not.toHaveBeenCalled();
-        expect(startKeystrokeSpy).not.toHaveBeenCalled();
-        expect(startClickSpy).not.toHaveBeenCalled();
-        expect(startTouchSpy).not.toHaveBeenCalled();
-        expect(startRenderingSpy).not.toHaveBeenCalled();
-    });
-
-    it('should initialize WASM if wasmPath is configured', () => {
-        ClientLibrary.initializeClient({ wasmPath: '/fp.js' });
-
-        expect(initWasmSpy).toHaveBeenCalledWith('/fp.js');
-    });
-
-    it('should disable phantom traps when configured', () => {
-        ClientLibrary.initializeClient({ phantomTraps: false });
-
-        expect(injectPhantomTrapsSpy).not.toHaveBeenCalled();
-    });
-
-    it('should initialize honeypots with the provided field names', () => {
-        const honeypotFields = ['email_confirm', 'user_nickname'];
-        ClientLibrary.initializeClient({ honeypots: honeypotFields });
-
-        expect(initHoneypotsSpy).toHaveBeenCalledWith(honeypotFields);
-    });
-
-    it('should not initialize honeypots if the array is empty', () => {
-        ClientLibrary.initializeClient({ honeypots: [] });
-
-        expect(initHoneypotsSpy).not.toHaveBeenCalled();
-    });
-
-    it('should inject trap URLs when provided', () => {
-        const urls = ['/trap1?sig=123', '/trap2?sig=456'];
-        ClientLibrary.initializeClient({ trapUrls: urls });
-
-        expect(injectTrapsSpy).toHaveBeenCalledWith(urls);
-    });
-
-    it('should not inject trap URLs if the array is empty', () => {
-        ClientLibrary.initializeClient({ trapUrls: [] });
-
-        expect(injectTrapsSpy).not.toHaveBeenCalled();
-    });
-
-    it('should initialize fetch interception when fetch config is present', () => {
-        const targetDomains = ['api.example.com'];
-        ClientLibrary.initializeClient({ fetch: { targetDomains } });
-
-        expect(initFetchSpy).toHaveBeenCalledWith(targetDomains);
-    });
-
-    it('should not initialize fetch interception if fetch config is absent', () => {
-        ClientLibrary.initializeClient(); // No fetch config
-
-        expect(initFetchSpy).not.toHaveBeenCalled();
-    });
-
-    it('should call all initializers correctly when a full config is provided', () => {
-        const config = {
-            mouse: true,
-            keystrokes: true,
-            honeypots: ['field1'],
-            trapUrls: ['/trap1'],
-            fetch: { targetDomains: ['api.com'] }
-        };
-        ClientLibrary.initializeClient(config);
-
-        expect(startMouseSpy).toHaveBeenCalled();
-        expect(startKeystrokeSpy).toHaveBeenCalled();
-        expect(initHoneypotsSpy).toHaveBeenCalledWith(config.honeypots);
-        expect(injectTrapsSpy).toHaveBeenCalledWith(config.trapUrls);
-        expect(initFetchSpy).toHaveBeenCalledWith(config.fetch.targetDomains);
-    });
-
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest';
+import {JSDOM} from 'jsdom';
+import ClientLibrary from '../fingerprint.client.js';
+
+// --- Setup JSDOM Environment ---
+// Vitest peut être configuré pour le faire automatiquement, mais le faire manuellement
+// ici rend le test explicite et portable.
+const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>', {
+    url: 'http://localhost',
+});
+
+// In recent Node.js versions, some global properties like 'navigator', 'performance',
+// and 'screen' are read-only. To ensure our JSDOM environment works correctly across
+// all versions, we use Object.defineProperty to make these properties writable.
+Object.defineProperty(global, 'window', { value: dom.window, writable: true });
+Object.defineProperty(global, 'document', { value: dom.window.document, writable: true });
+Object.defineProperty(global, 'navigator', { value: dom.window.navigator, writable: true });
+Object.defineProperty(global, 'screen', { value: dom.window.screen, writable: true });
+Object.defineProperty(global, 'performance', { value: dom.window.performance, writable: true });
+
+global.fetch = vi.fn(); // Mock global fetch
+global.Headers = dom.window.Headers;
+global.Request = dom.window.Request;
+global.URL = dom.window.URL;
+global.TextEncoder = dom.window.TextEncoder;
+
+
+describe('ClientLibrary.initializeClient', () => {
+
+    // On utilise des espions (spies) pour vérifier si les méthodes internes sont appelées.
+    let startMouseSpy, startKeystrokeSpy, startClickSpy, startTouchSpy, startRenderingSpy, initWasmSpy, initHoneypotsSpy, injectTrapsSpy, initFetchSpy, injectPhantomTrapsSpy;
+
+    beforeEach(() => {
+        // Réinitialiser l'état du client avant chaque test
+        ClientLibrary._resetCache();
+
+        // Créer les espions sur les méthodes internes
+        startMouseSpy = vi.spyOn(ClientLibrary, 'startMouseEntropyTracker');
+        startKeystrokeSpy = vi.spyOn(ClientLibrary, 'startKeystrokeDynamicsTracker');
+        startClickSpy = vi.spyOn(ClientLibrary, 'startClickTracker');
+        startTouchSpy = vi.spyOn(ClientLibrary, 'startTouchEventTracker');
+        startRenderingSpy = vi.spyOn(ClientLibrary, 'startRenderingTracker');
+        initWasmSpy = vi.spyOn(ClientLibrary, 'initializeWasm').mockResolvedValue(undefined);
+        initHoneypotsSpy = vi.spyOn(ClientLibrary, 'initializeHoneypots');
+        injectTrapsSpy = vi.spyOn(ClientLibrary, 'injectTrapLinks');
+        initFetchSpy = vi.spyOn(ClientLibrary, 'initializeFetch');
+        injectPhantomTrapsSpy = vi.spyOn(ClientLibrary, 'injectPhantomTraps');
+    });
+
+    afterEach(() => {
+        // Restaurer les espions après chaque test pour ne pas affecter les autres tests
+        vi.restoreAllMocks();
+    });
+
+    it('should enable all trackers by default', () => {
+        ClientLibrary.initializeClient();
+
+        expect(startMouseSpy).toHaveBeenCalled();
+        expect(startKeystrokeSpy).toHaveBeenCalled();
+        expect(startClickSpy).toHaveBeenCalled();
+        expect(startTouchSpy).toHaveBeenCalled();
+        expect(startRenderingSpy).toHaveBeenCalled();
+        expect(injectPhantomTrapsSpy).toHaveBeenCalled();
+    });
+
+    it('should disable trackers when configured', () => {
+        ClientLibrary.initializeClient({ mouse: false, keystrokes: false, clicks: false, touches: false, rendering: false });
+
+        expect(startMouseSpy).not.toHaveBeenCalled();
+        expect(startKeystrokeSpy).not.toHaveBeenCalled();
+        expect(startClickSpy).not.toHaveBeenCalled();
+        expect(startTouchSpy).not.toHaveBeenCalled();
+        expect(startRenderingSpy).not.toHaveBeenCalled();
+    });
+
+    it('should initialize WASM if wasmPath is configured', () => {
+        ClientLibrary.initializeClient({ wasmPath: '/fp.js' });
+
+        expect(initWasmSpy).toHaveBeenCalledWith('/fp.js');
+    });
+
+    it('should disable phantom traps when configured', () => {
+        ClientLibrary.initializeClient({ phantomTraps: false });
+
+        expect(injectPhantomTrapsSpy).not.toHaveBeenCalled();
+    });
+
+    it('should initialize honeypots with the provided field names', () => {
+        const honeypotFields = ['email_confirm', 'user_nickname'];
+        ClientLibrary.initializeClient({ honeypots: honeypotFields });
+
+        expect(initHoneypotsSpy).toHaveBeenCalledWith(honeypotFields);
+    });
+
+    it('should not initialize honeypots if the array is empty', () => {
+        ClientLibrary.initializeClient({ honeypots: [] });
+
+        expect(initHoneypotsSpy).not.toHaveBeenCalled();
+    });
+
+    it('should inject trap URLs when provided', () => {
+        const urls = ['/trap1?sig=123', '/trap2?sig=456'];
+        ClientLibrary.initializeClient({ trapUrls: urls });
+
+        expect(injectTrapsSpy).toHaveBeenCalledWith(urls);
+    });
+
+    it('should not inject trap URLs if the array is empty', () => {
+        ClientLibrary.initializeClient({ trapUrls: [] });
+
+        expect(injectTrapsSpy).not.toHaveBeenCalled();
+    });
+
+    it('should initialize fetch interception when fetch config is present', () => {
+        const targetDomains = ['api.example.com'];
+        ClientLibrary.initializeClient({ fetch: { targetDomains } });
+
+        expect(initFetchSpy).toHaveBeenCalledWith(targetDomains);
+    });
+
+    it('should not initialize fetch interception if fetch config is absent', () => {
+        ClientLibrary.initializeClient(); // No fetch config
+
+        expect(initFetchSpy).not.toHaveBeenCalled();
+    });
+
+    it('should call all initializers correctly when a full config is provided', () => {
+        const config = {
+            mouse: true,
+            keystrokes: true,
+            honeypots: ['field1'],
+            trapUrls: ['/trap1'],
+            fetch: { targetDomains: ['api.com'] }
+        };
+        ClientLibrary.initializeClient(config);
+
+        expect(startMouseSpy).toHaveBeenCalled();
+        expect(startKeystrokeSpy).toHaveBeenCalled();
+        expect(initHoneypotsSpy).toHaveBeenCalledWith(config.honeypots);
+        expect(injectTrapsSpy).toHaveBeenCalledWith(config.trapUrls);
+        expect(initFetchSpy).toHaveBeenCalledWith(config.fetch.targetDomains);
+    });
+
 });