/** * @dataProvider provideContentObjs */ public function testGetParsedFooter(CollaborationHubContent $content, $id) { $expected = ["<p><b>Test</b> content footer\n</p>", '', '']; $wc = TestingAccessWrapper::newFromObject($content); $actual = $wc->getParsedFooter(Title::newMainPage(), new ParserOptions()); $this->assertEquals($expected[$id], $actual, $id); }
protected function makeBlobStore($methods = null, $rl = null) { $blobStore = $this->getMockBuilder('MessageBlobStore')->setConstructorArgs([$rl])->setMethods($methods)->getMock(); $access = TestingAccessWrapper::newFromObject($blobStore); $access->wanCache = $this->wanCache; return $blobStore; }
function setUp() { parent::setUp(); require_once __DIR__ . '/../data/helpers/WellProtectedClass.php'; $this->raw = new WellProtectedClass(); $this->wrapped = TestingAccessWrapper::newFromObject($this->raw); }
public function testConstructor() { try { $provider = new BotPasswordSessionProvider(); $this->fail('Expected exception not thrown'); } catch (\InvalidArgumentException $ex) { $this->assertSame('MediaWiki\\Session\\BotPasswordSessionProvider::__construct: priority must be specified', $ex->getMessage()); } try { $provider = new BotPasswordSessionProvider(array('priority' => SessionInfo::MIN_PRIORITY - 1)); $this->fail('Expected exception not thrown'); } catch (\InvalidArgumentException $ex) { $this->assertSame('MediaWiki\\Session\\BotPasswordSessionProvider::__construct: Invalid priority', $ex->getMessage()); } try { $provider = new BotPasswordSessionProvider(array('priority' => SessionInfo::MAX_PRIORITY + 1)); $this->fail('Expected exception not thrown'); } catch (\InvalidArgumentException $ex) { $this->assertSame('MediaWiki\\Session\\BotPasswordSessionProvider::__construct: Invalid priority', $ex->getMessage()); } $provider = new BotPasswordSessionProvider(array('priority' => 40)); $priv = \TestingAccessWrapper::newFromObject($provider); $this->assertSame(40, $priv->priority); $this->assertSame('_BPsession', $priv->sessionCookieName); $this->assertSame(array(), $priv->sessionCookieOptions); $provider = new BotPasswordSessionProvider(array('priority' => 40, 'sessionCookieName' => null)); $priv = \TestingAccessWrapper::newFromObject($provider); $this->assertSame('_BPsession', $priv->sessionCookieName); $provider = new BotPasswordSessionProvider(array('priority' => 40, 'sessionCookieName' => 'Foo', 'sessionCookieOptions' => array('Bar'))); $priv = \TestingAccessWrapper::newFromObject($provider); $this->assertSame('Foo', $priv->sessionCookieName); $this->assertSame(array('Bar'), $priv->sessionCookieOptions); }
public function testConstructor() { $provider = new ThrottlePreAuthenticationProvider(); $providerPriv = \TestingAccessWrapper::newFromObject($provider); $config = new \HashConfig(['AccountCreationThrottle' => 123, 'PasswordAttemptThrottle' => [['count' => 5, 'seconds' => 300]]]); $provider->setConfig($config); $this->assertSame(['accountCreationThrottle' => [['count' => 123, 'seconds' => 86400]], 'passwordAttemptThrottle' => [['count' => 5, 'seconds' => 300]]], $providerPriv->throttleSettings); $accountCreationThrottle = \TestingAccessWrapper::newFromObject($providerPriv->accountCreationThrottle); $this->assertSame([['count' => 123, 'seconds' => 86400]], $accountCreationThrottle->conditions); $passwordAttemptThrottle = \TestingAccessWrapper::newFromObject($providerPriv->passwordAttemptThrottle); $this->assertSame([['count' => 5, 'seconds' => 300]], $passwordAttemptThrottle->conditions); $provider = new ThrottlePreAuthenticationProvider(['accountCreationThrottle' => [['count' => 43, 'seconds' => 10000]], 'passwordAttemptThrottle' => [['count' => 11, 'seconds' => 100]]]); $providerPriv = \TestingAccessWrapper::newFromObject($provider); $config = new \HashConfig(['AccountCreationThrottle' => 123, 'PasswordAttemptThrottle' => [['count' => 5, 'seconds' => 300]]]); $provider->setConfig($config); $this->assertSame(['accountCreationThrottle' => [['count' => 43, 'seconds' => 10000]], 'passwordAttemptThrottle' => [['count' => 11, 'seconds' => 100]]], $providerPriv->throttleSettings); $cache = new \HashBagOStuff(); $provider = new ThrottlePreAuthenticationProvider(['cache' => $cache]); $providerPriv = \TestingAccessWrapper::newFromObject($provider); $provider->setConfig(new \HashConfig(['AccountCreationThrottle' => [['count' => 1, 'seconds' => 1]], 'PasswordAttemptThrottle' => [['count' => 1, 'seconds' => 1]]])); $accountCreationThrottle = \TestingAccessWrapper::newFromObject($providerPriv->accountCreationThrottle); $this->assertSame($cache, $accountCreationThrottle->cache); $passwordAttemptThrottle = \TestingAccessWrapper::newFromObject($providerPriv->passwordAttemptThrottle); $this->assertSame($cache, $passwordAttemptThrottle->cache); }
protected function getInstance(array $args = []) { $req = new RememberMeAuthenticationRequest(); $reqWrapper = \TestingAccessWrapper::newFromObject($req); $reqWrapper->expiration = $args[0]; return $req; }
protected function setUp() { parent::setUp(); $this->cache = new WANObjectCache(['cache' => new HashBagOStuff(), 'pool' => 'testcache-hash', 'relayer' => new EventRelayerNull([])]); $wanCache = TestingAccessWrapper::newFromObject($this->cache); /** @noinspection PhpUndefinedFieldInspection */ $this->internalCache = $wanCache->cache; }
public function testMatch() { $token = \TestingAccessWrapper::newFromObject(new Token('sekret', 'salty', false)); $test = $token->toStringAtTimestamp(time() - 10); $this->assertTrue($token->match($test)); $this->assertTrue($token->match($test, 12)); $this->assertFalse($token->match($test, 8)); $this->assertFalse($token->match('ee2f7a2488dea9176c224cfb400d43be5644fdea-\\')); }
public function testConstructor() { $config = new \HashConfig(['EnableEmail' => true, 'EmailAuthentication' => true]); $provider = new EmailNotificationSecondaryAuthenticationProvider(); $provider->setConfig($config); $providerPriv = \TestingAccessWrapper::newFromObject($provider); $this->assertTrue($providerPriv->sendConfirmationEmail); $provider = new EmailNotificationSecondaryAuthenticationProvider(['sendConfirmationEmail' => false]); $provider->setConfig($config); $providerPriv = \TestingAccessWrapper::newFromObject($provider); $this->assertFalse($providerPriv->sendConfirmationEmail); }
public function testForcePrimaryAuthenticationProviders() { $mockA = $this->getMockForAbstractClass(PrimaryAuthenticationProvider::class); $mockB = $this->getMockForAbstractClass(PrimaryAuthenticationProvider::class); $mockB2 = $this->getMockForAbstractClass(PrimaryAuthenticationProvider::class); $mockA->expects($this->any())->method('getUniqueId')->will($this->returnValue('A')); $mockB->expects($this->any())->method('getUniqueId')->will($this->returnValue('B')); $mockB2->expects($this->any())->method('getUniqueId')->will($this->returnValue('B')); $this->primaryauthMocks = [$mockA]; $this->logger = new \TestLogger(true); // Test without first initializing the configured providers $this->initializeManager(); $this->manager->forcePrimaryAuthenticationProviders([$mockB], 'testing'); $this->assertSame(['B' => $mockB], $this->managerPriv->getPrimaryAuthenticationProviders()); $this->assertSame(null, $this->managerPriv->getAuthenticationProvider('A')); $this->assertSame($mockB, $this->managerPriv->getAuthenticationProvider('B')); $this->assertSame([[LogLevel::WARNING, 'Overriding AuthManager primary authn because testing']], $this->logger->getBuffer()); $this->logger->clearBuffer(); // Test with first initializing the configured providers $this->initializeManager(); $this->assertSame($mockA, $this->managerPriv->getAuthenticationProvider('A')); $this->assertSame(null, $this->managerPriv->getAuthenticationProvider('B')); $this->request->getSession()->setSecret('AuthManager::authnState', 'test'); $this->request->getSession()->setSecret('AuthManager::accountCreationState', 'test'); $this->manager->forcePrimaryAuthenticationProviders([$mockB], 'testing'); $this->assertSame(['B' => $mockB], $this->managerPriv->getPrimaryAuthenticationProviders()); $this->assertSame(null, $this->managerPriv->getAuthenticationProvider('A')); $this->assertSame($mockB, $this->managerPriv->getAuthenticationProvider('B')); $this->assertNull($this->request->getSession()->getSecret('AuthManager::authnState')); $this->assertNull($this->request->getSession()->getSecret('AuthManager::accountCreationState')); $this->assertSame([[LogLevel::WARNING, 'Overriding AuthManager primary authn because testing'], [LogLevel::WARNING, 'PrimaryAuthenticationProviders have already been accessed! I hope nothing breaks.']], $this->logger->getBuffer()); $this->logger->clearBuffer(); // Test duplicate IDs $this->initializeManager(); try { $this->manager->forcePrimaryAuthenticationProviders([$mockB, $mockB2], 'testing'); $this->fail('Expected exception not thrown'); } catch (\RuntimeException $ex) { $class1 = get_class($mockB); $class2 = get_class($mockB2); $this->assertSame("Duplicate specifications for id B (classes {$class2} and {$class1})", $ex->getMessage()); } // Wrong classes $mock = $this->getMockForAbstractClass(AuthenticationProvider::class); $mock->expects($this->any())->method('getUniqueId')->will($this->returnValue('X')); $class = get_class($mock); try { $this->manager->forcePrimaryAuthenticationProviders([$mock], 'testing'); $this->fail('Expected exception not thrown'); } catch (\RuntimeException $ex) { $this->assertSame("Expected instance of MediaWiki\\Auth\\PrimaryAuthenticationProvider, got {$class}", $ex->getMessage()); } }
protected function setUp() { parent::setUp(); if ($this->getCliArg('use-wanobjectcache')) { $name = $this->getCliArg('use-wanobjectcache'); $this->cache = ObjectCache::getWANInstance($name); } else { $this->cache = new WANObjectCache(['cache' => new HashBagOStuff(), 'pool' => 'testcache-hash', 'relayer' => new EventRelayerNull([])]); } $wanCache = TestingAccessWrapper::newFromObject($this->cache); $this->internalCache = $wanCache->cache; }
function testGCFraudFilters() { $this->setMwGlobals(array('wgGlobalCollectGatewayEnableMinfraud' => true)); $options = $this->getDonorTestData(); $options['email'] = '*****@*****.**'; $class = $this->testAdapterClass; $gateway = $this->getFreshGatewayObject($options); $gateway->runAntifraudFilters(); $this->assertEquals('reject', $gateway->getValidationAction(), 'Validation action is not as expected'); $exposed = TestingAccessWrapper::newFromObject($gateway); $this->assertEquals(157.5, $exposed->risk_score, 'RiskScore is not as expected'); }
/** * @covers ResourceLoaderClientHtml::__construct * @covers ResourceLoaderClientHtml::setModules * @covers ResourceLoaderClientHtml::setModuleStyles * @covers ResourceLoaderClientHtml::setModuleScripts * @covers ResourceLoaderClientHtml::getData * @covers ResourceLoaderClientHtml::getContext */ public function testGetData() { $context = self::makeContext(); $context->getResourceLoader()->register(self::makeSampleModules()); $client = new ResourceLoaderClientHtml($context); $client->setModules(['test', 'test.private.bottom', 'test.private.top', 'test.top', 'test.unregistered']); $client->setModuleStyles(['test.styles.mixed', 'test.styles.mixed.user.empty', 'test.styles.private', 'test.styles.pure', 'test.unregistered.styles']); $client->setModuleScripts(['test.scripts', 'test.scripts.mixed.user.empty', 'test.scripts.top', 'test.unregistered.scripts']); $expected = ['states' => ['test.private.top' => 'loading', 'test.private.bottom' => 'loading', 'test.styles.pure' => 'ready', 'test.styles.mixed.user.empty' => 'ready', 'test.styles.private' => 'ready', 'test.scripts' => 'loading', 'test.scripts.top' => 'loading', 'test.scripts.mixed.user.empty' => 'ready'], 'general' => ['top' => ['test.top'], 'bottom' => ['test']], 'styles' => ['test.styles.mixed', 'test.styles.pure'], 'scripts' => ['top' => ['test.scripts.top'], 'bottom' => ['test.scripts']], 'embed' => ['styles' => ['test.styles.private'], 'general' => ['top' => ['test.private.top'], 'bottom' => ['test.private.bottom']]]]; $access = TestingAccessWrapper::newFromObject($client); $this->assertEquals($expected, $access->getData()); }
public function testConstructor() { $provider = new CheckBlocksSecondaryAuthenticationProvider(); $providerPriv = \TestingAccessWrapper::newFromObject($provider); $config = new \HashConfig(['BlockDisablesLogin' => false]); $provider->setConfig($config); $this->assertSame(false, $providerPriv->blockDisablesLogin); $provider = new CheckBlocksSecondaryAuthenticationProvider(['blockDisablesLogin' => true]); $providerPriv = \TestingAccessWrapper::newFromObject($provider); $config = new \HashConfig(['BlockDisablesLogin' => false]); $provider->setConfig($config); $this->assertSame(true, $providerPriv->blockDisablesLogin); }
private function compareMessages($msg, $msg2) { $this->assertSame($msg->getKey(), $msg2->getKey(), 'getKey'); $this->assertSame($msg->getKeysToTry(), $msg2->getKeysToTry(), 'getKeysToTry'); $this->assertSame($msg->getParams(), $msg2->getParams(), 'getParams'); $this->assertSame($msg->getFormat(), $msg2->getFormat(), 'getFormat'); $this->assertSame($msg->getLanguage(), $msg2->getLanguage(), 'getLanguage'); $msg = TestingAccessWrapper::newFromObject($msg); $msg2 = TestingAccessWrapper::newFromObject($msg2); foreach (array('interface', 'useDatabase', 'title') as $key) { $this->assertSame($msg->{$key}, $msg2->{$key}, $key); } }
private function compareMessages($msg, $msg2) { $this->assertSame($msg->getKey(), $msg2->getKey(), 'getKey'); $this->assertSame($msg->getKeysToTry(), $msg2->getKeysToTry(), 'getKeysToTry'); $this->assertSame($msg->getParams(), $msg2->getParams(), 'getParams'); $this->assertSame($msg->getFormat(), $msg2->getFormat(), 'getFormat'); $this->assertSame($msg->getLanguage(), $msg2->getLanguage(), 'getLanguage'); $msg = TestingAccessWrapper::newFromObject($msg); $msg2 = TestingAccessWrapper::newFromObject($msg2); $this->assertSame($msg->interface, $msg2->interface, 'interface'); $this->assertSame($msg->useDatabase, $msg2->useDatabase, 'useDatabase'); $this->assertSame($msg->title ? $msg->title->getFullText() : null, $msg2->title ? $msg2->title->getFullText() : null, 'title'); }
/** * @dataProvider provideHandlers * @param ContentHandler $handler */ public function testMakeEmptyContent(ContentHandler $handler) { $content = $handler->makeEmptyContent(); $this->assertInstanceOf(Content::class, $content); if ($handler instanceof TextContentHandler) { // TextContentHandler::getContentClass() is protected, so bypass // that restriction $testingWrapper = TestingAccessWrapper::newFromObject($handler); $this->assertInstanceOf($testingWrapper->getContentClass(), $content); } $handlerClass = get_class($handler); $contentClass = get_class($content); $this->assertTrue($content->isValid(), "{$handlerClass}::makeEmptyContent() did not return a valid content ({$contentClass}::isValid())"); }
/** * @covers HashBagOStuff::doGet * @covers HashBagOStuff::expire */ public function testExpire() { $cache = new HashBagOStuff(); $cacheInternal = TestingAccessWrapper::newFromObject($cache); $cache->set('foo', 1); $cache->set('bar', 1, 10); $cache->set('baz', 1, -10); $this->assertEquals(0, $cacheInternal->bag['foo'][$cache::KEY_EXP], 'Indefinite'); // 2 seconds tolerance $this->assertEquals(time() + 10, $cacheInternal->bag['bar'][$cache::KEY_EXP], 'Future', 2); $this->assertEquals(time() - 10, $cacheInternal->bag['baz'][$cache::KEY_EXP], 'Past', 2); $this->assertEquals(1, $cache->get('bar'), 'Key not expired'); $this->assertEquals(false, $cache->get('baz'), 'Key expired'); }
/** * If you need a Session for testing but don't want to create a backend to * construct one, use this. * @param object $backend Object to serve as the SessionBackend * @param int $index Index * @return Session */ public static function getDummySession($backend = null, $index = -1) { $rc = new \ReflectionClass('MediaWiki\\Session\\Session'); if (!method_exists($rc, 'newInstanceWithoutConstructor')) { \PHPUnit_Framework_Assert::markTestSkipped('ReflectionClass::newInstanceWithoutConstructor isn\'t available'); } if ($backend === null) { $backend = new DummySessionBackend(); } $session = $rc->newInstanceWithoutConstructor(); $priv = \TestingAccessWrapper::newFromObject($session); $priv->backend = $backend; $priv->index = $index; return $session; }
public function testAbstractAuthenticationProvider() { $provider = $this->getMockForAbstractClass(AbstractAuthenticationProvider::class); $providerPriv = \TestingAccessWrapper::newFromObject($provider); $obj = $this->getMockForAbstractClass('Psr\\Log\\LoggerInterface'); $provider->setLogger($obj); $this->assertSame($obj, $providerPriv->logger, 'setLogger'); $obj = AuthManager::singleton(); $provider->setManager($obj); $this->assertSame($obj, $providerPriv->manager, 'setManager'); $obj = $this->getMockForAbstractClass('Config'); $provider->setConfig($obj); $this->assertSame($obj, $providerPriv->config, 'setConfig'); $this->assertType('string', $provider->getUniqueId(), 'getUniqueId'); }
public function testCheckAudience() { $mock = TestingAccessWrapper::newFromObject($this->getMockForAbstractClass('CentralIdLookup')); $user = static::getTestSysop()->getUser(); $this->assertSame($user, $mock->checkAudience($user)); $user = $mock->checkAudience(CentralIdLookup::AUDIENCE_PUBLIC); $this->assertInstanceOf('User', $user); $this->assertSame(0, $user->getId()); $this->assertNull($mock->checkAudience(CentralIdLookup::AUDIENCE_RAW)); try { $mock->checkAudience(100); $this->fail('Expected exception not thrown'); } catch (InvalidArgumentException $ex) { $this->assertSame('Invalid audience', $ex->getMessage()); } }
public function testPurgeMergeWeb() { $this->setMwGlobals('wgCommandLineMode', false); $urls1 = array(); $title = Title::newMainPage(); $urls1[] = $title->getCanonicalURL('?x=1'); $urls1[] = $title->getCanonicalURL('?x=2'); $urls1[] = $title->getCanonicalURL('?x=3'); $update1 = new CdnCacheUpdate($urls1); DeferredUpdates::addUpdate($update1); $urls2 = array(); $urls2[] = $title->getCanonicalURL('?x=2'); $urls2[] = $title->getCanonicalURL('?x=3'); $urls2[] = $title->getCanonicalURL('?x=4'); $update2 = new CdnCacheUpdate($urls2); DeferredUpdates::addUpdate($update2); $wrapper = TestingAccessWrapper::newFromObject($update1); $this->assertEquals(array_merge($urls1, $urls2), $wrapper->urls); }
/** * @dataProvider provideGetParameterFromSettings * @param string|null $input * @param array $paramSettings * @param mixed $expected * @param string[] $warnings */ public function testGetParameterFromSettings($input, $paramSettings, $expected, $warnings) { $mock = new MockApi(); $wrapper = TestingAccessWrapper::newFromObject($mock); $context = new DerivativeContext($mock); $context->setRequest(new FauxRequest($input !== null ? ['foo' => $input] : [])); $wrapper->mMainModule = new ApiMain($context); if ($expected instanceof UsageException) { try { $wrapper->getParameterFromSettings('foo', $paramSettings, true); } catch (UsageException $ex) { $this->assertEquals($expected, $ex); } } else { $result = $wrapper->getParameterFromSettings('foo', $paramSettings, true); $this->assertSame($expected, $result); $this->assertSame($warnings, $mock->warnings); } }
/** * Make sure language is staged correctly when qs param is uppercase */ function testLanguageCaseSensitivity() { $init = $this->getDonorTestData(); $init['language'] = 'FR'; $gateway = $this->getFreshGatewayObject($init); $gateway->do_transaction('donate'); $exposed = TestingAccessWrapper::newFromObject($gateway); $ret = $exposed->buildRequestParams(); $expected = array('allowedMethods' => 'card', 'billingAddress.street' => $init['street'], 'billingAddress.city' => $init['city'], 'billingAddress.postalCode' => $init['zip'], 'billingAddress.stateOrProvince' => $init['state'], 'billingAddress.country' => $init['country'], 'billingAddress.houseNumberOrName' => 'NA', 'billingAddressType' => 2, 'card.cardHolderName' => $init['fname'] . ' ' . $init['lname'], 'currencyCode' => $init['currency_code'], 'merchantAccount' => 'wikitest', 'merchantReference' => $exposed->getData_Staged('order_id'), 'merchantSig' => $exposed->getData_Staged('hpp_signature'), 'paymentAmount' => $init['amount'] * 100, 'skinCode' => 'testskin', 'shopperLocale' => 'fr_US', 'shopperEmail' => '*****@*****.**', 'offset' => '52'); //deal with problem keys. //@TODO: Refactor gateway so these are more testable $problems = array('sessionValidity', 'shipBeforeDate'); foreach ($problems as $oneproblem) { if (isset($ret[$oneproblem])) { unset($ret[$oneproblem]); } } $this->assertEquals($expected, $ret, 'Adyen "donate" transaction not constructing the expected redirect URL'); $this->assertNotNull($gateway->getData_Unstaged_Escaped('order_id'), "Adyen order_id is null, and we need one for 'merchantReference'"); }
public function testPreferences() { $prefs = array(); $repo = TestingAccessWrapper::newFromObject(new MediaWikiGadgetsDefinitionRepo()); // Force usage of a MediaWikiGadgetsDefinitionRepo GadgetRepo::setSingleton($repo); $gadgets = $repo->fetchStructuredList('* foo | foo.js ==keep-section1== * bar| bar.js ==remove-section== * baz [rights=embezzle] |baz.js ==keep-section2== * quux [rights=read] | quux.js'); $this->assertGreaterThanOrEqual(2, count($gadgets), "Gadget list parsed"); $repo->definitionCache = $gadgets; $this->assertTrue(GadgetHooks::getPreferences(new User(), $prefs), 'GetPrefences hook should return true'); $options = $prefs['gadgets']['options']; $this->assertFalse(isset($options['<gadget-section-remove-section>']), 'Must not show empty sections'); $this->assertTrue(isset($options['<gadget-section-keep-section1>'])); $this->assertTrue(isset($options['<gadget-section-keep-section2>'])); }
public function testClear() { $session = TestUtils::getDummySession(); $priv = \TestingAccessWrapper::newFromObject($session); $backend = $this->getMock('MediaWiki\\Session\\DummySessionBackend', array('canSetUser', 'setUser', 'save')); $backend->expects($this->once())->method('canSetUser')->will($this->returnValue(true)); $backend->expects($this->once())->method('setUser')->with($this->callback(function ($user) { return $user instanceof User && $user->isAnon(); })); $backend->expects($this->once())->method('save'); $priv->backend = $backend; $session->clear(); $this->assertSame(array(), $backend->data); $this->assertTrue($backend->dirty); $backend = $this->getMock('MediaWiki\\Session\\DummySessionBackend', array('canSetUser', 'setUser', 'save')); $backend->data = array(); $backend->expects($this->once())->method('canSetUser')->will($this->returnValue(true)); $backend->expects($this->once())->method('setUser')->with($this->callback(function ($user) { return $user instanceof User && $user->isAnon(); })); $backend->expects($this->once())->method('save'); $priv->backend = $backend; $session->clear(); $this->assertFalse($backend->dirty); $backend = $this->getMock('MediaWiki\\Session\\DummySessionBackend', array('canSetUser', 'setUser', 'save')); $backend->expects($this->once())->method('canSetUser')->will($this->returnValue(false)); $backend->expects($this->never())->method('setUser'); $backend->expects($this->once())->method('save'); $priv->backend = $backend; $session->clear(); $this->assertSame(array(), $backend->data); $this->assertTrue($backend->dirty); }
/** * Test conditional headers output * @dataProvider provideConditionalRequestHeadersOutput * @param array $conditions Return data for ApiBase::getConditionalRequestData * @param array $headers Expected output headers * @param bool $isError $isError flag * @param bool $post Request is a POST */ public function testConditionalRequestHeadersOutput($conditions, $headers, $isError = false, $post = false) { $request = new FauxRequest(array('action' => 'query', 'meta' => 'siteinfo'), $post); $response = $request->response(); $api = new ApiMain($request); $priv = TestingAccessWrapper::newFromObject($api); $priv->mInternalMode = false; $module = $this->getMockBuilder('ApiBase')->setConstructorArgs(array($api, 'mock'))->setMethods(array('getConditionalRequestData'))->getMockForAbstractClass(); $module->expects($this->any())->method('getConditionalRequestData')->will($this->returnCallback(function ($condition) use($conditions) { return isset($conditions[$condition]) ? $conditions[$condition] : null; })); $priv->mModule = $module; $priv->sendCacheHeaders($isError); foreach (array('Last-Modified', 'ETag') as $header) { $this->assertEquals(isset($headers[$header]) ? $headers[$header] : null, $response->getHeader($header), $header); } }
public function testGetAllowedUserRights() { $provider = $this->getMockForAbstractClass('MediaWiki\\Session\\SessionProvider'); $backend = TestUtils::getDummySessionBackend(); try { $provider->getAllowedUserRights($backend); $this->fail('Expected exception not thrown'); } catch (\InvalidArgumentException $ex) { $this->assertSame('Backend\'s provider isn\'t $this', $ex->getMessage()); } \TestingAccessWrapper::newFromObject($backend)->provider = $provider; $this->assertNull($provider->getAllowedUserRights($backend)); }
public function tearDown() { parent::tearDown(); TestingAccessWrapper::newFromClass('Hooks')->handlers = $this->originalHandlers; SpecialPageFactory::resetList(); }
function testStageFiscalNumber() { $init = $this->getDonorTestData('BR'); $init['fiscal_number'] = '000.034.567-89'; $gateway = $this->getFreshGatewayObject($init); $gateway->doPayment(); $exposed = TestingAccessWrapper::newFromObject($gateway); $staged = $exposed->getData_Staged('fiscal_number'); $this->assertEquals('00003456789', $staged, 'Not stripping fiscal_number punctuation in doPayment'); }