@anonympins/fingerprint 0.3.2 → 0.3.3

package/src/php/Tests/FingerprintEngineTest.php

@@ -0,0 +1,219 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint\Tests;
+
+use PHPUnit\Framework\TestCase;
+use Anonympins\Fingerprint\FingerprintEngine;
+use Anonympins\Fingerprint\FingerprintBuilder;
+use Anonympins\Fingerprint\RequestContext;
+use Anonympins\Fingerprint\Store\StoreManager;
+use Anonympins\Fingerprint\Store\InMemoryStore;
+use Anonympins\Fingerprint\Config\SecurityProfiles;
+
+class FingerprintEngineTest extends TestCase
+{
+    private FingerprintEngine $engine;
+    private array $securityConfig;
+
+    /**
+     * Cette méthode est appelée avant chaque test.
+     * Elle garantit que chaque test s'exécute dans un environnement propre.
+     */
+    protected function setUp(): void
+    {
+        // 1. Utiliser un store en mémoire propre pour chaque test
+        $store = new InMemoryStore();
+        StoreManager::configureStore($store);
+
+        // 2. Charger une configuration de sécurité de base pour les tests
+        $this->securityConfig = SecurityProfiles::createSecurityProfile('balanced', [
+            'verbose' => false, // Désactiver les logs pour ne pas polluer la sortie des tests
+            'challengeNewDevices' => false, // Simplifie les tests de base
+        ]);
+
+        // 3. Créer une nouvelle instance du moteur pour chaque test
+        $this->engine = new FingerprintEngine($this->securityConfig);
+    }
+
+    /**
+     * Crée un contexte de requête de base pour les tests.
+     *
+     * @param array<string, mixed> $overrides
+     * @return RequestContext
+     */
+    private function createRequestContext(array $overrides = []): RequestContext
+    {
+        $defaults = [
+            'clientIp' => '192.168.1.10',
+            'path' => '/',
+            'headers' => [
+                'user-agent' => 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36',
+                'accept-language' => 'en-US,en;q=0.9',
+            ],
+            'query' => [],
+            'body' => null,
+            'cookies' => [],
+            'httpVersion' => '1.1',
+        ];
+
+        $params = array_merge($defaults, $overrides);
+
+        return new RequestContext(
+            $params['clientIp'],
+            $params['path'],
+            $params['headers'],
+            $params['query'],
+            $params['body'],
+            $params['cookies'],
+            $params['httpVersion']
+        );
+    }
+
+    public function testAllowsLegitimateRequest(): void
+    {
+        $context = $this->createRequestContext();
+
+        // Simule une première visite
+        $firstDecision = $this->engine->processRequest($context);
+        $this->assertArrayHasKey('newCookieForResponse', $firstDecision, "Un nouveau cookie aurait dû être généré.");
+        $deviceIdCookie = $firstDecision['newCookieForResponse'];
+
+        // Simule une deuxième visite avec le cookie reçu
+        $nextContext = $this->createRequestContext([
+            'cookies' => [$deviceIdCookie['name'] => $deviceIdCookie['value']]
+        ]);
+        $secondDecision = $this->engine->processRequest($nextContext);
+
+        $this->assertEquals('next', $secondDecision['action']);
+        $this->assertLessThan($this->securityConfig['thresholds']['low'], $secondDecision['score']);
+    }
+
+    public function testIssuesChallengeForSuspiciousRequest(): void
+    {
+        // 1. First, establish a device identity to avoid the cookie-dropping penalty
+        $firstContext = $this->createRequestContext();
+        $firstDecision = $this->engine->processRequest($firstContext);
+        $this->assertArrayHasKey('newCookieForResponse', $firstDecision, "A device ID cookie should have been generated.");
+        $deviceIdCookie = $firstDecision['newCookieForResponse'];
+
+        // 2. Now, simulate a suspicious request from that same device (e.g., missing user-agent)
+        $suspiciousContext = $this->createRequestContext([
+            'cookies' => [$deviceIdCookie['name'] => $deviceIdCookie['value']],
+            'headers' => [
+                // No user-agent, which is anomalous
+                'accept-language' => 'en-US,en;q=0.9',
+            ]
+        ]);
+
+        $decision = $this->engine->processRequest($suspiciousContext);
+
+        $this->assertEquals('challenge', $decision['action'], "The action should be to issue a challenge.");
+        $this->assertGreaterThanOrEqual($this->securityConfig['thresholds']['low'], $decision['score'], "The score should be above the 'low' threshold.");
+        $this->assertLessThan($this->securityConfig['thresholds']['block'], $decision['score']);
+    }
+
+    public function testBlocksHighlySuspiciousRequest(): void
+    {
+        // Configure the engine to recognize the 'email_confirm' honeypot field.
+        // We need to create a new engine instance for this test with a custom config.
+        $config = SecurityProfiles::createSecurityProfile('balanced', [
+            'honeypot' => ['fields' => ['email_confirm']],
+            'verbose' => true,
+            'weights'=> ['honeypotScore' => 1]
+        ]);
+        $engine = new FingerprintEngine($config);
+
+        // 1. First, establish a device identity to avoid other scores interfering.
+        $firstContext = $this->createRequestContext();
+        $firstDecision = $engine->processRequest($firstContext);
+        $this->assertArrayHasKey('newCookieForResponse', $firstDecision);
+        $deviceIdCookie = $firstDecision['newCookieForResponse'];
+
+        // 2. Now, simulate a request from that device that falls into a honeypot trap.
+        $honeypotContext = $this->createRequestContext([
+            'cookies' => [$deviceIdCookie['name'] => $deviceIdCookie['value']],
+            // The bot filled in a hidden field, triggering the honeypot.
+            'body' => ['email_confirm' => 'bot@example.com']
+        ]);
+
+        $decision = $engine->processRequest($honeypotContext);
+
+        $this->assertEquals('block', $decision['action']);
+        $this->assertGreaterThanOrEqual($config['thresholds']['block'], $decision['score']);
+    }
+
+    public function testDetectsCookieDropping(): void
+    {
+        $context = $this->createRequestContext(['clientIp' => '1.2.3.4']);
+
+        // 1. Première requête, un "pending_cookie" est défini pour cette IP
+        $this->engine->processRequest($context);
+
+        // 2. Deuxième requête de la même IP, mais sans le cookie attendu
+        $contextWithoutCookie = $this->createRequestContext(['clientIp' => '1.2.3.4']);
+        $decision = $this->engine->processRequest($contextWithoutCookie);
+
+        // Le score de "cookieDropping" devrait être de 100
+        $this->assertEquals(100, $decision['vector']['cookieDroppingScore']);
+        // L'action devrait être un challenge car le score final sera élevé
+        $this->assertEquals('challenge', $decision['action']);
+    }
+
+    public function testDetectsFingerprintInconsistency(): void
+    {
+        $context = $this->createRequestContext();
+
+        // 1. Première visite, le fingerprint initial est stocké
+        $firstDecision = $this->engine->processRequest($context);
+        $deviceIdCookie = $firstDecision['newCookieForResponse'];
+
+        // 2. Deuxième visite avec le même cookie, mais un User-Agent complètement différent (incohérence)
+        $nextContext = $this->createRequestContext([
+            'cookies' => [$deviceIdCookie['name'] => $deviceIdCookie['value']],
+            'headers' => [
+                'user-agent' => 'DefinitelyNotTheSameBrowser/1.0',
+                'accept-language' => 'fr-FR',
+            ]
+        ]);
+
+        $decision = $this->engine->processRequest($nextContext);
+
+        // Le score d'incohérence devrait être de 100
+        $this->assertEquals(100, $decision['vector']['inconsistencyScore']);
+        // L'action devrait être un challenge ou un blocage
+        $this->assertContains($decision['action'], ['challenge', 'block']);
+    }
+
+    public function testAllowsWhitelistedIp(): void
+    {
+        $config = SecurityProfiles::createSecurityProfile('strict', [
+            'whitelist' => [['type' => 'allowlist', 'entries' => ['10.0.0.1']]]
+        ]);
+        $engine = new FingerprintEngine($config);
+
+        $context = $this->createRequestContext(['clientIp' => '10.0.0.1']);
+        $decision = $engine->processRequest($context);
+
+        $this->assertEquals('next', $decision['action']);
+        $this->assertEquals(0, $decision['score']);
+    }
+    public function testFingerprintBuilderCompareLogic(): void
+    {
+        $fp1 = (new FingerprintBuilder())->add('hw', '8_16')->add('gpu', 'nvidia')->__toString();
+        $fp2 = (new FingerprintBuilder())->add('hw', '8_16')->add('gpu', 'nvidia')->__toString();
+        $fp3 = (new FingerprintBuilder())->add('hw', '4_8')->add('gpu', 'amd')->__toString();
+        $fp4 = (new FingerprintBuilder())->add('hw', '8_16')->add('os', 'win32')->__toString(); // Partial match
+
+        $this->assertEquals(1.0, FingerprintBuilder::compare($fp1, $fp2), "Identical FPs should return 1.0");
+        $this->assertLessThan(0.5, FingerprintBuilder::compare($fp1, $fp3), "Different FPs should have low similarity");
+
+        // The partial match score calculation reflects the current weights in FingerprintBuilder.
+        // Matching keys: 'hw' (weight 1.5).
+        // All relevant keys considered from both fingerprints: 'hw' (1.5), 'gpu' (4.0), 'os' (0.8).
+        // Total weight = 1.5 + 4.0 + 0.8 = 6.3.
+        // Score = 1.5 / 6.3 = ~0.238095...
+        $this->assertEqualsWithDelta(0.238, FingerprintBuilder::compare($fp1, $fp4), 0.001, "Partial match score should reflect current weights");
+    }
+}

package/src/php/Tests/PowTest.php

@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint\Tests;
+
+use PHPUnit\Framework\TestCase;
+use Anonympins\Fingerprint\FingerprintEngine;
+use Anonympins\Fingerprint\ProblemManager;
+use Anonympins\Fingerprint\Store\InMemoryStore;
+use Anonympins\Fingerprint\Store\StoreManager;
+use Anonympins\Fingerprint\Config\SecurityProfiles;
+
+class PowTest extends TestCase
+{
+    private FingerprintEngine $engine;
+
+    protected function setUp(): void
+    {
+        // 1. Configurer un store en mémoire pour l'isolation des tests.
+        $store = new InMemoryStore();
+        StoreManager::configureStore($store);
+
+        // 2. Initialiser le ProblemManager avec une configuration et un store valides.
+        // C'est l'étape cruciale qui manquait.
+        $configPath = dirname(__FILE__) . '/problems.config.json';
+        ProblemManager::getInstance($configPath, $store);
+
+        // 3. Créer l'instance du moteur.
+        $this->engine = new FingerprintEngine(SecurityProfiles::createSecurityProfile('balanced'));
+    }
+
+    public function testGetProblemsIsExposedForTesting(): void
+    {
+        // Cette méthode appelle ProblemManager::getInstance() en interne.
+        // Grâce au setUp(), l'instance est déjà initialisée et le test passe.
+        $problems = $this->engine->getProblems();
+        $this->assertIsArray($problems);
+    }
+}

package/src/php/Tests/ProblemManagerTest.php

@@ -0,0 +1,295 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint\Tests;
+
+use PHPUnit\Framework\TestCase;
+use Anonympins\Fingerprint\ProblemManager;
+use Anonympins\Fingerprint\Store\IStore;
+use Anonympins\Fingerprint\Store\InMemoryStore;
+use Anonympins\Fingerprint\Optimization\FunctionRegistry; // Assurez-vous que cette classe est autoloadable
+
+class ProblemManagerTest extends TestCase
+{
+    private ?string $configPath = null;
+
+    protected function setUp(): void
+    {
+        // Réinitialise le singleton avant chaque test pour garantir l'isolation
+        ProblemManager::__internal_resetInstance();
+        FunctionRegistry::__internal_resetRegistry(); // Assure un registre de fonctions propre
+        $this->configPath = dirname(__FILE__).'/problems.config.json';
+    }
+
+    protected function tearDown(): void
+    {
+        ProblemManager::__internal_resetInstance();
+        FunctionRegistry::__internal_resetRegistry();
+    }
+
+    private function createConfigFile(array $content): void
+    {
+        // S'assurer que le répertoire existe
+        if (!is_dir(dirname($this->configPath))) {
+            mkdir(dirname($this->configPath), 0777, true);
+        }
+        file_put_contents($this->configPath, json_encode($content, JSON_PRETTY_PRINT));
+    }
+
+    public function testGetInstanceThrowsExceptionIfNotInitialized(): void
+    {
+        $this->expectException(\RuntimeException::class);
+        $this->expectExceptionMessage('ProblemManager must be initialized with configPath and store.');
+        ProblemManager::getInstance();
+    }
+
+    public function testGetInstanceCreatesAndReturnsInstance(): void
+    {
+        $storeMock = $this->createMock(IStore::class);
+
+        $instance1 = ProblemManager::getInstance($this->configPath, $storeMock);
+        $this->assertInstanceOf(ProblemManager::class, $instance1);
+
+        // Les appels suivants doivent retourner la même instance
+        $instance2 = ProblemManager::getInstance();
+        $this->assertSame($instance1, $instance2);
+        $this->assertTrue(ProblemManager::isInitialized());
+    }
+
+    public function testLoadProblemsHandlesMissingFile(): void
+    {
+        $storeMock = $this->createMock(IStore::class);
+        $missingConfigPath = dirname(__FILE__).'/non_existent_config.json';
+        if (file_exists($missingConfigPath)) {
+            unlink($missingConfigPath); // S'assurer que le fichier n'existe pas
+        }
+
+        // Ne doit pas lever d'exception, mais simplement ne pas initialiser de problèmes
+        $manager = ProblemManager::getInstance($missingConfigPath, $storeMock);
+        $this->assertNull($manager->dispatchWork(0.5));
+    }
+
+    public function testDispatchWorkCyclesThroughProblems(): void
+    {
+        $storeMock = $this->createMock(IStore::class);
+        $storeMock->method('get')->willReturn(null);
+
+        // Créer un fichier de configuration avec plusieurs problèmes pour tester le cycle
+        $this->createConfigFile([
+            [
+                "id" => "problem-1",
+                "workUnit" => ["type" => "simulated_annealing_iterations", "baseIterations" => 10000, "scalingFactor" => 2.0]
+            ],
+            [
+                "id" => "problem-2",
+                "workUnit" => ["type" => "simulated_annealing_iterations", "baseIterations" => 20000]
+            ],
+            [
+                "id" => "scaling-problem",
+                "workUnit" => ["type" => "multi_objective_genetic_algorithm", "baseGenerations" => 100, "scalingFactor" => 2.0, "solverName" => "test.solver"]
+            ],
+            [
+                "id" => "pareto-challenge",
+                "workUnit" => ["type" => "multi_objective_genetic_algorithm", "solverName" => "test.solver"]
+            ],
+            [
+                "id" => "problem-1",
+                "workUnit" => ["type" => "simulated_annealing_iterations", "baseIterations" => 10000, "scalingFactor" => 2.0]
+            ]
+        ]);
+
+        $manager = ProblemManager::getInstance($this->configPath, $storeMock);
+
+        $work1 = $manager->dispatchWork(0.5);
+        $this->assertEquals('problem-1', $work1['problemId']);
+
+        $work2 = $manager->dispatchWork(0.5);
+        $this->assertEquals('problem-2', $work2['problemId']);
+
+        // Cycle through a few more times to ensure it loops
+        $work3 = $manager->dispatchWork(0.5);
+        $this->assertEquals('scaling-problem', $work3['problemId']);
+
+        $work4 = $manager->dispatchWork(0.5);
+        $this->assertEquals('pareto-challenge', $work4['problemId']);
+
+        $work5 = $manager->dispatchWork(0.5);
+        $this->assertEquals('problem-1', $work5['problemId']); // Back to the start
+    }
+
+    public function testDispatchWorkScalesDifficulty(): void
+    {
+        $storeMock = $this->createMock(IStore::class);
+        $storeMock->method('get')->willReturn(null);
+
+        $this->createConfigFile([
+            [
+                "id" => "problem-1",
+                "workUnit" => ["type" => "simulated_annealing_iterations", "baseIterations" => 10000, "scalingFactor" => 2.0]
+            ],
+            [
+                "id" => "problem-1",
+                "workUnit" => ["type" => "simulated_annealing_iterations", "baseIterations" => 10000, "scalingFactor" => 2.0]
+            ],
+            [
+                "id" => "scaling-problem",
+                "workUnit" => ["type" => "multi_objective_genetic_algorithm", "baseGenerations" => 100, "scalingFactor" => 2.0, "solverName" => "test.solver"]
+            ]
+        ]);
+
+        $manager = ProblemManager::getInstance($this->configPath, $storeMock);
+
+        // Facteur de suspicion faible
+        $workLow = $manager->dispatchWork(0.1);
+        $this->assertLessThan(12000, $workLow['task']['iterations']); // 10000 * 2^0.1 ≈ 10717
+
+        // Facteur de suspicion moyen - dispatch 'problem-1'
+        $workMedium = $manager->dispatchWork(0.5);
+        $this->assertEquals(14142, $workMedium['task']['iterations']); // 10000 * 2^0.5
+
+        // Facteur de suspicion élevé - dispatch 'scaling-problem'
+        $workHigh = $manager->dispatchWork(1.0);
+        $this->assertEquals(200, $workHigh['task']['generations']); // 100 * 2^1.0
+    }
+
+    public function testIntegrateSolutionUpdatesStateForBetterSolution(): void
+    {
+        $problemId = 'problem-1';
+
+        $storeMock = $this->createMock(IStore::class);
+
+        $this->createConfigFile([
+            [
+                "id" => $problemId,
+                "workUnit" => [
+                    "type" => "simulated_annealing_iterations", // @phpstan-ignore-line
+                    "baseIterations" => 10000,
+                    // **LA CORRECTION** : La fonction de score est requise pour la vérification.
+                    "scoreFunction" => "test.calculateEnergy"
+                ]
+            ]
+        ]);
+
+        // Enregistrer une fonction de score factice pour le test.
+        FunctionRegistry::register('test.calculateEnergy', function ($solution, $payload) { // @phpstan-ignore-line
+            return 800.0; // Retourne la nouvelle "meilleure" énergie attendue.
+        });
+
+        $storeMock->method('get')
+            ->with("problem-state:{$problemId}")
+            ->willReturn(['bestEnergy' => 1000.0]);
+
+        // On s'attend à ce que le store soit mis à jour avec la nouvelle meilleure solution
+        $storeMock->expects($this->once())
+            ->method('set')
+            ->with(
+                "problem-state:{$problemId}",
+                $this->callback(function ($state) {
+                    return isset($state['bestEnergy']) && $state['bestEnergy'] === 800.0 && isset($state['bestSolution']);
+                })
+            );
+
+        $manager = ProblemManager::getInstance($this->configPath, $storeMock);
+
+        $newSolution = [
+            'solution' => [1, 2, 3],
+            'energy' => 800.0 // C'est une meilleure solution (score plus bas)
+        ];
+        $manager->integrateSolution($problemId, $newSolution);
+    }
+
+    public function testIntegrateSolutionDoesNotUpdateStateForWorseSolution(): void
+    {
+        $problemId = 'problem-1';
+
+        $storeMock = $this->createMock(IStore::class);
+
+        $this->createConfigFile([
+            [
+                "id" => $problemId,
+                "workUnit" => [
+                    "type" => "simulated_annealing_iterations", // @phpstan-ignore-line
+                    "baseIterations" => 10000,
+                    "scoreFunction" => "test.calculateEnergy"
+                ]
+            ]
+        ]);
+
+        // La fonction de score factice retourne une énergie *pire* que celle existante. // @phpstan-ignore-line
+        FunctionRegistry::register('test.calculateEnergy', function ($solution, $payload) {
+            return 1200.0;
+        });
+
+        $storeMock->method('get') // @phpstan-ignore-line
+            ->with("problem-state:{$problemId}")
+            ->willReturn(['bestEnergy' => 1000.0]);
+
+        // On s'attend à ce que `set` ne soit JAMAIS appelé car la solution n'est pas meilleure
+        $storeMock->expects($this->never())->method('set');
+
+        $manager = ProblemManager::getInstance($this->configPath, $storeMock);
+
+        $worseSolution = [
+            'solution' => [3, 2, 1], // Le contenu de la solution n'a pas d'importance pour ce test
+            'energy' => 1200.0 // C'est une moins bonne solution
+        ];
+        $manager->integrateSolution($problemId, $worseSolution);
+    }
+
+    public function testIntegrateParetoFront(): void
+    {
+        $problemId = 'pareto-challenge';
+
+        $storeMock = $this->createMock(IStore::class);
+
+        $this->createConfigFile([
+            [
+                "id" => "pareto-challenge",
+                "workUnit" => ["type" => "multi_objective_genetic_algorithm", "solverName" => "test.solver"]
+            ]
+        ]);
+        // Simule le comportement réel : le store contient déjà l'état initial.
+        $initialState = ['paretoFront' => [['solution' => 'A', 'objectives' => [10, 20]]]];
+        $storeMock->method('get')
+            ->with("problem-state:{$problemId}")
+            ->willReturn($initialState);
+
+        // A new solution that dominates the existing one.
+        $newFront = [['solution' => 'B', 'objectives' => [5, 15]]];
+
+        $storeMock->expects($this->once())
+            ->method('set')
+            ->with(
+                "problem-state:{$problemId}",
+                $this->callback(function ($state) {
+                    // The new front should contain only the new, dominant solution 'B'.
+                    return isset($state['paretoFront']) && count($state['paretoFront']) === 1 && $state['paretoFront'][0]['solution'] === 'B';
+                })
+            );
+
+        $manager = ProblemManager::getInstance($this->configPath, $storeMock);
+        $manager->integrateSolution($problemId, ['paretoFront' => $newFront]);
+    }
+
+    public function testLoadProblemsFromStore(): void
+    {
+        $store = new InMemoryStore();
+        $problemId = 'problem-1';
+
+        $this->createConfigFile([
+            [
+                "id" => "problem-1",
+                "workUnit" => ["type" => "simulated_annealing_iterations", "baseIterations" => 10000]
+            ]
+        ]);
+        $initialState = ['bestEnergy' => 5000.0, 'bestSolution' => [1, 2, 3]];
+        $store->set("problem-state:{$problemId}", $initialState);
+
+        $manager = ProblemManager::getInstance($this->configPath, $store);
+        $work = $manager->dispatchWork(0.1); // Dispatch 'problem-1'
+
+        $this->assertEquals($problemId, $work['problemId']);
+        $this->assertEquals($initialState['bestSolution'], $work['task']['initialSolution']);
+    }
+}

package/src/php/Tests/RequestUtilsTest.php

@@ -0,0 +1,81 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Anonympins\Fingerprint\Tests;
+
+use PHPUnit\Framework\TestCase;
+use Anonympins\Fingerprint\RequestContext;
+use Anonympins\Fingerprint\Utils\RequestUtils;
+
+class RequestUtilsTest extends TestCase
+{
+    private function createRequestContext(array $overrides = []): RequestContext
+    {
+        $defaults = [
+            'clientIp' => '127.0.0.1',
+            'path' => '/',
+            'headers' => ['user-agent' => 'Test UA'],
+            'query' => [],
+            'body' => null,
+            'cookies' => [],
+            'httpVersion' => '1.1',
+        ];
+        $params = array_merge($defaults, $overrides);
+        return new RequestContext(
+            $params['clientIp'], $params['path'], $params['headers'],
+            $params['query'], $params['body'], $params['cookies'], $params['httpVersion']
+        );
+    }
+
+    public function testGetClickVarianceScoreReturnsZeroForNoHistory(): void
+    {
+        $context = $this->createRequestContext([
+            'headers' => ['x-behavior-metrics' => json_encode([])]
+        ]);
+        $result = RequestUtils::getClickVarianceScore($context);
+        $this->assertEquals(0.0, $result['clickVarianceScore']);
+    }
+
+    public function testGetClickVarianceScoreReturnsZeroForInsufficientClicks(): void
+    {
+        $metrics = [
+            'clicksHistory' => [
+                ['x' => 10, 'y' => 10, 'targetId' => 'hash1'],
+                ['x' => 11, 'y' => 11, 'targetId' => 'hash1'],
+                ['x' => 100, 'y' => 100, 'targetId' => 'hash2']
+            ]
+        ];
+        $context = $this->createRequestContext(['headers' => ['x-behavior-metrics' => json_encode($metrics)]]);
+        $result = RequestUtils::getClickVarianceScore($context);
+        $this->assertEquals(0.0, $result['clickVarianceScore']);
+    }
+
+    public function testGetClickVarianceScoreReturnsHighScoreForLowVariance(): void
+    {
+        $metrics = [
+            'clicksHistory' => [
+                ['x' => 100, 'y' => 100, 'targetId' => 'hash1'],
+                ['x' => 100.1, 'y' => 100.2, 'targetId' => 'hash1'],
+                ['x' => 99.9, 'y' => 99.8, 'targetId' => 'hash1']
+            ]
+        ];
+        $context = $this->createRequestContext(['headers' => ['x-behavior-metrics' => json_encode($metrics)]]);
+        $result = RequestUtils::getClickVarianceScore($context);
+        $this->assertGreaterThan(90, $result['clickVarianceScore']);
+    }
+
+    public function testGetClickVarianceScoreReturnsLowScoreForHighVariance(): void
+    {
+        $metrics = [
+            'clicksHistory' => [
+                ['x' => 105, 'y' => 110, 'targetId' => 'hash1'],
+                ['x' => 98, 'y' => 102, 'targetId' => 'hash1'],
+                ['x' => 112, 'y' => 95, 'targetId' => 'hash1']
+            ]
+        ];
+        $context = $this->createRequestContext(['headers' => ['x-behavior-metrics' => json_encode($metrics)]]);
+        $result = RequestUtils::getClickVarianceScore($context);
+        $this->assertEquals(0.0, $result['clickVarianceScore']);
+    }
+}

package/src/php/Tests/problems.config.json

@@ -0,0 +1,9 @@
+[
+    {
+        "id": "problem-1",
+        "workUnit": {
+            "type": "simulated_annealing_iterations",
+            "baseIterations": 10000
+        }
+    }
+]