Issues in SimpleCacheTestCase.php (master) - Issues in master - wikimedia/mediawiki-extensions-Wikibase - Measure and Improve Code Quality continuously with Scrutinizer

Issues (1401)

Security Analysis no request data

Cross-Site Scripting

Cross-Site Scripting enables an attacker to inject code into the response of a web-request that is viewed by other users. It can for example be used to bypass access controls, or even to take over other users' accounts.

File Exposure

File Exposure allows an attacker to gain access to local files that he should not be able to access. These files can for example include database credentials, or other configuration files.

File Manipulation

File Manipulation enables an attacker to write custom data to files. This potentially leads to injection of arbitrary code on the server.

Object Injection

Object Injection enables an attacker to inject an object into PHP code, and can lead to arbitrary code execution, file exposure, or file manipulation attacks.

Code Injection

Code Injection enables an attacker to execute arbitrary code on the server.

Response Splitting

Response Splitting can be used to send arbitrary responses.

File Inclusion

File Inclusion enables an attacker to inject custom files into PHP's file loading mechanism, either explicitly passed to include, or for example via PHP's auto-loading mechanism.

Command Injection

Command Injection enables an attacker to inject a shell command that is execute with the privileges of the web-server. This can be used to expose sensitive data, or gain access of your server.

SQL Injection

SQL Injection enables an attacker to execute arbitrary SQL code on your database server gaining access to user data, or manipulating user data.

XPath Injection

XPath Injection enables an attacker to modify the parts of XML document that are read. If that XML document is for example used for authentication, this can lead to further vulnerabilities similar to SQL Injection.

LDAP Injection

LDAP Injection enables an attacker to inject LDAP statements potentially granting permission to run unauthorized queries, or modify content inside the LDAP tree.

Header Injection

Other Vulnerability

This category comprises other attack vectors such as manipulating the PHP runtime, loading custom extensions, freezing the runtime, or similar.

Regex Injection

Regex Injection enables an attacker to execute arbitrary code in your PHP process.

XML Injection

XML Injection enables an attacker to read files on your local filesystem including configuration files, or can be abused to freeze your web-server process.

Variable Injection

Variable Injection enables an attacker to overwrite program variables with custom data, and can lead to further vulnerabilities.

Unfortunately, the security analysis is currently not available for your project. If you are a non-commercial open-source project, please contact support to gain access.

lib/tests/phpunit/SimpleCacheTestCase.php (23 issues)

Labels

Severity

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php

namespace Wikibase\Lib\Tests;

/*
 * This file was originally part of php-cache organization. It was copied in context of
 * https://phabricator.wikimedia.org/T237164#6234226.
 *
 * The original from which this file was copied is
 * https://github.com/php-cache/integration-tests/blob/e023fbe54c9821dfefbe04db0074ee8682f7f577/src/SimpleCacheTest.php
 *
 * See there for the original version of this comment.
 */

use PHPUnit\Framework\TestCase;
use Psr\SimpleCache\CacheInterface;

/**
 * All modifications to the original MIT-licensed file are made under
 * @license GPL-2.0-or-later
 */
abstract class SimpleCacheTestCase extends TestCase {

	/**
	 * @var array with functionName => reason.
	 */
	protected $skippedTests = [];

	/**
	 * @var CacheInterface
	 */
	protected $cache;

	/**
	 * @return CacheInterface that is used in the tests
	 */
	abstract public function createSimpleCache();

	/**
	 * Advance time perceived by the cache for the purposes of testing TTL.
	 *
	 * The default implementation sleeps for the specified duration,
	 * but subclasses are encouraged to override this,
	 * adjusting a mocked time possibly set up in {@link createSimpleCache()},
	 * to speed up the tests.
	 *
	 * @param int $seconds
	 */
	public function advanceTime( $seconds ) {
		sleep( $seconds );
	}

	protected function setUp(): void {
		parent::setUp();

		$this->cache = $this->createSimpleCache();
	}

	protected function tearDown(): void {
		parent::tearDown();

		if ( $this->cache !== null ) {
			$this->cache->clear();
		}
	}

	/**
	 * Data provider for invalid cache keys.
	 *
	 * @return array
	 */
	public static function invalidKeys() {
		return array_merge(
			self::invalidArrayKeys(),
			[
				[ 2 ],
			]
		);
	}

	/**
	 * Data provider for invalid array keys.
	 *
	 * @return array
	 */
	public static function invalidArrayKeys() {
		return [
			[ '' ],
			[ true ],
			[ false ],
			[ null ],
			[ 2.5 ],
			[ '{str' ],
			[ 'rand{' ],
			[ 'rand{str' ],
			[ 'rand}str' ],
			[ 'rand(str' ],
			[ 'rand)str' ],
			[ 'rand/str' ],
			[ 'rand\\str' ],
			[ 'rand@str' ],
			[ 'rand:str' ],
			[ new \stdClass() ],
			[ [ 'array' ] ],
		];
	}

	/**
	 * @return array
	 */
	public static function invalidTtl() {
		return [
			[ '' ],
			[ true ],
			[ false ],
			[ 'abc' ],
			[ 2.5 ],
			[ ' 1' ], // can be casted to a int
			[ '12foo' ], // can be casted to a int
			[ '025' ], // can be interpreted as hex
			[ new \stdClass() ],
			[ [ 'array' ] ],
		];
	}

	/**
	 * Data provider for valid keys.
	 *
	 * @return array
	 */
	public static function validKeys() {
		return [
			[ 'AbC19_.' ],
			[ '1234567890123456789012345678901234567890123456789012345678901234' ],
		];
	}

	/**
	 * Data provider for valid data to store.
	 *
	 * @return array
	 */
	public static function validData() {
		return [
			[ 'AbC19_.' ],
			[ 4711 ],
			[ 47.11 ],
			[ true ],
			[ null ],
			[ [ 'key' => 'value' ] ],
			[ new \stdClass() ],
		];
	}

	public function testSet() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$result = $this->cache->set( 'key', 'value' );
		$this->assertTrue( $result, 'set() must return true if success' );
		$this->assertEquals( 'value', $this->cache->get( 'key' ) );
	}

	public function testSetTtl() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$result = $this->cache->set( 'key1', 'value', 1 );
		$this->assertTrue( $result, 'set() must return true if success' );
		$this->assertEquals( 'value', $this->cache->get( 'key1' ) );
		$this->advanceTime( 2 );
		$this->assertNull( $this->cache->get( 'key1' ), 'Value must expire after ttl.' );

		$this->cache->set( 'key2', 'value', new \DateInterval( 'PT1S' ) );
		$this->assertEquals( 'value', $this->cache->get( 'key2' ) );
		$this->advanceTime( 2 );
		$this->assertNull( $this->cache->get( 'key2' ), 'Value must expire after ttl.' );
	}

	public function testSetExpiredTtl() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->cache->set( 'key0', 'value' );
		$this->cache->set( 'key0', 'value', 0 );
		$this->assertNull( $this->cache->get( 'key0' ) );
		$this->assertFalse( $this->cache->has( 'key0' ) );

		$this->cache->set( 'key1', 'value', -1 );
		$this->assertNull( $this->cache->get( 'key1' ) );
		$this->assertFalse( $this->cache->has( 'key1' ) );
	}

	public function testGet() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->assertNull( $this->cache->get( 'key' ) );
		$this->assertEquals( 'foo', $this->cache->get( 'key', 'foo' ) );

		$this->cache->set( 'key', 'value' );
		$this->assertEquals( 'value', $this->cache->get( 'key', 'foo' ) );
	}

	public function testDelete() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->assertTrue( $this->cache->delete( 'key' ), 'Deleting a value that does not exist should return true' );
		$this->cache->set( 'key', 'value' );
		$this->assertTrue( $this->cache->delete( 'key' ), 'Delete must return true on success' );
		$this->assertNull( $this->cache->get( 'key' ), 'Values must be deleted on delete()' );
	}

	public function testClear() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->assertTrue( $this->cache->clear(), 'Clearing an empty cache should return true' );
		$this->cache->set( 'key', 'value' );
		$this->assertTrue( $this->cache->clear(), 'Delete must return true on success' );
		$this->assertNull( $this->cache->get( 'key' ), 'Values must be deleted on clear()' );
	}

	public function testSetMultiple() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$result = $this->cache->setMultiple( [ 'key0' => 'value0', 'key1' => 'value1' ] );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
		$this->assertTrue( $result, 'setMultiple() must return true if success' );
		$this->assertEquals( 'value0', $this->cache->get( 'key0' ) );
		$this->assertEquals( 'value1', $this->cache->get( 'key1' ) );
	}

	public function testSetMultipleWithIntegerArrayKey() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$result = $this->cache->setMultiple( [ '0' => 'value0' ] );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
		$this->assertTrue( $result, 'setMultiple() must return true if success' );
		$this->assertEquals( 'value0', $this->cache->get( '0' ) );
	}

	public function testSetMultipleTtl() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->cache->setMultiple( [ 'key2' => 'value2', 'key3' => 'value3' ], 1 );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
		$this->assertEquals( 'value2', $this->cache->get( 'key2' ) );
		$this->assertEquals( 'value3', $this->cache->get( 'key3' ) );
		$this->advanceTime( 2 );
		$this->assertNull( $this->cache->get( 'key2' ), 'Value must expire after ttl.' );
		$this->assertNull( $this->cache->get( 'key3' ), 'Value must expire after ttl.' );

		$this->cache->setMultiple( [ 'key4' => 'value4' ], new \DateInterval( 'PT1S' ) );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
		$this->assertEquals( 'value4', $this->cache->get( 'key4' ) );
		$this->advanceTime( 2 );
		$this->assertNull( $this->cache->get( 'key4' ), 'Value must expire after ttl.' );
	}

	public function testSetMultipleExpiredTtl() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->cache->setMultiple( [ 'key0' => 'value0', 'key1' => 'value1' ], 0 );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
		$this->assertNull( $this->cache->get( 'key0' ) );
		$this->assertNull( $this->cache->get( 'key1' ) );
	}

	public function testSetMultipleWithGenerator() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$gen = function () {
			yield 'key0' => 'value0';
			yield 'key1' => 'value1';
		};

		$this->cache->setMultiple( $gen() );
		$this->assertEquals( 'value0', $this->cache->get( 'key0' ) );
		$this->assertEquals( 'value1', $this->cache->get( 'key1' ) );
	}

	public function testGetMultiple() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$result = $this->cache->getMultiple( [ 'key0', 'key1' ] );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
		$keys = [];
		foreach ( $result as $i => $r ) {
			$keys[] = $i;
			$this->assertNull( $r );
		}
		sort( $keys );
		$this->assertSame( [ 'key0', 'key1' ], $keys );

		$this->cache->set( 'key3', 'value' );
		$result = $this->cache->getMultiple( [ 'key2', 'key3', 'key4' ], 'foo' );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
		$keys = [];
		foreach ( $result as $key => $r ) {
			$keys[] = $key;
			if ( $key === 'key3' ) {
				$this->assertEquals( 'value', $r );
			} else {
				$this->assertEquals( 'foo', $r );
			}
		}
		sort( $keys );
		$this->assertSame( [ 'key2', 'key3', 'key4' ], $keys );
	}

	public function testGetMultipleWithGenerator() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$gen = function () {
			yield 1 => 'key0';
			yield 1 => 'key1';
		};

		$this->cache->set( 'key0', 'value0' );
		$result = $this->cache->getMultiple( $gen() );
		$keys = [];
		foreach ( $result as $key => $r ) {
			$keys[] = $key;
			if ( $key === 'key0' ) {
				$this->assertEquals( 'value0', $r );
			} elseif ( $key === 'key1' ) {
				$this->assertNull( $r );
			} else {
				$this->assertFalse( true, 'This should not happend' );
			}
		}
		sort( $keys );
		$this->assertSame( [ 'key0', 'key1' ], $keys );
		$this->assertEquals( 'value0', $this->cache->get( 'key0' ) );
		$this->assertNull( $this->cache->get( 'key1' ) );
	}

	public function testDeleteMultiple() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->assertTrue( $this->cache->deleteMultiple( [] ), 'Deleting a empty array should return true' );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
		$this->assertTrue( $this->cache->deleteMultiple( [ 'key' ] ), 'Deleting a value that does not exist should return true' );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

		$this->cache->set( 'key0', 'value0' );
		$this->cache->set( 'key1', 'value1' );
		$this->assertTrue( $this->cache->deleteMultiple( [ 'key0', 'key1' ] ), 'Delete must return true on success' );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
		$this->assertNull( $this->cache->get( 'key0' ), 'Values must be deleted on deleteMultiple()' );
		$this->assertNull( $this->cache->get( 'key1' ), 'Values must be deleted on deleteMultiple()' );
	}

	public function testDeleteMultipleGenerator() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$gen = function () {
			yield 1 => 'key0';
			yield 1 => 'key1';
		};
		$this->cache->set( 'key0', 'value0' );
		$this->assertTrue( $this->cache->deleteMultiple( $gen() ), 'Deleting a generator should return true' );

		$this->assertNull( $this->cache->get( 'key0' ), 'Values must be deleted on deleteMultiple()' );
		$this->assertNull( $this->cache->get( 'key1' ), 'Values must be deleted on deleteMultiple()' );
	}

	public function testHas() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->assertFalse( $this->cache->has( 'key0' ) );
		$this->cache->set( 'key0', 'value0' );
		$this->assertTrue( $this->cache->has( 'key0' ) );
	}

	public function testBasicUsageWithLongKey() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$key = str_repeat( 'a', 300 );

		$this->assertFalse( $this->cache->has( $key ) );
		$this->assertTrue( $this->cache->set( $key, 'value' ) );

		$this->assertTrue( $this->cache->has( $key ) );
		$this->assertSame( 'value', $this->cache->get( $key ) );

		$this->assertTrue( $this->cache->delete( $key ) );

		$this->assertFalse( $this->cache->has( $key ) );
	}

	/**
	 * @dataProvider invalidKeys
	 */
	public function testGetInvalidKeys( $key ) {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->expectException( 'Psr\SimpleCache\InvalidArgumentException' );
		$this->cache->get( $key );
	}

	/**
	 * @dataProvider invalidKeys
	 */
	public function testGetMultipleInvalidKeys( $key ) {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->expectException( 'Psr\SimpleCache\InvalidArgumentException' );
		$result = $this->cache->getMultiple( [ 'key1', $key, 'key2' ] );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
	}

	public function testGetMultipleNoIterable() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->expectException( 'Psr\SimpleCache\InvalidArgumentException' );
		$result = $this->cache->getMultiple( 'key' );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
	}

	/**
	 * @dataProvider invalidKeys
	 */
	public function testSetInvalidKeys( $key ) {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->expectException( 'Psr\SimpleCache\InvalidArgumentException' );
		$this->cache->set( $key, 'foobar' );
	}

	/**
	 * @dataProvider invalidArrayKeys
	 */
	public function testSetMultipleInvalidKeys( $key ) {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$values = function () use ( $key ) {
			yield 'key1' => 'foo';
			yield $key => 'bar';
			yield 'key2' => 'baz';
		};
		$this->expectException( 'Psr\SimpleCache\InvalidArgumentException' );
		$this->cache->setMultiple( $values() );
	}

	public function testSetMultipleNoIterable() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->expectException( 'Psr\SimpleCache\InvalidArgumentException' );
		$this->cache->setMultiple( 'key' );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
	}

	/**
	 * @dataProvider invalidKeys
	 */
	public function testHasInvalidKeys( $key ) {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->expectException( 'Psr\SimpleCache\InvalidArgumentException' );
		$this->cache->has( $key );
	}

	/**
	 * @dataProvider invalidKeys
	 */
	public function testDeleteInvalidKeys( $key ) {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->expectException( 'Psr\SimpleCache\InvalidArgumentException' );
		$this->cache->delete( $key );
	}

	/**
	 * @dataProvider invalidKeys
	 */
	public function testDeleteMultipleInvalidKeys( $key ) {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->expectException( 'Psr\SimpleCache\InvalidArgumentException' );
		$this->cache->deleteMultiple( [ 'key1', $key, 'key2' ] );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
	}

	public function testDeleteMultipleNoIterable() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->expectException( 'Psr\SimpleCache\InvalidArgumentException' );
		$this->cache->deleteMultiple( 'key' );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
	}

	/**
	 * @dataProvider invalidTtl
	 */
	public function testSetInvalidTtl( $ttl ) {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->expectException( 'Psr\SimpleCache\InvalidArgumentException' );
		$this->cache->set( 'key', 'value', $ttl );
	}

	/**
	 * @dataProvider invalidTtl
	 */
	public function testSetMultipleInvalidTtl( $ttl ) {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->expectException( 'Psr\SimpleCache\InvalidArgumentException' );
		$this->cache->setMultiple( [ 'key' => 'value' ], $ttl );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
	}

	public function testNullOverwrite() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->cache->set( 'key', 5 );
		$this->cache->set( 'key', null );

		$this->assertNull( $this->cache->get( 'key' ), 'Setting null to a key must overwrite previous value' );
	}

	public function testDataTypeString() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->cache->set( 'key', '5' );
		$result = $this->cache->get( 'key' );
		$this->assertTrue( '5' === $result, 'Wrong data type. If we store a string we must get an string back.' );
		$this->assertTrue( is_string( $result ), 'Wrong data type. If we store a string we must get an string back.' );
	}

	public function testDataTypeInteger() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->cache->set( 'key', 5 );
		$result = $this->cache->get( 'key' );
		$this->assertTrue( 5 === $result, 'Wrong data type. If we store an int we must get an int back.' );
		$this->assertTrue( is_int( $result ), 'Wrong data type. If we store an int we must get an int back.' );
	}

	public function testDataTypeFloat() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$float = 1.23456789;
		$this->cache->set( 'key', $float );
		$result = $this->cache->get( 'key' );
		$this->assertTrue( is_float( $result ), 'Wrong data type. If we store float we must get an float back.' );
		$this->assertEquals( $float, $result );
	}

	public function testDataTypeBoolean() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->cache->set( 'key', false );
		$result = $this->cache->get( 'key' );
		$this->assertTrue( is_bool( $result ), 'Wrong data type. If we store boolean we must get an boolean back.' );
		$this->assertFalse( $result );
		$this->assertTrue( $this->cache->has( 'key' ), 'has() should return true when true are stored. ' );
	}

	public function testDataTypeArray() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$array = [ 'a' => 'foo', 2 => 'bar' ];
		$this->cache->set( 'key', $array );
		$result = $this->cache->get( 'key' );
		$this->assertTrue( is_array( $result ), 'Wrong data type. If we store array we must get an array back.' );
		$this->assertEquals( $array, $result );
	}

	public function testDataTypeObject() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$object = new \stdClass();
		$object->a = 'foo';
		$this->cache->set( 'key', $object );
		$result = $this->cache->get( 'key' );
		$this->assertTrue( is_object( $result ), 'Wrong data type. If we store object we must get an object back.' );
		$this->assertEquals( $object, $result );
	}

	public function testBinaryData() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$data = '';
		for ( $i = 0; $i < 256; $i++ ) {
			$data .= chr( $i );
		}

		$array = [ 'a' => 'foo', 2 => 'bar' ];
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
		$this->cache->set( 'key', $data );
		$result = $this->cache->get( 'key' );
		$this->assertTrue( $data === $result, 'Binary data must survive a round trip.' );
	}

	/**
	 * @dataProvider validKeys
	 */
	public function testSetValidKeys( $key ) {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->cache->set( $key, 'foobar' );
		$this->assertEquals( 'foobar', $this->cache->get( $key ) );
	}

	/**
	 * @dataProvider validKeys
	 */
	public function testSetMultipleValidKeys( $key ) {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->cache->setMultiple( [ $key => 'foobar' ] );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
		$result = $this->cache->getMultiple( [ $key ] );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
		$keys = [];
		foreach ( $result as $i => $r ) {
			$keys[] = $i;
			$this->assertEquals( $key, $i );
			$this->assertEquals( 'foobar', $r );
		}
		$this->assertSame( [ $key ], $keys );
	}

	/**
	 * @dataProvider validData
	 */
	public function testSetValidData( $data ) {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->cache->set( 'key', $data );
		$this->assertEquals( $data, $this->cache->get( 'key' ) );
	}

	/**
	 * @dataProvider validData
	 */
	public function testSetMultipleValidData( $data ) {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$this->cache->setMultiple( [ 'key' => $data ] );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
		$result = $this->cache->getMultiple( [ 'key' ] );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
		$keys = [];
		foreach ( $result as $i => $r ) {
			$keys[] = $i;
			$this->assertEquals( $data, $r );
		}
		$this->assertSame( [ 'key' ], $keys );
	}

	public function testObjectAsDefaultValue() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$obj = new \stdClass();
		$obj->foo = 'value';
		$this->assertEquals( $obj, $this->cache->get( 'key', $obj ) );
	}

	public function testObjectDoesNotChangeInCache() {
		if ( isset( $this->skippedTests[__FUNCTION__] ) ) {
			$this->markTestSkipped( $this->skippedTests[__FUNCTION__] );
		}

		$obj = new \stdClass();
		$obj->foo = 'value';
		$this->cache->set( 'key', $obj );
		$obj->foo = 'changed';

		$cacheObject = $this->cache->get( 'key' );
		$this->assertEquals( 'value', $cacheObject->foo, 'Object in cache should not have their values changed.' );
	}
}


wikimedia / mediawiki-extensions-Wikibase

Issues (1401)

Security Analysis no request data

lib/tests/phpunit/SimpleCacheTestCase.php (23 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like