tests/phpunit/unit/includes/session/SessionUnitTest.php

   1 <?php
   2
   3 namespace MediaWiki\Session;
   4
   5 use Psr\Log\LogLevel;
   6 use MediaWikiUnitTestCase;
   7 use Wikimedia\TestingAccessWrapper;
   8
   9 /**
  10  * @group Session
  11  * @covers MediaWiki\Session\Session
  12  */
  13 class SessionUnitTest extends MediaWikiUnitTestCase {
  14
  15         public function testConstructor() {
  16                 $backend = TestUtils::getDummySessionBackend();
  17                 TestingAccessWrapper::newFromObject( $backend )->requests = [ -1 => 'dummy' ];
  18                 TestingAccessWrapper::newFromObject( $backend )->id = new SessionId( 'abc' );
  19
  20                 $session = new Session( $backend, 42, new \TestLogger );
  21                 $priv = TestingAccessWrapper::newFromObject( $session );
  22                 $this->assertSame( $backend, $priv->backend );
  23                 $this->assertSame( 42, $priv->index );
  24
  25                 $request = new \FauxRequest();
  26                 $priv2 = TestingAccessWrapper::newFromObject( $session->sessionWithRequest( $request ) );
  27                 $this->assertSame( $backend, $priv2->backend );
  28                 $this->assertNotSame( $priv->index, $priv2->index );
  29                 $this->assertSame( $request, $priv2->getRequest() );
  30         }
  31
  32         /**
  33          * @dataProvider provideMethods
  34          * @param string $m Method to test
  35          * @param array $args Arguments to pass to the method
  36          * @param bool $index Whether the backend method gets passed the index
  37          * @param bool $ret Whether the method returns a value
  38          */
  39         public function testMethods( $m, $args, $index, $ret ) {
  40                 $mock = $this->getMockBuilder( DummySessionBackend::class )
  41                         ->setMethods( [ $m, 'deregisterSession' ] )
  42                         ->getMock();
  43                 $mock->expects( $this->once() )->method( 'deregisterSession' )
  44                         ->with( $this->identicalTo( 42 ) );
  45
  46                 $tmp = $mock->expects( $this->once() )->method( $m );
  47                 $expectArgs = [];
  48                 if ( $index ) {
  49                         $expectArgs[] = $this->identicalTo( 42 );
  50                 }
  51                 foreach ( $args as $arg ) {
  52                         $expectArgs[] = $this->identicalTo( $arg );
  53                 }
  54                 $tmp = call_user_func_array( [ $tmp, 'with' ], $expectArgs );
  55
  56                 $retval = new \stdClass;
  57                 $tmp->will( $this->returnValue( $retval ) );
  58
  59                 $session = TestUtils::getDummySession( $mock, 42 );
  60
  61                 if ( $ret ) {
  62                         $this->assertSame( $retval, call_user_func_array( [ $session, $m ], $args ) );
  63                 } else {
  64                         $this->assertNull( call_user_func_array( [ $session, $m ], $args ) );
  65                 }
  66
  67                 // Trigger Session destructor
  68                 $session = null;
  69         }
  70
  71         public static function provideMethods() {
  72                 return [
  73                         [ 'getId', [], false, true ],
  74                         [ 'getSessionId', [], false, true ],
  75                         [ 'resetId', [], false, true ],
  76                         [ 'getProvider', [], false, true ],
  77                         [ 'isPersistent', [], false, true ],
  78                         [ 'persist', [], false, false ],
  79                         [ 'unpersist', [], false, false ],
  80                         [ 'shouldRememberUser', [], false, true ],
  81                         [ 'setRememberUser', [ true ], false, false ],
  82                         [ 'getRequest', [], true, true ],
  83                         [ 'getUser', [], false, true ],
  84                         [ 'getAllowedUserRights', [], false, true ],
  85                         [ 'canSetUser', [], false, true ],
  86                         [ 'setUser', [ new \stdClass ], false, false ],
  87                         [ 'suggestLoginUsername', [], true, true ],
  88                         [ 'shouldForceHTTPS', [], false, true ],
  89                         [ 'setForceHTTPS', [ true ], false, false ],
  90                         [ 'getLoggedOutTimestamp', [], false, true ],
  91                         [ 'setLoggedOutTimestamp', [ 123 ], false, false ],
  92                         [ 'getProviderMetadata', [], false, true ],
  93                         [ 'save', [], false, false ],
  94                         [ 'delaySave', [], false, true ],
  95                         [ 'renew', [], false, false ],
  96                 ];
  97         }
  98
  99         public function testDataAccess() {
 100                 $session = TestUtils::getDummySession();
 101                 $backend = TestingAccessWrapper::newFromObject( $session )->backend;
 102
 103                 $this->assertEquals( 1, $session->get( 'foo' ) );
 104                 $this->assertEquals( 'zero', $session->get( 0 ) );
 105                 $this->assertFalse( $backend->dirty );
 106
 107                 $this->assertEquals( null, $session->get( 'null' ) );
 108                 $this->assertEquals( 'default', $session->get( 'null', 'default' ) );
 109                 $this->assertFalse( $backend->dirty );
 110
 111                 $session->set( 'foo', 55 );
 112                 $this->assertEquals( 55, $backend->data['foo'] );
 113                 $this->assertTrue( $backend->dirty );
 114                 $backend->dirty = false;
 115
 116                 $session->set( 1, 'one' );
 117                 $this->assertEquals( 'one', $backend->data[1] );
 118                 $this->assertTrue( $backend->dirty );
 119                 $backend->dirty = false;
 120
 121                 $session->set( 1, 'one' );
 122                 $this->assertFalse( $backend->dirty );
 123
 124                 $this->assertTrue( $session->exists( 'foo' ) );
 125                 $this->assertTrue( $session->exists( 1 ) );
 126                 $this->assertFalse( $session->exists( 'null' ) );
 127                 $this->assertFalse( $session->exists( 100 ) );
 128                 $this->assertFalse( $backend->dirty );
 129
 130                 $session->remove( 'foo' );
 131                 $this->assertArrayNotHasKey( 'foo', $backend->data );
 132                 $this->assertTrue( $backend->dirty );
 133                 $backend->dirty = false;
 134                 $session->remove( 1 );
 135                 $this->assertArrayNotHasKey( 1, $backend->data );
 136                 $this->assertTrue( $backend->dirty );
 137                 $backend->dirty = false;
 138
 139                 $session->remove( 101 );
 140                 $this->assertFalse( $backend->dirty );
 141
 142                 $backend->data = [ 'a', 'b', '?' => 'c' ];
 143                 $this->assertSame( 3, $session->count() );
 144                 $this->assertSame( 3, count( $session ) );
 145                 $this->assertFalse( $backend->dirty );
 146
 147                 $data = [];
 148                 foreach ( $session as $key => $value ) {
 149                         $data[$key] = $value;
 150                 }
 151                 $this->assertEquals( $backend->data, $data );
 152                 $this->assertFalse( $backend->dirty );
 153
 154                 $this->assertEquals( $backend->data, iterator_to_array( $session ) );
 155                 $this->assertFalse( $backend->dirty );
 156         }
 157
 158         public function testArrayAccess() {
 159                 $logger = new \TestLogger;
 160                 $session = TestUtils::getDummySession( null, -1, $logger );
 161                 $backend = TestingAccessWrapper::newFromObject( $session )->backend;
 162
 163                 $this->assertEquals( 1, $session['foo'] );
 164                 $this->assertEquals( 'zero', $session[0] );
 165                 $this->assertFalse( $backend->dirty );
 166
 167                 $logger->setCollect( true );
 168                 $this->assertEquals( null, $session['null'] );
 169                 $logger->setCollect( false );
 170                 $this->assertFalse( $backend->dirty );
 171                 $this->assertSame( [
 172                         [ LogLevel::DEBUG, 'Undefined index (auto-adds to session with a null value): null' ]
 173                 ], $logger->getBuffer() );
 174                 $logger->clearBuffer();
 175
 176                 $session['foo'] = 55;
 177                 $this->assertEquals( 55, $backend->data['foo'] );
 178                 $this->assertTrue( $backend->dirty );
 179                 $backend->dirty = false;
 180
 181                 $session[1] = 'one';
 182                 $this->assertEquals( 'one', $backend->data[1] );
 183                 $this->assertTrue( $backend->dirty );
 184                 $backend->dirty = false;
 185
 186                 $session[1] = 'one';
 187                 $this->assertFalse( $backend->dirty );
 188
 189                 $session['bar'] = [ 'baz' => [] ];
 190                 $session['bar']['baz']['quux'] = 2;
 191                 $this->assertEquals( [ 'baz' => [ 'quux' => 2 ] ], $backend->data['bar'] );
 192
 193                 $logger->setCollect( true );
 194                 $session['bar2']['baz']['quux'] = 3;
 195                 $logger->setCollect( false );
 196                 $this->assertEquals( [ 'baz' => [ 'quux' => 3 ] ], $backend->data['bar2'] );
 197                 $this->assertSame( [
 198                         [ LogLevel::DEBUG, 'Undefined index (auto-adds to session with a null value): bar2' ]
 199                 ], $logger->getBuffer() );
 200                 $logger->clearBuffer();
 201
 202                 $backend->dirty = false;
 203                 $this->assertTrue( isset( $session['foo'] ) );
 204                 $this->assertTrue( isset( $session[1] ) );
 205                 $this->assertFalse( isset( $session['null'] ) );
 206                 $this->assertFalse( isset( $session['missing'] ) );
 207                 $this->assertFalse( isset( $session[100] ) );
 208                 $this->assertFalse( $backend->dirty );
 209
 210                 unset( $session['foo'] );
 211                 $this->assertArrayNotHasKey( 'foo', $backend->data );
 212                 $this->assertTrue( $backend->dirty );
 213                 $backend->dirty = false;
 214                 unset( $session[1] );
 215                 $this->assertArrayNotHasKey( 1, $backend->data );
 216                 $this->assertTrue( $backend->dirty );
 217                 $backend->dirty = false;
 218
 219                 unset( $session[101] );
 220                 $this->assertFalse( $backend->dirty );
 221         }
 222
 223         public function testTokens() {
 224                 $session = TestUtils::getDummySession();
 225                 $priv = TestingAccessWrapper::newFromObject( $session );
 226                 $backend = $priv->backend;
 227
 228                 $token = TestingAccessWrapper::newFromObject( $session->getToken() );
 229                 $this->assertArrayHasKey( 'wsTokenSecrets', $backend->data );
 230                 $this->assertArrayHasKey( 'default', $backend->data['wsTokenSecrets'] );
 231                 $secret = $backend->data['wsTokenSecrets']['default'];
 232                 $this->assertSame( $secret, $token->secret );
 233                 $this->assertSame( '', $token->salt );
 234                 $this->assertTrue( $token->wasNew() );
 235
 236                 $token = TestingAccessWrapper::newFromObject( $session->getToken( 'foo' ) );
 237                 $this->assertSame( $secret, $token->secret );
 238                 $this->assertSame( 'foo', $token->salt );
 239                 $this->assertFalse( $token->wasNew() );
 240
 241                 $backend->data['wsTokenSecrets']['secret'] = 'sekret';
 242                 $token = TestingAccessWrapper::newFromObject(
 243                         $session->getToken( [ 'bar', 'baz' ], 'secret' )
 244                 );
 245                 $this->assertSame( 'sekret', $token->secret );
 246                 $this->assertSame( 'bar|baz', $token->salt );
 247                 $this->assertFalse( $token->wasNew() );
 248
 249                 $session->resetToken( 'secret' );
 250                 $this->assertArrayHasKey( 'wsTokenSecrets', $backend->data );
 251                 $this->assertArrayHasKey( 'default', $backend->data['wsTokenSecrets'] );
 252                 $this->assertArrayNotHasKey( 'secret', $backend->data['wsTokenSecrets'] );
 253
 254                 $session->resetAllTokens();
 255                 $this->assertArrayNotHasKey( 'wsTokenSecrets', $backend->data );
 256         }
 257
 258 }