Update expectations

Author: rybakit

README.md

@@ -136,6 +136,15 @@ public function testExecuteQueryFetchesAllRows() : void
 
 *ClientPacker*
 
+Format:
+
+```
+@requires clientPacker <packer>
+```
+where `<packer>` is either `pure`, `pecl`, or a fully qualified class name, e.g. `Tarantool\Client\Packer\PurePacker`.
+
+Example:
+
 ```php
 /**
  * @requires clientPacker pure 
@@ -148,6 +157,15 @@ public function testPackerUnpacksBigIntegerAsDecimal() : void
 
 *LuaCondition*
 
+Format:
+
+```
+@requires luaCondition <lua-expression>
+```
+where `<lua-expression>` is an arbitrary lua expression that should be evaluated to a Boolean value.
+
+Example:
+
 ```php
 /**
  * @requires luaCondition box.session.user() ~= 'guest'
@@ -160,6 +178,16 @@ public function testChangeUserPassword() : void
 
 *Tarantool*
 
+Format:
+
+```
+@requires Tarantool <version-constraint>
+```
+where `<version-constraint>` is a composer-like version constraint. For details on supported formats, 
+please see the Composer [documentation](https://getcomposer.org/doc/articles/versions.md#writing-version-constraints).
+
+Example:
+
 ```php
 /**
  * @requires Tarantool ^2.3.2 
@@ -170,6 +198,11 @@ public function testPrepareCreatesPreparedStatement() : void
 }
 ```
 
+> *Note*
+>
+> If you're interested in how to create and register your own annotations,
+> please refer to the `rybakit/phpunit-extras` [README](https://github.com/rybakit/phpunit-extras).
+
 
 ## Expectations
 
@@ -212,16 +245,18 @@ public function testGetSpaceIsCached() : void
 }
 ```
 
-In order to check SQL statements, use the `Tarantool\PhpUnit\Expectation\SqlStatementExpectations` trait,
+In order to assert prepared statement allocations, use the `Tarantool\PhpUnit\Expectation\PreparedStatementExpectations` trait,
 which contains the following methods:
 
- * `expectSqlStatementToBeExecuted(int $count) : void`
- * `expectSqlStatementToBeExecutedAtLeast(int $count) : void`
- * `expectSqlStatementToBeExecutedAtMost(int $count) : void`
- * `expectSqlStatementToBeExecutedOnce() : void`
- * `expectSqlStatementToBeNeverCalled() : void`
- * `expectSqlStatementToBeExecutedAtLeastOnce() : void`
- * `expectSqlStatementToBeExecutedAtMostOnce() : void`
+ * `expectPreparedStatementToBe<TYPE>(int $count) : void`
+ * `expectPreparedStatementToBe<TYPE>AtLeast(int $count) : void`
+ * `expectPreparedStatementToBe<TYPE>AtMost(int $count) : void`
+ * `expectPreparedStatementToBe<TYPE>Once() : void`
+ * `expectPreparedStatementToBeNever<TYPE>() : void`
+ * `expectPreparedStatementToBe<TYPE>AtLeastOnce() : void`
+ * `expectPreparedStatementToBe<TYPE>AtMostOnce() : void`
+
+where `<TYPE>` is either `Allocated` or `Deallocated`.
 
 Usage example:
 
@@ -230,7 +265,7 @@ public function testCloseDeallocatesPreparedStatement() : void
 {
     $stmt = $this->client->prepare('SELECT ?');
 
-    $this->expectSqlStatementToBeExecutedOnce();
+    $this->expectPreparedStatementToBeDeallocatedOnce();
     $stmt->close();
 }
 ```

src/Expectation/Expectations.php

@@ -16,5 +16,5 @@
 trait Expectations
 {
     use RequestExpectations;
-    use SqlStatementExpectations;
+    use PreparedStatementExpectations;
 }

src/Expectation/ExpressionContext/SqlStatementCountContext.php renamed to src/Expectation/ExpressionContext/PreparedStatementCountContext.php

@@ -16,7 +16,7 @@
 use PHPUnitExtras\Expectation\ExpressionContext;
 use Tarantool\Client\Client;
 
-final class SqlStatementCountContext implements ExpressionContext
+final class PreparedStatementCountContext implements ExpressionContext
 {
     /** @var Client */
     private $client;
@@ -27,6 +27,9 @@ final class SqlStatementCountContext implements ExpressionContext
     /** @var int */
     private $initialValue;
 
+    /** @var int|null */
+    private $finalValue;
+
     private function __construct(Client $client, string $expression)
     {
         $this->client = $client;
@@ -56,9 +59,13 @@ public function getExpression() : string
 
     public function getValues() : array
     {
+        if (null === $this->finalValue) {
+            $this->finalValue = $this->getValue();
+        }
+
         return [
             'old_count' => $this->initialValue,
-            'new_count' => $this->getValue(),
+            'new_count' => $this->finalValue,
         ];
     }
 

src/Expectation/ExpressionContext/RequestCountContext.php

@@ -48,6 +48,9 @@ final class RequestCountContext implements ExpressionContext
     /** @var int */
     private $initialValue;
 
+    /** @var int|null */
+    private $finalValue;
+
     private function __construct(Client $client, RequestCounter $requestCounter, string $requestName, string $expression)
     {
         $this->requestCounter = $requestCounter;
@@ -79,9 +82,13 @@ public function getExpression() : string
 
     public function getValues() : array
     {
+        if (null === $this->finalValue) {
+            $this->finalValue = $this->getValue();
+        }
+
         return [
             'old_count' => $this->initialValue,
-            'new_count' => $this->getValue(),
+            'new_count' => $this->finalValue,
         ];
     }
 

src/Expectation/PreparedStatementExpectations.php

@@ -0,0 +1,102 @@
+<?php
+
+/**
+ * This file is part of the tarantool/phpunit-extras package.
+ *
+ * (c) Eugene Leonovich <gen.work@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Tarantool\PhpUnit\Expectation;
+
+use PHPUnitExtras\Expectation\Expectation;
+use PHPUnitExtras\Expectation\ExpressionExpectation;
+use Tarantool\Client\Client;
+use Tarantool\PhpUnit\Expectation\ExpressionContext\PreparedStatementCountContext;
+
+trait PreparedStatementExpectations
+{
+    public function expectPreparedStatementToBeAllocated(int $count) : void
+    {
+        $context = PreparedStatementCountContext::exactly($this->getClient(), $count);
+        $this->expect(new ExpressionExpectation($context));
+    }
+
+    public function expectPreparedStatementToBeDeallocated(int $count) : void
+    {
+        $context = PreparedStatementCountContext::exactly($this->getClient(), -$count);
+        $this->expect(new ExpressionExpectation($context));
+    }
+
+    public function expectPreparedStatementToBeAllocatedAtLeast(int $count) : void
+    {
+        $context = PreparedStatementCountContext::atLeast($this->getClient(), $count);
+        $this->expect(new ExpressionExpectation($context));
+    }
+
+    public function expectPreparedStatementToBeDeallocatedAtLeast(int $count) : void
+    {
+        $context = PreparedStatementCountContext::atMost($this->getClient(), -$count);
+        $this->expect(new ExpressionExpectation($context));
+    }
+
+    public function expectPreparedStatementToBeAllocatedAtMost(int $count) : void
+    {
+        $context = PreparedStatementCountContext::atMost($this->getClient(), $count);
+        $this->expect(new ExpressionExpectation($context));
+    }
+
+    public function expectPreparedStatementToBeDeallocatedAtMost(int $count) : void
+    {
+        $context = PreparedStatementCountContext::atLeast($this->getClient(), -$count);
+        $this->expect(new ExpressionExpectation($context));
+    }
+
+    public function expectPreparedStatementToBeAllocatedOnce() : void
+    {
+        $this->expectPreparedStatementToBeAllocated(1);
+    }
+
+    public function expectPreparedStatementToBeDeallocatedOnce() : void
+    {
+        $this->expectPreparedStatementToBeDeallocated(1);
+    }
+
+    public function expectPreparedStatementToBeNeverAllocated() : void
+    {
+        $this->expectPreparedStatementToBeAllocated(0);
+    }
+
+    public function expectPreparedStatementToBeNeverDeallocated() : void
+    {
+        $this->expectPreparedStatementToBeDeallocated(0);
+    }
+
+    public function expectPreparedStatementToBeAllocatedAtLeastOnce() : void
+    {
+        $this->expectPreparedStatementToBeAllocatedAtLeast(1);
+    }
+
+    public function expectPreparedStatementToBeDeallocatedAtLeastOnce() : void
+    {
+        $this->expectPreparedStatementToBeDeallocatedAtLeast(1);
+    }
+
+    public function expectPreparedStatementToBeAllocatedAtMostOnce() : void
+    {
+        $this->expectPreparedStatementToBeAllocatedAtMost(1);
+    }
+
+    public function expectPreparedStatementToBeDeallocatedAtMostOnce() : void
+    {
+        $this->expectPreparedStatementToBeDeallocatedAtMost(1);
+    }
+
+    abstract protected function expect(Expectation $expectation) : void;
+
+    abstract protected function getClient() : Client;
+}