MWRestrictionsTest.php

Go to the documentation of this file.

<?php
class MWRestrictionsTest extends PHPUnit_Framework_TestCase {
 
    protected static $restrictionsForChecks;
 
    public static function setUpBeforeClass() {
        self::$restrictionsForChecks = MWRestrictions::newFromArray( [
            'IPAddresses' => [
                '10.0.0.0/8',
                '172.16.0.0/12',
                '2001:db8::/33',
            ]
        ] );
    }
 
    public function testNewDefault() {
        $ret = MWRestrictions::newDefault();
        $this->assertInstanceOf( 'MWRestrictions', $ret );
        $this->assertSame(
            '{"IPAddresses":["0.0.0.0/0","::/0"]}',
            $ret->toJson()
        );
    }
 
    public function testArray( $data, $expect ) {
        if ( $expect === true ) {
            $ret = MWRestrictions::newFromArray( $data );
            $this->assertInstanceOf( 'MWRestrictions', $ret );
            $this->assertSame( $data, $ret->toArray() );
        } else {
            try {
                MWRestrictions::newFromArray( $data );
                $this->fail( 'Expected exception not thrown' );
            } catch ( InvalidArgumentException $ex ) {
                $this->assertEquals( $expect, $ex );
            }
        }
    }
 
    public static function provideArray() {
        return [
            [ [ 'IPAddresses' => [] ], true ],
            [ [ 'IPAddresses' => [ '127.0.0.1/32' ] ], true ],
            [
                [ 'IPAddresses' => [ '256.0.0.1/32' ] ],
                new InvalidArgumentException( 'Invalid IP address: 256.0.0.1/32' )
            ],
            [
                [ 'IPAddresses' => '127.0.0.1/32' ],
                new InvalidArgumentException( 'IPAddresses is not an array' )
            ],
            [
                [],
                new InvalidArgumentException( 'Array is missing required keys: IPAddresses' )
            ],
            [
                [ 'foo' => 'bar', 'bar' => 42 ],
                new InvalidArgumentException( 'Array contains invalid keys: foo, bar' )
            ],
        ];
    }
 
    public function testJson( $json, $expect ) {
        if ( is_array( $expect ) ) {
            $ret = MWRestrictions::newFromJson( $json );
            $this->assertInstanceOf( 'MWRestrictions', $ret );
            $this->assertSame( $expect, $ret->toArray() );
 
            $this->assertSame( $json, $ret->toJson( false ) );
            $this->assertSame( $json, (string)$ret );
 
            $this->assertSame(
                FormatJson::encode( $expect, true, FormatJson::ALL_OK ),
                $ret->toJson( true )
            );
        } else {
            try {
                MWRestrictions::newFromJson( $json );
                $this->fail( 'Expected exception not thrown' );
            } catch ( InvalidArgumentException $ex ) {
                $this->assertTrue( true );
            }
        }
    }
 
    public static function provideJson() {
        return [
            [
                '{"IPAddresses":[]}',
                [ 'IPAddresses' => [] ]
            ],
            [
                '{"IPAddresses":["127.0.0.1/32"]}',
                [ 'IPAddresses' => [ '127.0.0.1/32' ] ]
            ],
            [
                '{"IPAddresses":["256.0.0.1/32"]}',
                new InvalidArgumentException( 'Invalid IP address: 256.0.0.1/32' )
            ],
            [
                '{"IPAddresses":"127.0.0.1/32"}',
                new InvalidArgumentException( 'IPAddresses is not an array' )
            ],
            [
                '{}',
                new InvalidArgumentException( 'Array is missing required keys: IPAddresses' )
            ],
            [
                '{"foo":"bar","bar":42}',
                new InvalidArgumentException( 'Array contains invalid keys: foo, bar' )
            ],
            [
                '{"IPAddresses":[]',
                new InvalidArgumentException( 'Invalid restrictions JSON' )
            ],
            [
                '"IPAddresses"',
                new InvalidArgumentException( 'Invalid restrictions JSON' )
            ],
        ];
    }
 
    public function testCheckIP( $ip, $pass ) {
        $this->assertSame( $pass, self::$restrictionsForChecks->checkIP( $ip ) );
    }
 
    public static function provideCheckIP() {
        return [
            [ '10.0.0.1', true ],
            [ '172.16.0.0', true ],
            [ '192.0.2.1', false ],
            [ '2001:db8:1::', true ],
            [ '2001:0db8:0000:0000:0000:0000:0000:0000', true ],
            [ '2001:0DB8:8000::', false ],
        ];
    }
 
    public function testCheck( $request, $expect ) {
        $this->assertEquals( $expect, self::$restrictionsForChecks->check( $request ) );
    }
 
    public function provideCheck() {
        $ret = [];
 
        $mockBuilder = $this->getMockBuilder( 'FauxRequest' )
            ->setMethods( [ 'getIP' ] );
 
        foreach ( self::provideCheckIP() as $checkIP ) {
            $ok = [];
            $request = $mockBuilder->getMock();
 
            $request->expects( $this->any() )->method( 'getIP' )
                ->will( $this->returnValue( $checkIP[0] ) );
            $ok['ip'] = $checkIP[1];
 
            /* If we ever add more restrictions, add nested for loops here:
             *  foreach ( self::provideCheckFoo() as $checkFoo ) {
             *      $request->expects( $this->any() )->method( 'getFoo' )
             *          ->will( $this->returnValue( $checkFoo[0] );
             *      $ok['foo'] = $checkFoo[1];
             *
             *      foreach ( self::provideCheckBar() as $checkBar ) {
             *          $request->expects( $this->any() )->method( 'getBar' )
             *              ->will( $this->returnValue( $checkBar[0] );
             *          $ok['bar'] = $checkBar[1];
             *
             *          // etc.
             *      }
             *  }
             */
 
            $status = Status::newGood();
            $status->setResult( $ok === array_filter( $ok ), $ok );
            $ret[] = [ $request, $status ];
        }
 
        return $ret;
    }
}