tests/phpunit/includes/sparql/SparqlClientTest.php

   1 <?php
   2
   3 namespace MediaWiki\Sparql;
   4
   5 use Http;
   6 use MediaWiki\Http\HttpRequestFactory;
   7 use MWHttpRequest;
   8 use PHPUnit4And6Compat;
   9
  10 /**
  11  * @covers \MediaWiki\Sparql\SparqlClient
  12  */
  13 class SparqlClientTest extends \PHPUnit\Framework\TestCase {
  14
  15         use PHPUnit4And6Compat;
  16
  17         private function getRequestFactory( $request ) {
  18                 $requestFactory = $this->getMock( HttpRequestFactory::class );
  19                 $requestFactory->method( 'create' )->willReturn( $request );
  20                 return $requestFactory;
  21         }
  22
  23         private function getRequestMock( $content ) {
  24                 $request = $this->getMockBuilder( MWHttpRequest::class )->disableOriginalConstructor()->getMock();
  25                 $request->method( 'execute' )->willReturn( \Status::newGood( 200 ) );
  26                 $request->method( 'getContent' )->willReturn( $content );
  27                 return $request;
  28         }
  29
  30         public function testQuery() {
  31                 $json = <<<JSON
  32 {
  33   "head" : {
  34     "vars" : [ "x", "y", "z" ]
  35   },
  36   "results" : {
  37     "bindings" : [ {
  38       "x" : {
  39         "type" : "uri",
  40         "value" : "http://wikiba.se/ontology#Dump"
  41       },
  42       "y" : {
  43         "type" : "uri",
  44         "value" : "http://creativecommons.org/ns#license"
  45       },
  46       "z" : {
  47         "type" : "uri",
  48         "value" : "http://creativecommons.org/publicdomain/zero/1.0/"
  49       }
  50     }, {
  51       "x" : {
  52         "type" : "uri",
  53         "value" : "http://wikiba.se/ontology#Dump"
  54       },
  55       "z" : {
  56         "type" : "literal",
  57         "value" : "0.1.0"
  58       }
  59     } ]
  60   }
  61 }
  62 JSON;
  63
  64                 $request = $this->getRequestMock( $json );
  65                 $client = new SparqlClient( 'http://acme.test/', $this->getRequestFactory( $request ) );
  66
  67                 // values only
  68                 $result = $client->query( "TEST SPARQL" );
  69                 $this->assertCount( 2, $result );
  70                 $this->assertEquals( 'http://wikiba.se/ontology#Dump', $result[0]['x'] );
  71                 $this->assertEquals( 'http://creativecommons.org/ns#license', $result[0]['y'] );
  72                 $this->assertEquals( '0.1.0', $result[1]['z'] );
  73                 $this->assertNull( $result[1]['y'] );
  74                 // raw data format
  75                 $result = $client->query( "TEST SPARQL 2", true );
  76                 $this->assertCount( 2, $result );
  77                 $this->assertEquals( 'uri', $result[0]['x']['type'] );
  78                 $this->assertEquals( 'http://wikiba.se/ontology#Dump', $result[0]['x']['value'] );
  79                 $this->assertEquals( 'literal', $result[1]['z']['type'] );
  80                 $this->assertEquals( '0.1.0', $result[1]['z']['value'] );
  81                 $this->assertNull( $result[1]['y'] );
  82         }
  83
  84         /**
  85          * @expectedException \Mediawiki\Sparql\SparqlException
  86          */
  87         public function testBadQuery() {
  88                 $request = $this->getMockBuilder( MWHttpRequest::class )->disableOriginalConstructor()->getMock();
  89                 $client = new SparqlClient( 'http://acme.test/', $this->getRequestFactory( $request ) );
  90
  91                 $request->method( 'execute' )->willReturn( \Status::newFatal( "Bad query" ) );
  92                 $result = $client->query( "TEST SPARQL 3" );
  93         }
  94
  95         public function optionsProvider() {
  96                 return [
  97                         'defaults' => [
  98                                 'TEST тест SPARQL 4 ',
  99                                 null,
 100                                 null,
 101                                 [
 102                                         'http://acme.test/',
 103                                         'query=TEST+%D1%82%D0%B5%D1%81%D1%82+SPARQL+4+',
 104                                         'format=json',
 105                                         'maxQueryTimeMillis=30000',
 106                                 ],
 107                                 [
 108                                         'method' => 'GET',
 109                                         'userAgent' => Http::userAgent() . " SparqlClient",
 110                                         'timeout' => 30
 111                                 ]
 112                         ],
 113                         'big query' => [
 114                                 str_repeat( 'ZZ', SparqlClient::MAX_GET_SIZE ),
 115                                 null,
 116                                 null,
 117                                 [
 118                                         'format=json',
 119                                         'maxQueryTimeMillis=30000',
 120                                 ],
 121                                 [
 122                                         'method' => 'POST',
 123                                         'postData' => 'query=' . str_repeat( 'ZZ', SparqlClient::MAX_GET_SIZE ),
 124                                 ]
 125                         ],
 126                         'timeout 1s' => [
 127                                 'TEST SPARQL 4',
 128                                 null,
 129                                 1,
 130                                 [
 131                                         'maxQueryTimeMillis=1000',
 132                                 ],
 133                                 [
 134                                         'timeout' => 1
 135                                 ]
 136                         ],
 137                         'more options' => [
 138                                 'TEST SPARQL 5',
 139                                 [
 140                                         'userAgent' => 'My Test',
 141                                         'randomOption' => 'duck',
 142                                 ],
 143                                 null,
 144                                 [],
 145                                 [
 146                                         'userAgent' => 'My Test',
 147                                         'randomOption' => 'duck',
 148                                 ]
 149                         ],
 150
 151                 ];
 152         }
 153
 154         /**
 155          * @dataProvider  optionsProvider
 156          * @param string $sparql
 157          * @param array|null $options
 158          * @param int|null $timeout
 159          * @param array $expectedUrl
 160          * @param array $expectedOptions
 161          */
 162         public function testOptions( $sparql, $options, $timeout, $expectedUrl, $expectedOptions ) {
 163                 $requestFactory = $this->getMock( HttpRequestFactory::class );
 164                 $client = new SparqlClient( 'http://acme.test/',  $requestFactory );
 165
 166                 $request = $this->getRequestMock( '{}' );
 167
 168                 $requestFactory->method( 'create' )->willReturnCallback(
 169                         function ( $url, $options ) use ( $request, $expectedUrl, $expectedOptions ) {
 170                                 foreach ( $expectedUrl as $eurl ) {
 171                                         $this->assertContains( $eurl, $url );
 172                                 }
 173                                 foreach ( $expectedOptions as $ekey => $evalue ) {
 174                                         $this->assertArrayHasKey( $ekey, $options );
 175                                         $this->assertEquals( $options[$ekey], $evalue );
 176                                 }
 177                                 return $request;
 178                         }
 179                 );
 180
 181                 if ( !is_null( $options ) ) {
 182                         $client->setClientOptions( $options );
 183                 }
 184                 if ( !is_null( $timeout ) ) {
 185                         $client->setTimeout( $timeout );
 186                 }
 187
 188                 $result = $client->query( $sparql );
 189         }
 190
 191 }