},
"require-dev": {
"composer/spdx-licenses": "1.1.4",
+ "hamcrest/hamcrest-php": "^2.0",
"jakub-onderka/php-parallel-lint": "0.9.2",
+ "jetbrains/phpstorm-stubs": "dev-master#1b9906084d6635456fcf3f3a01f0d7d5b99a578a",
"justinrainbow/json-schema": "~3.0",
"mediawiki/mediawiki-codesniffer": "0.7.2",
- "jetbrains/phpstorm-stubs": "dev-master#1b9906084d6635456fcf3f3a01f0d7d5b99a578a",
"monolog/monolog": "~1.22.1",
"nikic/php-parser": "2.1.0",
"nmred/kafka-php": "0.1.5",
"phpunit/phpunit": "4.8.35",
+ "psy/psysh": "0.8.3",
"wikimedia/avro": "1.7.7",
- "hamcrest/hamcrest-php": "^2.0",
- "wmde/hamcrest-html-matchers": "^0.1.0",
- "psy/psysh": "0.8.3"
+ "wikimedia/testing-access-wrapper": "~1.0",
+ "wmde/hamcrest-html-matchers": "^0.1.0"
},
"suggest": {
"ext-apc": "Local data and opcode cache",
<?php
+use Wikimedia\TestingAccessWrapper;
+
class MWHttpRequestTestCase extends PHPUnit_Framework_TestCase {
protected static $httpEngine;
protected $oldHttpEngine;
<?php
+
use MediaWiki\Logger\LegacySpi;
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\Logger\MonologSpi;
use MediaWiki\MediaWikiServices;
use Psr\Log\LoggerInterface;
+use Wikimedia\TestingAccessWrapper;
/**
* @since 1.18
+++ /dev/null
-<?php
-
-class WellProtectedParentClass {
- private $privateParentProperty;
-
- public function __construct() {
- $this->privateParentProperty = 9000;
- }
-
- private function incrementPrivateParentPropertyValue() {
- $this->privateParentProperty++;
- }
-
- public function getPrivateParentProperty() {
- return $this->privateParentProperty;
- }
-}
-
-class WellProtectedClass extends WellProtectedParentClass {
- protected static $staticProperty = 'sp';
- private static $staticPrivateProperty = 'spp';
-
- protected $property;
- private $privateProperty;
-
- protected static function staticMethod() {
- return 'sm';
- }
-
- private static function staticPrivateMethod() {
- return 'spm';
- }
-
- public function __construct() {
- parent::__construct();
- $this->property = 1;
- $this->privateProperty = 42;
- }
-
- protected function incrementPropertyValue() {
- $this->property++;
- }
-
- private function incrementPrivatePropertyValue() {
- $this->privateProperty++;
- }
-
- public function getProperty() {
- return $this->property;
- }
-
- public function getPrivateProperty() {
- return $this->privateProperty;
- }
-
- protected function whatSecondArg( $a, $b = false ) {
- return $b;
- }
-}
<?php
-use MediaWiki\MediaWikiServices;
+
+use Wikimedia\TestingAccessWrapper;
class MessageTest extends MediaWikiLangTestCase {
<?php
+use Wikimedia\TestingAccessWrapper;
+
/**
*
* @author Matthew Flaschen
<?php
+
+use Wikimedia\TestingAccessWrapper;
+
/**
* @group Search
* @group Database
/**
* Circumvent access restrictions on object internals
*
- * This can be helpful for writing tests that can probe object internals,
- * without having to modify the class under test to accomodate.
+ * Kept around for backwards compatibility.
*
- * Wrap an object with private methods as follows:
- * $title = TestingAccessWrapper::newFromObject( Title::newFromDBkey( $key ) );
- *
- * You can access private and protected instance methods and variables:
- * $formatter = $title->getTitleFormatter();
- *
- * TODO:
- * - Organize other helper classes in tests/testHelpers.inc into a directory.
+ * @deprecated Use \Wikimedia\TestingAccessWrapper (proveded by the
+ * wikimedia/testing-access-wrapper Composer library)
*/
-class TestingAccessWrapper {
- /** @var mixed The object, or the class name for static-only access */
- public $object;
-
- /**
- * Return the same object, without access restrictions.
- */
- public static function newFromObject( $object ) {
- if ( !is_object( $object ) ) {
- throw new InvalidArgumentException( __METHOD__ . ' must be called with an object' );
- }
- $wrapper = new TestingAccessWrapper();
- $wrapper->object = $object;
- return $wrapper;
- }
-
- /**
- * Allow access to non-public static methods and properties of the class.
- * Use non-static access,
- */
- public static function newFromClass( $className ) {
- if ( !is_string( $className ) ) {
- throw new InvalidArgumentException( __METHOD__ . ' must be called with a class name' );
- }
- $wrapper = new TestingAccessWrapper();
- $wrapper->object = $className;
- return $wrapper;
- }
-
- public function __call( $method, $args ) {
- $methodReflection = $this->getMethod( $method );
-
- if ( $this->isStatic() && !$methodReflection->isStatic() ) {
- throw new DomainException( __METHOD__ . ': Cannot call non-static when wrapping static class' );
- }
-
- return $methodReflection->invokeArgs( $methodReflection->isStatic() ? null : $this->object,
- $args );
- }
-
- public function __set( $name, $value ) {
- $propertyReflection = $this->getProperty( $name );
-
- if ( $this->isStatic() && !$propertyReflection->isStatic() ) {
- throw new DomainException( __METHOD__ . ': Cannot set property when wrapping static class' );
- }
-
- $propertyReflection->setValue( $this->object, $value );
- }
-
- public function __get( $name ) {
- $propertyReflection = $this->getProperty( $name );
-
- if ( $this->isStatic() && !$propertyReflection->isStatic() ) {
- throw new DomainException( __METHOD__ . ': Cannot get property when wrapping static class' );
- }
-
- return $propertyReflection->getValue( $this->object );
- }
-
- private function isStatic() {
- return is_string( $this->object );
- }
-
- /**
- * Return a property and make it accessible.
- * @param string $name
- * @return ReflectionMethod
- */
- private function getMethod( $name ) {
- $classReflection = new ReflectionClass( $this->object );
- $methodReflection = $classReflection->getMethod( $name );
- $methodReflection->setAccessible( true );
- return $methodReflection;
- }
-
- /**
- * Return a property and make it accessible.
- *
- * ReflectionClass::getProperty() fails if the private property is defined
- * in a parent class. This works more like ReflectionClass::getMethod().
- *
- * @param string $name
- * @return ReflectionProperty
- * @throws ReflectionException
- */
- private function getProperty( $name ) {
- $classReflection = new ReflectionClass( $this->object );
- try {
- $propertyReflection = $classReflection->getProperty( $name );
- } catch ( ReflectionException $ex ) {
- while ( true ) {
- $classReflection = $classReflection->getParentClass();
- if ( !$classReflection ) {
- throw $ex;
- }
- try {
- $propertyReflection = $classReflection->getProperty( $name );
- } catch ( ReflectionException $ex2 ) {
- continue;
- }
- if ( $propertyReflection->isPrivate() ) {
- break;
- } else {
- throw $ex;
- }
- }
- }
- $propertyReflection->setAccessible( true );
- return $propertyReflection;
- }
+class TestingAccessWrapper extends \Wikimedia\TestingAccessWrapper {
}
+++ /dev/null
-<?php
-
-class TestingAccessWrapperTest extends MediaWikiTestCase {
- protected $raw;
- protected $wrapped;
- protected $wrappedStatic;
-
- function setUp() {
- parent::setUp();
-
- require_once __DIR__ . '/../data/helpers/WellProtectedClass.php';
- $this->raw = new WellProtectedClass();
- $this->wrapped = TestingAccessWrapper::newFromObject( $this->raw );
- $this->wrappedStatic = TestingAccessWrapper::newFromClass( 'WellProtectedClass' );
- }
-
- /**
- * @expectedException InvalidArgumentException
- */
- function testConstructorException() {
- TestingAccessWrapper::newFromObject( 'WellProtectedClass' );
- }
-
- /**
- * @expectedException InvalidArgumentException
- */
- function testStaticConstructorException() {
- TestingAccessWrapper::newFromClass( new WellProtectedClass() );
- }
-
- function testGetProperty() {
- $this->assertSame( 1, $this->wrapped->property );
- $this->assertSame( 42, $this->wrapped->privateProperty );
- $this->assertSame( 9000, $this->wrapped->privateParentProperty );
- $this->assertSame( 'sp', $this->wrapped->staticProperty );
- $this->assertSame( 'spp', $this->wrapped->staticPrivateProperty );
- $this->assertSame( 'sp', $this->wrappedStatic->staticProperty );
- $this->assertSame( 'spp', $this->wrappedStatic->staticPrivateProperty );
- }
-
- /**
- * @expectedException DomainException
- */
- function testGetException() {
- $this->wrappedStatic->property;
- }
-
- function testSetProperty() {
- $this->wrapped->property = 10;
- $this->assertSame( 10, $this->wrapped->property );
- $this->assertSame( 10, $this->raw->getProperty() );
-
- $this->wrapped->privateProperty = 11;
- $this->assertSame( 11, $this->wrapped->privateProperty );
- $this->assertSame( 11, $this->raw->getPrivateProperty() );
-
- $this->wrapped->privateParentProperty = 12;
- $this->assertSame( 12, $this->wrapped->privateParentProperty );
- $this->assertSame( 12, $this->raw->getPrivateParentProperty() );
-
- $this->wrapped->staticProperty = 'x';
- $this->assertSame( 'x', $this->wrapped->staticProperty );
- $this->assertSame( 'x', $this->wrappedStatic->staticProperty );
-
- $this->wrapped->staticPrivateProperty = 'y';
- $this->assertSame( 'y', $this->wrapped->staticPrivateProperty );
- $this->assertSame( 'y', $this->wrappedStatic->staticPrivateProperty );
-
- $this->wrappedStatic->staticProperty = 'X';
- $this->assertSame( 'X', $this->wrapped->staticProperty );
- $this->assertSame( 'X', $this->wrappedStatic->staticProperty );
-
- $this->wrappedStatic->staticPrivateProperty = 'Y';
- $this->assertSame( 'Y', $this->wrapped->staticPrivateProperty );
- $this->assertSame( 'Y', $this->wrappedStatic->staticPrivateProperty );
-
- // don't rely on PHPUnit to restore static properties
- $this->wrapped->staticProperty = 'sp';
- $this->wrapped->staticPrivateProperty = 'spp';
- }
-
- /**
- * @expectedException DomainException
- */
- function testSetException() {
- $this->wrappedStatic->property = 1;
- }
-
- function testCallMethod() {
- $this->wrapped->incrementPropertyValue();
- $this->assertSame( 2, $this->wrapped->property );
- $this->assertSame( 2, $this->raw->getProperty() );
-
- $this->wrapped->incrementPrivatePropertyValue();
- $this->assertSame( 43, $this->wrapped->privateProperty );
- $this->assertSame( 43, $this->raw->getPrivateProperty() );
-
- $this->wrapped->incrementPrivateParentPropertyValue();
- $this->assertSame( 9001, $this->wrapped->privateParentProperty );
- $this->assertSame( 9001, $this->raw->getPrivateParentProperty() );
-
- $this->assertSame( 'sm', $this->wrapped->staticMethod() );
- $this->assertSame( 'spm', $this->wrapped->staticPrivateMethod() );
- $this->assertSame( 'sm', $this->wrappedStatic->staticMethod() );
- $this->assertSame( 'spm', $this->wrappedStatic->staticPrivateMethod() );
- }
-
- function testCallMethodTwoArgs() {
- $this->assertSame( 'two', $this->wrapped->whatSecondArg( 'one', 'two' ) );
- }
-
- /**
- * @expectedException DomainException
- */
- function testCallMethodException() {
- $this->wrappedStatic->incrementPropertyValue();
- }
-
-}
<?php
+use Wikimedia\TestingAccessWrapper;
+
/**
* @covers WatchedItemQueryService
*/
<?php
+use Wikimedia\TestingAccessWrapper;
+
/**
* @group API
* @group Database
<?php
+use Wikimedia\TestingAccessWrapper;
+
/**
* @group API
*/
<?php
+use Wikimedia\TestingAccessWrapper;
+
/**
* @group API
* @group Database
<?php
+use Wikimedia\TestingAccessWrapper;
+
/**
* @group API
* @group Database
<?php
+use Wikimedia\TestingAccessWrapper;
+
/**
* @group API
*/
namespace MediaWiki\Auth;
+use Wikimedia\TestingAccessWrapper;
+
/**
* @group AuthManager
* @covers MediaWiki\Auth\AbstractAuthenticationProvider
class AbstractAuthenticationProviderTest extends \MediaWikiTestCase {
public function testAbstractAuthenticationProvider() {
$provider = $this->getMockForAbstractClass( AbstractAuthenticationProvider::class );
- $providerPriv = \TestingAccessWrapper::newFromObject( $provider );
+ $providerPriv = TestingAccessWrapper::newFromObject( $provider );
$obj = $this->getMockForAbstractClass( 'Psr\Log\LoggerInterface' );
$provider->setLogger( $obj );
namespace MediaWiki\Auth;
use MediaWiki\MediaWikiServices;
+use Wikimedia\TestingAccessWrapper;
/**
* @group AuthManager
$provider = $this->getMockForAbstractClass(
AbstractPasswordPrimaryAuthenticationProvider::class
);
- $providerPriv = \TestingAccessWrapper::newFromObject( $provider );
+ $providerPriv = TestingAccessWrapper::newFromObject( $provider );
$this->assertTrue( $providerPriv->authoritative );
$provider = $this->getMockForAbstractClass(
AbstractPasswordPrimaryAuthenticationProvider::class,
[ [ 'authoritative' => false ] ]
);
- $providerPriv = \TestingAccessWrapper::newFromObject( $provider );
+ $providerPriv = TestingAccessWrapper::newFromObject( $provider );
$this->assertFalse( $providerPriv->authoritative );
}
AbstractPasswordPrimaryAuthenticationProvider::class
);
$provider->setConfig( MediaWikiServices::getInstance()->getMainConfig() );
- $providerPriv = \TestingAccessWrapper::newFromObject( $provider );
+ $providerPriv = TestingAccessWrapper::newFromObject( $provider );
$obj = $providerPriv->getPasswordFactory();
$this->assertInstanceOf( 'PasswordFactory', $obj );
);
$provider->setConfig( MediaWikiServices::getInstance()->getMainConfig() );
$provider->setLogger( new \Psr\Log\NullLogger() );
- $providerPriv = \TestingAccessWrapper::newFromObject( $provider );
+ $providerPriv = TestingAccessWrapper::newFromObject( $provider );
$obj = $providerPriv->getPassword( null );
$this->assertInstanceOf( 'Password', $obj );
MediaWikiServices::getInstance()->getMainConfig()
] ) );
$provider->setLogger( new \Psr\Log\NullLogger() );
- $providerPriv = \TestingAccessWrapper::newFromObject( $provider );
+ $providerPriv = TestingAccessWrapper::newFromObject( $provider );
$this->mergeMwGlobalArrayValue( 'wgHooks', [ 'ResetPasswordExpiration' => [] ] );
);
$provider->setConfig( MediaWikiServices::getInstance()->getMainConfig() );
$provider->setLogger( new \Psr\Log\NullLogger() );
- $providerPriv = \TestingAccessWrapper::newFromObject( $provider );
+ $providerPriv = TestingAccessWrapper::newFromObject( $provider );
$this->assertEquals( $uppStatus, $providerPriv->checkPasswordValidity( 'foo', 'bar' ) );
$provider->setConfig( $config );
$provider->setLogger( new \Psr\Log\NullLogger() );
$provider->setManager( $manager );
- $providerPriv = \TestingAccessWrapper::newFromObject( $provider );
+ $providerPriv = TestingAccessWrapper::newFromObject( $provider );
$manager->removeAuthenticationSessionData( null );
$status = \Status::newGood();
AbstractPasswordPrimaryAuthenticationProvider::class,
[ [ 'authoritative' => false ] ]
);
- $providerPriv = \TestingAccessWrapper::newFromObject( $provider );
+ $providerPriv = TestingAccessWrapper::newFromObject( $provider );
$req = new PasswordAuthenticationRequest;
AbstractPasswordPrimaryAuthenticationProvider::class,
[ [ 'authoritative' => true ] ]
);
- $providerPriv = \TestingAccessWrapper::newFromObject( $provider );
+ $providerPriv = TestingAccessWrapper::newFromObject( $provider );
$req->password = '';
$ret = $providerPriv->failResponse( $req );
use Psr\Log\LogLevel;
use StatusValue;
use Wikimedia\ScopedCallback;
+use Wikimedia\TestingAccessWrapper;
/**
* @group AuthManager
}
$this->manager = new AuthManager( $this->request, $this->config );
$this->manager->setLogger( $this->logger );
- $this->managerPriv = \TestingAccessWrapper::newFromObject( $this->manager );
+ $this->managerPriv = TestingAccessWrapper::newFromObject( $this->manager );
}
/**
'logger' => new \Psr\Log\NullLogger(),
'store' => new \HashBagOStuff(),
] );
- \TestingAccessWrapper::newFromObject( $manager )->getProvider( (string)$provider );
+ TestingAccessWrapper::newFromObject( $manager )->getProvider( (string)$provider );
$reset = \MediaWiki\Session\TestUtils::setSessionManagerSingleton( $manager );
$this->assertSame( \RequestContext::getMain()->getRequest(), $singleton->getRequest() );
$this->assertSame(
\RequestContext::getMain()->getConfig(),
- \TestingAccessWrapper::newFromObject( $singleton )->config
+ TestingAccessWrapper::newFromObject( $singleton )->config
);
}
namespace MediaWiki\Auth;
+use Wikimedia\TestingAccessWrapper;
+
/**
* @group AuthManager
* @group Database
class CheckBlocksSecondaryAuthenticationProviderTest extends \MediaWikiTestCase {
public function testConstructor() {
$provider = new CheckBlocksSecondaryAuthenticationProvider();
- $providerPriv = \TestingAccessWrapper::newFromObject( $provider );
+ $providerPriv = TestingAccessWrapper::newFromObject( $provider );
$config = new \HashConfig( [
'BlockDisablesLogin' => false
] );
$provider = new CheckBlocksSecondaryAuthenticationProvider(
[ 'blockDisablesLogin' => true ]
);
- $providerPriv = \TestingAccessWrapper::newFromObject( $provider );
+ $providerPriv = TestingAccessWrapper::newFromObject( $provider );
$config = new \HashConfig( [
'BlockDisablesLogin' => false
] );
namespace MediaWiki\Auth;
+use Wikimedia\TestingAccessWrapper;
+
/**
* @group AuthManager
* @covers MediaWiki\Auth\ConfirmLinkSecondaryAuthenticationProvider
->will( $this->returnValue( "BadReq" ) );
$user = \User::newFromName( 'UTSysop' );
- $provider = \TestingAccessWrapper::newFromObject(
+ $provider = TestingAccessWrapper::newFromObject(
new ConfirmLinkSecondaryAuthenticationProvider
);
$request = new \FauxRequest();
$r->action = AuthManager::ACTION_CHANGE;
$r->username = $user->getName();
}
- $this->assertEquals( $expectReqs, \TestingAccessWrapper::newFromObject( $req )->linkRequests );
+ $this->assertEquals( $expectReqs, TestingAccessWrapper::newFromObject( $req )->linkRequests );
}
public function testContinueLinkAttempt() {
->will( $this->returnValue( $obj ) );
$this->assertSame(
$obj,
- \TestingAccessWrapper::newFromObject( $mock )->continueLinkAttempt( $user, 'state', $reqs )
+ TestingAccessWrapper::newFromObject( $mock )->continueLinkAttempt( $user, 'state', $reqs )
);
// Now test the actual functioning
$request = new \FauxRequest();
$manager = new AuthManager( $request, $config );
$provider->setManager( $manager );
- $provider = \TestingAccessWrapper::newFromObject( $provider );
+ $provider = TestingAccessWrapper::newFromObject( $provider );
$req = new ConfirmLinkAuthenticationRequest( $reqs );
namespace MediaWiki\Auth;
use Psr\Log\LoggerInterface;
+use Wikimedia\TestingAccessWrapper;
class EmailNotificationSecondaryAuthenticationProviderTest extends \PHPUnit_Framework_TestCase {
public function testConstructor() {
$provider = new EmailNotificationSecondaryAuthenticationProvider();
$provider->setConfig( $config );
- $providerPriv = \TestingAccessWrapper::newFromObject( $provider );
+ $providerPriv = TestingAccessWrapper::newFromObject( $provider );
$this->assertTrue( $providerPriv->sendConfirmationEmail );
$provider = new EmailNotificationSecondaryAuthenticationProvider( [
'sendConfirmationEmail' => false,
] );
$provider->setConfig( $config );
- $providerPriv = \TestingAccessWrapper::newFromObject( $provider );
+ $providerPriv = TestingAccessWrapper::newFromObject( $provider );
$this->assertFalse( $providerPriv->sendConfirmationEmail );
}
namespace MediaWiki\Auth;
use MediaWiki\MediaWikiServices;
+use Wikimedia\TestingAccessWrapper;
/**
* @group AuthManager
$provider->setConfig( $this->config );
$provider->setLogger( new \Psr\Log\NullLogger() );
$provider->setManager( $this->manager );
- $providerPriv = \TestingAccessWrapper::newFromObject( $provider );
+ $providerPriv = TestingAccessWrapper::newFromObject( $provider );
$user = $this->getMutableTestUser()->getUser();
$userName = $user->getName();
namespace MediaWiki\Auth;
+use Wikimedia\TestingAccessWrapper;
+
/**
* @group AuthManager
* @covers MediaWiki\Auth\RememberMeAuthenticationRequest
public function testGetFieldInfo_2() {
$req = new RememberMeAuthenticationRequest();
- $reqWrapper = \TestingAccessWrapper::newFromObject( $req );
+ $reqWrapper = TestingAccessWrapper::newFromObject( $req );
$reqWrapper->expiration = 30 * 24 * 3600;
$this->assertNotEmpty( $req->getFieldInfo() );
protected function getInstance( array $args = [] ) {
$req = new RememberMeAuthenticationRequest();
- $reqWrapper = \TestingAccessWrapper::newFromObject( $req );
+ $reqWrapper = TestingAccessWrapper::newFromObject( $req );
$reqWrapper->expiration = $args[0];
return $req;
}
namespace MediaWiki\Auth;
+use Wikimedia\TestingAccessWrapper;
+
/**
* @group AuthManager
* @covers MediaWiki\Auth\ResetPasswordSecondaryAuthenticationProvider
] );
$manager = new AuthManager( new \FauxRequest, $config );
$provider->setManager( $manager );
- $provider = \TestingAccessWrapper::newFromObject( $provider );
+ $provider = TestingAccessWrapper::newFromObject( $provider );
$msg = wfMessage( 'foo' );
$skipReq = new ButtonAuthenticationRequest(
use MediaWiki\MediaWikiServices;
use Wikimedia\ScopedCallback;
+use Wikimedia\TestingAccessWrapper;
/**
* @group AuthManager
'PasswordReminderResendTime' => 101,
] );
- $p = \TestingAccessWrapper::newFromObject( new TemporaryPasswordPrimaryAuthenticationProvider() );
+ $p = TestingAccessWrapper::newFromObject( new TemporaryPasswordPrimaryAuthenticationProvider() );
$p->setConfig( $config );
$this->assertSame( false, $p->emailEnabled );
$this->assertSame( 100, $p->newPasswordExpiry );
$this->assertSame( 101, $p->passwordReminderResendTime );
- $p = \TestingAccessWrapper::newFromObject( new TemporaryPasswordPrimaryAuthenticationProvider( [
+ $p = TestingAccessWrapper::newFromObject( new TemporaryPasswordPrimaryAuthenticationProvider( [
'emailEnabled' => true,
'newPasswordExpiry' => 42,
'passwordReminderResendTime' => 43,
$pwhash = $passwordFactory->newFromPlaintext( 'password' )->toString();
$provider = $this->getProvider();
- $providerPriv = \TestingAccessWrapper::newFromObject( $provider );
+ $providerPriv = TestingAccessWrapper::newFromObject( $provider );
$this->assertFalse( $provider->testUserCanAuthenticate( '<invalid>' ) );
$this->assertFalse( $provider->testUserCanAuthenticate( 'DoesNotExist' ) );
$reqs = [ PasswordAuthenticationRequest::class => $req ];
$provider = $this->getProvider();
- $providerPriv = \TestingAccessWrapper::newFromObject( $provider );
+ $providerPriv = TestingAccessWrapper::newFromObject( $provider );
$providerPriv->newPasswordExpiry = 100;
ScopedCallback::consume( $resetMailer );
$this->assertTrue( $mailed );
- $priv = \TestingAccessWrapper::newFromObject( $provider );
+ $priv = TestingAccessWrapper::newFromObject( $provider );
$req->username = '<invalid>';
$status = $priv->sendPasswordResetEmail( $req );
$this->assertEquals( \Status::newFatal( 'noname' ), $status );
namespace MediaWiki\Auth;
+use Wikimedia\TestingAccessWrapper;
+
/**
* @group AuthManager
* @group Database
class ThrottlePreAuthenticationProviderTest extends \MediaWikiTestCase {
public function testConstructor() {
$provider = new ThrottlePreAuthenticationProvider();
- $providerPriv = \TestingAccessWrapper::newFromObject( $provider );
+ $providerPriv = TestingAccessWrapper::newFromObject( $provider );
$config = new \HashConfig( [
'AccountCreationThrottle' => [ [
'count' => 123,
'accountCreationThrottle' => [ [ 'count' => 123, 'seconds' => 86400 ] ],
'passwordAttemptThrottle' => [ [ 'count' => 5, 'seconds' => 300 ] ]
], $providerPriv->throttleSettings );
- $accountCreationThrottle = \TestingAccessWrapper::newFromObject(
+ $accountCreationThrottle = TestingAccessWrapper::newFromObject(
$providerPriv->accountCreationThrottle );
$this->assertSame( [ [ 'count' => 123, 'seconds' => 86400 ] ],
$accountCreationThrottle->conditions );
- $passwordAttemptThrottle = \TestingAccessWrapper::newFromObject(
+ $passwordAttemptThrottle = TestingAccessWrapper::newFromObject(
$providerPriv->passwordAttemptThrottle );
$this->assertSame( [ [ 'count' => 5, 'seconds' => 300 ] ],
$passwordAttemptThrottle->conditions );
'accountCreationThrottle' => [ [ 'count' => 43, 'seconds' => 10000 ] ],
'passwordAttemptThrottle' => [ [ 'count' => 11, 'seconds' => 100 ] ],
] );
- $providerPriv = \TestingAccessWrapper::newFromObject( $provider );
+ $providerPriv = TestingAccessWrapper::newFromObject( $provider );
$config = new \HashConfig( [
'AccountCreationThrottle' => [ [
'count' => 123,
$cache = new \HashBagOStuff();
$provider = new ThrottlePreAuthenticationProvider( [ 'cache' => $cache ] );
- $providerPriv = \TestingAccessWrapper::newFromObject( $provider );
+ $providerPriv = TestingAccessWrapper::newFromObject( $provider );
$provider->setConfig( new \HashConfig( [
'AccountCreationThrottle' => [ [ 'count' => 1, 'seconds' => 1 ] ],
'PasswordAttemptThrottle' => [ [ 'count' => 1, 'seconds' => 1 ] ],
] ) );
- $accountCreationThrottle = \TestingAccessWrapper::newFromObject(
+ $accountCreationThrottle = TestingAccessWrapper::newFromObject(
$providerPriv->accountCreationThrottle );
$this->assertSame( $cache, $accountCreationThrottle->cache );
- $passwordAttemptThrottle = \TestingAccessWrapper::newFromObject(
+ $passwordAttemptThrottle = TestingAccessWrapper::newFromObject(
$providerPriv->passwordAttemptThrottle );
$this->assertSame( $cache, $passwordAttemptThrottle->cache );
}
use Psr\Log\AbstractLogger;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
+use Wikimedia\TestingAccessWrapper;
/**
* @group AuthManager
[ 'type' => 'foo', 'cache' => $cache ]
);
$throttler->setLogger( $logger );
- $throttlerPriv = \TestingAccessWrapper::newFromObject( $throttler );
+ $throttlerPriv = TestingAccessWrapper::newFromObject( $throttler );
$this->assertSame( [ [ 'count' => 123, 'seconds' => 456 ] ], $throttlerPriv->conditions );
$this->assertSame( 'foo', $throttlerPriv->type );
$this->assertSame( $cache, $throttlerPriv->cache );
$throttler = new Throttler( [ [ 'count' => 123, 'seconds' => 456 ] ] );
$throttler->setLogger( new NullLogger() );
- $throttlerPriv = \TestingAccessWrapper::newFromObject( $throttler );
+ $throttlerPriv = TestingAccessWrapper::newFromObject( $throttler );
$this->assertSame( [ [ 'count' => 123, 'seconds' => 456 ] ], $throttlerPriv->conditions );
$this->assertSame( 'custom', $throttlerPriv->type );
$this->assertInstanceOf( BagOStuff::class, $throttlerPriv->cache );
'seconds' => 654 ] ] ] );
$throttler = new Throttler();
$throttler->setLogger( new NullLogger() );
- $throttlerPriv = \TestingAccessWrapper::newFromObject( $throttler );
+ $throttlerPriv = TestingAccessWrapper::newFromObject( $throttler );
$this->assertSame( [ [ 'count' => 321, 'seconds' => 654 ] ], $throttlerPriv->conditions );
$this->assertSame( 'password', $throttlerPriv->type );
$this->assertInstanceOf( BagOStuff::class, $throttlerPriv->cache );
public function testNormalizeThrottleConditions( $condition, $normalized ) {
$throttler = new Throttler( $condition );
$throttler->setLogger( new NullLogger() );
- $throttlerPriv = \TestingAccessWrapper::newFromObject( $throttler );
+ $throttlerPriv = TestingAccessWrapper::newFromObject( $throttler );
$this->assertSame( $normalized, $throttlerPriv->conditions );
}
}
public function testNormalizeThrottleConditions2() {
- $priv = \TestingAccessWrapper::newFromClass( Throttler::class );
+ $priv = TestingAccessWrapper::newFromClass( Throttler::class );
$this->assertSame( [], $priv->normalizeThrottleConditions( null ) );
$this->assertSame( [], $priv->normalizeThrottleConditions( 'bad' ) );
}
<?php
+use Wikimedia\TestingAccessWrapper;
+
/**
* @covers ChangesListBooleanFilterGroup
*/
<?php
+use Wikimedia\TestingAccessWrapper;
+
/**
* @covers ChangesListFilter
*/
<?php
+use Wikimedia\TestingAccessWrapper;
+
/**
* @covers ChangesListStringOptionsFilterGroup
*/
namespace MediaWiki\Logger;
use MediaWikiTestCase;
-use TestingAccessWrapper;
+use Wikimedia\TestingAccessWrapper;
class MonologSpiTest extends MediaWikiTestCase {
use MediaWikiTestCase;
use Monolog\Logger;
+use Wikimedia\TestingAccessWrapper;
class KafkaHandlerTest extends MediaWikiTestCase {
->method( 'send' )
->will( $this->returnValue( true ) );
// evil hax
- \TestingAccessWrapper::newFromObject( $mockMethod )->matcher->parametersMatcher =
+ TestingAccessWrapper::newFromObject( $mockMethod )->matcher->parametersMatcher =
new \PHPUnit_Framework_MockObject_Matcher_ConsecutiveParameters( [
[ $this->anything(), $this->anything(), [ 'words' ] ],
[ $this->anything(), $this->anything(), [ 'lines' ] ]
use LengthException;
use LogicException;
use MediaWikiTestCase;
-use TestingAccessWrapper;
+use Wikimedia\TestingAccessWrapper;
class LineFormatterTest extends MediaWikiTestCase {
<?php
+use Wikimedia\TestingAccessWrapper;
+
class CdnCacheUpdateTest extends MediaWikiTestCase {
public function testPurgeMergeWeb() {
$this->setMwGlobals( 'wgCommandLineMode', false );
<?php
+use Wikimedia\TestingAccessWrapper;
+
/**
* @group FileRepo
* @group FileBackend
<?php
+use Wikimedia\TestingAccessWrapper;
+
/**
* @group FileRepo
* @group FileBackend
<?php
+use Wikimedia\TestingAccessWrapper;
+
/**
* @group BagOStuff
*/
<?php
+use Wikimedia\TestingAccessWrapper;
+
/**
* @group BagOStuff
*/
<?php
+use Wikimedia\TestingAccessWrapper;
+
class WANObjectCacheTest extends PHPUnit_Framework_TestCase {
/** @var WANObjectCache */
private $cache;
<?php
+
+use Wikimedia\TestingAccessWrapper;
+
/**
* @group BagOStuff
*/
<?php
+use Wikimedia\TestingAccessWrapper;
+
class ExtensionProcessorTest extends MediaWikiTestCase {
private $dir, $dirname;
<?php
+use Wikimedia\TestingAccessWrapper;
+
/**
* @group Cache
* @covers MessageBlobStore
<?php
+use Wikimedia\TestingAccessWrapper;
+
/**
* @group ResourceLoader
*/
<?php
+use Wikimedia\TestingAccessWrapper;
+
/**
* @group ResourceLoader
*/
<?php
+use Wikimedia\TestingAccessWrapper;
+
class ResourceLoaderTest extends ResourceLoaderTestCase {
protected function setUp() {
use MediaWiki\MediaWikiServices;
use Wikimedia\Rdbms\IDatabase;
+use Wikimedia\TestingAccessWrapper;
class ResourceLoaderWikiModuleTest extends ResourceLoaderTestCase {
<?php
+
use MediaWiki\MediaWikiServices;
+use Wikimedia\TestingAccessWrapper;
/**
* @group Search
use Psr\Log\LogLevel;
use MediaWikiTestCase;
+use Wikimedia\TestingAccessWrapper;
/**
* @group Session
$provider = new BotPasswordSessionProvider( [
'priority' => 40
] );
- $priv = \TestingAccessWrapper::newFromObject( $provider );
+ $priv = TestingAccessWrapper::newFromObject( $provider );
$this->assertSame( 40, $priv->priority );
$this->assertSame( '_BPsession', $priv->sessionCookieName );
$this->assertSame( [], $priv->sessionCookieOptions );
'priority' => 40,
'sessionCookieName' => null,
] );
- $priv = \TestingAccessWrapper::newFromObject( $provider );
+ $priv = TestingAccessWrapper::newFromObject( $provider );
$this->assertSame( '_BPsession', $priv->sessionCookieName );
$provider = new BotPasswordSessionProvider( [
'sessionCookieName' => 'Foo',
'sessionCookieOptions' => [ 'Bar' ],
] );
- $priv = \TestingAccessWrapper::newFromObject( $provider );
+ $priv = TestingAccessWrapper::newFromObject( $provider );
$this->assertSame( 'Foo', $priv->sessionCookieName );
$this->assertSame( [ 'Bar' ], $priv->sessionCookieOptions );
}
$provider->setLogger( $logger );
$backend = TestUtils::getDummySessionBackend();
- $backendPriv = \TestingAccessWrapper::newFromObject( $backend );
+ $backendPriv = TestingAccessWrapper::newFromObject( $backend );
try {
$provider->getAllowedUserRights( $backend );
use MediaWikiTestCase;
use User;
use Psr\Log\LogLevel;
+use Wikimedia\TestingAccessWrapper;
/**
* @group Session
}
$config = $this->getConfig();
- $p = \TestingAccessWrapper::newFromObject(
+ $p = TestingAccessWrapper::newFromObject(
new CookieSessionProvider( [ 'priority' => 1 ] )
);
$p->setLogger( new \TestLogger() );
], $p->cookieOptions );
$config->set( 'SessionName', 'SessionName' );
- $p = \TestingAccessWrapper::newFromObject(
+ $p = TestingAccessWrapper::newFromObject(
new CookieSessionProvider( [ 'priority' => 3 ] )
);
$p->setLogger( new \TestLogger() );
'httpOnly' => true,
], $p->cookieOptions );
- $p = \TestingAccessWrapper::newFromObject( new CookieSessionProvider( [
+ $p = TestingAccessWrapper::newFromObject( new CookieSessionProvider( [
'priority' => 10,
'callUserSetCookiesHook' => true,
'cookieOptions' => [
$this->assertEquals(
$extendedCookies,
- \TestingAccessWrapper::newFromObject( $provider )->getExtendedLoginCookies(),
+ TestingAccessWrapper::newFromObject( $provider )->getExtendedLoginCookies(),
'List of extended cookies (subclasses can add values, but we\'re calling the core one here)'
);
new \Psr\Log\NullLogger(),
10
);
- \TestingAccessWrapper::newFromObject( $backend )->usePhpSessionHandling = false;
+ TestingAccessWrapper::newFromObject( $backend )->usePhpSessionHandling = false;
$mock = $this->getMockBuilder( 'stdClass' )
->setMethods( [ 'onUserSetCookies' ] )
new \Psr\Log\NullLogger(),
10
);
- \TestingAccessWrapper::newFromObject( $backend )->usePhpSessionHandling = false;
+ TestingAccessWrapper::newFromObject( $backend )->usePhpSessionHandling = false;
$backend->setUser( $user );
$backend->setRememberUser( $remember );
$backend->setForceHTTPS( $secure );
new \Psr\Log\NullLogger(),
10
);
- \TestingAccessWrapper::newFromObject( $backend )->usePhpSessionHandling = false;
+ TestingAccessWrapper::newFromObject( $backend )->usePhpSessionHandling = false;
// Anonymous user
$mock = $this->getMockBuilder( 'stdClass' )
}
public function testSetLoggedOutCookie() {
- $provider = \TestingAccessWrapper::newFromObject( new CookieSessionProvider( [
+ $provider = TestingAccessWrapper::newFromObject( new CookieSessionProvider( [
'priority' => 1,
'sessionName' => 'MySessionName',
'cookieOptions' => [ 'prefix' => 'x' ],
$provider->setLogger( new \Psr\Log\NullLogger() );
$provider->setConfig( $this->getConfig() );
$provider->setManager( SessionManager::singleton() );
- $provider = \TestingAccessWrapper::newFromObject( $provider );
+ $provider = TestingAccessWrapper::newFromObject( $provider );
$request = new \FauxRequest();
$request->setCookies( [
public function testGetLoginCookieExpiration() {
$config = $this->getConfig();
- $provider = \TestingAccessWrapper::newFromObject( new CookieSessionProvider( [
+ $provider = TestingAccessWrapper::newFromObject( new CookieSessionProvider( [
'priority' => 10
] ) );
$provider->setLogger( new \Psr\Log\NullLogger() );
use MediaWikiTestCase;
use User;
+use Wikimedia\TestingAccessWrapper;
/**
* @group Session
public function testConstructor() {
$provider = $this->getMockBuilder( ImmutableSessionProviderWithCookie::class )
->getMockForAbstractClass();
- $priv = \TestingAccessWrapper::newFromObject( $provider );
+ $priv = TestingAccessWrapper::newFromObject( $provider );
$this->assertNull( $priv->sessionCookieName );
$this->assertSame( [], $priv->sessionCookieOptions );
'sessionCookieOptions' => [ 'Bar' ],
] ] )
->getMockForAbstractClass();
- $priv = \TestingAccessWrapper::newFromObject( $provider );
+ $priv = TestingAccessWrapper::newFromObject( $provider );
$this->assertSame( 'Foo', $priv->sessionCookieName );
$this->assertSame( [ 'Bar' ], $priv->sessionCookieOptions );
'bad' => 'bad',
], '' );
- $provider = \TestingAccessWrapper::newFromObject( $this->getProvider( null ) );
+ $provider = TestingAccessWrapper::newFromObject( $this->getProvider( null ) );
try {
$provider->getSessionIdFromCookie( $request );
$this->fail( 'Expected exception not thrown' );
);
}
- $provider = \TestingAccessWrapper::newFromObject( $this->getProvider( 'Foo' ) );
+ $provider = TestingAccessWrapper::newFromObject( $this->getProvider( 'Foo' ) );
$this->assertSame(
'wgfoo---------------------------',
$provider->getSessionIdFromCookie( $request )
);
- $provider = \TestingAccessWrapper::newFromObject( $this->getProvider( 'Foo', 'Bar' ) );
+ $provider = TestingAccessWrapper::newFromObject( $this->getProvider( 'Foo', 'Bar' ) );
$this->assertSame(
'foobar--------------------------',
$provider->getSessionIdFromCookie( $request )
);
- $provider = \TestingAccessWrapper::newFromObject( $this->getProvider( 'Foo', '' ) );
+ $provider = TestingAccessWrapper::newFromObject( $this->getProvider( 'Foo', '' ) );
$this->assertSame(
'foo-----------------------------',
$provider->getSessionIdFromCookie( $request )
);
- $provider = \TestingAccessWrapper::newFromObject( $this->getProvider( 'bad', '' ) );
+ $provider = TestingAccessWrapper::newFromObject( $this->getProvider( 'bad', '' ) );
$this->assertSame( null, $provider->getSessionIdFromCookie( $request ) );
- $provider = \TestingAccessWrapper::newFromObject( $this->getProvider( 'none', '' ) );
+ $provider = TestingAccessWrapper::newFromObject( $this->getProvider( 'none', '' ) );
$this->assertSame( null, $provider->getSessionIdFromCookie( $request ) );
}
$provider = $this->getProvider( 'session' );
$provider->setLogger( new \Psr\Log\NullLogger() );
- $priv = \TestingAccessWrapper::newFromObject( $provider );
+ $priv = TestingAccessWrapper::newFromObject( $provider );
$priv->sessionCookieOptions = [
'prefix' => 'x',
'path' => 'CookiePath',
new \Psr\Log\NullLogger(),
10
);
- \TestingAccessWrapper::newFromObject( $backend )->usePhpSessionHandling = false;
+ TestingAccessWrapper::newFromObject( $backend )->usePhpSessionHandling = false;
$backend->setRememberUser( $remember );
$backend->setForceHTTPS( $secure );
public function testUnpersistSession() {
$provider = $this->getProvider( 'session', '' );
$provider->setLogger( new \Psr\Log\NullLogger() );
- $priv = \TestingAccessWrapper::newFromObject( $provider );
+ $priv = TestingAccessWrapper::newFromObject( $provider );
// No cookie
$priv->sessionCookieName = null;
use Psr\Log\LogLevel;
use MediaWikiTestCase;
+use Wikimedia\TestingAccessWrapper;
/**
* @group Session
$rProp = new \ReflectionProperty( PHPSessionHandler::class, 'instance' );
$rProp->setAccessible( true );
if ( $rProp->getValue() ) {
- $old = \TestingAccessWrapper::newFromObject( $rProp->getValue() );
+ $old = TestingAccessWrapper::newFromObject( $rProp->getValue() );
$oldManager = $old->manager;
$oldStore = $old->store;
$oldLogger = $old->logger;
}
public function testEnableFlags() {
- $handler = \TestingAccessWrapper::newFromObject(
+ $handler = TestingAccessWrapper::newFromObject(
$this->getMockBuilder( PHPSessionHandler::class )
->setMethods( null )
->disableOriginalConstructor()
$this->assertFalse( wfIniGetBool( 'session.use_trans_sid' ) );
$this->assertNotNull( $rProp->getValue() );
- $priv = \TestingAccessWrapper::newFromObject( $rProp->getValue() );
+ $priv = TestingAccessWrapper::newFromObject( $rProp->getValue() );
$this->assertSame( $manager, $priv->manager );
$this->assertSame( $store, $priv->store );
$this->assertSame( $logger, $priv->logger );
'logger' => $logger,
] );
PHPSessionHandler::install( $manager );
- $wrap = \TestingAccessWrapper::newFromObject( $rProp->getValue() );
+ $wrap = TestingAccessWrapper::newFromObject( $rProp->getValue() );
$reset[] = new \Wikimedia\ScopedCallback(
[ $wrap, 'setEnableFlags' ],
[ $wrap->enable ? $wrap->warn ? 'warn' : 'enable' : 'disable' ]
->setMethods( null )
->disableOriginalConstructor()
->getMock();
- \TestingAccessWrapper::newFromObject( $handler )->setEnableFlags( 'disable' );
+ TestingAccessWrapper::newFromObject( $handler )->setEnableFlags( 'disable' );
$oldValue = $rProp->getValue();
$rProp->setValue( $handler );
$reset = new \Wikimedia\ScopedCallback( [ $rProp, 'setValue' ], [ $oldValue ] );
->setMethods( null )
->disableOriginalConstructor()
->getMock();
- \TestingAccessWrapper::newFromObject( $handler )->setEnableFlags( 'enable' );
+ TestingAccessWrapper::newFromObject( $handler )->setEnableFlags( 'enable' );
call_user_func_array( [ $handler, $method ], $args );
}
use MediaWikiTestCase;
use User;
+use Wikimedia\TestingAccessWrapper;
/**
* @group Session
$id = new SessionId( $info->getId() );
$backend = new SessionBackend( $id, $info, $this->store, $logger, 10 );
- $priv = \TestingAccessWrapper::newFromObject( $backend );
+ $priv = TestingAccessWrapper::newFromObject( $backend );
$priv->persist = false;
$priv->requests = [ 100 => new \FauxRequest() ];
$priv->requests[100]->setSessionId( $id );
$priv->usePhpSessionHandling = false;
- $manager = \TestingAccessWrapper::newFromObject( $this->manager );
+ $manager = TestingAccessWrapper::newFromObject( $this->manager );
$manager->allSessionBackends = [ $backend->getId() => $backend ] + $manager->allSessionBackends;
$manager->allSessionIds = [ $backend->getId() => $id ] + $manager->allSessionIds;
$manager->sessionProviders = [ (string)$this->provider => $this->provider ];
$this->assertSame( $info->wasPersisted(), $backend->isPersistent() );
$this->assertSame( $info->wasRemembered(), $backend->shouldRememberUser() );
$this->assertSame( $info->forceHTTPS(), $backend->shouldForceHTTPS() );
- $this->assertSame( $expire, \TestingAccessWrapper::newFromObject( $backend )->expires );
+ $this->assertSame( $expire, TestingAccessWrapper::newFromObject( $backend )->expires );
$this->assertSame( [ 'foo' ], $backend->getProviderMetadata() );
}
public function testSessionStuff() {
$backend = $this->getBackend();
- $priv = \TestingAccessWrapper::newFromObject( $backend );
+ $priv = TestingAccessWrapper::newFromObject( $backend );
$priv->requests = []; // Remove dummy session
- $manager = \TestingAccessWrapper::newFromObject( $this->manager );
+ $manager = TestingAccessWrapper::newFromObject( $this->manager );
$request1 = new \FauxRequest();
$session1 = $backend->getSession( $request1 );
$this->assertInstanceOf( Session::class, $session2 );
$this->assertSame( 2, count( $priv->requests ) );
- $index = \TestingAccessWrapper::newFromObject( $session1 )->index;
+ $index = TestingAccessWrapper::newFromObject( $session1 )->index;
$this->assertSame( $request1, $backend->getRequest( $index ) );
$this->assertSame( null, $backend->suggestLoginUsername( $index ) );
public function testSetProviderMetadata() {
$backend = $this->getBackend();
- $priv = \TestingAccessWrapper::newFromObject( $backend );
+ $priv = TestingAccessWrapper::newFromObject( $backend );
$priv->providerMetadata = [ 'dummy' ];
try {
->will( $this->returnValue( false ) );
$this->provider->expects( $this->never() )->method( 'sessionIdWasReset' );
$backend = $this->getBackend( User::newFromName( 'UTSysop' ) );
- $manager = \TestingAccessWrapper::newFromObject( $this->manager );
+ $manager = TestingAccessWrapper::newFromObject( $this->manager );
$sessionId = $backend->getSessionId();
$backend->resetId();
$this->assertSame( self::SESSIONID, $backend->getId() );
$backend = $this->getBackend();
$this->provider->expects( $this->once() )->method( 'sessionIdWasReset' )
->with( $this->identicalTo( $backend ), $this->identicalTo( self::SESSIONID ) );
- $manager = \TestingAccessWrapper::newFromObject( $this->manager );
+ $manager = TestingAccessWrapper::newFromObject( $this->manager );
$sessionId = $backend->getSessionId();
$backend->resetId();
$this->assertNotEquals( self::SESSIONID, $backend->getId() );
$this->provider = null;
$backend = $this->getBackend();
- $wrap = \TestingAccessWrapper::newFromObject( $backend );
+ $wrap = TestingAccessWrapper::newFromObject( $backend );
$wrap->persist = true;
$wrap->expires = 0;
$backend->persist();
->setMethods( [ 'unpersistSession' ] )->getMock();
$this->provider->expects( $this->once() )->method( 'unpersistSession' );
$backend = $this->getBackend();
- $wrap = \TestingAccessWrapper::newFromObject( $backend );
+ $wrap = TestingAccessWrapper::newFromObject( $backend );
$wrap->store = new \CachedBagOStuff( $this->store );
$wrap->persist = true;
$wrap->dataDirty = true;
public function testDirty() {
$backend = $this->getBackend();
- $priv = \TestingAccessWrapper::newFromObject( $backend );
+ $priv = TestingAccessWrapper::newFromObject( $backend );
$priv->dataDirty = false;
$backend->dirty();
$this->assertTrue( $priv->dataDirty );
$backend = $this->getBackend();
$data = $backend->getData();
$this->assertSame( [], $data );
- $this->assertTrue( \TestingAccessWrapper::newFromObject( $backend )->dataDirty );
+ $this->assertTrue( TestingAccessWrapper::newFromObject( $backend )->dataDirty );
$data['???'] = '!!!';
$this->assertSame( [ '???' => '!!!' ], $data );
$this->store->setSessionData( self::SESSIONID, $testData );
$backend = $this->getBackend();
$this->assertSame( $testData, $backend->getData() );
- $this->assertFalse( \TestingAccessWrapper::newFromObject( $backend )->dataDirty );
+ $this->assertFalse( TestingAccessWrapper::newFromObject( $backend )->dataDirty );
}
public function testAddData() {
$backend = $this->getBackend();
- $priv = \TestingAccessWrapper::newFromObject( $backend );
+ $priv = TestingAccessWrapper::newFromObject( $backend );
$priv->data = [ 'foo' => 1 ];
$priv->dataDirty = false;
public function testDelaySave() {
$this->mergeMwGlobalArrayValue( 'wgHooks', [ 'SessionMetadata' => [ $this ] ] );
$backend = $this->getBackend();
- $priv = \TestingAccessWrapper::newFromObject( $backend );
+ $priv = TestingAccessWrapper::newFromObject( $backend );
$priv->persist = true;
// Saves happen normally when no delay is in effect
$backend = $this->getBackend( $user );
$this->store->deleteSession( self::SESSIONID );
$this->assertFalse( $backend->isPersistent(), 'sanity check' );
- \TestingAccessWrapper::newFromObject( $backend )->metaDirty = false;
- \TestingAccessWrapper::newFromObject( $backend )->dataDirty = false;
+ TestingAccessWrapper::newFromObject( $backend )->metaDirty = false;
+ TestingAccessWrapper::newFromObject( $backend )->dataDirty = false;
$backend->save();
$this->assertFalse( $this->store->getSession( self::SESSIONID ), 'making sure it didn\'t save' );
$this->store->setSessionData( self::SESSIONID, $testData );
$backend = $this->getBackend( $user );
$this->store->deleteSession( self::SESSIONID );
- \TestingAccessWrapper::newFromObject( $backend )->persist = false;
- \TestingAccessWrapper::newFromObject( $backend )->forcePersist = true;
+ TestingAccessWrapper::newFromObject( $backend )->persist = false;
+ TestingAccessWrapper::newFromObject( $backend )->forcePersist = true;
$this->assertFalse( $backend->isPersistent(), 'sanity check' );
- \TestingAccessWrapper::newFromObject( $backend )->metaDirty = false;
- \TestingAccessWrapper::newFromObject( $backend )->dataDirty = false;
+ TestingAccessWrapper::newFromObject( $backend )->metaDirty = false;
+ TestingAccessWrapper::newFromObject( $backend )->dataDirty = false;
$backend->save();
$this->assertFalse( $this->store->getSession( self::SESSIONID ), 'making sure it didn\'t save' );
$this->mergeMwGlobalArrayValue( 'wgHooks', [ 'SessionMetadata' => [ $neverHook ] ] );
$this->store->setSessionData( self::SESSIONID, $testData );
$backend = $this->getBackend( $user );
- \TestingAccessWrapper::newFromObject( $backend )->requests[100]
+ TestingAccessWrapper::newFromObject( $backend )->requests[100]
->setSessionId( new SessionId( 'x' ) );
$this->store->deleteSession( self::SESSIONID );
- \TestingAccessWrapper::newFromObject( $backend )->persist = false;
- \TestingAccessWrapper::newFromObject( $backend )->forcePersist = true;
+ TestingAccessWrapper::newFromObject( $backend )->persist = false;
+ TestingAccessWrapper::newFromObject( $backend )->forcePersist = true;
$this->assertFalse( $backend->isPersistent(), 'sanity check' );
- \TestingAccessWrapper::newFromObject( $backend )->metaDirty = false;
- \TestingAccessWrapper::newFromObject( $backend )->dataDirty = false;
+ TestingAccessWrapper::newFromObject( $backend )->metaDirty = false;
+ TestingAccessWrapper::newFromObject( $backend )->dataDirty = false;
$backend->save();
$this->assertFalse( $this->store->getSession( self::SESSIONID ), 'making sure it didn\'t save' );
$backend = $this->getBackend( $user );
$this->store->deleteSession( self::SESSIONID );
$this->assertFalse( $backend->isPersistent(), 'sanity check' );
- \TestingAccessWrapper::newFromObject( $backend )->metaDirty = false;
- \TestingAccessWrapper::newFromObject( $backend )->dataDirty = true;
+ TestingAccessWrapper::newFromObject( $backend )->metaDirty = false;
+ TestingAccessWrapper::newFromObject( $backend )->dataDirty = true;
$backend->save();
$this->assertTrue( $this->onSessionMetadataCalled );
$blob = $this->store->getSession( self::SESSIONID );
$this->store->setSessionData( self::SESSIONID, $testData );
$backend = $this->getBackend( $user );
$this->store->deleteSession( self::SESSIONID );
- \TestingAccessWrapper::newFromObject( $backend )->persist = true;
+ TestingAccessWrapper::newFromObject( $backend )->persist = true;
$this->assertTrue( $backend->isPersistent(), 'sanity check' );
- \TestingAccessWrapper::newFromObject( $backend )->metaDirty = false;
- \TestingAccessWrapper::newFromObject( $backend )->dataDirty = false;
+ TestingAccessWrapper::newFromObject( $backend )->metaDirty = false;
+ TestingAccessWrapper::newFromObject( $backend )->dataDirty = false;
$backend->save();
$this->assertFalse( $this->store->getSession( self::SESSIONID ), 'making sure it didn\'t save' );
$this->store->setSessionData( self::SESSIONID, $testData );
$backend = $this->getBackend( $user );
$this->store->deleteSession( self::SESSIONID );
- \TestingAccessWrapper::newFromObject( $backend )->persist = true;
- \TestingAccessWrapper::newFromObject( $backend )->forcePersist = true;
+ TestingAccessWrapper::newFromObject( $backend )->persist = true;
+ TestingAccessWrapper::newFromObject( $backend )->forcePersist = true;
$this->assertTrue( $backend->isPersistent(), 'sanity check' );
- \TestingAccessWrapper::newFromObject( $backend )->metaDirty = false;
- \TestingAccessWrapper::newFromObject( $backend )->dataDirty = false;
+ TestingAccessWrapper::newFromObject( $backend )->metaDirty = false;
+ TestingAccessWrapper::newFromObject( $backend )->dataDirty = false;
$backend->save();
$this->assertFalse( $this->store->getSession( self::SESSIONID ), 'making sure it didn\'t save' );
$this->store->setSessionData( self::SESSIONID, $testData );
$backend = $this->getBackend( $user );
$this->store->deleteSession( self::SESSIONID );
- \TestingAccessWrapper::newFromObject( $backend )->persist = true;
+ TestingAccessWrapper::newFromObject( $backend )->persist = true;
$this->assertTrue( $backend->isPersistent(), 'sanity check' );
- \TestingAccessWrapper::newFromObject( $backend )->metaDirty = false;
- \TestingAccessWrapper::newFromObject( $backend )->dataDirty = true;
+ TestingAccessWrapper::newFromObject( $backend )->metaDirty = false;
+ TestingAccessWrapper::newFromObject( $backend )->dataDirty = true;
$backend->save();
$this->assertTrue( $this->onSessionMetadataCalled );
$blob = $this->store->getSession( self::SESSIONID );
$this->store->setSessionData( self::SESSIONID, $testData );
$backend = $this->getBackend( $user );
$this->store->deleteSession( self::SESSIONID );
- \TestingAccessWrapper::newFromObject( $backend )->persist = true;
- \TestingAccessWrapper::newFromObject( $backend )->forcePersist = true;
+ TestingAccessWrapper::newFromObject( $backend )->persist = true;
+ TestingAccessWrapper::newFromObject( $backend )->forcePersist = true;
$this->assertTrue( $backend->isPersistent(), 'sanity check' );
- \TestingAccessWrapper::newFromObject( $backend )->metaDirty = false;
- \TestingAccessWrapper::newFromObject( $backend )->dataDirty = true;
+ TestingAccessWrapper::newFromObject( $backend )->metaDirty = false;
+ TestingAccessWrapper::newFromObject( $backend )->dataDirty = true;
$backend->save();
$this->assertTrue( $this->onSessionMetadataCalled );
$blob = $this->store->getSession( self::SESSIONID );
$this->store->setSessionData( self::SESSIONID, $testData );
$backend = $this->getBackend( $user );
$this->store->deleteSession( self::SESSIONID );
- \TestingAccessWrapper::newFromObject( $backend )->persist = true;
+ TestingAccessWrapper::newFromObject( $backend )->persist = true;
$this->assertTrue( $backend->isPersistent(), 'sanity check' );
- \TestingAccessWrapper::newFromObject( $backend )->metaDirty = true;
- \TestingAccessWrapper::newFromObject( $backend )->dataDirty = false;
+ TestingAccessWrapper::newFromObject( $backend )->metaDirty = true;
+ TestingAccessWrapper::newFromObject( $backend )->dataDirty = false;
$backend->save();
$this->assertTrue( $this->onSessionMetadataCalled );
$blob = $this->store->getSession( self::SESSIONID );
$this->store->setSessionData( self::SESSIONID, $testData );
$backend = $this->getBackend( $user );
$this->store->deleteSession( self::SESSIONID );
- \TestingAccessWrapper::newFromObject( $backend )->persist = true;
+ TestingAccessWrapper::newFromObject( $backend )->persist = true;
$this->assertTrue( $backend->isPersistent(), 'sanity check' );
- \TestingAccessWrapper::newFromObject( $backend )->metaDirty = false;
- \TestingAccessWrapper::newFromObject( $backend )->dataDirty = false;
- \TestingAccessWrapper::newFromObject( $backend )->dataHash = 'Doesn\'t match';
+ TestingAccessWrapper::newFromObject( $backend )->metaDirty = false;
+ TestingAccessWrapper::newFromObject( $backend )->dataDirty = false;
+ TestingAccessWrapper::newFromObject( $backend )->dataHash = 'Doesn\'t match';
$backend->save();
$this->assertTrue( $this->onSessionMetadataCalled );
$blob = $this->store->getSession( self::SESSIONID );
}
// SessionManager::preventSessionsForUser
- \TestingAccessWrapper::newFromObject( $this->manager )->preventUsers = [
+ TestingAccessWrapper::newFromObject( $this->manager )->preventUsers = [
$user->getName() => true,
];
$this->provider = $neverProvider;
$this->store->setSessionData( self::SESSIONID, $testData );
$backend = $this->getBackend( $user );
$this->store->deleteSession( self::SESSIONID );
- \TestingAccessWrapper::newFromObject( $backend )->persist = true;
+ TestingAccessWrapper::newFromObject( $backend )->persist = true;
$this->assertTrue( $backend->isPersistent(), 'sanity check' );
- \TestingAccessWrapper::newFromObject( $backend )->metaDirty = true;
- \TestingAccessWrapper::newFromObject( $backend )->dataDirty = true;
+ TestingAccessWrapper::newFromObject( $backend )->metaDirty = true;
+ TestingAccessWrapper::newFromObject( $backend )->dataDirty = true;
$backend->save();
$this->assertFalse( $this->store->getSession( self::SESSIONID ), 'making sure it didn\'t save' );
}
$this->store->setSessionData( self::SESSIONID, $testData );
$backend = $this->getBackend( $user );
$this->store->deleteSession( self::SESSIONID );
- $wrap = \TestingAccessWrapper::newFromObject( $backend );
+ $wrap = TestingAccessWrapper::newFromObject( $backend );
$this->assertFalse( $backend->isPersistent(), 'sanity check' );
$wrap->metaDirty = false;
$wrap->dataDirty = false;
$this->store->setSessionData( self::SESSIONID, $testData );
$backend = $this->getBackend( $user );
$this->store->deleteSession( self::SESSIONID );
- $wrap = \TestingAccessWrapper::newFromObject( $backend );
+ $wrap = TestingAccessWrapper::newFromObject( $backend );
$wrap->persist = true;
$this->assertTrue( $backend->isPersistent(), 'sanity check' );
$wrap->metaDirty = false;
$this->store->setSessionData( self::SESSIONID, $testData );
$backend = $this->getBackend( $user );
$this->store->deleteSession( self::SESSIONID );
- $wrap = \TestingAccessWrapper::newFromObject( $backend );
+ $wrap = TestingAccessWrapper::newFromObject( $backend );
$this->assertFalse( $backend->isPersistent(), 'sanity check' );
$wrap->metaDirty = false;
$wrap->dataDirty = false;
if ( !PHPSessionHandler::isEnabled() ) {
$rProp = new \ReflectionProperty( PHPSessionHandler::class, 'instance' );
$rProp->setAccessible( true );
- $handler = \TestingAccessWrapper::newFromObject( $rProp->getValue() );
+ $handler = TestingAccessWrapper::newFromObject( $rProp->getValue() );
$resetHandler = new \Wikimedia\ScopedCallback( function () use ( $handler ) {
session_write_close();
$handler->enable = false;
}
$backend = $this->getBackend( static::getTestSysop()->getUser() );
- \TestingAccessWrapper::newFromObject( $backend )->usePhpSessionHandling = true;
+ TestingAccessWrapper::newFromObject( $backend )->usePhpSessionHandling = true;
$resetSingleton = TestUtils::setSessionManagerSingleton( $this->manager );
- $manager = \TestingAccessWrapper::newFromObject( $this->manager );
+ $manager = TestingAccessWrapper::newFromObject( $this->manager );
$request = \RequestContext::getMain()->getRequest();
$manager->globalSession = $backend->getSession( $request );
$manager->globalSessionRequest = $request;
session_id( '' );
- \TestingAccessWrapper::newFromObject( $backend )->checkPHPSession();
+ TestingAccessWrapper::newFromObject( $backend )->checkPHPSession();
$this->assertSame( $backend->getId(), session_id() );
session_write_close();
$backend2 = $this->getBackend(
User::newFromName( 'UTSysop' ), 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'
);
- \TestingAccessWrapper::newFromObject( $backend2 )->usePhpSessionHandling = true;
+ TestingAccessWrapper::newFromObject( $backend2 )->usePhpSessionHandling = true;
session_id( '' );
- \TestingAccessWrapper::newFromObject( $backend2 )->checkPHPSession();
+ TestingAccessWrapper::newFromObject( $backend2 )->checkPHPSession();
$this->assertSame( '', session_id() );
}
if ( !PHPSessionHandler::isEnabled() ) {
$rProp = new \ReflectionProperty( PHPSessionHandler::class, 'instance' );
$rProp->setAccessible( true );
- $handler = \TestingAccessWrapper::newFromObject( $rProp->getValue() );
+ $handler = TestingAccessWrapper::newFromObject( $rProp->getValue() );
$resetHandler = new \Wikimedia\ScopedCallback( function () use ( $handler ) {
session_write_close();
$handler->enable = false;
}
$backend = $this->getBackend( User::newFromName( 'UTSysop' ) );
- \TestingAccessWrapper::newFromObject( $backend )->usePhpSessionHandling = true;
+ TestingAccessWrapper::newFromObject( $backend )->usePhpSessionHandling = true;
$resetSingleton = TestUtils::setSessionManagerSingleton( $this->manager );
- $manager = \TestingAccessWrapper::newFromObject( $this->manager );
+ $manager = TestingAccessWrapper::newFromObject( $this->manager );
$request = \RequestContext::getMain()->getRequest();
$manager->globalSession = $backend->getSession( $request );
$manager->globalSessionRequest = $request;
if ( !PHPSessionHandler::isEnabled() ) {
$rProp = new \ReflectionProperty( PHPSessionHandler::class, 'instance' );
$rProp->setAccessible( true );
- $handler = \TestingAccessWrapper::newFromObject( $rProp->getValue() );
+ $handler = TestingAccessWrapper::newFromObject( $rProp->getValue() );
$resetHandler = new \Wikimedia\ScopedCallback( function () use ( $handler ) {
session_write_close();
$handler->enable = false;
}
$backend = $this->getBackend( User::newFromName( 'UTSysop' ) );
- $wrap = \TestingAccessWrapper::newFromObject( $backend );
+ $wrap = TestingAccessWrapper::newFromObject( $backend );
$wrap->usePhpSessionHandling = true;
$wrap->persist = true;
$resetSingleton = TestUtils::setSessionManagerSingleton( $this->manager );
- $manager = \TestingAccessWrapper::newFromObject( $this->manager );
+ $manager = TestingAccessWrapper::newFromObject( $this->manager );
$request = \RequestContext::getMain()->getRequest();
$manager->globalSession = $backend->getSession( $request );
$manager->globalSessionRequest = $request;
use MediaWikiTestCase;
use Psr\Log\LogLevel;
use User;
+use Wikimedia\TestingAccessWrapper;
/**
* @group Session
}
$rProp = new \ReflectionProperty( PHPSessionHandler::class, 'instance' );
$rProp->setAccessible( true );
- $handler = \TestingAccessWrapper::newFromObject( $rProp->getValue() );
+ $handler = TestingAccessWrapper::newFromObject( $rProp->getValue() );
$oldEnable = $handler->enable;
$reset[] = new \Wikimedia\ScopedCallback( function () use ( $handler, $oldEnable ) {
if ( $handler->enable ) {
}
public function testConstructor() {
- $manager = \TestingAccessWrapper::newFromObject( $this->getManager() );
+ $manager = TestingAccessWrapper::newFromObject( $this->getManager() );
$this->assertSame( $this->config, $manager->config );
$this->assertSame( $this->logger, $manager->logger );
$this->assertSame( $this->store, $manager->store );
- $manager = \TestingAccessWrapper::newFromObject( new SessionManager() );
+ $manager = TestingAccessWrapper::newFromObject( new SessionManager() );
$this->assertSame( \RequestContext::getMain()->getConfig(), $manager->config );
- $manager = \TestingAccessWrapper::newFromObject( new SessionManager( [
+ $manager = TestingAccessWrapper::newFromObject( new SessionManager( [
'config' => $this->config,
] ) );
$this->assertSame( \ObjectCache::$instances['testSessionStore'], $manager->store );
public function testGetEmptySession() {
$manager = $this->getManager();
- $pmanager = \TestingAccessWrapper::newFromObject( $manager );
+ $pmanager = TestingAccessWrapper::newFromObject( $manager );
$request = new \FauxRequest();
$providerBuilder = $this->getMockBuilder( 'DummySessionProvider' )
public function testGetProviders() {
$realManager = $this->getManager();
- $manager = \TestingAccessWrapper::newFromObject( $realManager );
+ $manager = TestingAccessWrapper::newFromObject( $realManager );
$this->config->set( 'SessionProviders', [
[ 'class' => 'DummySessionProvider' ],
] );
$providers = $manager->getProviders();
$this->assertArrayHasKey( 'DummySessionProvider', $providers );
- $provider = \TestingAccessWrapper::newFromObject( $providers['DummySessionProvider'] );
+ $provider = TestingAccessWrapper::newFromObject( $providers['DummySessionProvider'] );
$this->assertSame( $manager->logger, $provider->logger );
$this->assertSame( $manager->config, $provider->config );
$this->assertSame( $realManager, $provider->getManager() );
}
public function testShutdown() {
- $manager = \TestingAccessWrapper::newFromObject( $this->getManager() );
+ $manager = TestingAccessWrapper::newFromObject( $this->getManager() );
$manager->setLogger( new \Psr\Log\NullLogger() );
$mock = $this->getMockBuilder( 'stdClass' )
}
public function testGetSessionFromInfo() {
- $manager = \TestingAccessWrapper::newFromObject( $this->getManager() );
+ $manager = TestingAccessWrapper::newFromObject( $this->getManager() );
$request = new \FauxRequest();
$id = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
'userInfo' => UserInfo::newFromName( 'UTSysop', true ),
'idIsSafe' => true,
] );
- \TestingAccessWrapper::newFromObject( $info )->idIsSafe = true;
- $session1 = \TestingAccessWrapper::newFromObject(
+ TestingAccessWrapper::newFromObject( $info )->idIsSafe = true;
+ $session1 = TestingAccessWrapper::newFromObject(
$manager->getSessionFromInfo( $info, $request )
);
- $session2 = \TestingAccessWrapper::newFromObject(
+ $session2 = TestingAccessWrapper::newFromObject(
$manager->getSessionFromInfo( $info, $request )
);
$this->assertSame( $session1->getSessionId(), $session2->getSessionId() );
$this->assertSame( $id, $session1->getId() );
- \TestingAccessWrapper::newFromObject( $info )->idIsSafe = false;
+ TestingAccessWrapper::newFromObject( $info )->idIsSafe = false;
$session3 = $manager->getSessionFromInfo( $info, $request );
$this->assertNotSame( $id, $session3->getId() );
}
$manager = $this->getManager();
$session = $manager->getSessionForRequest( new \FauxRequest );
- $backend = \TestingAccessWrapper::newFromObject( $session )->backend;
+ $backend = TestingAccessWrapper::newFromObject( $session )->backend;
$sessionId = $session->getSessionId();
$id = (string)$sessionId;
$provider3->expects( $this->any() )->method( '__toString' )
->will( $this->returnValue( 'Mock3' ) );
- \TestingAccessWrapper::newFromObject( $manager )->sessionProviders = [
+ TestingAccessWrapper::newFromObject( $manager )->sessionProviders = [
(string)$provider => $provider,
(string)$provider2 => $provider2,
(string)$provider3 => $provider3,
namespace MediaWiki\Session;
use MediaWikiTestCase;
+use Wikimedia\TestingAccessWrapper;
/**
* @group Session
$config = new \HashConfig();
$provider = $this->getMockForAbstractClass( SessionProvider::class );
- $priv = \TestingAccessWrapper::newFromObject( $provider );
+ $priv = TestingAccessWrapper::newFromObject( $provider );
$provider->setConfig( $config );
$this->assertSame( $config, $priv->config );
$provider = $this->getMockForAbstractClass( SessionProvider::class,
[], 'MockSessionProvider' );
$provider->setConfig( $config );
- $priv = \TestingAccessWrapper::newFromObject( $provider );
+ $priv = TestingAccessWrapper::newFromObject( $provider );
$this->assertSame( 'eoq8cb1mg7j30ui5qolafps4hg29k5bb', $priv->hashToSessionId( 'foobar' ) );
$this->assertSame( '4do8j7tfld1g8tte9jqp3csfgmulaun9',
);
}
- \TestingAccessWrapper::newFromObject( $backend )->provider = $provider;
+ TestingAccessWrapper::newFromObject( $backend )->provider = $provider;
$this->assertNull( $provider->getAllowedUserRights( $backend ) );
}
use Psr\Log\LogLevel;
use MediaWikiTestCase;
use User;
+use Wikimedia\TestingAccessWrapper;
/**
* @group Session
public function testConstructor() {
$backend = TestUtils::getDummySessionBackend();
- \TestingAccessWrapper::newFromObject( $backend )->requests = [ -1 => 'dummy' ];
- \TestingAccessWrapper::newFromObject( $backend )->id = new SessionId( 'abc' );
+ TestingAccessWrapper::newFromObject( $backend )->requests = [ -1 => 'dummy' ];
+ TestingAccessWrapper::newFromObject( $backend )->id = new SessionId( 'abc' );
$session = new Session( $backend, 42, new \TestLogger );
- $priv = \TestingAccessWrapper::newFromObject( $session );
+ $priv = TestingAccessWrapper::newFromObject( $session );
$this->assertSame( $backend, $priv->backend );
$this->assertSame( 42, $priv->index );
$request = new \FauxRequest();
- $priv2 = \TestingAccessWrapper::newFromObject( $session->sessionWithRequest( $request ) );
+ $priv2 = TestingAccessWrapper::newFromObject( $session->sessionWithRequest( $request ) );
$this->assertSame( $backend, $priv2->backend );
$this->assertNotSame( $priv->index, $priv2->index );
$this->assertSame( $request, $priv2->getRequest() );
public function testDataAccess() {
$session = TestUtils::getDummySession();
- $backend = \TestingAccessWrapper::newFromObject( $session )->backend;
+ $backend = TestingAccessWrapper::newFromObject( $session )->backend;
$this->assertEquals( 1, $session->get( 'foo' ) );
$this->assertEquals( 'zero', $session->get( 0 ) );
public function testArrayAccess() {
$logger = new \TestLogger;
$session = TestUtils::getDummySession( null, -1, $logger );
- $backend = \TestingAccessWrapper::newFromObject( $session )->backend;
+ $backend = TestingAccessWrapper::newFromObject( $session )->backend;
$this->assertEquals( 1, $session['foo'] );
$this->assertEquals( 'zero', $session[0] );
public function testClear() {
$session = TestUtils::getDummySession();
- $priv = \TestingAccessWrapper::newFromObject( $session );
+ $priv = TestingAccessWrapper::newFromObject( $session );
$backend = $this->getMockBuilder( DummySessionBackend::class )
->setMethods( [ 'canSetUser', 'setUser', 'save' ] )
public function testTokens() {
$session = TestUtils::getDummySession();
- $priv = \TestingAccessWrapper::newFromObject( $session );
+ $priv = TestingAccessWrapper::newFromObject( $session );
$backend = $priv->backend;
- $token = \TestingAccessWrapper::newFromObject( $session->getToken() );
+ $token = TestingAccessWrapper::newFromObject( $session->getToken() );
$this->assertArrayHasKey( 'wsTokenSecrets', $backend->data );
$this->assertArrayHasKey( 'default', $backend->data['wsTokenSecrets'] );
$secret = $backend->data['wsTokenSecrets']['default'];
$this->assertSame( '', $token->salt );
$this->assertTrue( $token->wasNew() );
- $token = \TestingAccessWrapper::newFromObject( $session->getToken( 'foo' ) );
+ $token = TestingAccessWrapper::newFromObject( $session->getToken( 'foo' ) );
$this->assertSame( $secret, $token->secret );
$this->assertSame( 'foo', $token->salt );
$this->assertFalse( $token->wasNew() );
$backend->data['wsTokenSecrets']['secret'] = 'sekret';
- $token = \TestingAccessWrapper::newFromObject(
+ $token = TestingAccessWrapper::newFromObject(
$session->getToken( [ 'bar', 'baz' ], 'secret' )
);
$this->assertSame( 'sekret', $token->secret );
// Unserializable data
$iv = \MWCryptRand::generate( 16, true );
- list( $encKey, $hmacKey ) = \TestingAccessWrapper::newFromObject( $session )->getSecretKeys();
+ list( $encKey, $hmacKey ) = TestingAccessWrapper::newFromObject( $session )->getSecretKeys();
$ciphertext = openssl_encrypt( 'foobar', 'aes-256-ctr', $encKey, OPENSSL_RAW_DATA, $iv );
$sealed = base64_encode( $iv ) . '.' . base64_encode( $ciphertext );
$hmac = hash_hmac( 'sha256', $sealed, $hmacKey, true );
namespace MediaWiki\Session;
use Psr\Log\LoggerInterface;
+use Wikimedia\TestingAccessWrapper;
/**
* Utility functions for Session unit tests
}
$ret = $rc->newInstanceWithoutConstructor();
- \TestingAccessWrapper::newFromObject( $ret )->logger = new \TestLogger;
+ TestingAccessWrapper::newFromObject( $ret )->logger = new \TestLogger;
return $ret;
}
}
$session = $rc->newInstanceWithoutConstructor();
- $priv = \TestingAccessWrapper::newFromObject( $session );
+ $priv = TestingAccessWrapper::newFromObject( $session );
$priv->backend = $backend;
$priv->index = $index;
$priv->logger = $logger ?: new \TestLogger;
namespace MediaWiki\Session;
use MediaWikiTestCase;
+use Wikimedia\TestingAccessWrapper;
/**
* @group Session
}
public function testToStringAtTimestamp() {
- $token = \TestingAccessWrapper::newFromObject( new Token( 'sekret', 'salty', false ) );
+ $token = TestingAccessWrapper::newFromObject( new Token( 'sekret', 'salty', false ) );
$this->assertSame(
'd9ade0c7d4349e9df9094e61c33a5a0d5644fde2+\\',
}
public function testMatch() {
- $token = \TestingAccessWrapper::newFromObject( new Token( 'sekret', 'salty', false ) );
+ $token = TestingAccessWrapper::newFromObject( new Token( 'sekret', 'salty', false ) );
$test = $token->toStringAtTimestamp( time() - 10 );
$this->assertTrue( $token->match( $test ) );
<?php
+
+use Wikimedia\TestingAccessWrapper;
+
/**
* Test class for ChangesListSpecialPage class
*
<?php
+use Wikimedia\TestingAccessWrapper;
+
/**
* Test class for SpecialRecentchanges class
*
<?php
+use Wikimedia\TestingAccessWrapper;
+
/**
* @author Addshore
*
use MediaWiki\Session\SessionManager;
use Wikimedia\ScopedCallback;
+use Wikimedia\TestingAccessWrapper;
/**
* @covers BotPassword
<?php
+use Wikimedia\TestingAccessWrapper;
+
/**
* @covers CentralIdLookup
* @group Database
define( 'NS_UNITTEST_TALK', 5601 );
use MediaWiki\MediaWikiServices;
+use Wikimedia\TestingAccessWrapper;
/**
* @group Database
<?php
+use Wikimedia\TestingAccessWrapper;
+
/**
* Checks that all API modules, core and extensions, have documentation i18n messages
*
<?php
+
+use Wikimedia\TestingAccessWrapper;
+
/**
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
dépôts / lhc / web / wiklou.git / commitdiff