CompatibilityDaoTest.php

Go to the documentation of this file.

<?php
/*
 SPDX-FileCopyrightText: © 2026 Harshit Gandhi <gandhiharshit716@gmail.com>
 
 SPDX-License-Identifier: GPL-2.0-only
*/
namespace Fossology\Lib\Dao;
 
use Fossology\Lib\Db\DbManager;
use Fossology\Lib\Test\TestPgDb;
use Mockery as M;
use Monolog\Logger;
use PHPUnit\Framework\TestCase;
 
class CompatibilityDaoTest extends TestCase
{
  private $testDb;
 
  private $dbManager;
 
  private $compatibilityDao;
 
  private $assertCountBefore;
 
  private $authClass;
 
  private $firstLicenseId;
 
  private $secondLicenseId;
 
  protected function setUp() : void
  {
    $this->testDb = new TestPgDb("compatibilitydao");
    $this->dbManager = $this->testDb->getDbManager();
    $this->assertCountBefore = \Hamcrest\MatcherAssert::getCount();
 
    $this->testDb->createPlainTables(["license_ref", "license_rules"]);
    $this->testDb->createSequences(["license_ref_rf_pk_seq",
      "license_rules_lr_pk_seq"]);
    $this->testDb->alterTables(["license_ref", "license_rules"]);
    $this->testDb->insertData_license_ref(2);
 
    $licenses = $this->dbManager->getRows(
      "SELECT rf_pk FROM license_ref ORDER BY rf_pk LIMIT 2;");
    $this->firstLicenseId = intval($licenses[0]['rf_pk']);
    $this->secondLicenseId = intval($licenses[1]['rf_pk']);
 
    $this->authClass = M::mock('alias:Fossology\Lib\Auth\Auth');
    $this->authClass->shouldReceive('isAdmin')->andReturn(true);
 
    $this->compatibilityDao = new CompatibilityDao($this->dbManager,
      new Logger("test"), M::mock(LicenseDao::class), M::mock(AgentDao::class));
  }
 
  protected function tearDown() : void
  {
    $this->addToAssertionCount(
      \Hamcrest\MatcherAssert::getCount() - $this->assertCountBefore);
    M::close();
    $this->testDb = null;
    $this->dbManager = null;
  }
 
  private function insertRule($comment, $result = true)
  {
    $ruleId = $this->compatibilityDao->insertRule($this->firstLicenseId, null,
      null, "Strong Copyleft", $comment, $result);
    $this->assertGreaterThan(0, $ruleId, "Unable to insert the test rule.");
    return $ruleId;
  }
 
  public function testInsertRule()
  {
    $ruleId = $this->insertRule("A rule", false);
 
    $rule = $this->compatibilityDao->getRuleById($ruleId);
    $this->assertEquals($this->firstLicenseId, intval($rule['first_rf_fk']));
    $this->assertNull($rule['second_rf_fk']);
    $this->assertNull($rule['first_type']);
    $this->assertEquals("Strong Copyleft", $rule['second_type']);
    $this->assertEquals("A rule", $rule['comment']);
    $this->assertEquals("f", $rule['compatibility']);
  }
 
  public function testInsertRuleWithoutComment()
  {
    $this->assertEquals(-1, $this->compatibilityDao->insertRule(
      $this->firstLicenseId, null, null, "Strong Copyleft", "  ", true));
  }
 
  public function testGetRuleById()
  {
    $ruleId = $this->insertRule("A rule");
 
    $rule = $this->compatibilityDao->getRuleById($ruleId);
    $this->assertEquals($ruleId, intval($rule['lr_pk']));
    $this->assertNotEmpty($rule['first_rf_shortname']);
    $this->assertNull($rule['second_rf_shortname']);
 
    $this->assertNull($this->compatibilityDao->getRuleById($ruleId + 100));
  }
 
  public function testGetAllRulesPaginated()
  {
    $firstRule = $this->insertRule("First rule");
    $secondRule = $this->insertRule("Second rule");
    $this->insertRule("Third rule");
 
    $this->assertEquals(3, $this->compatibilityDao->getTotalRulesCount());
 
    $rules = $this->compatibilityDao->getAllRules(2, 0);
    $this->assertCount(2, $rules);
    $this->assertEquals($firstRule, intval($rules[0]['lr_pk']));
    $this->assertEquals($secondRule, intval($rules[1]['lr_pk']));
 
    $rules = $this->compatibilityDao->getAllRules(2, 2);
    $this->assertCount(1, $rules);
    $this->assertEquals("Third rule", $rules[0]['comment']);
  }
 
  public function testGetAllRulesWithSearchTerm()
  {
    $this->insertRule("Permissive with copyleft");
    $this->insertRule("Copyleft with copyleft");
 
    $this->assertEquals(1,
      $this->compatibilityDao->getTotalRulesCount("%permissive%"));
    $rules = $this->compatibilityDao->getAllRules(10, 0, "%permissive%");
    $this->assertCount(1, $rules);
    $this->assertEquals("Permissive with copyleft", $rules[0]['comment']);
  }
 
  public function testGetAllRulesWithQuoteInSearchTerm()
  {
    $this->insertRule("A rule");
    $searchTerm = "%' OR comment LIKE '%";
 
    $this->assertEquals(0,
      $this->compatibilityDao->getTotalRulesCount($searchTerm));
    $this->assertCount(0,
      $this->compatibilityDao->getAllRules(10, 0, $searchTerm));
  }
 
  public function testUpdateRuleCompatibilityFromBoolean()
  {
    $ruleId = $this->insertRule("A rule", true);
 
    $this->assertEquals(1, $this->compatibilityDao->updateRuleFromArray(
      [$ruleId => ["result" => false]]));
    $this->assertEquals("f",
      $this->compatibilityDao->getRuleById($ruleId)['compatibility']);
 
    $this->assertEquals(1, $this->compatibilityDao->updateRuleFromArray(
      [$ruleId => ["result" => true]]));
    $this->assertEquals("t",
      $this->compatibilityDao->getRuleById($ruleId)['compatibility']);
  }
 
  public function testUpdateRuleCompatibilityFromDbBoolean()
  {
    $ruleId = $this->insertRule("A rule", true);
 
    $this->assertEquals(1, $this->compatibilityDao->updateRuleFromArray(
      [$ruleId => ["result" => "f"]]));
    $this->assertEquals("f",
      $this->compatibilityDao->getRuleById($ruleId)['compatibility']);
  }
 
  public function testUpdateRuleFromArray()
  {
    $ruleId = $this->insertRule("A rule");
 
    $this->assertEquals(1, $this->compatibilityDao->updateRuleFromArray([
      $ruleId => [
        "firstLic" => null,
        "secondLic" => $this->secondLicenseId,
        "firstType" => "Permissive",
        "secondType" => null,
        "comment" => "An updated rule",
        "result" => false
      ]
    ]));
 
    $rule = $this->compatibilityDao->getRuleById($ruleId);
    $this->assertNull($rule['first_rf_fk']);
    $this->assertEquals($this->secondLicenseId, intval($rule['second_rf_fk']));
    $this->assertEquals("Permissive", $rule['first_type']);
    $this->assertNull($rule['second_type']);
    $this->assertEquals("An updated rule", $rule['comment']);
    $this->assertEquals("f", $rule['compatibility']);
  }
 
  public function testUpdateRuleWithUnknownId()
  {
    $this->expectException(\UnexpectedValueException::class);
 
    $this->compatibilityDao->updateRuleFromArray(
      [999 => ["comment" => "An updated rule"]]);
  }
 
  public function testDeleteRule()
  {
    $ruleId = $this->insertRule("A rule");
 
    $this->assertTrue($this->compatibilityDao->deleteRule($ruleId));
    $this->assertNull($this->compatibilityDao->getRuleById($ruleId));
    $this->assertEquals(0, $this->compatibilityDao->getTotalRulesCount());
  }
}