Merge pull request #117 from microsoftgraph/dev

2.0.0-RC9

Author: SilasKenneth

.github/CODEOWNERS

@@ -1 +1 @@
-* @ddyett @MichaelMainer @nikithauc @zengin @silaskenneth @Ndiritu @shemogumbe
+* @microsoftgraph/msgraph-devx-php-write

src/GraphConstants.php

@@ -25,7 +25,7 @@ final class GraphConstants
     const REST_ENDPOINT = "https://graph.microsoft.com/";
 
     // Define HTTP request constants
-    const SDK_VERSION = "2.0.0-RC7";
+    const SDK_VERSION = "2.0.0-RC8";
 
     // Define error constants
     const MAX_PAGE_SIZE = 999;

src/Models/PageResult.php

@@ -2,12 +2,16 @@
 
 namespace Microsoft\Graph\Core\Models;
 
-class PageResult
+use Microsoft\Kiota\Abstractions\Serialization\Parsable;
+use Microsoft\Kiota\Abstractions\Serialization\ParseNode;
+use Microsoft\Kiota\Abstractions\Serialization\SerializationWriter;
+
+class PageResult implements Parsable
 {
     /** @var string|null $odataNextLink */
-    private ?string $odataNextLink;
+    private ?string $odataNextLink = null;
     /** @var array<mixed>|null $value  */
-    private ?array $value;
+    private ?array $value = null;
 
     /**
      * @return string|null
@@ -36,4 +40,23 @@ public function setOdataNextLink(?string $nextLink): void{
     public function setValue(?array $value): void {
         $this->value = $value;
     }
+
+    public function createFromDiscriminatorValue(ParseNode $parseNode): PageResult
+    {
+        return new PageResult();
+    }
+
+    public function getFieldDeserializers(): array
+    {
+        return [
+            '@odata.nextLink' => fn (ParseNode $parseNode) => $this->setOdataNextLink($parseNode->getStringValue()),
+            'value' => fn (ParseNode $parseNode) => $this->setValue($parseNode->getCollectionOfPrimitiveValues())
+        ];
+    }
+
+    public function serialize(SerializationWriter $writer): void
+    {
+        $writer->writeStringValue('@odata.nextLink', $this->getOdataNextLink());
+        $writer->writeAnyValue('value', $this->getValue());
+    }
 }

src/Tasks/PageIterator.php

@@ -26,7 +26,7 @@ class PageIterator
     private bool $hasNext = false;
     private int $pauseIndex;
     /**
-     * @var array{class-string<T>, string} $constructorCallable
+     * @var array{class-string<Parsable>, string} $constructorCallable
     */
     private array $constructorCallable;
     /** @var RequestHeaders */
@@ -37,12 +37,18 @@ class PageIterator
     /**
      * @param Parsable|array<mixed>|object|null $response paged collection response
      * @param RequestAdapter $requestAdapter
-     * @param array{class-string<T>,string} $constructorCallable The method to construct a paged response object.
+     * @param array{class-string<Parsable>,string}|null $constructorCallable
+     * The method to construct a paged response object.
      * @throws JsonException
      */
-    public function __construct($response, RequestAdapter $requestAdapter, array $constructorCallable)
+    public function __construct($response, RequestAdapter $requestAdapter, ?array $constructorCallable = null)
     {
         $this->requestAdapter = $requestAdapter;
+        if ($response instanceof Parsable && !$constructorCallable) {
+            $constructorCallable = [get_class($response), 'createFromDiscriminatorValue'];
+        } elseif ($constructorCallable === null) {
+            $constructorCallable = [PageResult::class, 'createFromDiscriminatorValue'];
+        }
         $this->constructorCallable = $constructorCallable;
         $this->pauseIndex = 0;
         $this->headers = new RequestHeaders();
@@ -131,8 +137,8 @@ public static function convertToPage($response): ?PageResult
 
         $value = null;
         if (is_array($response)) {
-            $value = $response['value'];
-        } elseif (is_object($response) && is_a($response, Parsable::class) &&
+            $value = $response['value'] ?? ['value' => []];
+        } elseif ($response instanceof Parsable &&
             method_exists($response, 'getValue')) {
             $value = $response->getValue();
         } elseif (is_object($response)) {
@@ -143,11 +149,10 @@ public static function convertToPage($response): ?PageResult
             throw new InvalidArgumentException('The response does not contain a value.');
         }
 
-        $parsablePage =  (is_object($response) && is_a($response, Parsable::class)) ? $response : json_decode(json_encode($response,JSON_THROW_ON_ERROR), true);
+        $parsablePage =  ($response instanceof Parsable) ? $response : json_decode(json_encode($response, JSON_THROW_ON_ERROR), true);
         if (is_array($parsablePage)) {
             $page->setOdataNextLink($parsablePage['@odata.nextLink'] ?? '');
-        } elseif (is_object($parsablePage) &&
-            is_a($parsablePage, Parsable::class) &&
+        } elseif ($parsablePage instanceof Parsable &&
             method_exists($parsablePage, 'getOdataNextLink')) {
             $page->setOdataNextLink($parsablePage->getOdataNextLink());
         }

tests/Authentication/GraphPhpLeagueAccessTokenProviderTest.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Microsoft\Graph\Core\Test\Authentication;
+
+use Microsoft\Graph\Core\Authentication\GraphPhpLeagueAccessTokenProvider;
+use Microsoft\Kiota\Authentication\Oauth\ClientCredentialContext;
+use PHPUnit\Framework\TestCase;
+
+class GraphPhpLeagueAccessTokenProviderTest extends TestCase
+{
+    public function testSuccessfullyInitializesClass(): void
+    {
+        $context = new ClientCredentialContext('tenant', 'clientId', 'secret');
+        $leagueAccessTokenProvider = new GraphPhpLeagueAccessTokenProvider($context, []);
+        $this->assertNotEmpty($leagueAccessTokenProvider->getAllowedHostsValidator()->getAllowedHosts());
+    }
+
+}

tests/Authentication/GraphPhpLeagueAuthenticationProviderTest.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Microsoft\Graph\Core\Test\Authentication;
+
+use Microsoft\Graph\Core\Authentication\GraphPhpLeagueAccessTokenProvider;
+use Microsoft\Graph\Core\Authentication\GraphPhpLeagueAuthenticationProvider;
+use Microsoft\Kiota\Authentication\Oauth\ClientCredentialContext;
+use PHPUnit\Framework\TestCase;
+
+class GraphPhpLeagueAuthenticationProviderTest extends TestCase
+{
+    public function testSuccessfullyInitializesClass(): void
+    {
+        $context = new ClientCredentialContext('tenant', 'clientId', 'secret');
+        $leagueAuthProvider = new GraphPhpLeagueAuthenticationProvider($context, []);
+        $this->assertNotEmpty($leagueAuthProvider->getAccessTokenProvider()->getAllowedHostsValidator()->getAllowedHosts());
+    }
+}

tests/Middleware/GraphTelemetryHandlerTest.php

@@ -2,15 +2,19 @@
 
 namespace Microsoft\Graph\Core\Core\Test\Middleware;
 
+use GuzzleHttp\Exception\GuzzleException;
 use GuzzleHttp\Handler\MockHandler;
 use GuzzleHttp\HandlerStack;
 use GuzzleHttp\Psr7\Response;
+use GuzzleHttp\Psr7\Utils;
 use Microsoft\Graph\Core\GraphConstants;
 use Microsoft\Graph\Core\GraphClientFactory;
 use Microsoft\Graph\Core\Middleware\GraphMiddleware;
 use Microsoft\Graph\Core\Middleware\Option\GraphTelemetryOption;
+use Microsoft\Kiota\Http\Middleware\Options\CompressionOption;
 use PHPUnit\Framework\TestCase;
 use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseInterface;
 
 class GraphTelemetryHandlerTest extends TestCase
 {
@@ -107,4 +111,39 @@ private function executeMockRequestWithGraphTelemetryHandler(array $mockResponse
         $guzzleClient = GraphClientFactory::createWithMiddleware($handlerStack);
         return $guzzleClient->get("/", $requestOptions);
     }
+    /**
+     * @throws GuzzleException
+     */
+    public function testRequestOptionsOverrideForCompression(): void
+    {
+        $compressionOption = new CompressionOption([CompressionOption::gzip()]);
+        $requestOptions = [
+            CompressionOption::class => $compressionOption,
+            'body' => Utils::streamFor("{Some JSOn}")
+        ];
+        $mockResponse = [
+            function (RequestInterface $request) {
+                $this->assertTrue($request->hasHeader('Content-Encoding'));
+                $this->assertEquals("gzip", $request->getHeaderLine('Content-Encoding'));
+                return new Response(200);
+            }
+        ];
+        $this->executeMockRequestWithCompressionHandler($mockResponse, $compressionOption, $requestOptions);
+    }
+    /**
+     * @param array<mixed> $mockResponses
+     * @param CompressionOption|null $compressionOption
+     * @param array<string, mixed> $requestOptions
+     * @return ResponseInterface
+     * @throws GuzzleException
+     */
+    private function executeMockRequestWithCompressionHandler(array $mockResponses, ?CompressionOption $compressionOption = null, array $requestOptions = []): ResponseInterface
+    {
+        $mockHandler = new MockHandler($mockResponses);
+        $handlerStack = new HandlerStack($mockHandler);
+        $handlerStack->push(GraphMiddleware::compression($compressionOption));
+
+        $guzzleClient = GraphClientFactory::createWithMiddleware($handlerStack);
+        return $guzzleClient->post("/", $requestOptions);
+    }
 }

tests/Models/PageResultTest.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Microsoft\Graph\Core\Test\Models;
+
+use Microsoft\Graph\Core\Models\PageResult;
+use Microsoft\Kiota\Serialization\Json\JsonSerializationWriter;
+use Microsoft\Kiota\Serialization\Json\JsonSerializationWriterFactory;
+use PHPUnit\Framework\TestCase;
+
+class PageResultTest extends TestCase
+{
+    public function testCanSetAndGetValues(): void {
+        $pageResult = new PageResult();
+        $writer = (new JsonSerializationWriterFactory())->getSerializationWriter('application/json');
+        $pageResult->setValue([['name' => 'Kenny'], ['name' => 'James']]);
+        $this->assertCount(2, $pageResult->getValue());
+        $pageResult->setOdataNextLink('nextPage');
+        $this->assertEquals('nextPage', $pageResult->getOdataNextLink());
+        $pageResult->serialize($writer);
+
+        $this->assertEquals('"@odata.nextLink":"nextPage","value":[{"name":"Kenny"},{"name":"James"}]', $writer->getSerializedContent()->getContents());
+    }
+}

tests/Tasks/PageIteratorTest.php

@@ -6,6 +6,7 @@
 use GuzzleHttp\Exception\GuzzleException;
 use GuzzleHttp\Handler\MockHandler;
 use GuzzleHttp\HandlerStack;
+use GuzzleHttp\Promise\Promise;
 use GuzzleHttp\Psr7\Response;
 use GuzzleHttp\Psr7\Utils;
 use Http\Promise\FulfilledPromise;
@@ -24,6 +25,7 @@ class PageIteratorTest extends TestCase
     private Client $testClient;
     private RequestAdapter $mockRequestAdapter;
     private RequestInformation $requestInfoMock;
+    private ?array $nextPageContent = null;
     private $firstPageContent;
 
     /**
@@ -104,7 +106,7 @@ protected function setUp(): void {
             }
             ';
         $this->mockRequestAdapter->method('sendAsync')
-            ->willReturn($usersPage);
+            ->willReturn(($this->nextPageContent !== null ? new FulfilledPromise($this->nextPageContent) : $usersPage));
         $this->mock = new MockHandler([
             new Response(200, ['X-Foo' => 'Bar'], $firstPageData),
         ]);
@@ -119,7 +121,7 @@ protected function setUp(): void {
     public function testHandlerCanWork(): void {
         $pageIterator = new PageIterator($this->firstPageContent, $this->mockRequestAdapter, [UsersResponse::class, 'createFromDiscriminator']);
         $count = 0;
-        $pageIterator->iterate(function ($value) use (&$count)  {
+        $pageIterator->iterate(function () use (&$count)  {
             $count++;
             return true;
         });
@@ -147,6 +149,10 @@ public function testCanResumeIteration(): void{
         $this->assertEquals(4, $count);
     }
 
+    /**
+     * @throws \JsonException
+     * @throws \Exception
+     */
     public function testCanPauseIteration(): void {
         $pageIterator = new PageIterator($this->firstPageContent, $this->mockRequestAdapter, [UsersResponse::class, 'createFromDiscriminator']);
         $count = 0;
@@ -179,4 +185,43 @@ public function testCanDeserializeUsingCallback(): void {
 
         $this->assertInstanceOf(User::class, $usersArray[0]);
     }
+
+    /**
+     * @throws \Exception
+     */
+    public function testCanPaginateWithoutCallableClass(): void {
+        $pageIterator = new PageIterator($this->firstPageContent, $this->mockRequestAdapter);
+        $count = 0;
+        $usersArray = [];
+        $pageIterator->iterate(function ($value) use (&$count,&$usersArray)  {
+            $parseNode = new JsonParseNode($value);
+            /** @var User $user */
+            $user = $parseNode->getObjectValue([User::class, 'createFromDiscriminator']);
+            $usersArray []= $user;
+            $count++;
+            return true;
+        });
+
+        $this->assertInstanceOf(User::class, $usersArray[0]);
+    }
+
+    /**
+     * @throws \JsonException
+     * @throws \Exception
+     */
+    public function testCanGetFromParsablePageObject(): void
+    {
+        $parsable = (new JsonParseNode($this->firstPageContent))->getObjectValue([UsersResponse::class, 'createFromDiscriminator']);
+        $pageIterator = new PageIterator($parsable, $this->mockRequestAdapter, [UsersResponse::class, 'createFromDiscriminator']);
+        $count = 0;
+        $this->nextPageContent = [];
+        $data = [];
+        $pageIterator->iterate(static function($value) use (&$count, &$data) {
+            $data []= $value;
+            $count++;
+            return $count < 2;
+        });
+        $this->assertEquals(2, $count);
+        $this->assertInstanceOf(User::class, $data[0]);
+    }
 }

tests/Tasks/UsersResponse.php

@@ -8,31 +8,32 @@
 
 class UsersResponse implements Parsable
 {
-    public ?string $nextLink = null;
+    public ?string $odataNextLink = null;
+    /** @phpstan-ignore-next-line */
     public ?array $value = null;
     public function getFieldDeserializers(): array
     {
         return [
-            '@odata.nextLink' => fn (ParseNode $p) => $this->setNextLink($p->getStringValue()),
+            '@odata.nextLink' => fn (ParseNode $p) => $this->setOdataNextLink($p->getStringValue()),
             'value' => fn (ParseNode $p) => $this->setValue($p->getCollectionOfObjectValues([User::class, 'createFromDiscriminator']))
         ];
     }
 
     public function serialize(SerializationWriter $writer): void
     {
-        $writer->writeStringValue('@odata.nextLink', $this->nextLink);
+        $writer->writeStringValue('@odata.nextLink', $this->odataNextLink);
         $writer->writeCollectionOfObjectValues('value', $this->value);
     }
 
     /**
      * @param string|null $nextLink
      */
-    public function setNextLink(?string $nextLink): void {
-        $this->nextLink = $nextLink;
+    public function setOdataNextLink(?string $nextLink): void {
+        $this->odataNextLink = $nextLink;
     }
 
     /**
-     * @param array|null $value
+     * @param array<mixed>|null $value
      */
     public function setValue(?array $value): void {
         $this->value = $value;
@@ -41,4 +42,20 @@ public function setValue(?array $value): void {
     public static function createFromDiscriminator(ParseNode $parseNode): UsersResponse {
         return new UsersResponse();
     }
+
+    /**
+     * @return string|null
+     */
+    public function getOdataNextLink(): ?string
+    {
+        return $this->odataNextLink;
+    }
+
+    /**
+     * @return array<mixed>|null
+     */
+    public function getValue(): ?array
+    {
+        return $this->value;
+    }
 }