LicenseCompatibilityRuleControllerTest.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\UI\Api\Test\Controllers;
 
use Fossology\Lib\Auth\Auth;
use Fossology\Lib\Dao\CompatibilityDao;
use Fossology\Lib\Db\DbManager;
use Fossology\UI\Api\Controllers\LicenseCompatibilityRuleController;
use Fossology\UI\Api\Exceptions\HttpBadRequestException;
use Fossology\UI\Api\Exceptions\HttpForbiddenException;
use Fossology\UI\Api\Exceptions\HttpInternalServerErrorException;
use Fossology\UI\Api\Exceptions\HttpNotFoundException;
use Fossology\UI\Api\Helper\DbHelper;
use Fossology\UI\Api\Helper\ResponseHelper;
use Fossology\UI\Api\Helper\RestHelper;
use Fossology\UI\Api\Models\ApiVersion;
use Fossology\UI\Api\Models\Info;
use Fossology\UI\Api\Models\InfoType;
use Fossology\UI\Api\Models\LicenseCompatibilityRule;
use Mockery as M;
use Slim\Psr7\Factory\StreamFactory;
use Slim\Psr7\Headers;
use Slim\Psr7\Request;
use Slim\Psr7\Uri;
 
class LicenseCompatibilityRuleControllerTest extends \PHPUnit\Framework\TestCase
{
  private $assertCountBefore;
 
  private $dbHelper;
 
  private $dbManager;
 
  private $restHelper;
 
  private $compatibilityDao;
 
  private $licenseYamlPlugin;
 
  private $ruleController;
 
  private $streamFactory;
 
  protected function setUp() : void
  {
    global $container, $SysConf;
    $container = M::mock('ContainerBuilder');
    $this->dbHelper = M::mock(DbHelper::class);
    $this->dbManager = M::mock(DbManager::class);
    $this->restHelper = M::mock(RestHelper::class);
    $this->compatibilityDao = M::mock(CompatibilityDao::class);
    $this->licenseYamlPlugin = M::mock('admin_license_from_yaml');
 
    $this->dbHelper->shouldReceive('getDbManager')->andReturn($this->dbManager);
    $this->restHelper->shouldReceive('getDbHelper')->andReturn($this->dbHelper);
    $this->restHelper->shouldReceive('getPlugin')
      ->withArgs(array('admin_license_from_yaml'))
      ->andReturn($this->licenseYamlPlugin);
 
    $container->shouldReceive('get')->withArgs(array(
      'helper.restHelper'))->andReturn($this->restHelper);
    $container->shouldReceive('get')->withArgs(array(
      'dao.compatibility'))->andReturn($this->compatibilityDao);
 
    $SysConf['SYSCONFIG']['LicenseTypes'] = "Permissive, Strong Copyleft";
 
    $this->ruleController = new LicenseCompatibilityRuleController($container);
    $this->assertCountBefore = \Hamcrest\MatcherAssert::getCount();
    $this->streamFactory = new StreamFactory();
  }
 
  protected function tearDown() : void
  {
    $this->addToAssertionCount(
      \Hamcrest\MatcherAssert::getCount() - $this->assertCountBefore);
    M::close();
  }
 
  private function getResponseJson($response)
  {
    $response->getBody()->seek(0);
    return json_decode($response->getBody()->getContents(), true);
  }
 
  private function getRuleRow($ruleId)
  {
    return [
      "lr_pk" => $ruleId,
      "first_rf_fk" => 306,
      "second_rf_fk" => null,
      "first_rf_shortname" => "MIT",
      "second_rf_shortname" => null,
      "first_type" => "Permissive",
      "second_type" => "Strong Copyleft",
      "comment" => "Rule $ruleId",
      "compatibility" => "t"
    ];
  }
 
  private function createJsonRequest($method, $body,
                                     $version = ApiVersion::V2)
  {
    $requestHeaders = new Headers();
    $requestHeaders->setHeader('Content-Type', 'application/json');
    $request = new Request($method, new Uri("HTTP", "localhost"),
      $requestHeaders, [], [],
      $this->streamFactory->createStream(json_encode($body)));
    return $request->withAttribute(ApiVersion::ATTRIBUTE_NAME, $version);
  }
 
  private function createGetRequest($query = "", $version = ApiVersion::V2)
  {
    $request = new Request("GET",
      new Uri("HTTP", "localhost", null, "/license-compatibility-rules",
        $query),
      new Headers(), [], [], $this->streamFactory->createStream());
    return $request->withAttribute(ApiVersion::ATTRIBUTE_NAME, $version);
  }
 
  public function testGetRulesV1()
  {
    $this->testGetRules(ApiVersion::V1);
  }
 
  public function testGetRulesV2()
  {
    $this->testGetRules();
  }
 
  private function testGetRules($version = ApiVersion::V2)
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $rows = [$this->getRuleRow(1), $this->getRuleRow(2)];
 
    $this->compatibilityDao->shouldReceive('getTotalRulesCount')
      ->withArgs([""])->andReturn(2);
    $this->compatibilityDao->shouldReceive('getAllRules')
      ->withArgs([100, 0, ""])->andReturn($rows);
 
    $expected = [];
    foreach ($rows as $row) {
      $expected[] = LicenseCompatibilityRule::fromArray($row)
        ->getArray($version);
    }
 
    $actualResponse = $this->ruleController->getRules(
      $this->createGetRequest("", $version), new ResponseHelper(), []);
 
    $this->assertEquals(200, $actualResponse->getStatusCode());
    $this->assertEquals(1,
      intval($actualResponse->getHeaderLine('X-Total-Pages')));
    $this->assertEquals($expected, $this->getResponseJson($actualResponse));
  }
 
  public function testGetRulesWithPaginationAndSearch()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $rows = [$this->getRuleRow(3)];
 
    $this->compatibilityDao->shouldReceive('getTotalRulesCount')
      ->withArgs(["%copyleft%"])->andReturn(3);
    $this->compatibilityDao->shouldReceive('getAllRules')
      ->withArgs([2, 2, "%copyleft%"])->andReturn($rows);
 
    $actualResponse = $this->ruleController->getRules(
      $this->createGetRequest("page=2&limit=2&search=copyleft"),
      new ResponseHelper(), []);
 
    $this->assertEquals(200, $actualResponse->getStatusCode());
    $this->assertEquals(2,
      intval($actualResponse->getHeaderLine('X-Total-Pages')));
    $this->assertCount(1, $this->getResponseJson($actualResponse));
  }
 
  public function testGetRulesInvalidLimit()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $this->expectException(HttpBadRequestException::class);
 
    $this->ruleController->getRules($this->createGetRequest("limit=-1"),
      new ResponseHelper(), []);
  }
 
  public function testGetRulesZeroLimit()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $this->expectException(HttpBadRequestException::class);
 
    $this->ruleController->getRules($this->createGetRequest("limit=0"),
      new ResponseHelper(), []);
  }
 
  public function testGetRulesNonNumericLimit()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $this->expectException(HttpBadRequestException::class);
 
    $this->ruleController->getRules($this->createGetRequest("limit=abc"),
      new ResponseHelper(), []);
  }
 
  public function testGetRulesZeroPage()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $this->compatibilityDao->shouldReceive('getTotalRulesCount')
      ->withArgs([""])->andReturn(2);
    $this->expectException(HttpBadRequestException::class);
 
    $this->ruleController->getRules($this->createGetRequest("page=0"),
      new ResponseHelper(), []);
  }
 
  public function testGetRulesPageOutOfRange()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $this->compatibilityDao->shouldReceive('getTotalRulesCount')
      ->withArgs([""])->andReturn(2);
    $this->expectException(HttpBadRequestException::class);
 
    $this->ruleController->getRules($this->createGetRequest("page=5&limit=2"),
      new ResponseHelper(), []);
  }
 
  public function testGetRulesNotAdmin()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_WRITE;
    $this->expectException(HttpForbiddenException::class);
 
    $this->ruleController->getRules($this->createGetRequest(),
      new ResponseHelper(), []);
  }
 
  public function testCreateRule()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $this->dbHelper->shouldReceive('doesIdExist')
      ->withArgs(["license_ref", "rf_pk", 306])->andReturn(true);
    $this->compatibilityDao->shouldReceive('insertRule')
      ->withArgs([306, null, null, "Strong Copyleft", "New rule", true])
      ->andReturn(9);
 
    $request = $this->createJsonRequest("POST", [
      "firstLicenseId" => 306,
      "secondType" => "Strong Copyleft",
      "comment" => "New rule",
      "compatibility" => true
    ]);
 
    $expectedResponse = new Info(201, "Rule 9 added successfully.",
      InfoType::INFO);
    $actualResponse = $this->ruleController->createRule($request,
      new ResponseHelper(), []);
 
    $this->assertEquals($expectedResponse->getCode(),
      $actualResponse->getStatusCode());
    $this->assertEquals($expectedResponse->getArray(),
      $this->getResponseJson($actualResponse));
  }
 
  public function testCreateRuleWithV1FieldNames()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $this->compatibilityDao->shouldReceive('insertRule')
      ->withArgs([null, null, "Permissive", null, "New rule", false])
      ->andReturn(10);
 
    $request = $this->createJsonRequest("POST", [
      "first_type" => "Permissive",
      "comment" => "New rule",
      "compatibility" => false
    ], ApiVersion::V1);
 
    $actualResponse = $this->ruleController->createRule($request,
      new ResponseHelper(), []);
 
    $this->assertEquals(201, $actualResponse->getStatusCode());
  }
 
  public function testCreateRuleWithoutComment()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $this->expectException(HttpBadRequestException::class);
 
    $this->ruleController->createRule($this->createJsonRequest("POST", [
      "firstType" => "Permissive",
      "compatibility" => true
    ]), new ResponseHelper(), []);
  }
 
  public function testCreateRuleWithEmptyComment()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $this->expectException(HttpBadRequestException::class);
 
    $this->ruleController->createRule($this->createJsonRequest("POST", [
      "firstType" => "Permissive",
      "comment" => "  ",
      "compatibility" => true
    ]), new ResponseHelper(), []);
  }
 
  public function testCreateRuleWithoutLicenseAndType()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $this->expectException(HttpBadRequestException::class);
 
    $this->ruleController->createRule($this->createJsonRequest("POST", [
      "comment" => "Default rule",
      "compatibility" => true
    ]), new ResponseHelper(), []);
  }
 
  public function testCreateRuleWithUnknownLicense()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $this->dbHelper->shouldReceive('doesIdExist')
      ->withArgs(["license_ref", "rf_pk", 999])->andReturn(false);
    $this->expectException(HttpBadRequestException::class);
 
    $this->ruleController->createRule($this->createJsonRequest("POST", [
      "firstLicenseId" => 999,
      "comment" => "New rule",
      "compatibility" => true
    ]), new ResponseHelper(), []);
  }
 
  public function testCreateRuleWithUnknownLicenseType()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $this->expectException(HttpBadRequestException::class);
 
    $this->ruleController->createRule($this->createJsonRequest("POST", [
      "firstType" => "Unknown Type",
      "comment" => "New rule",
      "compatibility" => true
    ]), new ResponseHelper(), []);
  }
 
  public function testCreateRuleFailure()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $this->compatibilityDao->shouldReceive('insertRule')->andReturn(-2);
    $this->expectException(HttpInternalServerErrorException::class);
 
    $this->ruleController->createRule($this->createJsonRequest("POST", [
      "firstType" => "Permissive",
      "comment" => "New rule",
      "compatibility" => true
    ]), new ResponseHelper(), []);
  }
 
  public function testUpdateRule()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $ruleId = 4;
    $this->compatibilityDao->shouldReceive('getRuleById')->withArgs([$ruleId])
      ->andReturn($this->getRuleRow($ruleId));
    $this->compatibilityDao->shouldReceive('updateRuleFromArray')
      ->withArgs([[$ruleId => ["comment" => "Updated rule",
        "result" => false]]])->andReturn(1);
 
    $request = $this->createJsonRequest("PUT", [
      "comment" => "Updated rule",
      "compatibility" => false
    ]);
 
    $expectedResponse = new Info(200, "Rule $ruleId updated successfully.",
      InfoType::INFO);
    $actualResponse = $this->ruleController->updateRule($request,
      new ResponseHelper(), ["id" => $ruleId]);
 
    $this->assertEquals($expectedResponse->getCode(),
      $actualResponse->getStatusCode());
    $this->assertEquals($expectedResponse->getArray(),
      $this->getResponseJson($actualResponse));
  }
 
  public function testUpdateRuleResetLicense()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $ruleId = 4;
    $this->compatibilityDao->shouldReceive('getRuleById')->withArgs([$ruleId])
      ->andReturn($this->getRuleRow($ruleId));
    $this->compatibilityDao->shouldReceive('updateRuleFromArray')
      ->withArgs([[$ruleId => ["firstLic" => null, "firstType" => null]]])
      ->andReturn(1);
 
    $request = $this->createJsonRequest("PUT", [
      "firstLicenseId" => null,
      "firstType" => null
    ]);
 
    $actualResponse = $this->ruleController->updateRule($request,
      new ResponseHelper(), ["id" => $ruleId]);
 
    $this->assertEquals(200, $actualResponse->getStatusCode());
  }
 
  public function testUpdateRuleNotFound()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $this->compatibilityDao->shouldReceive('getRuleById')->withArgs([8])
      ->andReturn(null);
    $this->expectException(HttpNotFoundException::class);
 
    $this->ruleController->updateRule(
      $this->createJsonRequest("PUT", ["comment" => "Updated rule"]),
      new ResponseHelper(), ["id" => 8]);
  }
 
  public function testUpdateRuleEmptyBody()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $this->compatibilityDao->shouldReceive('getRuleById')->withArgs([4])
      ->andReturn($this->getRuleRow(4));
    $this->expectException(HttpBadRequestException::class);
 
    $this->ruleController->updateRule($this->createJsonRequest("PUT", []),
      new ResponseHelper(), ["id" => 4]);
  }
 
  public function testUpdateRuleWithoutRuleValues()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $this->compatibilityDao->shouldReceive('getRuleById')->withArgs([4])
      ->andReturn($this->getRuleRow(4));
    $this->expectException(HttpBadRequestException::class);
 
    $this->ruleController->updateRule(
      $this->createJsonRequest("PUT", ["unknownField" => "value"]),
      new ResponseHelper(), ["id" => 4]);
  }
 
  public function testDeleteRule()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $ruleId = 4;
    $this->compatibilityDao->shouldReceive('getRuleById')->withArgs([$ruleId])
      ->andReturn($this->getRuleRow($ruleId));
    $this->compatibilityDao->shouldReceive('deleteRule')->withArgs([$ruleId])
      ->andReturn(true);
 
    $expectedResponse = new Info(200, "Rule $ruleId deleted successfully.",
      InfoType::INFO);
    $actualResponse = $this->ruleController->deleteRule(null,
      new ResponseHelper(), ["id" => $ruleId]);
 
    $this->assertEquals($expectedResponse->getCode(),
      $actualResponse->getStatusCode());
    $this->assertEquals($expectedResponse->getArray(),
      $this->getResponseJson($actualResponse));
  }
 
  public function testDeleteRuleNotFound()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $this->compatibilityDao->shouldReceive('getRuleById')->withArgs([8])
      ->andReturn(null);
    $this->expectException(HttpNotFoundException::class);
 
    $this->ruleController->deleteRule(null, new ResponseHelper(),
      ["id" => 8]);
  }
 
  public function testDeleteRuleFailure()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $this->compatibilityDao->shouldReceive('getRuleById')->withArgs([4])
      ->andReturn($this->getRuleRow(4));
    $this->compatibilityDao->shouldReceive('deleteRule')->withArgs([4])
      ->andReturn(false);
    $this->expectException(HttpInternalServerErrorException::class);
 
    $this->ruleController->deleteRule(null, new ResponseHelper(),
      ["id" => 4]);
  }
 
  public function testImportRules()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $this->licenseYamlPlugin->shouldReceive('getFileInputName')
      ->andReturn("fileInput");
    $this->licenseYamlPlugin->shouldReceive('handleFileUpload')
      ->withArgs([null, true])
      ->andReturn([true, "Read yaml: 2 license rules", 200]);
 
    $expectedResponse = new Info(200, "Read yaml: 2 license rules",
      InfoType::INFO);
    $actualResponse = $this->ruleController->importRules(
      $this->createJsonRequest("POST", []), new ResponseHelper(), []);
 
    $this->assertEquals($expectedResponse->getCode(),
      $actualResponse->getStatusCode());
    $this->assertEquals($expectedResponse->getArray(),
      $this->getResponseJson($actualResponse));
  }
 
  public function testImportRulesInvalidFile()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $this->licenseYamlPlugin->shouldReceive('getFileInputName')
      ->andReturn("fileInput");
    $this->licenseYamlPlugin->shouldReceive('handleFileUpload')
      ->withArgs([null, true])->andReturn([false, "No file selected", 400]);
    $this->expectException(HttpBadRequestException::class);
 
    $this->ruleController->importRules($this->createJsonRequest("POST", []),
      new ResponseHelper(), []);
  }
 
  public function testExportRules()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $rows = [[
      "firstname" => "MIT",
      "secondname" => null,
      "firsttype" => null,
      "secondtype" => "Strong Copyleft",
      "compatibility" => "true",
      "comment" => "Rule 1"
    ]];
    $this->compatibilityDao->shouldReceive('getDefaultCompatibility')
      ->andReturn(false);
    $this->dbManager->shouldReceive('getRows')->andReturn($rows);
 
    $actualResponse = $this->ruleController->exportRules(
      $this->createGetRequest(), new ResponseHelper(), []);
 
    $this->assertEquals(200, $actualResponse->getStatusCode());
    $this->assertEquals("text/x-yaml; charset=UTF-8",
      $actualResponse->getHeaderLine('Content-type'));
    $actualResponse->getBody()->seek(0);
    $this->assertEquals(yaml_emit(["default" => false, "rules" => $rows]),
      $actualResponse->getBody()->getContents());
  }
 
  public function testExportRulesNotFound()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_ADMIN;
    $this->compatibilityDao->shouldReceive('getRuleById')->withArgs([8])
      ->andReturn(null);
    $this->expectException(HttpNotFoundException::class);
 
    $this->ruleController->exportRules($this->createGetRequest("id=8"),
      new ResponseHelper(), []);
  }
 
  public function testExportRulesNotAdmin()
  {
    $_SESSION[Auth::USER_LEVEL] = Auth::PERM_WRITE;
    $this->expectException(HttpForbiddenException::class);
 
    $this->ruleController->exportRules($this->createGetRequest(),
      new ResponseHelper(), []);
  }
}