Page MenuHomeWickedGov Phorge
Files F4159350

LicenseParserTest.php
No OneTemporary
Actions

Size
9 KB
Referenced Files
None
Subscribers
None

LicenseParserTest.php
View Options

<?php
namespace CommonsMetadata;
/**
* @covers \CommonsMetadata\LicenseParser
* @group Extensions/CommonsMetadata
*/
class LicenseParserTest extends \MediaWikiIntegrationTestCase {
/** @var LicenseParser */
protected $licenseParser;
public function setUp(): void {
parent::setUp();
$this->licenseParser = new LicenseParser();
}
/**
* @dataProvider provideUnrecognizedLicenses
*/
public function testUnrecognizedLicenses( ?string $licenseString ): void {
$data = $this->licenseParser->parseLicenseString( $licenseString );
$this->assertLicenseIsNotRecognized( $data );
}
public static function provideUnrecognizedLicenses(): iterable {
yield 'null license string' => [ null ];
yield 'empty license string' => [ '' ];
yield 'wrong license string' => [ 'foo' ];
yield 'CC license without version' => [ 'cc-by-sa' ];
yield 'non-free license (CC-BY-NC-SA 3.0)' => [ 'cc-by-nc-sa-3.0' ];
yield 'non-free license (CC-BY-ND 2.1)' => [ 'cc-by-nd-2.1' ];
}
public function testNormalCCLicense() {
$licenseString = 'cc-by-sa-1.0';
$data = $this->licenseParser->parseLicenseString( $licenseString );
$this->assertLicenseFamilyEquals( 'cc', $data );
$this->assertLicenseTypeEquals( 'cc-by-sa', $data );
$this->assertLicenseVersionEquals( '1.0', $data );
$this->assertLicenseRegionEquals( null, $data );
$this->assertLicenseNameEquals( 'cc-by-sa-1.0', $data );
}
public function testNormalCCLicenseInUppercase() {
$licenseString = 'CC-BY-SA-1.0';
$data = $this->licenseParser->parseLicenseString( $licenseString );
$this->assertLicenseFamilyEquals( 'cc', $data );
$this->assertLicenseTypeEquals( 'cc-by-sa', $data );
$this->assertLicenseNameEquals( 'cc-by-sa-1.0', $data );
}
public function testNormalCCLicenseWithSpaces() {
$licenseString = 'CC BY-SA 1.0';
$data = $this->licenseParser->parseLicenseString( $licenseString );
$this->assertLicenseFamilyEquals( 'cc', $data );
$this->assertLicenseTypeEquals( 'cc-by-sa', $data );
$this->assertLicenseNameEquals( 'cc-by-sa-1.0', $data );
}
public function testCCSALicense() {
$licenseString = 'CC-SA-1.0';
$data = $this->licenseParser->parseLicenseString( $licenseString );
$this->assertLicenseFamilyEquals( 'cc', $data );
$this->assertLicenseTypeEquals( 'cc-sa', $data );
$this->assertLicenseNameEquals( 'cc-sa-1.0', $data );
}
public function testRegionalCCLicense() {
$licenseString = 'cc-by-2.0-fr';
$data = $this->licenseParser->parseLicenseString( $licenseString );
$this->assertLicenseTypeEquals( 'cc-by', $data );
$this->assertLicenseRegionEquals( 'fr', $data );
$this->assertLicenseNameEquals( 'cc-by-2.0-fr', $data );
}
public function testRegionalCCLicenseWithInvalidRegion() {
$licenseString = 'cc-by-2.0-foo';
$data = $this->licenseParser->parseLicenseString( $licenseString );
$this->assertLicenseIsNotRecognized( $data );
}
public function testRegionalCCLicenseWithSpecialRegion() {
$licenseString = 'cc-by-2.0-scotland';
$data = $this->licenseParser->parseLicenseString( $licenseString );
$this->assertLicenseTypeEquals( 'cc-by', $data );
$this->assertLicenseRegionEquals( 'scotland', $data );
$this->assertLicenseNameEquals( 'cc-by-2.0-scotland', $data );
}
public function testCC0() {
$licenseString = 'CC0';
$data = $this->licenseParser->parseLicenseString( $licenseString );
$this->assertLicenseTypeEquals( 'cc0', $data );
$this->assertLicenseVersionEquals( null, $data );
$this->assertLicenseNameEquals( 'cc0', $data );
}
public function testPD() {
$licenseString = 'Public Domain';
$data = $this->licenseParser->parseLicenseString( $licenseString );
$this->assertLicenseFamilyEquals( 'pd', $data );
$this->assertLicenseNameEquals( 'pd', $data );
}
/**
* @dataProvider provideGetLicensePriorityData
* @param array $greaterLicenseData
* @param array $smallerLicenseData
*/
public function testGetLicensePriority( $greaterLicenseData, $smallerLicenseData ) {
$this->assertLicenseHasGreaterPriority( $greaterLicenseData, $smallerLicenseData );
}
public static function provideGetLicensePriorityData() {
// phpcs:disable MediaWiki.WhiteSpace.SpaceBeforeSingleLineComment.NewLineComment
return [
[ // PD wins over CC
[ // this should have higher priority...
'family' => 'pd',
'type' => null,
'version' => null,
'region' => null,
'name' => 'pd',
],
[ // ...than this
'family' => 'cc',
'type' => 'cc-by-sa',
'version' => '2.0',
'region' => null,
'name' => 'cc-by-sa-2.0',
],
],
[ // CC wins over unknown
[ // this should have higher priority...
'family' => 'cc',
'type' => 'cc-by-sa',
'version' => '2.5',
'region' => null,
'name' => 'cc-by-sa-2.5',
],
[ // ...than this
'family' => 'gfdl',
'type' => null,
'version' => null,
'region' => null,
'name' => 'gfdl',
],
],
[ // BY wins over BY-SA
[ // this should have higher priority...
'family' => 'cc',
'type' => 'cc-by',
'version' => '2.5',
'region' => null,
'name' => 'cc-by-sa-2.5',
],
[ // ...than this
'family' => 'cc',
'type' => 'cc-by-sa',
'version' => '2.0',
'region' => null,
'name' => 'cc-by-sa-2.0',
],
],
[ // higher CC wins
[ // this should have higher priority...
'family' => 'cc',
'type' => 'cc-by-sa',
'version' => '2.5',
'region' => null,
'name' => 'cc-by-sa-2.5',
],
[ // ...than this
'family' => 'cc',
'type' => 'cc-by-sa',
'version' => '2.0',
'region' => null,
'name' => 'cc-by-sa-2.0',
],
],
];
// phpcs:enable MediaWiki.WhiteSpace.SpaceBeforeSingleLineComment.NewLineComment
}
public function testSortDataByLicensePriority() {
$licenses = [ 'gfdl', 'public domain', '', 'cc-by-sa-2.0', 'cc-by-2.0',
'cc-by-sa-3.5', 'cc-by-3.5', 'foobar' ];
$expectedSortedLicenses = [ 'public domain', 'cc-by-3.5', 'cc-by-2.0', 'cc-by-sa-3.5',
'cc-by-sa-2.0', 'gfdl', '', 'foobar' ];
$actualSortedLicenses = $this->licenseParser->sortDataByLicensePriority( $licenses,
static function ( $v ) {
return $v;
}
);
$this->assertArrayEquals( $expectedSortedLicenses, $actualSortedLicenses, true );
// test that array keys are kept
$licenses = [ 'a' => 'cc-by-2.0', 'b' => 'cc-by-3.5' ];
$expectedSortedLicenses = [ 'b' => 'cc-by-3.5', 'a' => 'cc-by-2.0' ];
$actualSortedLicenses = $this->licenseParser->sortDataByLicensePriority( $licenses,
static function ( $v ) {
return $v;
}
);
$this->assertArrayEquals( $expectedSortedLicenses, $actualSortedLicenses, true, true );
// test with the same data structure that's used by the collector
$licenseData = [
[
'UsageTerms' => 'foo',
],
[
'LicenseShortName' => 'cc-by-sa-2.0',
'UsageTerms' => 'Creative Commons',
],
[
'LicenseShortName' => 'cc-by-sa-4.0',
'UsageTerms' => 'Creative Commons',
],
];
$expectedSortOrder = [ 2, 1, 0 ];
$sortedLicenseData = $this->licenseParser->sortDataByLicensePriority( $licenseData,
static function ( $license ) {
if ( !isset( $license['LicenseShortName'] ) ) {
return '';
}
return $license['LicenseShortName'];
}
);
$this->assertArrayEquals( $licenseData, $sortedLicenseData, false, true );
$this->assertArrayEquals( $expectedSortOrder, array_keys( $sortedLicenseData ), true );
}
protected function assertLicenseIsRecognized( $licenseData ) {
$this->assertNotNull( $licenseData );
}
protected function assertLicenseIsNotRecognized( $licenseData ) {
$this->assertNull( $licenseData );
}
protected function assertLicenseElementEquals( $expected, $element, $licenseData ) {
$this->assertIsArray( $licenseData );
$this->assertArrayHasKey( $element, $licenseData );
$this->assertEquals( $expected, $licenseData[$element] );
}
protected function assertLicenseFamilyEquals( $family, $licenseData ) {
$this->assertLicenseElementEquals( $family, 'family', $licenseData );
}
protected function assertLicenseTypeEquals( $type, $licenseData ) {
$this->assertLicenseElementEquals( $type, 'type', $licenseData );
}
protected function assertLicenseVersionEquals( $version, $licenseData ) {
$this->assertLicenseElementEquals( $version, 'version', $licenseData );
}
protected function assertLicenseRegionEquals( $region, $licenseData ) {
$this->assertLicenseElementEquals( $region, 'region', $licenseData );
}
protected function assertLicenseNameEquals( $name, $licenseData ) {
$this->assertLicenseElementEquals( $name, 'name', $licenseData );
}
protected function assertLicenseHasGreaterPriority( $greaterLicenseData, $smallerLicenseData ) {
$getLicensePriorityMethod = new \ReflectionMethod(
$this->licenseParser, 'getLicensePriority' );
$getLicensePriorityMethod->setAccessible( true );
$greaterLicensePriority = $getLicensePriorityMethod->invokeArgs(
$this->licenseParser, [ $greaterLicenseData ] );
$smallerLicensePriority = $getLicensePriorityMethod->invokeArgs(
$this->licenseParser, [ $smallerLicenseData ] );
$this->assertGreaterThan( $smallerLicensePriority, $greaterLicensePriority );
}
}

File Metadata

Mime Type
text/x-php
Expires
Aug 19 2026, 23:51 (9 w, 1 d ago)
Storage Engine
local-disk
Storage Format
Raw Data
Storage Handle
22/81/841d10791903f103cd3189d63b82
Default Alt Text
LicenseParserTest.php (9 KB)

Event Timeline