updated all guides

Author: DavertMik

guides/09-Data.md

@@ -1,4 +1,4 @@
-# Working with Data
+# Data Management
 
 Tests should not affect each other. That's a rule of thumb. When tests interact with a database,
 they may change the data inside it, which would eventually lead to data inconsistency.
@@ -17,16 +17,14 @@ you should use a special test database for testing. **Do not ever run tests on d
 
 Codeception has a `Db` module, which takes on most of the tasks of database interaction.
 
-{% highlight yaml %}
-
+```yaml
 modules:
     config:
         Db:
             dsn: 'PDO DSN HERE'
             user: 'root'
             password:
-
-{% endhighlight %}
+```
 
 <div class="alert alert-notice">
 Use <a href="https://codeception.com/docs/06-ModulesAndHelpers#Dynamic-Configuration-With-Params">module parameters</a>
@@ -36,8 +34,7 @@ to set the database credentials from environment variables or from application c
 Db module can cleanup database between tests by loading a database dump. This can be done by parsing SQL file and
 executing its commands using current connection
 
-{% highlight yaml %}
-
+```yaml
 modules:
     config:
         Db:
@@ -48,14 +45,12 @@ modules:
             cleanup: true # reload dump between tests
             populate: true # load dump before all tests
 
-
-{% endhighlight %}
+```
 
  Alternatively an external tool (like mysql client, or pg_restore) can be used. This approach is faster and won't produce parsing errors while loading a dump.
  Use `populator` config option to specify the command. For MySQL it can look like this:
 
-{% highlight yaml %}
-
+```yaml
  modules:
     enabled:
        - Db:
@@ -65,8 +60,7 @@ modules:
           cleanup: true # run populator before each test
           populate: true # run populator before all test
           populator: 'mysql -u $user $dbname < tests/_data/dump.sql'
-
-{% endhighlight %}
+```
 
 See the [Db module reference](https://codeception.com/docs/modules/Db#SQL-data-dump) for more examples.
 
@@ -87,34 +81,27 @@ The Db module provides actions to create and verify data inside a database.
 If you want to create a special database record for one test,
 you can use [`haveInDatabase`](https://codeception.com/docs/modules/Db#haveInDatabase) method of `Db` module:
 
-{% highlight php %}
-
-<?php
+```php
 $I->haveInDatabase('posts', [
   'title' => 'Top 10 Testing Frameworks',
   'body' => '1. Codeception'
 ]);
 $I->amOnPage('/posts');
 $I->see('Top 10 Testing Frameworks');
-
-
-{% endhighlight %}
+```
 
 `haveInDatabase` inserts a row with the provided values into the database.
 All added records will be deleted at the end of the test.
 
 If you want to check that a table record was created
 use [`seeInDatabase`](https://codeception.com/docs/modules/Db#haveInDatabase) method:
 
-{% highlight php %}
-
-<?php
+```php
 $I->amOnPage('/posts/1');
 $I->fillField('comment', 'This is nice!');
 $I->click('Submit');
 $I->seeInDatabase('comments', ['body' => 'This is nice!']);
-
-{% endhighlight %}
+```
 
 See the module [reference](https://codeception.com/docs/modules/Db) for other methods you can use for database testing.
 
@@ -155,9 +142,7 @@ Corresponding framework modules provide similar methods for ORM access:
 
 They allow you to create and check data by model name and field names in the model. Here is the example in Laravel:
 
-{% highlight php %}
-
-<?php
+```php
 // create record and get its id
 $id = $I->haveRecord('posts', ['body' => 'My first blogpost', 'user_id' => 1]);
 $I->amOnPage('/posts/'.$id);
@@ -167,30 +152,27 @@ $I->seeRecord('posts', ['id' => $id]);
 $I->click('Delete');
 // record was deleted
 $I->dontSeeRecord('posts', ['id' => $id]);
+```
 
-{% endhighlight %}
-
-Laravel5 module provides the method `have` which uses the [factory](https://laravel.com/docs/5.8/database-testing#generating-factories) method to generate models with fake data.
+Laravel5 module provides the method `have` which uses the [factory](https://laravel.com/docs/9.x/database-testing#creating-models-using-factories) method to generate models with fake data.
 
 If you want to use ORM for integration testing only, you should enable the framework module with only the `ORM` part enabled:
 
-{% highlight yaml %}
-
+```yaml
 modules:
     enabled:
-        - Laravel5:
+        - Laravel:
             - part: ORM
+```
 
-{% endhighlight %}
-
-{% highlight yaml %}
+Similarly for Yii2 framework:
 
+```yaml
 modules:
     enabled:
         - Yii2:
             - part: ORM
-
-{% endhighlight %}
+```
 
 This way no web actions will be added to `$I` object.
 
@@ -199,44 +181,30 @@ Please note that inside acceptance tests, web applications work inside a webserv
 by rolling back transactions. You will need to disable cleaning up,
 and use the `Db` module to clean the database up between tests. Here is a sample config:
 
-{% highlight yaml %}
-
+```yaml
 modules:
     enabled:
         - WebDriver:
             url: http://localhost
             browser: firefox
-        - Laravel5:
+        - Laravel:
             cleanup: false
         - Db
-
-{% endhighlight %}
+```
 
 ### Doctrine
 
 Doctrine is also a popular ORM, unlike some others it implements the DataMapper pattern and is not bound to any framework.
 The [Doctrine2](https://codeception.com/docs/modules/Doctrine2) module requires an `EntityManager` instance to work with.
 It can be obtained from a Symfony framework or Zend Framework (configured with Doctrine):
 
-{% highlight yaml %}
-
+```yaml
 modules:
     enabled:
         - Symfony
         - Doctrine2:
             depends: Symfony
-
-{% endhighlight %}
-
-{% highlight yaml %}
-
-modules:
-    enabled:
-        - ZF2
-        - Doctrine2:
-            depends: ZF2
-
-{% endhighlight %}
+```
 
 If no framework is used with Doctrine you should provide the `connection_callback` option
 with a valid callback to a function which returns an `EntityManager` instance.
@@ -259,41 +227,34 @@ and are provided by the [DataFactory](https://codeception.com/docs/modules/DataF
 
 Once configured, it can create records with ease:
 
-{% highlight php %}
-
-<?php
+```php
 // creates a new user
-$user_id = $I->have('App\Model\User');
+$user_id = $I->have(\App\Model\User::class);
 // creates 3 posts
-$I->haveMultiple('App\Model\Post', 3);
-
-{% endhighlight %}
+$I->haveMultiple(\App\Model\Post::class, 3);
+```
 
 Created records will be deleted at the end of a test.
 The DataFactory module only works with ORM, so it requires one of the ORM modules to be enabled:
 
-{% highlight yaml %}
-
+```yaml
 modules:
     enabled:
         - Yii2:
             configFile: path/to/config.php
         - DataFactory:
             depends: Yii2
+```
 
-{% endhighlight %}
-
-{% highlight yaml %}
-
+```yaml
 modules:
     enabled:
         - Symfony
         - Doctrine2:
             depends: Symfony
         - DataFactory:
             depends: Doctrine2
-
-{% endhighlight %}
+```
 
 DataFactory provides a powerful solution for managing data in integration/functional/acceptance tests.
 Read the [full reference](https://codeception.com/docs/modules/DataFactory) to learn how to set this module up.
@@ -309,24 +270,24 @@ This principle is so general that it can work for testing APIs, items on a web p
 Let's check that list of categories on a page is the same it was before.    
 Create a snapshot class:
 
-{% highlight php %}
- vendor/bin/codecept g:snapshot Categories
-
-{% endhighlight %}
+```php
+php vendor/bin/codecept g:snapshot Categories
+```
 
 Inject an actor class via constructor and implement `fetchData` method which should return a data set from a test.
 
-{% highlight php %}
-
+```php
 <?php
-namespace Snapshot;
+
+namespace Tests\Support\Snapshot;
+
+use Tests\Support\AcceptanceTester;
 
 class Categories extends \Codeception\Snapshot
 {
-    /** @var \AcceptanceTester */
-    protected $i;
+    protected AcceptanceTester $i;
 
-    public function __construct(\AcceptanceTester $I)
+    public function __construct(AcceptanceTester $I)
     {
         $this->i = $I;
     }
@@ -337,60 +298,51 @@ class Categories extends \Codeception\Snapshot
         return $this->i->grabMultiple('a.category');
     }
 }
-
-{% endhighlight %}
+```
 
 Inside a test you can inject the snapshot class and call `assert` method on it:
 
-{% highlight php %}
-
-<?php
-public function testCategoriesAreTheSame(\AcceptanceTester $I, \Snapshot\Categories $snapshot)
+```php
+public function testCategoriesAreTheSame(AcceptanceTester $I, \Tests\Snapshot\Categories $snapshot)
 {
     $I->amOnPage('/categories');
     // if previously saved array of users does not match current set, test will fail
     // to update data in snapshot run test with --debug flag
     $snapshot->assert();
 }
-
-{% endhighlight %}
+```
 
 On the first run, data will be obtained via `fetchData` method and saved to `tests/_data` directory in json format.
 On next execution the obtained data will be compared with previously saved snapshot.
 
-> To update a snapshot with a new data run tests in `--debug` mode.
+> To update a snapshot with new data, run tests in `--debug` mode.
 
 By default Snapshot uses `assertEquals` assertion, however this can be customized by overriding `assertData` method.
 
-### Failed assertion output
+### Failed Assertion Output
 
 The assertion performed by `assertData` will not display the typical diff output from `assertEquals` or any customized failed assertion.
 To have the diff displayed when running tests, you can call the snapshot method `shouldShowDiffOnFail`:
 
-{% highlight php %}
-
-<?php
-public function testCategoriesAreTheSame(\AcceptanceTester $I, \Snapshot\Categories $snapshot)
+```php
+public function testCategoriesAreTheSame(AcceptanceTester $I, \Tests\Snapshot\Categories $snapshot)
 {
     $I->amOnPage('/categories');
     // I want to see the diff in case the snapshot data changes
     $snapshot->shouldShowDiffOnFail();
     $snapshot->assert();
 }
-
-{% endhighlight %}
+```
 
 If ever needed, the diff output can also be omitted by calling `shouldShowDiffOnFail(false)`.
 
-### Working with different data formats
+### Change Storage Format
 
 By default, all snapshot files are stored in json format, so if you have to work with different formats, neither the diff output or the snapshot file data will be helpful. 
 To fix this, you can call the snapshot method `shouldSaveAsJson(false)` and set the file extension by calling `setSnapshotFileExtension()`:
 
-{% highlight php %}
-
-<?php
-public function testCategoriesAreTheSame(\AcceptanceTester $I, \Snapshot\Categories $snapshot)
+```php
+public function testCategoriesAreTheSame(AcceptanceTester $I, \Tests\Snapshot\Categories $snapshot)
 {
     // I fetch an HTML page
     $I->amOnPage('/categories.html');
@@ -399,16 +351,8 @@ public function testCategoriesAreTheSame(\AcceptanceTester $I, \Snapshot\Categor
     $snapshot->setSnapshotFileExtension('html');
     $snapshot->assert();
 }
-
-{% endhighlight %}
+```
 
 The snapshot file will be stored without encoding it to json format, and with the `.html` extension.
 
 > Beware that this option will not perform any changes in the data returned by `fetchData`, and store it as it is.
-
-## Conclusion
-
-Codeception also assists the developer when dealing with data. Tools for database population
-and cleaning up are bundled within the `Db` module. If you use ORM, you can use one of the provided framework modules
-to operate with database through a data abstraction layer, and use the DataFactory module to generate new records with ease.
-