[Slim4] Add string formats support to Data Mocker (#4975)

* [Slim4] Support byte data format

* [Slim4] Support date and date-time data formats

* [Slim4] Support password data format

* [Slim4] Support uuid data format

* [Slim4] Fix test of password format mocking

'00000' is numeric type, because PHPUnit doesn't make strict type
comparison.

* [Slim4] Fix data format key in object mocking

* [Slim4] Support binary data format

* [Slim4] Support email data format

* [Slim4] Base64 encode binary format output

Raw bytes string breaks PHP stdout output, so I've decided to use base64
encoding format for binary format too.

* [Slim4] Refresh samples

modules/openapi-generator/src/main/resources/php-slim4-server/openapi_data_mocker.mustache

@@ -36,6 +36,7 @@ namespace {{mockPackage}};
 use {{mockPackage}}\{{interfaceNamePrefix}}OpenApiDataMocker{{interfaceNameSuffix}} as IMocker;
 use {{utilsPackage}}\{{traitNamePrefix}}ModelUtils{{traitNameSuffix}};
 use StdClass;
+use DateTime;
 use InvalidArgumentException;
 
 /**
@@ -193,6 +194,26 @@ final class OpenApiDataMocker implements IMocker
         $enum = null,
         $pattern = null
     ) {
+        $str = '';
+        $getLoremIpsum = function ($length) {
+            return str_pad(
+                '',
+                $length,
+                'Lorem ipsum dolor sit amet, consectetur adipiscing elit. ',
+                \STR_PAD_RIGHT
+            );
+        };
+        $truncateOrPad = function ($text, $min = null, $max = null, $glue = '') {
+            if ($max !== null && mb_strlen($text) > $max) {
+                // truncate
+                $text = substr($text, 0, $max);
+            } elseif ($min !== null && mb_strlen($text) < $min) {
+                // pad
+                $text = str_pad('', $min, $text . $glue, \STR_PAD_RIGHT);
+            }
+            return $text;
+        };
+
         if ($enum !== null) {
             if (
                 is_array($enum) === false
@@ -231,7 +252,72 @@ final class OpenApiDataMocker implements IMocker
             throw new InvalidArgumentException('"maxLength" value cannot be less than "minLength"');
         }
 
-        return str_pad('', mt_rand($minLength, $maxLength), 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. ', \STR_PAD_RIGHT);
+        switch ($dataFormat) {
+            case IMocker::DATA_FORMAT_BYTE:
+            case IMocker::DATA_FORMAT_BINARY:
+                // base64 encoded string
+                $inputLength = 1;
+                $str = base64_encode($getLoremIpsum($inputLength));
+                while (mb_strlen($str) < $minLength) {
+                    $inputLength++;
+                    $str = base64_encode($getLoremIpsum($inputLength));
+                }
+
+                // base64 encoding produces strings devided by 4, so resulted string can exceed maxLength parameter
+                // I think truncated(invalid) base64 string is better than oversized, cause this data is fake anyway
+                $str = $truncateOrPad($str, null, $maxLength, '. ');
+                break;
+            case IMocker::DATA_FORMAT_DATE:
+            case IMocker::DATA_FORMAT_DATE_TIME:
+                // min unix timestamp is 0 and max is 2147483647 for 32bit systems which equals 2038-01-19 03:14:07
+                $date = DateTime::createFromFormat('U', mt_rand(0, 2147483647));
+                $str = ($dataFormat === IMocker::DATA_FORMAT_DATE) ? $date->format('Y-m-d') : $date->format('Y-m-d\TH:i:sP');
+
+                // truncate or pad datestring to fit minLength and maxLength
+                $str = $truncateOrPad($str, $minLength, $maxLength, ' ');
+                break;
+            case IMocker::DATA_FORMAT_PASSWORD:
+                // use list of most popular passwords
+                $obviousPassList = [
+                    'qwerty',
+                    'qwerty12345',
+                    'hello',
+                    '12345',
+                    '0000',
+                    'qwerty12345!',
+                    'qwertyuiop[]',
+                ];
+                $str = $obviousPassList[mt_rand(0, count($obviousPassList) - 1)];
+
+                // truncate or pad password to fit minLength and maxLength
+                $str = $truncateOrPad($str, $minLength, $maxLength);
+                break;
+            case IMocker::DATA_FORMAT_UUID:
+                // use php built-in uniqid function
+                $str = uniqid();
+
+                // truncate or pad password to fit minLength and maxLength
+                $str = $truncateOrPad($str, $minLength, $maxLength);
+                break;
+            case IMocker::DATA_FORMAT_EMAIL:
+                // just for visionary purpose, not related to real persons
+                $fakeEmailList = [
+                    'johndoe',
+                    'lhoswald',
+                    'ojsimpson',
+                    'mlking',
+                    'jfkennedy',
+                ];
+                $str = $fakeEmailList[mt_rand(0, count($fakeEmailList) - 1)] . '@example.com';
+
+                // truncate or pad email to fit minLength and maxLength
+                $str = $truncateOrPad($str, $minLength, $maxLength);
+                break;
+            default:
+                $str = $getLoremIpsum(mt_rand($minLength, $maxLength));
+        }
+
+        return $str;
     }
 
     /**

modules/openapi-generator/src/main/resources/php-slim4-server/openapi_data_mocker_test.mustache

@@ -342,7 +342,6 @@ class OpenApiDataMockerTest extends TestCase
             IsType::TYPE_STRING,
         ];
         $notTypes = [
-            IsType::TYPE_NUMERIC,
             IsType::TYPE_FLOAT,
             IsType::TYPE_INT,
             IsType::TYPE_ARRAY,
@@ -363,6 +362,22 @@ class OpenApiDataMockerTest extends TestCase
             [null, null, null, null, $types, $notTypes],
             [null, null, null, ['foobar', 'foobaz', 'hello world'], $types, $notTypes],
             [null, null, null, ['foobar'], $types, $notTypes],
+            [IMocker::DATA_FORMAT_PASSWORD, 0, null, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_PASSWORD, 10, null, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_PASSWORD, 0, 100, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_PASSWORD, 10, 50, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_PASSWORD, 10, 10, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_PASSWORD, 0, 0, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_EMAIL, null, null, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_EMAIL, 10, null, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_EMAIL, 10, 10, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_EMAIL, null, 8, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_EMAIL, 16, null, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_EMAIL, 25, null, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_EMAIL, 25, 25, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_EMAIL, null, 20, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_EMAIL, 30, null, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_EMAIL, 1, 1, null, $types, $notTypes],
         ];
     }
 
@@ -398,6 +413,175 @@ class OpenApiDataMockerTest extends TestCase
         ];
     }
 
+    /**
+     * @covers ::mock
+     * @covers ::mockString
+     * @dataProvider provideMockStringByteFormatArguments
+     */
+    public function testMockStringWithByteFormat(
+        $dataFormat,
+        $minLength,
+        $maxLength
+    ) {
+        $mocker = new OpenApiDataMocker();
+        $str = $mocker->mockString($dataFormat, $minLength, $maxLength);
+        $str2 = $mocker->mock(IMocker::DATA_TYPE_STRING, $dataFormat, ['minLength' => $minLength, 'maxLength' => $maxLength]);
+        $base64pattern = '/^[\w\+\/\=]*$/';
+        $this->assertRegExp($base64pattern, $str);
+        $this->assertRegExp($base64pattern, $str2);
+        if ($minLength !== null) {
+            $this->assertGreaterThanOrEqual($minLength, mb_strlen($str));
+            $this->assertGreaterThanOrEqual($minLength, mb_strlen($str2));
+        }
+        if ($maxLength !== null) {
+            $this->assertLessThanOrEqual($maxLength, mb_strlen($str));
+            $this->assertLessThanOrEqual($maxLength, mb_strlen($str2));
+        }
+    }
+
+    public function provideMockStringByteFormatArguments()
+    {
+        return [
+            [IMocker::DATA_FORMAT_BYTE, null, null],
+            [IMocker::DATA_FORMAT_BYTE, 10, null],
+            [IMocker::DATA_FORMAT_BYTE, 10, 10],
+            [IMocker::DATA_FORMAT_BYTE, null, 12],
+        ];
+    }
+
+    /**
+     * @covers ::mock
+     * @covers ::mockString
+     * @dataProvider provideMockStringBinaryFormatArguments
+     */
+    public function testMockStringWithBinaryFormat(
+        $dataFormat,
+        $minLength,
+        $maxLength
+    ) {
+        $mocker = new OpenApiDataMocker();
+        $str = $mocker->mockString($dataFormat, $minLength, $maxLength);
+        $str2 = $mocker->mock(IMocker::DATA_TYPE_STRING, $dataFormat, ['minLength' => $minLength, 'maxLength' => $maxLength]);
+        if ($minLength !== null) {
+            $this->assertGreaterThanOrEqual($minLength, strlen($str));
+            $this->assertGreaterThanOrEqual($minLength, strlen($str2));
+        }
+        if ($maxLength !== null) {
+            $this->assertLessThanOrEqual($maxLength, strlen($str));
+            $this->assertLessThanOrEqual($maxLength, strlen($str2));
+        }
+    }
+
+    public function provideMockStringBinaryFormatArguments()
+    {
+        return [
+            [IMocker::DATA_FORMAT_BINARY, 0, null],
+            [IMocker::DATA_FORMAT_BINARY, 10, null],
+            [IMocker::DATA_FORMAT_BINARY, 0, 100],
+            [IMocker::DATA_FORMAT_BINARY, 10, 50],
+            [IMocker::DATA_FORMAT_BINARY, 10, 10],
+            [IMocker::DATA_FORMAT_BINARY, 0, 0],
+        ];
+    }
+
+    /**
+     * @covers ::mock
+     * @covers ::mockString
+     * @dataProvider provideMockStringDateFormatArguments
+     */
+    public function testMockStringWithDateAndDateTimeFormat(
+        $dataFormat,
+        $minLength,
+        $maxLength,
+        $dtFormat
+    ) {
+        $mocker = new OpenApiDataMocker();
+        $str = $mocker->mockString($dataFormat, $minLength, $maxLength);
+        $str2 = $mocker->mock(IMocker::DATA_TYPE_STRING, $dataFormat, ['minLength' => $minLength, 'maxLength' => $maxLength]);
+
+        if ($dtFormat !== null) {
+            $date = DateTime::createFromFormat($dtFormat, $str);
+            $date2 = DateTime::createFromFormat($dtFormat, $str2);
+            $this->assertInstanceOf(DateTime::class, $date);
+            $this->assertInstanceOf(DateTime::class, $date2);
+        }
+        if ($minLength !== null) {
+            $this->assertGreaterThanOrEqual($minLength, mb_strlen($str));
+            $this->assertGreaterThanOrEqual($minLength, mb_strlen($str2));
+        }
+        if ($maxLength !== null) {
+            $this->assertLessThanOrEqual($maxLength, mb_strlen($str));
+            $this->assertLessThanOrEqual($maxLength, mb_strlen($str2));
+        }
+    }
+
+    public function provideMockStringDateFormatArguments()
+    {
+        return [
+            [IMocker::DATA_FORMAT_DATE, null, null, 'Y-m-d'],
+            [IMocker::DATA_FORMAT_DATE, 10, null, 'Y-m-d'],
+            [IMocker::DATA_FORMAT_DATE, 10, 10, 'Y-m-d'],
+            [IMocker::DATA_FORMAT_DATE, null, 8, null],
+            [IMocker::DATA_FORMAT_DATE, 16, null, null],
+            [IMocker::DATA_FORMAT_DATE_TIME, null, null, 'Y-m-d\TH:i:sP'],
+            [IMocker::DATA_FORMAT_DATE_TIME, 25, null, 'Y-m-d\TH:i:sP'],
+            [IMocker::DATA_FORMAT_DATE_TIME, 25, 25, 'Y-m-d\TH:i:sP'],
+            [IMocker::DATA_FORMAT_DATE_TIME, null, 20, null],
+            [IMocker::DATA_FORMAT_DATE_TIME, 30, null, null],
+        ];
+    }
+
+    /**
+     * @covers ::mock
+     * @covers ::mockString
+     * @dataProvider provideMockStringUuidFormatArguments
+     */
+    public function testMockStringWithUuidFormat(
+        $minLength,
+        $maxLength
+    ) {
+        $mocker = new OpenApiDataMocker();
+        $arr = [];
+        $arr2 = [];
+        $hexPattern = '/^[a-f0-9]*$/';
+
+        while (count($arr) < 100 && count($arr2) < 100) {
+            $str = $mocker->mockString(IMocker::DATA_FORMAT_UUID, $minLength, $maxLength);
+            $str2 = $mocker->mock(IMocker::DATA_TYPE_STRING, IMocker::DATA_FORMAT_UUID, ['minLength' => $minLength, 'maxLength' => $maxLength]);
+            $arr[] = $str;
+            $arr2[] = $str2;
+
+            $this->assertRegExp($hexPattern, $str);
+            $this->assertRegExp($hexPattern, $str2);
+
+            if ($minLength !== null) {
+                $this->assertGreaterThanOrEqual($minLength, mb_strlen($str));
+                $this->assertGreaterThanOrEqual($minLength, mb_strlen($str2));
+            }
+            if ($maxLength !== null) {
+                $this->assertLessThanOrEqual($maxLength, mb_strlen($str));
+                $this->assertLessThanOrEqual($maxLength, mb_strlen($str2));
+            }
+        }
+    }
+
+    public function provideMockStringUuidFormatArguments()
+    {
+        return [
+            [null, null],
+            [10, null],
+            [10, 10],
+            [null, 8],
+            [16, null],
+            [null, null],
+            [25, null],
+            [25, 25],
+            [null, 20],
+            [30, null],
+            [1, 1],
+        ];
+    }
+
     /**
      * @covers ::mockBoolean
      */

samples/server/petstore/php-slim4/lib/Mock/OpenApiDataMocker.php

@@ -28,6 +28,7 @@ namespace OpenAPIServer\Mock;
 use OpenAPIServer\Mock\OpenApiDataMockerInterface as IMocker;
 use OpenAPIServer\Utils\ModelUtilsTrait;
 use StdClass;
+use DateTime;
 use InvalidArgumentException;
 
 /**
@@ -185,6 +186,26 @@ final class OpenApiDataMocker implements IMocker
         $enum = null,
         $pattern = null
     ) {
+        $str = '';
+        $getLoremIpsum = function ($length) {
+            return str_pad(
+                '',
+                $length,
+                'Lorem ipsum dolor sit amet, consectetur adipiscing elit. ',
+                \STR_PAD_RIGHT
+            );
+        };
+        $truncateOrPad = function ($text, $min = null, $max = null, $glue = '') {
+            if ($max !== null && mb_strlen($text) > $max) {
+                // truncate
+                $text = substr($text, 0, $max);
+            } elseif ($min !== null && mb_strlen($text) < $min) {
+                // pad
+                $text = str_pad('', $min, $text . $glue, \STR_PAD_RIGHT);
+            }
+            return $text;
+        };
+
         if ($enum !== null) {
             if (
                 is_array($enum) === false
@@ -223,7 +244,72 @@ final class OpenApiDataMocker implements IMocker
             throw new InvalidArgumentException('"maxLength" value cannot be less than "minLength"');
         }
 
-        return str_pad('', mt_rand($minLength, $maxLength), 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. ', \STR_PAD_RIGHT);
+        switch ($dataFormat) {
+            case IMocker::DATA_FORMAT_BYTE:
+            case IMocker::DATA_FORMAT_BINARY:
+                // base64 encoded string
+                $inputLength = 1;
+                $str = base64_encode($getLoremIpsum($inputLength));
+                while (mb_strlen($str) < $minLength) {
+                    $inputLength++;
+                    $str = base64_encode($getLoremIpsum($inputLength));
+                }
+
+                // base64 encoding produces strings devided by 4, so resulted string can exceed maxLength parameter
+                // I think truncated(invalid) base64 string is better than oversized, cause this data is fake anyway
+                $str = $truncateOrPad($str, null, $maxLength, '. ');
+                break;
+            case IMocker::DATA_FORMAT_DATE:
+            case IMocker::DATA_FORMAT_DATE_TIME:
+                // min unix timestamp is 0 and max is 2147483647 for 32bit systems which equals 2038-01-19 03:14:07
+                $date = DateTime::createFromFormat('U', mt_rand(0, 2147483647));
+                $str = ($dataFormat === IMocker::DATA_FORMAT_DATE) ? $date->format('Y-m-d') : $date->format('Y-m-d\TH:i:sP');
+
+                // truncate or pad datestring to fit minLength and maxLength
+                $str = $truncateOrPad($str, $minLength, $maxLength, ' ');
+                break;
+            case IMocker::DATA_FORMAT_PASSWORD:
+                // use list of most popular passwords
+                $obviousPassList = [
+                    'qwerty',
+                    'qwerty12345',
+                    'hello',
+                    '12345',
+                    '0000',
+                    'qwerty12345!',
+                    'qwertyuiop[]',
+                ];
+                $str = $obviousPassList[mt_rand(0, count($obviousPassList) - 1)];
+
+                // truncate or pad password to fit minLength and maxLength
+                $str = $truncateOrPad($str, $minLength, $maxLength);
+                break;
+            case IMocker::DATA_FORMAT_UUID:
+                // use php built-in uniqid function
+                $str = uniqid();
+
+                // truncate or pad password to fit minLength and maxLength
+                $str = $truncateOrPad($str, $minLength, $maxLength);
+                break;
+            case IMocker::DATA_FORMAT_EMAIL:
+                // just for visionary purpose, not related to real persons
+                $fakeEmailList = [
+                    'johndoe',
+                    'lhoswald',
+                    'ojsimpson',
+                    'mlking',
+                    'jfkennedy',
+                ];
+                $str = $fakeEmailList[mt_rand(0, count($fakeEmailList) - 1)] . '@example.com';
+
+                // truncate or pad email to fit minLength and maxLength
+                $str = $truncateOrPad($str, $minLength, $maxLength);
+                break;
+            default:
+                $str = $getLoremIpsum(mt_rand($minLength, $maxLength));
+        }
+
+        return $str;
     }
 
     /**

samples/server/petstore/php-slim4/test/Mock/OpenApiDataMockerTest.php

@@ -334,7 +334,6 @@ class OpenApiDataMockerTest extends TestCase
             IsType::TYPE_STRING,
         ];
         $notTypes = [
-            IsType::TYPE_NUMERIC,
             IsType::TYPE_FLOAT,
             IsType::TYPE_INT,
             IsType::TYPE_ARRAY,
@@ -355,6 +354,22 @@ class OpenApiDataMockerTest extends TestCase
             [null, null, null, null, $types, $notTypes],
             [null, null, null, ['foobar', 'foobaz', 'hello world'], $types, $notTypes],
             [null, null, null, ['foobar'], $types, $notTypes],
+            [IMocker::DATA_FORMAT_PASSWORD, 0, null, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_PASSWORD, 10, null, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_PASSWORD, 0, 100, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_PASSWORD, 10, 50, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_PASSWORD, 10, 10, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_PASSWORD, 0, 0, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_EMAIL, null, null, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_EMAIL, 10, null, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_EMAIL, 10, 10, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_EMAIL, null, 8, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_EMAIL, 16, null, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_EMAIL, 25, null, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_EMAIL, 25, 25, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_EMAIL, null, 20, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_EMAIL, 30, null, null, $types, $notTypes],
+            [IMocker::DATA_FORMAT_EMAIL, 1, 1, null, $types, $notTypes],
         ];
     }
 
@@ -390,6 +405,175 @@ class OpenApiDataMockerTest extends TestCase
         ];
     }
 
+    /**
+     * @covers ::mock
+     * @covers ::mockString
+     * @dataProvider provideMockStringByteFormatArguments
+     */
+    public function testMockStringWithByteFormat(
+        $dataFormat,
+        $minLength,
+        $maxLength
+    ) {
+        $mocker = new OpenApiDataMocker();
+        $str = $mocker->mockString($dataFormat, $minLength, $maxLength);
+        $str2 = $mocker->mock(IMocker::DATA_TYPE_STRING, $dataFormat, ['minLength' => $minLength, 'maxLength' => $maxLength]);
+        $base64pattern = '/^[\w\+\/\=]*$/';
+        $this->assertRegExp($base64pattern, $str);
+        $this->assertRegExp($base64pattern, $str2);
+        if ($minLength !== null) {
+            $this->assertGreaterThanOrEqual($minLength, mb_strlen($str));
+            $this->assertGreaterThanOrEqual($minLength, mb_strlen($str2));
+        }
+        if ($maxLength !== null) {
+            $this->assertLessThanOrEqual($maxLength, mb_strlen($str));
+            $this->assertLessThanOrEqual($maxLength, mb_strlen($str2));
+        }
+    }
+
+    public function provideMockStringByteFormatArguments()
+    {
+        return [
+            [IMocker::DATA_FORMAT_BYTE, null, null],
+            [IMocker::DATA_FORMAT_BYTE, 10, null],
+            [IMocker::DATA_FORMAT_BYTE, 10, 10],
+            [IMocker::DATA_FORMAT_BYTE, null, 12],
+        ];
+    }
+
+    /**
+     * @covers ::mock
+     * @covers ::mockString
+     * @dataProvider provideMockStringBinaryFormatArguments
+     */
+    public function testMockStringWithBinaryFormat(
+        $dataFormat,
+        $minLength,
+        $maxLength
+    ) {
+        $mocker = new OpenApiDataMocker();
+        $str = $mocker->mockString($dataFormat, $minLength, $maxLength);
+        $str2 = $mocker->mock(IMocker::DATA_TYPE_STRING, $dataFormat, ['minLength' => $minLength, 'maxLength' => $maxLength]);
+        if ($minLength !== null) {
+            $this->assertGreaterThanOrEqual($minLength, strlen($str));
+            $this->assertGreaterThanOrEqual($minLength, strlen($str2));
+        }
+        if ($maxLength !== null) {
+            $this->assertLessThanOrEqual($maxLength, strlen($str));
+            $this->assertLessThanOrEqual($maxLength, strlen($str2));
+        }
+    }
+
+    public function provideMockStringBinaryFormatArguments()
+    {
+        return [
+            [IMocker::DATA_FORMAT_BINARY, 0, null],
+            [IMocker::DATA_FORMAT_BINARY, 10, null],
+            [IMocker::DATA_FORMAT_BINARY, 0, 100],
+            [IMocker::DATA_FORMAT_BINARY, 10, 50],
+            [IMocker::DATA_FORMAT_BINARY, 10, 10],
+            [IMocker::DATA_FORMAT_BINARY, 0, 0],
+        ];
+    }
+
+    /**
+     * @covers ::mock
+     * @covers ::mockString
+     * @dataProvider provideMockStringDateFormatArguments
+     */
+    public function testMockStringWithDateAndDateTimeFormat(
+        $dataFormat,
+        $minLength,
+        $maxLength,
+        $dtFormat
+    ) {
+        $mocker = new OpenApiDataMocker();
+        $str = $mocker->mockString($dataFormat, $minLength, $maxLength);
+        $str2 = $mocker->mock(IMocker::DATA_TYPE_STRING, $dataFormat, ['minLength' => $minLength, 'maxLength' => $maxLength]);
+
+        if ($dtFormat !== null) {
+            $date = DateTime::createFromFormat($dtFormat, $str);
+            $date2 = DateTime::createFromFormat($dtFormat, $str2);
+            $this->assertInstanceOf(DateTime::class, $date);
+            $this->assertInstanceOf(DateTime::class, $date2);
+        }
+        if ($minLength !== null) {
+            $this->assertGreaterThanOrEqual($minLength, mb_strlen($str));
+            $this->assertGreaterThanOrEqual($minLength, mb_strlen($str2));
+        }
+        if ($maxLength !== null) {
+            $this->assertLessThanOrEqual($maxLength, mb_strlen($str));
+            $this->assertLessThanOrEqual($maxLength, mb_strlen($str2));
+        }
+    }
+
+    public function provideMockStringDateFormatArguments()
+    {
+        return [
+            [IMocker::DATA_FORMAT_DATE, null, null, 'Y-m-d'],
+            [IMocker::DATA_FORMAT_DATE, 10, null, 'Y-m-d'],
+            [IMocker::DATA_FORMAT_DATE, 10, 10, 'Y-m-d'],
+            [IMocker::DATA_FORMAT_DATE, null, 8, null],
+            [IMocker::DATA_FORMAT_DATE, 16, null, null],
+            [IMocker::DATA_FORMAT_DATE_TIME, null, null, 'Y-m-d\TH:i:sP'],
+            [IMocker::DATA_FORMAT_DATE_TIME, 25, null, 'Y-m-d\TH:i:sP'],
+            [IMocker::DATA_FORMAT_DATE_TIME, 25, 25, 'Y-m-d\TH:i:sP'],
+            [IMocker::DATA_FORMAT_DATE_TIME, null, 20, null],
+            [IMocker::DATA_FORMAT_DATE_TIME, 30, null, null],
+        ];
+    }
+
+    /**
+     * @covers ::mock
+     * @covers ::mockString
+     * @dataProvider provideMockStringUuidFormatArguments
+     */
+    public function testMockStringWithUuidFormat(
+        $minLength,
+        $maxLength
+    ) {
+        $mocker = new OpenApiDataMocker();
+        $arr = [];
+        $arr2 = [];
+        $hexPattern = '/^[a-f0-9]*$/';
+
+        while (count($arr) < 100 && count($arr2) < 100) {
+            $str = $mocker->mockString(IMocker::DATA_FORMAT_UUID, $minLength, $maxLength);
+            $str2 = $mocker->mock(IMocker::DATA_TYPE_STRING, IMocker::DATA_FORMAT_UUID, ['minLength' => $minLength, 'maxLength' => $maxLength]);
+            $arr[] = $str;
+            $arr2[] = $str2;
+
+            $this->assertRegExp($hexPattern, $str);
+            $this->assertRegExp($hexPattern, $str2);
+
+            if ($minLength !== null) {
+                $this->assertGreaterThanOrEqual($minLength, mb_strlen($str));
+                $this->assertGreaterThanOrEqual($minLength, mb_strlen($str2));
+            }
+            if ($maxLength !== null) {
+                $this->assertLessThanOrEqual($maxLength, mb_strlen($str));
+                $this->assertLessThanOrEqual($maxLength, mb_strlen($str2));
+            }
+        }
+    }
+
+    public function provideMockStringUuidFormatArguments()
+    {
+        return [
+            [null, null],
+            [10, null],
+            [10, 10],
+            [null, 8],
+            [16, null],
+            [null, null],
+            [25, null],
+            [25, 25],
+            [null, 20],
+            [30, null],
+            [1, 1],
+        ];
+    }
+
     /**
      * @covers ::mockBoolean
      */