schedulerTest.php

Go to the documentation of this file.

<?php
/*
 * Copyright (C) 2019, Siemens AG
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

require_once "./SchedulerTestRunnerCli.php";
require_once "./SchedulerTestRunnerScheduler.php";

use Fossology\Lib\Db\DbManager;
use Fossology\Lib\Test\TestPgDb;
use Fossology\Lib\Test\TestInstaller;
use Monolog\Logger;
use Fossology\Lib\Dao\LicenseDao;
use Fossology\Lib\Dao\UploadDao;
use Fossology\Lib\Dao\UploadPermissionDao;
use Fossology\Ojo\Test\SchedulerTestRunnerCli;
use Fossology\Ojo\Test\SchedulerTestRunnerScheduler;

class OjoScheduledTest extends \PHPUnit\Framework\TestCase
{

  private $testDb;
  private $dbManager;
  private $licenseDao;
  private $testInstaller;
  private $uploadDao;
  private $uploadPermDao;
  private $cliRunner;
  private $schedulerRunner;
  private $regressionFile;

  protected function setUp()
  {
    $this->regressionFile = "regexTest.json";

    $this->testDb = new TestPgDb("ojoSched" . time());
    $this->dbManager = $this->testDb->getDbManager();

    $logger = new Logger("OjoSchedulerTest");

    $this->licenseDao = new LicenseDao($this->dbManager);
    $this->uploadPermDao = \Mockery::mock(UploadPermissionDao::class);
    $this->uploadDao = new UploadDao($this->dbManager, $logger,
      $this->uploadPermDao);

    $this->cliRunner = new SchedulerTestRunnerCli($this->testDb);
    $this->schedulerRunner = new SchedulerTestRunnerScheduler($this->testDb);
  }

  protected function tearDown()
  {
    $this->testDb->fullDestruct();
    $this->testDb = null;
    $this->dbManager = null;
    $this->licenseDao = null;
  }

  private function setUpRepo()
  {
    $sysConf = $this->testDb->getFossSysConf();
    $this->testInstaller = new TestInstaller($sysConf);
    $this->testInstaller->init();
    $this->testInstaller->cpRepo();
  }

  private function rmRepo()
  {
    $this->testInstaller->rmRepo();
    $this->testInstaller->clear();
  }

  private function setUpTables()
  {
    $this->testDb->createPlainTables(
      array(
        'agent',
        'uploadtree',
        'upload',
        'pfile',
        'users',
        'ars_master',
        'license_ref',
        'license_file',
        'highlight'
      ));
    $this->testDb->createSequences(
      array(
        'agent_agent_pk_seq',
        'upload_upload_pk_seq',
        'pfile_pfile_pk_seq',
        'users_user_pk_seq',
        'nomos_ars_ars_pk_seq',
        'license_ref_rf_pk_seq',
        'license_file_fl_pk_seq',
        'license_file_fl_pk_seq'
      ));
    $this->testDb->createConstraints(
      array(
        'agent_pkey',
        'upload_pkey_idx',
        'pfile_pkey',
        'user_pkey',
        'license_file_pkey'
      ));
    $this->testDb->alterTables(
      array(
        'agent',
        'pfile',
        'upload',
        'ars_master',
        'users',
        'license_ref',
        'license_file'
      ));
    $this->testDb->createInheritedTables(array(
      'uploadtree_a'
    ));

    $this->testDb->insertData(
      array(
        'upload',
        'pfile',
        'uploadtree_a',
        'users',
        'license_ref'
      ), false);
  }

  private function resultArrayContainsLicense($resultArray, $licenseName)
  {
    foreach ($resultArray as $result) {
      if (strcmp($result["license"], $licenseName) === 0) {
        return true;
      }
    }
    return false;
  }

  private function compareMatches($left, $right)
  {
    if (strcmp($left["file"], $right["file"]) !== 0) {
      return strcmp($left["file"], $right["file"]);
    }
    if ($left["results"] === null) {
      if ($right["results"] === null) {
        return 0;
      }
      return 1;
    }
    if ($right["results"] === null) {
      return -1;
    }
    if (count($left["results"]) !== count($right["results"])) {
      return count($left["results"]) - count($right["results"]);
    }
    foreach ($left["results"] as $key => $result) {
      if (strcmp($result["license"], $right["results"][$key]["license"]) !== 0) {
        return strcmp($result["license"], $right[$key]["license"]);
      }
    }
    return 0;
  }

  private function compareMatchesFiles($left, $right)
  {
    return strcmp($left["file"], $right["file"]);
  }

  public function testRun()
  {
    $this->setUpTables();
    $this->setUpRepo();
    $uploadId = 44;
    list ($success, $output, $retCode) = $this->schedulerRunner->run($uploadId);
    $this->rmRepo();
    $this->assertTrue($success, 'running ojo failed');
    $this->assertEquals($retCode, 0, "ojo failed ($retCode): $output");

    $uploadTreeTableName = $this->uploadDao->getUploadtreeTableName($uploadId);
    $uploadParent = $this->uploadDao->getItemTreeBounds(460, $uploadTreeTableName);
    $licenseMatches = $this->licenseDao->getLicensesPerFileNameForAgentId(
      $uploadParent, [1]);

    $this->assertGreaterThan(8, count($licenseMatches), $output);
    $this->assertContains("Classpath-exception-2.0",
      $licenseMatches["spdx.tar/spdx/GPL-2.0_WITH_Classpath-exception-2.0"]["scanResults"]);
    $this->assertContains("GPL-2.0-only",
      $licenseMatches["spdx.tar/spdx/GPL-2.0_WITH_Classpath-exception-2.0"]["scanResults"]);

    $this->assertContains("GPL-2.0-only",
      $licenseMatches["spdx.tar/spdx/GPL-2.0_OR_MIT"]["scanResults"]);
    $this->assertContains("MIT",
      $licenseMatches["spdx.tar/spdx/GPL-2.0_OR_MIT"]["scanResults"]);

    $this->assertContains("GPL-2.0-or-later",
      $licenseMatches["spdx.tar/spdx/GPL-2.0-or-later"]["scanResults"]);

    $this->assertContains("GPL-2.0-only",
      $licenseMatches["spdx.tar/spdx/GPL-2.0-only"]["scanResults"]);

    $this->assertContains("LGPL-2.1-or-later",
      $licenseMatches["spdx.tar/spdx/GPL-2.0_AND_LGPL-2.1-or-later_OR_MIT"]["scanResults"]);
    $this->assertContains("GPL-2.0-only",
      $licenseMatches["spdx.tar/spdx/GPL-2.0_AND_LGPL-2.1-or-later_OR_MIT"]["scanResults"]);
    $this->assertContains("MIT",
      $licenseMatches["spdx.tar/spdx/GPL-2.0_AND_LGPL-2.1-or-later_OR_MIT"]["scanResults"]);

    $this->assertContains("GPL-2.0-or-later",
      $licenseMatches["spdx.tar/spdx/GPL-2.0+"]["scanResults"]);

    $this->assertContains("GPL-2.0-only",
      $licenseMatches["spdx.tar/spdx/GPL-2.0"]["scanResults"]);
  }

  public function testCli()
  {
    $testFile = "../../../nomos/agent_tests/testdata/NomosTestfiles/SPDX/MPL-2.0_AND_BSD-2-Clause_AND_MIT_OR_Apache-2.0.txt";

    $args = "--json $testFile";
    list ($success, $output, $retCode) = $this->cliRunner->run($args);
    $this->assertTrue($success, 'running ojo failed');
    $this->assertEquals($retCode, 0, "ojo failed ($retCode): $output");

    $this->assertJson($output);
    $result = json_decode($output, true);
    $resultArray = $result[0]["results"];

    $this->assertEquals($testFile, $result[0]["file"]);
    $this->assertTrue($this->resultArrayContainsLicense($resultArray,
      "MPL-2.0-no-copyleft-exception"));
    $this->assertTrue($this->resultArrayContainsLicense($resultArray,
      "BSD-2-Clause"));
    $this->assertTrue($this->resultArrayContainsLicense($resultArray,
      "MIT"));
    $this->assertTrue($this->resultArrayContainsLicense($resultArray,
      "Apache-2.0"));
    $this->assertTrue($this->resultArrayContainsLicense($resultArray,
      "Dual-license"));
  }

  public function regressionTest()
  {
    $testDir = "../../../nomos/agent_tests/testdata/NomosTestfiles/SPDX";

    $args = "--json --directory $testDir";
    list ($success, $output, $retCode) = $this->cliRunner->run($args);
    $this->assertTrue($success, 'running ojo failed');
    $this->assertEquals($retCode, 0, "ojo failed ($retCode): $output");
    $this->assertJson($output);

    // Load data from last run
    $jsonFromFile = json_decode(file_get_contents($this->regressionFile), true);
    // Load result from agent
    $jsonFromOutput = json_decode($output, true);

    // Sort the data to reduce differences
    usort($jsonFromFile, array('OjoScheduledTest', 'compareMatchesFiles'));
    usort($jsonFromOutput, array('OjoScheduledTest', 'compareMatchesFiles'));

    // Find the difference
    $jsonDiff = array_udiff($jsonFromFile, $jsonFromOutput,
      array('OjoScheduledTest', 'compareMatches'));

    $outputDiff = "JSON does not match regression test file.\n";
    $outputDiff .= "Following are the results not in regression test file.\n";
    $outputDiff .= print_r($jsonDiff, true);

    $this->assertEquals(0, count($jsonDiff), $outputDiff);
  }
}