tests/phpunit/includes/sparql/SparqlClientTest.php

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