feat: added support for database testing via IntegrationUtility

chore: added examples for database testing

chore: simplified code coverage to not use execution paths

chore: added suggestion to install testcontainers additionally to this
package

Author: IvanChepurnyi

README.md

@@ -1,4 +1,4 @@
-# Essentials for testing Magento 2 modules
+# 🎯 Essentials for testing Magento 2 modules
 
 Using mocking frameworks for testing Magento 2 modules is counterproductive as you replicate line by line your actual calls to a magento implementation.
 
@@ -11,11 +11,16 @@ As well as set of fake objects there is an  `ObjectManagerInterface` implementat
 Each fake object is covered by automated tests to make sure that behaviour is correct your tests can test your code specific behaviour by using different scenarios.
 
 
-## Installation
+## 📦 Installation
 ```bash
 composer require --dev ecomdev/magento2-test-essentials
 ```
 
+For database based tests it is recommended also to install collection of [testcontainers](https://github.com/EcomDev/testcontainer-magento-data):
+```bash
+composer require --dev ecomdev/testcontainers-magento-data
+```
+
 ## Examples
 
 ### Testing Class with Store and Configuration
@@ -56,7 +61,7 @@ class YourService
 }
 ```
 
-
+**YourServiceTest.php**
 ```php
 use PHPUnit\Framework\TestCase;
 use PHPUnit\Framework\Attributes\Test;
@@ -91,7 +96,7 @@ class YourServiceTest extends TestCase
 
         // Creates product without any constructor
         // but if you rely on data fields, it works great
-        $product = $this->objectManager->create(Product::class); 
+        $product = $this->objectManager->get(Product::class); 
 
         $applier->applyCurrentStoreToProduct(
             $product
@@ -109,7 +114,7 @@ class YourServiceTest extends TestCase
             $this->objectManager->get(ScopeConfig::class)
         );
 
-        $product = $this->objectManager->create(Product::class); 
+        $product = $this->objectManager->get(Product::class);
 
         $applier->applyCurrentStoreToProduct(
             $product
@@ -120,19 +125,87 @@ class YourServiceTest extends TestCase
 }
 ```
 
-### Easy Resource Model Testing
+### Easy Real Database Integration Testing
 
+In combination with magento data [testcontainers](https://github.com/EcomDev/testcontainer-magento-data-php) it is possible to write quick integration tests
+
+Imagine your service depends on Magento's `ResourceConnection` which is almost impossible to instantiate without installing whole Magento app:
+```php
+use Magento\Framework\App\ResourceConnection;
+
+class SomeSimpleService 
+{
+    public function __construct(private readonly ResourceConnection $resourceConnection)
+    {
+    }
+    
+    public function totalNumberOfSimpleProducts(): int 
+    {
+        $connection = $this->resourceConnection->getConnection();
+        $select = $connection->select()
+            ->from(
+                $this->resourceConnection->getTableName('catalog_product_entity'),
+                 ['count' => 'COUNT(*)']
+             )
+            ->where('type_id = ?', 'simple')
+            
+        return (int)$connection->fetchOne($select);
+    }    
+}
 ```
-TBD
+
+Now you can create all the required dependencies with the help of `IntegrationUtility` by specifying connection details:
+```php
+
+use EcomDev\TestContainers\MagentoData\DbConnectionSettings;
+use EcomDev\TestContainers\MagentoData\DbContainerBuilder;
+use Magento\Framework\App\ResourceConnection;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
+
+class IntegrationUtilityTest extends TestCase
+{
+    #[Test]
+    public function returnsCorrectAmountOfSimpleProductsInSampleDataDb()
+    {
+        $container = DbContainerBuilder::mysql()
+            ->withSampleData()
+            ->build();
+        
+        $connectionSettings = $connection->getConnectionSettings();
+        
+        $objectManager = IntegrationUtility::setupDatabaseObjects(
+            DeploymentConfig::new()
+                ->withDatabaseConnection(
+                    $connection->host,
+                    $connection->user,
+                    $connection->password,
+                    $connection->database
+                )
+        );
+        
+        $service = $objectManager->get(SomeSimpleService::class);
+        
+        $this->assertEquals(
+            1891,
+            $service->totalNumberOfSimpleProducts()
+        );
+    }
+}
 ```
 
+Now there is no excuse to not write tests for your database components!
 
-## Features
+##  ✨ Features
 
 - [x] `ObjectManagerInterface` implementation which mimics platform's behaviour
 - [x] `StoreInterface` implementation as a simple data object for testing store related behaviour
 - [x] `GroupInterface` implementation as a simple data object for testing store group related behaviour
 - [x] `WebsiteInterface` implementation as a simple data object for testing website related behaviour
 - [x] `ScopeConfigurationInterface` implementation for testing configuration dependent functionality
 - [x] `DeploymentConfig` implementation for using in configuration caches, db connections, http cache, etc
-- [ ] `ResourceConnection` implementation for quick testing of database components
+- [x] `ResourceConnection` implementation for quick testing of database components
+
+## 📜 License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.

composer.json

@@ -13,7 +13,8 @@
   "require-dev": {
     "squizlabs/php_codesniffer": "^3.0",
     "phpunit/phpunit": "^11.5",
-    "brianium/paratest": "^7.7"
+    "brianium/paratest": "^7.7",
+    "ecomdev/testcontainers-magento-data":"~1.1"
   },
   "suggest": {
     "ecomdev/testcontainers-magento-data": "Database Containers pre-populated with various data",

phpunit.xml

@@ -10,6 +10,6 @@
       <directory>src</directory>
     </include>
   </source>
-  <coverage ignoreDeprecatedCodeUnits="true" pathCoverage="true">
+  <coverage ignoreDeprecatedCodeUnits="true">
   </coverage>
 </phpunit>

src/DeploymentConfig.php

@@ -43,7 +43,7 @@ public function withDatabaseConnection(
             ->withSetting($this->databaseSettingPath($connectionName, 'dbname'), $dbname)
             ->withSetting($this->databaseSettingPath($connectionName, 'active'), 1)
             ->withSetting($this->databaseSettingPath($connectionName, 'engine'), 'innodb')
-            ->withSetting($this->databaseSettingPath($connectionName, 'initStatements'), ['SET NAMES utf8'])
+            ->withSetting($this->databaseSettingPath($connectionName, 'initStatements'), 'SET NAMES utf8')
             ->withSetting($this->databaseSettingPath($connectionName, 'driver_options'), [
                 PDO::MYSQL_ATTR_SSL_VERIFY_SERVER_CERT => false
             ]);

src/IntegrationUtility.php

@@ -0,0 +1,132 @@
+<?php
+
+namespace EcomDev\Magento2TestEssentials;
+
+use Magento\Backend\Helper\Js;
+use Magento\Framework\App\ResourceConnection;
+use Magento\Framework\App\ResourceConnection\ConfigInterface;
+use Magento\Framework\App\ResourceConnection\ConnectionAdapterInterface;
+use Magento\Framework\DB\Adapter\Pdo\MysqlFactory;
+use Magento\Framework\DB\Adapter\Pdo\Mysql as PdoMysql;
+use Magento\Framework\DB\Logger\Quiet;
+use Magento\Framework\DB\LoggerInterface;
+use Magento\Framework\DB\Select\ColumnsRenderer;
+use Magento\Framework\DB\Select\DistinctRenderer;
+use Magento\Framework\DB\Select\ForUpdateRenderer;
+use Magento\Framework\DB\Select\FromRenderer;
+use Magento\Framework\DB\Select\GroupRenderer;
+use Magento\Framework\DB\Select\HavingRenderer;
+use Magento\Framework\DB\Select\LimitRenderer;
+use Magento\Framework\DB\Select\OrderRenderer;
+use Magento\Framework\DB\Select\SelectRenderer;
+use Magento\Framework\DB\Select\UnionRenderer;
+use Magento\Framework\DB\Select\WhereRenderer;
+use Magento\Framework\DB\SelectFactory;
+use Magento\Framework\Model\ResourceModel\Type\Db\ConnectionFactory;
+use Magento\Framework\Model\ResourceModel\Type\Db\ConnectionFactoryInterface;
+use Magento\Framework\Model\ResourceModel\Type\Db\Pdo\Mysql;
+use Magento\Framework\Serialize\Serializer\Json;
+use Magento\Framework\Serialize\SerializerInterface;
+
+final class IntegrationUtility
+{
+    public static function withSetupDatabaseObjects(
+        ObjectManager $objectManager,
+        DeploymentConfig $deploymentConfig
+    ): ObjectManager {
+
+        return $objectManager
+            ->withObject(\Magento\Framework\App\DeploymentConfig::class, $deploymentConfig)
+            ->withObject(DeploymentConfig::class, $deploymentConfig)
+            ->withFactory(
+                ConnectionFactoryInterface::class,
+                static fn ($objectManager) => new ConnectionFactory($objectManager)
+            )
+            ->withDefaultArguments(PdoMysql::class, [
+                'serializer' => new Json()
+            ])
+            ->withObject(LoggerInterface::class, new Quiet())
+            ->withObject(SerializerInterface::class, new Json())
+            ->withFactory(SelectRenderer::class, static fn ($objectManager) => new SelectRenderer([
+                'distinct' => [
+                    'renderer' => $objectManager->create(DistinctRenderer::class),
+                    'sort' => 100,
+                    'part' => 'distinct',
+                ],
+                'columns' => [
+                    'renderer' => $objectManager->create(ColumnsRenderer::class),
+                    'sort' => 200,
+                    'part' => 'columns',
+                ],
+                'union' => [
+                    'renderer' => $objectManager->create(UnionRenderer::class),
+                    'sort' => 300,
+                    'part' => 'union',
+                ],
+                'from' => [
+                    'renderer' => $objectManager->create(FromRenderer::class),
+                    'sort' => 400,
+                    'part' => 'from',
+                ],
+                'where' => [
+                    'renderer' => $objectManager->create(WhereRenderer::class),
+                    'sort' => 500,
+                    'part' => 'where',
+                ],
+                'group' => [
+                    'renderer' => $objectManager->create(GroupRenderer::class),
+                    'sort' => 600,
+                    'part' => 'group',
+                ],
+                'having' => [
+                    'renderer' => $objectManager->create(HavingRenderer::class),
+                    'sort' => 700,
+                    'part' => 'having',
+                ],
+                'order' => [
+                    'renderer' => $objectManager->create(OrderRenderer::class),
+                    'sort' => 800,
+                    'part' => 'order',
+                ],
+                'limit' => [
+                    'renderer' => $objectManager->create(LimitRenderer::class),
+                    'sort' => 900,
+                    'part' => 'limitcount',
+                ],
+                'for_update' => [
+                    'renderer' => $objectManager->create(ForUpdateRenderer::class),
+                    'sort' => 1000,
+                    'part' => 'forupdate'
+                ]
+            ]))
+            ->withFactory(
+                SelectFactory::class,
+                static fn ($objectManager, array $arguments) => new SelectFactory(
+                    $objectManager->get(SelectRenderer::class),
+                    $arguments['parts'] ?? []
+                )
+            )
+            ->withFactory(
+                ConnectionAdapterInterface::class,
+                static fn ($objectManager, $arguments) => new Mysql($arguments['config'] ?? [], $objectManager->create(MysqlFactory::class))
+            )
+            ->withFactory(
+                ConfigInterface::class,
+                static fn (ObjectManager $objectManager) => $objectManager
+                    ->create(ResourceConnectionConfig::class)
+            )
+            ->withFactory(
+                ResourceConnection::class,
+                static fn (ObjectManager $objectManager) => new ResourceConnection(
+                    $objectManager->get(ConfigInterface::class),
+                    $objectManager->get(ConnectionFactoryInterface::class),
+                    $objectManager->get(DeploymentConfig::class)
+                )
+            );
+    }
+
+    public static function setupDatabaseObjects(DeploymentConfig $deploymentConfig): ObjectManager
+    {
+        return self::withSetupDatabaseObjects(ObjectManager::new(), $deploymentConfig);
+    }
+}

src/ObjectManager.php

@@ -26,6 +26,13 @@ final class ObjectManager implements ObjectManagerInterface
      */
     private array $factories = [];
 
+    /**
+     * List of default arguments for an object creation
+     *
+     * @var array[]
+     */
+    private array $defaultArguments = [];
+
     /**
      * Creates a new instance of ObjectManager
      */
@@ -83,6 +90,16 @@ public function withFactory(string $type, callable $factory): self
         return $objectManager;
     }
 
+    /**
+     * Adds a factory for a specific type an object manager
+     */
+    public function withDefaultArguments(string $type, array $arguments): self
+    {
+        $objectManager = clone $this;
+        $objectManager->defaultArguments[$type] = $arguments;
+        return $objectManager;
+    }
+
     /**
      * Creates an instance of an object
      */
@@ -100,6 +117,7 @@ private function createObject(string $type, array $arguments = null): object
             return $class->newInstanceWithoutConstructor();
         }
 
+        $arguments += $this->defaultArguments[$type] ?? [];
         $constructorArgs = [];
 
         foreach ($constructor->getParameters() as $parameter) {

src/ResourceConnectionConfig.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace EcomDev\Magento2TestEssentials;
+
+use Magento\Framework\App\ResourceConnection\ConfigInterface;
+
+final class ResourceConnectionConfig implements ConfigInterface
+{
+    public function __construct(private readonly DeploymentConfig $deploymentConfig)
+    {
+    }
+
+    public function getConnectionName($resourceName)
+    {
+        if ($this->deploymentConfig->get('db/connection/' . $resourceName)) {
+            return $resourceName;
+        }
+
+        return 'default';
+    }
+}