AC-12092_PHPUnit10: PHP Unit10 Deprecation Fixes for Framework Code, Jwt and Test Modules

Author: Raj Mohan

lib/internal/Magento/Framework/Code/Test/Unit/GeneratorTest.php

@@ -341,10 +341,15 @@ public static function trueFalseDataProvider(): array
      *
      * @return array
      */
-    public function generateValidClassDataProvider(): array
+    public static function generateValidClassDataProvider(): array
     {
+        $expectedEntities = [
+            'factory' => Factory::ENTITY_TYPE,
+            'proxy' => Proxy::ENTITY_TYPE,
+            'interceptor' => Interceptor::ENTITY_TYPE,
+        ];
         $data = [];
-        foreach ($this->expectedEntities as $generatedEntity) {
+        foreach ($expectedEntities as $generatedEntity) {
             $generatedEntity = ucfirst($generatedEntity);
             $data['test class for ' . $generatedEntity] = [
                 'className' => self::SOURCE_CLASS,

lib/internal/Magento/Framework/Jwt/Test/Unit/Jwe/JweEncryptionJwksTest.php

@@ -18,27 +18,27 @@
 
 class JweEncryptionJwksTest extends TestCase
 {
-    public function getConstructorCases(): array
+    public static function getConstructorCases(): array
     {
         return [
-            'valid-jwk' => [$this->createJwk(Jwk::PUBLIC_KEY_USE_ENCRYPTION), true],
+            'valid-jwk' => [['use' => Jwk::PUBLIC_KEY_USE_ENCRYPTION], true],
             'valid-jwks' => [
-                $this->createJwkSet(
+                [
                     [
-                        $this->createJwk(Jwk::PUBLIC_KEY_USE_ENCRYPTION),
-                        $this->createJwk(Jwk::PUBLIC_KEY_USE_ENCRYPTION)
+                        ['use' => Jwk::PUBLIC_KEY_USE_ENCRYPTION],
+                        ['use' => Jwk::PUBLIC_KEY_USE_ENCRYPTION]
                     ]
-                ),
+                ],
                 true
             ],
-            'invalid-jwk' => [$this->createJwk(Jwk::PUBLIC_KEY_USE_SIGNATURE), false],
+            'invalid-jwk' => [['use' => Jwk::PUBLIC_KEY_USE_SIGNATURE], false],
             'invalid-jwks' => [
-                $this->createJwkSet(
+                [
                     [
-                        $this->createJwk(Jwk::PUBLIC_KEY_USE_SIGNATURE),
-                        $this->createJwk(Jwk::PUBLIC_KEY_USE_ENCRYPTION)
+                        ['use' => Jwk::PUBLIC_KEY_USE_SIGNATURE],
+                        ['use' => Jwk::PUBLIC_KEY_USE_ENCRYPTION]
                     ]
-                ),
+                ],
                 false
             ]
         ];
@@ -52,29 +52,39 @@ public function getConstructorCases(): array
      * @return void
      * @dataProvider getConstructorCases
      */
-    public function testConstruct($jwks, $valid): void
+    public function testConstruct(array $jwkData, bool $valid): void
     {
+        if (isset($jwkData[0]) && is_array($jwkData[0])) {
+            $jwks = array_map(function ($data) {
+                return $this->createJwk($data['use']);
+            }, $jwkData[0]);
+            $jwkSet = $this->createJwkSet($jwks);
+            $jwksObject = $jwkSet;
+        } else {
+            $jwksObject = $this->createJwk($jwkData['use']);
+        }
+
         if (!$valid) {
             $this->expectException(EncryptionException::class);
         }
 
-        new JweEncryptionJwks($jwks, JweEncryptionSettingsInterface::CONTENT_ENCRYPTION_ALGO_A128GCM);
+        new JweEncryptionJwks($jwksObject, JweEncryptionSettingsInterface::CONTENT_ENCRYPTION_ALGO_A128GCM);
     }
 
-    public function getAlgorithmCases(): array
+    public static function getAlgorithmCases(): array
     {
         return [
             'one-algo' => [
-                $this->createJwk(Jwk::PUBLIC_KEY_USE_ENCRYPTION, Jwk::ALGORITHM_RSA_OAEP),
+                ['use' => Jwk::PUBLIC_KEY_USE_ENCRYPTION, 'alg' => Jwk::ALGORITHM_RSA_OAEP],
                 Jwk::ALGORITHM_RSA_OAEP
             ],
             'json' => [
-                $this->createJwkSet(
+                [
                     [
-                        $this->createJwk(Jwk::PUBLIC_KEY_USE_ENCRYPTION),
-                        $this->createJwk(Jwk::PUBLIC_KEY_USE_ENCRYPTION)
+                        ['use' => Jwk::PUBLIC_KEY_USE_ENCRYPTION, 'alg' => Jwk::ALGORITHM_RSA_OAEP],
+                        ['use' => Jwk::PUBLIC_KEY_USE_ENCRYPTION, 'alg' => Jwk::ALGORITHM_RSA_OAEP]
                     ]
-                ),
+                ],
                 'jwe-json-serialization'
             ],
         ];
@@ -83,14 +93,23 @@ public function getAlgorithmCases(): array
     /**
      * Test algorithm logic.
      *
-     * @param Jwk|JwkSet $jwk
+     * @param array $jwkData
      * @param string $expectedName
      * @return void
      * @dataProvider getAlgorithmCases
      */
-    public function testGetAlgorithmName($jwk, string $expectedName): void
+    public function testGetAlgorithmName(array $jwkData, string $expectedName): void
     {
-        $model = new JweEncryptionJwks($jwk, JweEncryptionSettingsInterface::CONTENT_ENCRYPTION_ALGO_A128GCM);
+        if (isset($jwkData['use'])) {
+            $jwk = $this->createJwk($jwkData['use'], $jwkData['alg']);
+            $model = new JweEncryptionJwks($jwk, JweEncryptionSettingsInterface::CONTENT_ENCRYPTION_ALGO_A128GCM);
+        } else {
+            $jwks = array_map(function ($data) {
+                return $this->createJwk($data['use'], $data['alg']);
+            }, $jwkData[0]);
+            $jwkSet = $this->createJwkSet($jwks);
+            $model = new JweEncryptionJwks($jwkSet, JweEncryptionSettingsInterface::CONTENT_ENCRYPTION_ALGO_A128GCM);
+        }
 
         $this->assertEquals($expectedName, $model->getAlgorithmName());
     }

lib/internal/Magento/Framework/Jwt/Test/Unit/Jws/JwsSignatureJwksTest.php

@@ -16,27 +16,17 @@
 
 class JwsSignatureJwksTest extends TestCase
 {
-    public function getConstructorCases(): array
+    public static function getConstructorCases(): array
     {
         return [
-            'valid-jwk' => [$this->createJwk(Jwk::PUBLIC_KEY_USE_SIGNATURE), true],
+            'valid-jwk' => [Jwk::PUBLIC_KEY_USE_SIGNATURE, true],
             'valid-jwks' => [
-                $this->createJwkSet(
-                    [
-                        $this->createJwk(Jwk::PUBLIC_KEY_USE_SIGNATURE),
-                        $this->createJwk(Jwk::PUBLIC_KEY_USE_SIGNATURE)
-                    ]
-                ),
+                [Jwk::PUBLIC_KEY_USE_SIGNATURE, Jwk::PUBLIC_KEY_USE_SIGNATURE],
                 true
             ],
-            'invalid-jwk' => [$this->createJwk(Jwk::PUBLIC_KEY_USE_ENCRYPTION), false],
+            'invalid-jwk' => [Jwk::PUBLIC_KEY_USE_ENCRYPTION, false],
             'invalid-jwks' => [
-                $this->createJwkSet(
-                    [
-                        $this->createJwk(Jwk::PUBLIC_KEY_USE_SIGNATURE),
-                        $this->createJwk(Jwk::PUBLIC_KEY_USE_ENCRYPTION)
-                    ]
-                ),
+                [Jwk::PUBLIC_KEY_USE_SIGNATURE, Jwk::PUBLIC_KEY_USE_ENCRYPTION],
                 false
             ]
         ];
@@ -52,42 +42,58 @@ public function getConstructorCases(): array
      */
     public function testConstruct($jwks, $valid): void
     {
+        if (is_array($jwks)) {
+            $jwks = array_map(function ($keyUse) {
+                return $this->createJwk($keyUse);
+            }, $jwks);
+            $jwks = $this->createJwkSet($jwks);
+        } else {
+            $jwks = $this->createJwk($jwks);
+        }
+
         if (!$valid) {
             $this->expectException(EncryptionException::class);
         }
 
         new JwsSignatureJwks($jwks);
     }
 
-    public function getAlgorithmCases(): array
+    public static function getAlgorithmCases(): array
     {
         return [
             'one-algo' => [
-                $this->createJwk(Jwk::PUBLIC_KEY_USE_SIGNATURE, Jwk::ALGORITHM_HS384),
+                [Jwk::PUBLIC_KEY_USE_SIGNATURE, Jwk::ALGORITHM_HS384],
                 Jwk::ALGORITHM_HS384
             ],
             'json' => [
-                $this->createJwkSet(
-                    [
-                        $this->createJwk(Jwk::PUBLIC_KEY_USE_SIGNATURE),
-                        $this->createJwk(Jwk::PUBLIC_KEY_USE_SIGNATURE)
-                    ]
-                ),
+                [
+                    [Jwk::PUBLIC_KEY_USE_SIGNATURE, Jwk::ALGORITHM_HS256],
+                    [Jwk::PUBLIC_KEY_USE_SIGNATURE, Jwk::ALGORITHM_HS256]
+                ],
                 'jws-json-serialization'
-            ],
+            ]
         ];
     }
 
     /**
      * Test algorithm logic.
      *
-     * @param Jwk|JwkSet $jwk
+     * @param array $jwksData
      * @param string $expectedName
      * @return void
      * @dataProvider getAlgorithmCases
      */
-    public function testGetAlgorithmName($jwk, string $expectedName): void
+    public function testGetAlgorithmName(array $jwkData, string $expectedName): void
     {
+        if (is_array($jwkData[0])) {
+            $jwks = array_map(function ($data) {
+                return $this->createJwk($data[0], $data[1]);
+            }, $jwkData);
+            $jwk = $this->createJwkSet($jwks);
+        } else {
+            $jwk = $this->createJwk($jwkData[0], $jwkData[1]);
+        }
+
         $model = new JwsSignatureJwks($jwk);
 
         $this->assertEquals($expectedName, $model->getAlgorithmName());

lib/internal/Magento/Framework/Test/Unit/ValidatorTest.php

@@ -48,18 +48,24 @@ protected function tearDown(): void
      * @dataProvider isValidDataProvider
      *
      * @param mixed $value
-     * @param ValidatorInterface[] $validators
+     * @param array $validatorsClosure
      * @param boolean $expectedResult
      * @param array $expectedMessages
      * @param boolean $breakChainOnFailure
      */
     public function testIsValid(
         $value,
-        $validators,
+        $validatorsClosure,
         $expectedResult,
         $expectedMessages = [],
         $breakChainOnFailure = false
     ) {
+        $validators = [];
+        foreach ($validatorsClosure as $key => $validator) {
+            if (is_callable($validator)) {
+                $validators[$key] = $validator($this);
+            }
+        }
         foreach ($validators as $validator) {
             $this->_validator->addValidator($validator, $breakChainOnFailure);
         }
@@ -73,31 +79,16 @@ public function testIsValid(
      *
      * @return array
      */
-    public function isValidDataProvider()
+    public static function isValidDataProvider()
     {
         $result = [];
         $value = 'test';
+        $dataA = ['foo' => ['Foo message 1'], 'bar' => ['Foo message 2']];
+        $dataB = ['foo' => ['Bar message 1'], 'bar' => ['Bar message 2']];
 
         // Case 1. Validators fails without breaking chain
-        $validatorA = $this->getMockForAbstractClass(ValidatorInterface::class);
-        $validatorA->expects($this->once())->method('isValid')->with($value)->willReturn(false);
-        $validatorA->expects(
-            $this->once()
-        )->method(
-            'getMessages'
-        )->willReturn(
-            ['foo' => ['Foo message 1'], 'bar' => ['Foo message 2']]
-        );
-
-        $validatorB = $this->getMockForAbstractClass(ValidatorInterface::class);
-        $validatorB->expects($this->once())->method('isValid')->with($value)->willReturn(false);
-        $validatorB->expects(
-            $this->once()
-        )->method(
-            'getMessages'
-        )->willReturn(
-            ['foo' => ['Bar message 1'], 'bar' => ['Bar message 2']]
-        );
+        $validatorA = static fn (self $testCase) => $testCase->getValidatorMock($dataA, $value);
+        $validatorB = static fn (self $testCase) => $testCase->getValidatorMock($dataB, $value);
 
         $result[] = [
             $value,
@@ -107,35 +98,44 @@ public function isValidDataProvider()
         ];
 
         // Case 2. Validators fails with breaking chain
-        $validatorA = $this->getMockForAbstractClass(ValidatorInterface::class);
-        $validatorA->expects($this->once())->method('isValid')->with($value)->willReturn(false);
-        $validatorA->expects(
-            $this->once()
-        )->method(
-            'getMessages'
-        )->willReturn(
-            ['field' => 'Error message']
-        );
-
-        $validatorB = $this->getMockForAbstractClass(ValidatorInterface::class);
-        $validatorB->expects($this->never())->method('isValid');
+        $dataC = ['field' => 'Error message'];
+        $validatorA = static fn (self $testCase) => $testCase->getValidatorMock($dataC, $value);
+        $validatorB = static fn (self $testCase) => $testCase->getValidatorMockWithExpectsNever();
 
         $result[] = [$value, [$validatorA, $validatorB], false, ['field' => 'Error message'], true];
 
         // Case 3. Validators succeed
-        $validatorA = $this->getMockForAbstractClass(ValidatorInterface::class);
-        $validatorA->expects($this->once())->method('isValid')->with($value)->willReturn(true);
-        $validatorA->expects($this->never())->method('getMessages');
-
-        $validatorB = $this->getMockForAbstractClass(ValidatorInterface::class);
-        $validatorB->expects($this->once())->method('isValid')->with($value)->willReturn(true);
-        $validatorB->expects($this->never())->method('getMessages');
+        $validatorA = static fn (self $testCase) => $testCase->getValidatorMockWithValidatorsSucceed($value);
+        $validatorB = static fn (self $testCase) => $testCase->getValidatorMockWithValidatorsSucceed($value);
 
         $result[] = [$value, [$validatorA, $validatorB], true];
 
         return $result;
     }
 
+    public function getValidatorMock($data, $value)
+    {
+        $validatorMock = $this->getMockForAbstractClass(ValidatorInterface::class);
+        $validatorMock->expects($this->once())->method('isValid')->with($value)->willReturn(false);
+        $validatorMock->expects($this->once())->method('getMessages')->willReturn($data);
+        return $validatorMock;
+    }
+
+    public function getValidatorMockWithExpectsNever()
+    {
+        $validatorMock = $this->getMockForAbstractClass(ValidatorInterface::class);
+        $validatorMock->expects($this->never())->method('isValid');
+        return $validatorMock;
+    }
+
+    public function getValidatorMockWithValidatorsSucceed($value)
+    {
+        $validatorMock = $this->getMockForAbstractClass(ValidatorInterface::class);
+        $validatorMock->expects($this->once())->method('isValid')->with($value)->willReturn(true);
+        $validatorMock->expects($this->never())->method('getMessages');
+        return $validatorMock;
+    }
+
     /**
      * Test addValidator
      */