bit-badger/pdo-document
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 16 Wiki Activity

Changes for beta10 (#5)

Browse Source 
- Add In/InArray support
- Add ORDER BY support for `Find` functions
- Update dependencies
- Implement fixes identified via static analysis

Reviewed-on: #5
This commit is contained in:
Daniel J. Summers 2024-09-27 02:15:00 +00:00
parent 9e0e663811
commit d067f8983f
66 changed files with 1728 additions and 664 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
composer.json
View File

@ -26,7 +26,8 @@
}, },
"require-dev": { "require-dev": {
"phpunit/phpunit": "^11", "phpunit/phpunit": "^11",
"square/pjson": "^0.5.0" "square/pjson": "^0.5.0",
"phpstan/phpstan": "^1.12"
}, },
"autoload": { "autoload": {
"psr-4": { "psr-4": {

186
composer.lock generated
View File

@ -4,7 +4,7 @@
"Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies", "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
"This file is @generated automatically" "This file is @generated automatically"
], ],
"content-hash": "f3351c794dd1261ee4bf18380f58463d", "content-hash": "7f9c6e825e6f0968b2dedefec770f558",
"packages": [ "packages": [
{ {
"name": "bit-badger/inspired-by-fsharp", "name": "bit-badger/inspired-by-fsharp",
@ -53,16 +53,16 @@
}, },
{ {
"name": "netresearch/jsonmapper", "name": "netresearch/jsonmapper",
"version": "v4.4.1", "version": "v4.5.0",
"source": { "source": {
"type": "git", "type": "git",
"url": "https://github.com/cweiske/jsonmapper.git", "url": "https://github.com/cweiske/jsonmapper.git",
"reference": "132c75c7dd83e45353ebb9c6c9f591952995bbf0" "reference": "8e76efb98ee8b6afc54687045e1b8dba55ac76e5"
}, },
"dist": { "dist": {
"type": "zip", "type": "zip",
"url": "https://api.github.com/repos/cweiske/jsonmapper/zipball/132c75c7dd83e45353ebb9c6c9f591952995bbf0", "url": "https://api.github.com/repos/cweiske/jsonmapper/zipball/8e76efb98ee8b6afc54687045e1b8dba55ac76e5",
"reference": "132c75c7dd83e45353ebb9c6c9f591952995bbf0", "reference": "8e76efb98ee8b6afc54687045e1b8dba55ac76e5",
"shasum": "" "shasum": ""
}, },
"require": { "require": {
@ -98,9 +98,9 @@
"support": { "support": {
"email": "cweiske@cweiske.de", "email": "cweiske@cweiske.de",
"issues": "https://github.com/cweiske/jsonmapper/issues", "issues": "https://github.com/cweiske/jsonmapper/issues",
"source": "https://github.com/cweiske/jsonmapper/tree/v4.4.1" "source": "https://github.com/cweiske/jsonmapper/tree/v4.5.0"
}, },
"time": "2024-01-31T06:18:54+00:00" "time": "2024-09-08T10:13:13+00:00"
} }
], ],
"packages-dev": [ "packages-dev": [
@ -166,16 +166,16 @@
}, },
{ {
"name": "nikic/php-parser", "name": "nikic/php-parser",
"version": "v5.1.0", "version": "v5.2.0",
"source": { "source": {
"type": "git", "type": "git",
"url": "https://github.com/nikic/PHP-Parser.git", "url": "https://github.com/nikic/PHP-Parser.git",
"reference": "683130c2ff8c2739f4822ff7ac5c873ec529abd1" "reference": "23c79fbbfb725fb92af9bcf41065c8e9a0d49ddb"
}, },
"dist": { "dist": {
"type": "zip", "type": "zip",
"url": "https://api.github.com/repos/nikic/PHP-Parser/zipball/683130c2ff8c2739f4822ff7ac5c873ec529abd1", "url": "https://api.github.com/repos/nikic/PHP-Parser/zipball/23c79fbbfb725fb92af9bcf41065c8e9a0d49ddb",
"reference": "683130c2ff8c2739f4822ff7ac5c873ec529abd1", "reference": "23c79fbbfb725fb92af9bcf41065c8e9a0d49ddb",
"shasum": "" "shasum": ""
}, },
"require": { "require": {
@ -218,9 +218,9 @@
], ],
"support": { "support": {
"issues": "https://github.com/nikic/PHP-Parser/issues", "issues": "https://github.com/nikic/PHP-Parser/issues",
"source": "https://github.com/nikic/PHP-Parser/tree/v5.1.0" "source": "https://github.com/nikic/PHP-Parser/tree/v5.2.0"
}, },
"time": "2024-07-01T20:03:41+00:00" "time": "2024-09-15T16:40:33+00:00"
}, },
{ {
"name": "phar-io/manifest", "name": "phar-io/manifest",
@ -341,33 +341,91 @@
"time": "2022-02-21T01:04:05+00:00" "time": "2022-02-21T01:04:05+00:00"
}, },
{ {
"name": "phpunit/php-code-coverage", "name": "phpstan/phpstan",
"version": "11.0.5", "version": "1.12.5",
"source": { "source": {
"type": "git", "type": "git",
"url": "https://github.com/sebastianbergmann/php-code-coverage.git", "url": "https://github.com/phpstan/phpstan.git",
"reference": "19b6365ab8b59a64438c0c3f4241feeb480c9861" "reference": "7e6c6cb7cecb0a6254009a1a8a7d54ec99812b17"
}, },
"dist": { "dist": {
"type": "zip", "type": "zip",
"url": "https://api.github.com/repos/sebastianbergmann/php-code-coverage/zipball/19b6365ab8b59a64438c0c3f4241feeb480c9861", "url": "https://api.github.com/repos/phpstan/phpstan/zipball/7e6c6cb7cecb0a6254009a1a8a7d54ec99812b17",
"reference": "19b6365ab8b59a64438c0c3f4241feeb480c9861", "reference": "7e6c6cb7cecb0a6254009a1a8a7d54ec99812b17",
"shasum": ""
},
"require": {
"php": "^7.2|^8.0"
},
"conflict": {
"phpstan/phpstan-shim": "*"
},
"bin": [
"phpstan",
"phpstan.phar"
],
"type": "library",
"autoload": {
"files": [
"bootstrap.php"
]
},
"notification-url": "https://packagist.org/downloads/",
"license": [
"MIT"
],
"description": "PHPStan - PHP Static Analysis Tool",
"keywords": [
"dev",
"static analysis"
],
"support": {
"docs": "https://phpstan.org/user-guide/getting-started",
"forum": "https://github.com/phpstan/phpstan/discussions",
"issues": "https://github.com/phpstan/phpstan/issues",
"security": "https://github.com/phpstan/phpstan/security/policy",
"source": "https://github.com/phpstan/phpstan-src"
},
"funding": [
{
"url": "https://github.com/ondrejmirtes",
"type": "github"
},
{
"url": "https://github.com/phpstan",
"type": "github"
}
],
"time": "2024-09-26T12:45:22+00:00"
},
{
"name": "phpunit/php-code-coverage",
"version": "11.0.6",
"source": {
"type": "git",
"url": "https://github.com/sebastianbergmann/php-code-coverage.git",
"reference": "ebdffc9e09585dafa71b9bffcdb0a229d4704c45"
},
"dist": {
"type": "zip",
"url": "https://api.github.com/repos/sebastianbergmann/php-code-coverage/zipball/ebdffc9e09585dafa71b9bffcdb0a229d4704c45",
"reference": "ebdffc9e09585dafa71b9bffcdb0a229d4704c45",
"shasum": "" "shasum": ""
}, },
"require": { "require": {
"ext-dom": "*", "ext-dom": "*",
"ext-libxml": "*", "ext-libxml": "*",
"ext-xmlwriter": "*", "ext-xmlwriter": "*",
"nikic/php-parser": "^5.0", "nikic/php-parser": "^5.1.0",
"php": ">=8.2", "php": ">=8.2",
"phpunit/php-file-iterator": "^5.0", "phpunit/php-file-iterator": "^5.0.1",
"phpunit/php-text-template": "^4.0", "phpunit/php-text-template": "^4.0.1",
"sebastian/code-unit-reverse-lookup": "^4.0", "sebastian/code-unit-reverse-lookup": "^4.0.1",
"sebastian/complexity": "^4.0", "sebastian/complexity": "^4.0.1",
"sebastian/environment": "^7.0", "sebastian/environment": "^7.2.0",
"sebastian/lines-of-code": "^3.0", "sebastian/lines-of-code": "^3.0.1",
"sebastian/version": "^5.0", "sebastian/version": "^5.0.1",
"theseer/tokenizer": "^1.2.0" "theseer/tokenizer": "^1.2.3"
}, },
"require-dev": { "require-dev": {
"phpunit/phpunit": "^11.0" "phpunit/phpunit": "^11.0"
@ -379,7 +437,7 @@
"type": "library", "type": "library",
"extra": { "extra": {
"branch-alias": { "branch-alias": {
"dev-main": "11.0-dev" "dev-main": "11.0.x-dev"
} }
}, },
"autoload": { "autoload": {
@ -408,7 +466,7 @@
"support": { "support": {
"issues": "https://github.com/sebastianbergmann/php-code-coverage/issues", "issues": "https://github.com/sebastianbergmann/php-code-coverage/issues",
"security": "https://github.com/sebastianbergmann/php-code-coverage/security/policy", "security": "https://github.com/sebastianbergmann/php-code-coverage/security/policy",
"source": "https://github.com/sebastianbergmann/php-code-coverage/tree/11.0.5" "source": "https://github.com/sebastianbergmann/php-code-coverage/tree/11.0.6"
}, },
"funding": [ "funding": [
{ {
@ -416,20 +474,20 @@
"type": "github" "type": "github"
} }
], ],
"time": "2024-07-03T05:05:37+00:00" "time": "2024-08-22T04:37:56+00:00"
}, },
{ {
"name": "phpunit/php-file-iterator", "name": "phpunit/php-file-iterator",
"version": "5.0.1", "version": "5.1.0",
"source": { "source": {
"type": "git", "type": "git",
"url": "https://github.com/sebastianbergmann/php-file-iterator.git", "url": "https://github.com/sebastianbergmann/php-file-iterator.git",
"reference": "6ed896bf50bbbfe4d504a33ed5886278c78e4a26" "reference": "118cfaaa8bc5aef3287bf315b6060b1174754af6"
}, },
"dist": { "dist": {
"type": "zip", "type": "zip",
"url": "https://api.github.com/repos/sebastianbergmann/php-file-iterator/zipball/6ed896bf50bbbfe4d504a33ed5886278c78e4a26", "url": "https://api.github.com/repos/sebastianbergmann/php-file-iterator/zipball/118cfaaa8bc5aef3287bf315b6060b1174754af6",
"reference": "6ed896bf50bbbfe4d504a33ed5886278c78e4a26", "reference": "118cfaaa8bc5aef3287bf315b6060b1174754af6",
"shasum": "" "shasum": ""
}, },
"require": { "require": {
@ -469,7 +527,7 @@
"support": { "support": {
"issues": "https://github.com/sebastianbergmann/php-file-iterator/issues", "issues": "https://github.com/sebastianbergmann/php-file-iterator/issues",
"security": "https://github.com/sebastianbergmann/php-file-iterator/security/policy", "security": "https://github.com/sebastianbergmann/php-file-iterator/security/policy",
"source": "https://github.com/sebastianbergmann/php-file-iterator/tree/5.0.1" "source": "https://github.com/sebastianbergmann/php-file-iterator/tree/5.1.0"
}, },
"funding": [ "funding": [
{ {
@ -477,7 +535,7 @@
"type": "github" "type": "github"
} }
], ],
"time": "2024-07-03T05:06:37+00:00" "time": "2024-08-27T05:02:59+00:00"
}, },
{ {
"name": "phpunit/php-invoker", "name": "phpunit/php-invoker",
@ -665,16 +723,16 @@
}, },
{ {
"name": "phpunit/phpunit", "name": "phpunit/phpunit",
"version": "11.2.8", "version": "11.3.6",
"source": { "source": {
"type": "git", "type": "git",
"url": "https://github.com/sebastianbergmann/phpunit.git", "url": "https://github.com/sebastianbergmann/phpunit.git",
"reference": "a7a29e8d3113806f18f99d670f580a30e8ffff39" "reference": "d62c45a19c665bb872c2a47023a0baf41a98bb2b"
}, },
"dist": { "dist": {
"type": "zip", "type": "zip",
"url": "https://api.github.com/repos/sebastianbergmann/phpunit/zipball/a7a29e8d3113806f18f99d670f580a30e8ffff39", "url": "https://api.github.com/repos/sebastianbergmann/phpunit/zipball/d62c45a19c665bb872c2a47023a0baf41a98bb2b",
"reference": "a7a29e8d3113806f18f99d670f580a30e8ffff39", "reference": "d62c45a19c665bb872c2a47023a0baf41a98bb2b",
"shasum": "" "shasum": ""
}, },
"require": { "require": {
@ -688,20 +746,20 @@
"phar-io/manifest": "^2.0.4", "phar-io/manifest": "^2.0.4",
"phar-io/version": "^3.2.1", "phar-io/version": "^3.2.1",
"php": ">=8.2", "php": ">=8.2",
"phpunit/php-code-coverage": "^11.0.5", "phpunit/php-code-coverage": "^11.0.6",
"phpunit/php-file-iterator": "^5.0.1", "phpunit/php-file-iterator": "^5.1.0",
"phpunit/php-invoker": "^5.0.1", "phpunit/php-invoker": "^5.0.1",
"phpunit/php-text-template": "^4.0.1", "phpunit/php-text-template": "^4.0.1",
"phpunit/php-timer": "^7.0.1", "phpunit/php-timer": "^7.0.1",
"sebastian/cli-parser": "^3.0.2", "sebastian/cli-parser": "^3.0.2",
"sebastian/code-unit": "^3.0.1", "sebastian/code-unit": "^3.0.1",
"sebastian/comparator": "^6.0.1", "sebastian/comparator": "^6.1.0",
"sebastian/diff": "^6.0.2", "sebastian/diff": "^6.0.2",
"sebastian/environment": "^7.2.0", "sebastian/environment": "^7.2.0",
"sebastian/exporter": "^6.1.3", "sebastian/exporter": "^6.1.3",
"sebastian/global-state": "^7.0.2", "sebastian/global-state": "^7.0.2",
"sebastian/object-enumerator": "^6.0.1", "sebastian/object-enumerator": "^6.0.1",
"sebastian/type": "^5.0.1", "sebastian/type": "^5.1.0",
"sebastian/version": "^5.0.1" "sebastian/version": "^5.0.1"
}, },
"suggest": { "suggest": {
@ -713,7 +771,7 @@
"type": "library", "type": "library",
"extra": { "extra": {
"branch-alias": { "branch-alias": {
"dev-main": "11.2-dev" "dev-main": "11.3-dev"
} }
}, },
"autoload": { "autoload": {
@ -745,7 +803,7 @@
"support": { "support": {
"issues": "https://github.com/sebastianbergmann/phpunit/issues", "issues": "https://github.com/sebastianbergmann/phpunit/issues",
"security": "https://github.com/sebastianbergmann/phpunit/security/policy", "security": "https://github.com/sebastianbergmann/phpunit/security/policy",
"source": "https://github.com/sebastianbergmann/phpunit/tree/11.2.8" "source": "https://github.com/sebastianbergmann/phpunit/tree/11.3.6"
}, },
"funding": [ "funding": [
{ {
@ -761,7 +819,7 @@
"type": "tidelift" "type": "tidelift"
} }
], ],
"time": "2024-07-18T14:56:37+00:00" "time": "2024-09-19T10:54:28+00:00"
}, },
{ {
"name": "sebastian/cli-parser", "name": "sebastian/cli-parser",
@ -935,16 +993,16 @@
}, },
{ {
"name": "sebastian/comparator", "name": "sebastian/comparator",
"version": "6.0.1", "version": "6.1.0",
"source": { "source": {
"type": "git", "type": "git",
"url": "https://github.com/sebastianbergmann/comparator.git", "url": "https://github.com/sebastianbergmann/comparator.git",
"reference": "131942b86d3587291067a94f295498ab6ac79c20" "reference": "fa37b9e2ca618cb051d71b60120952ee8ca8b03d"
}, },
"dist": { "dist": {
"type": "zip", "type": "zip",
"url": "https://api.github.com/repos/sebastianbergmann/comparator/zipball/131942b86d3587291067a94f295498ab6ac79c20", "url": "https://api.github.com/repos/sebastianbergmann/comparator/zipball/fa37b9e2ca618cb051d71b60120952ee8ca8b03d",
"reference": "131942b86d3587291067a94f295498ab6ac79c20", "reference": "fa37b9e2ca618cb051d71b60120952ee8ca8b03d",
"shasum": "" "shasum": ""
}, },
"require": { "require": {
@ -955,12 +1013,12 @@
"sebastian/exporter": "^6.0" "sebastian/exporter": "^6.0"
}, },
"require-dev": { "require-dev": {
"phpunit/phpunit": "^11.0" "phpunit/phpunit": "^11.3"
}, },
"type": "library", "type": "library",
"extra": { "extra": {
"branch-alias": { "branch-alias": {
"dev-main": "6.0-dev" "dev-main": "6.1-dev"
} }
}, },
"autoload": { "autoload": {
@ -1000,7 +1058,7 @@
"support": { "support": {
"issues": "https://github.com/sebastianbergmann/comparator/issues", "issues": "https://github.com/sebastianbergmann/comparator/issues",
"security": "https://github.com/sebastianbergmann/comparator/security/policy", "security": "https://github.com/sebastianbergmann/comparator/security/policy",
"source": "https://github.com/sebastianbergmann/comparator/tree/6.0.1" "source": "https://github.com/sebastianbergmann/comparator/tree/6.1.0"
}, },
"funding": [ "funding": [
{ {
@ -1008,7 +1066,7 @@
"type": "github" "type": "github"
} }
], ],
"time": "2024-07-03T04:48:07+00:00" "time": "2024-09-11T15:42:56+00:00"
}, },
{ {
"name": "sebastian/complexity", "name": "sebastian/complexity",
@ -1577,28 +1635,28 @@
}, },
{ {
"name": "sebastian/type", "name": "sebastian/type",
"version": "5.0.1", "version": "5.1.0",
"source": { "source": {
"type": "git", "type": "git",
"url": "https://github.com/sebastianbergmann/type.git", "url": "https://github.com/sebastianbergmann/type.git",
"reference": "fb6a6566f9589e86661291d13eba708cce5eb4aa" "reference": "461b9c5da241511a2a0e8f240814fb23ce5c0aac"
}, },
"dist": { "dist": {
"type": "zip", "type": "zip",
"url": "https://api.github.com/repos/sebastianbergmann/type/zipball/fb6a6566f9589e86661291d13eba708cce5eb4aa", "url": "https://api.github.com/repos/sebastianbergmann/type/zipball/461b9c5da241511a2a0e8f240814fb23ce5c0aac",
"reference": "fb6a6566f9589e86661291d13eba708cce5eb4aa", "reference": "461b9c5da241511a2a0e8f240814fb23ce5c0aac",
"shasum": "" "shasum": ""
}, },
"require": { "require": {
"php": ">=8.2" "php": ">=8.2"
}, },
"require-dev": { "require-dev": {
"phpunit/phpunit": "^11.0" "phpunit/phpunit": "^11.3"
}, },
"type": "library", "type": "library",
"extra": { "extra": {
"branch-alias": { "branch-alias": {
"dev-main": "5.0-dev" "dev-main": "5.1-dev"
} }
}, },
"autoload": { "autoload": {
@ -1622,7 +1680,7 @@
"support": { "support": {
"issues": "https://github.com/sebastianbergmann/type/issues", "issues": "https://github.com/sebastianbergmann/type/issues",
"security": "https://github.com/sebastianbergmann/type/security/policy", "security": "https://github.com/sebastianbergmann/type/security/policy",
"source": "https://github.com/sebastianbergmann/type/tree/5.0.1" "source": "https://github.com/sebastianbergmann/type/tree/5.1.0"
}, },
"funding": [ "funding": [
{ {
@ -1630,7 +1688,7 @@
"type": "github" "type": "github"
} }
], ],
"time": "2024-07-03T05:11:49+00:00" "time": "2024-09-17T13:12:04+00:00"
}, },
{ {
"name": "sebastian/version", "name": "sebastian/version",

2
src/Configuration.php
View File

@ -34,7 +34,7 @@ class Configuration
/** @var string|null The password to use to establish a data connection (use env PDO_DOC_PASSWORD if possible) */ /** @var string|null The password to use to establish a data connection (use env PDO_DOC_PASSWORD if possible) */
public static ?string $password = null; public static ?string $password = null;
/** @var array|null Options to use for connections (driver-specific) */ /** @var mixed[]|null Options to use for connections (driver-specific) */
public static ?array $options = null; public static ?array $options = null;
/** @var Option<Mode> The mode in which the library is operating */ /** @var Option<Mode> The mode in which the library is operating */

10
src/Count.php
View File

@ -31,23 +31,23 @@ class Count
* Count matching documents using a comparison on JSON fields * Count matching documents using a comparison on JSON fields
* *
* @param string $tableName The name of the table in which documents should be counted * @param string $tableName The name of the table in which documents should be counted
* @param array|Field[] $fields The field comparison to match * @param Field[] $fields The field comparison to match
* @param FieldMatch|null $match How to handle multiple conditions (optional; defaults to All) * @param FieldMatch|null $match How to handle multiple conditions (optional; defaults to All)
* @return int The count of documents matching the field comparison * @return int The count of documents matching the field comparison
* @throws DocumentException If one is encountered * @throws DocumentException If one is encountered
*/ */
public static function byFields(string $tableName, array $fields, ?FieldMatch $match = null): int public static function byFields(string $tableName, array $fields, ?FieldMatch $match = null): int
{ {
$namedFields = Parameters::nameFields($fields); Parameters::nameFields($fields);
return Custom::scalar(Query\Count::byFields($tableName, $namedFields, $match), return Custom::scalar(Query\Count::byFields($tableName, $fields, $match), Parameters::addFields($fields, []),
Parameters::addFields($namedFields, []), new CountMapper()); new CountMapper());
} }
/** /**
* Count matching documents using a JSON containment query (`@>`; PostgreSQL only) * Count matching documents using a JSON containment query (`@>`; PostgreSQL only)
* *
* @param string $tableName The name of the table in which documents should be counted * @param string $tableName The name of the table in which documents should be counted
* @param array|object $criteria The criteria for the JSON containment query * @param mixed[]|object $criteria The criteria for the JSON containment query
* @return int The number of documents matching the JSON containment query * @return int The number of documents matching the JSON containment query
* @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs * @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs
*/ */

12
src/Custom.php
View File

@ -23,7 +23,7 @@ class Custom
* Prepare a query for execution and run it * Prepare a query for execution and run it
* *
* @param string $query The query to be run * @param string $query The query to be run
* @param array $parameters The parameters for the query * @param array<string, mixed> $parameters The parameters for the query
* @return PDOStatement The result of executing the query * @return PDOStatement The result of executing the query
* @throws DocumentException If the query execution is unsuccessful * @throws DocumentException If the query execution is unsuccessful
*/ */
@ -67,7 +67,7 @@ class Custom
* *
* @template TDoc The domain type of the document to retrieve * @template TDoc The domain type of the document to retrieve
* @param string $query The query to be executed * @param string $query The query to be executed
* @param array $parameters Parameters to use in executing the query * @param array<string, mixed> $parameters Parameters to use in executing the query
* @param Mapper<TDoc> $mapper Mapper to deserialize the result * @param Mapper<TDoc> $mapper Mapper to deserialize the result
* @return DocumentList<TDoc> The items matching the query * @return DocumentList<TDoc> The items matching the query
* @throws DocumentException If any is encountered * @throws DocumentException If any is encountered
@ -82,7 +82,7 @@ class Custom
* *
* @template TDoc The domain type of the document to retrieve * @template TDoc The domain type of the document to retrieve
* @param string $query The query to be executed * @param string $query The query to be executed
* @param array $parameters Parameters to use in executing the query * @param array<string, mixed> $parameters Parameters to use in executing the query
* @param Mapper<TDoc> $mapper Mapper to deserialize the result * @param Mapper<TDoc> $mapper Mapper to deserialize the result
* @return TDoc[] The items matching the query * @return TDoc[] The items matching the query
* @throws DocumentException If any is encountered * @throws DocumentException If any is encountered
@ -97,7 +97,7 @@ class Custom
* *
* @template TDoc The domain type of the document to retrieve * @template TDoc The domain type of the document to retrieve
* @param string $query The query to be executed (will have "LIMIT 1" appended) * @param string $query The query to be executed (will have "LIMIT 1" appended)
* @param array $parameters Parameters to use in executing the query * @param array<string, mixed> $parameters Parameters to use in executing the query
* @param Mapper<TDoc> $mapper Mapper to deserialize the result * @param Mapper<TDoc> $mapper Mapper to deserialize the result
* @return Option<TDoc> A `Some` instance if the item is found, `None` otherwise * @return Option<TDoc> A `Some` instance if the item is found, `None` otherwise
* @throws DocumentException If any is encountered * @throws DocumentException If any is encountered
@ -116,7 +116,7 @@ class Custom
* Execute a query that does not return a value * Execute a query that does not return a value
* *
* @param string $query The query to execute * @param string $query The query to execute
* @param array $parameters Parameters to use in executing the query * @param array<string, mixed> $parameters Parameters to use in executing the query
* @throws DocumentException If any is encountered * @throws DocumentException If any is encountered
*/ */
public static function nonQuery(string $query, array $parameters): void public static function nonQuery(string $query, array $parameters): void
@ -133,7 +133,7 @@ class Custom
* *
* @template T The scalar type to return * @template T The scalar type to return
* @param string $query The query to retrieve the value * @param string $query The query to retrieve the value
* @param array $parameters Parameters to use in executing the query * @param array<string, mixed> $parameters Parameters to use in executing the query
* @param Mapper<T> $mapper The mapper to obtain the result * @param Mapper<T> $mapper The mapper to obtain the result
* @return mixed|false|T The scalar value if found, false if not * @return mixed|false|T The scalar value if found, false if not
* @throws DocumentException If any is encountered * @throws DocumentException If any is encountered

2
src/Definition.php
View File

@ -30,7 +30,7 @@ class Definition
* *
* @param string $tableName The name of the table which should be indexed * @param string $tableName The name of the table which should be indexed
* @param string $indexName The name of the index * @param string $indexName The name of the index
* @param array $fields Fields which should be a part of this index * @param string[] $fields Fields which should be a part of this index
* @throws DocumentException If any is encountered * @throws DocumentException If any is encountered
*/ */
public static function ensureFieldIndex(string $tableName, string $indexName, array $fields): void public static function ensureFieldIndex(string $tableName, string $indexName, array $fields): void

9
src/Delete.php
View File

@ -29,22 +29,21 @@ class Delete
* Delete documents by matching a comparison on JSON fields * Delete documents by matching a comparison on JSON fields
* *
* @param string $tableName The table from which documents should be deleted * @param string $tableName The table from which documents should be deleted
* @param array|Field[] $fields The field comparison to match * @param Field[] $fields The field comparison to match
* @param FieldMatch|null $match How to handle multiple conditions (optional; defaults to All) * @param FieldMatch|null $match How to handle multiple conditions (optional; defaults to All)
* @throws DocumentException If any is encountered * @throws DocumentException If any is encountered
*/ */
public static function byFields(string $tableName, array $fields, ?FieldMatch $match = null): void public static function byFields(string $tableName, array $fields, ?FieldMatch $match = null): void
{ {
$namedFields = Parameters::nameFields($fields); Parameters::nameFields($fields);
Custom::nonQuery(Query\Delete::byFields($tableName, $namedFields, $match), Custom::nonQuery(Query\Delete::byFields($tableName, $fields, $match), Parameters::addFields($fields, []));
Parameters::addFields($namedFields, []));
} }
/** /**
* Delete documents matching a JSON containment query (`@>`; PostgreSQL only) * Delete documents matching a JSON containment query (`@>`; PostgreSQL only)
* *
* @param string $tableName The table from which documents should be deleted * @param string $tableName The table from which documents should be deleted
* @param array|object $criteria The JSON containment query values * @param mixed[]|object $criteria The JSON containment query values
* @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs * @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs
*/ */
public static function byContains(string $tableName, array|object $criteria): void public static function byContains(string $tableName, array|object $criteria): void

6
src/Document.php
View File

@ -17,7 +17,7 @@ class Document
* Insert a new document * Insert a new document
* *
* @param string $tableName The name of the table into which the document should be inserted * @param string $tableName The name of the table into which the document should be inserted
* @param array|object $document The document to be inserted * @param mixed[]|object $document The document to be inserted
* @throws DocumentException If any is encountered * @throws DocumentException If any is encountered
*/ */
public static function insert(string $tableName, array|object $document): void public static function insert(string $tableName, array|object $document): void
@ -47,7 +47,7 @@ class Document
* Save a document, inserting it if it does not exist and updating it if it does (AKA "upsert") * Save a document, inserting it if it does not exist and updating it if it does (AKA "upsert")
* *
* @param string $tableName The name of the table to which the document should be saved * @param string $tableName The name of the table to which the document should be saved
* @param array|object $document The document to be saved * @param mixed[]|object $document The document to be saved
* @throws DocumentException If any is encountered * @throws DocumentException If any is encountered
*/ */
public static function save(string $tableName, array|object $document): void public static function save(string $tableName, array|object $document): void
@ -60,7 +60,7 @@ class Document
* *
* @param string $tableName The table in which the document should be updated * @param string $tableName The table in which the document should be updated
* @param mixed $docId The ID of the document to be updated * @param mixed $docId The ID of the document to be updated
* @param array|object $document The document to be updated * @param mixed[]|object $document The document to be updated
* @throws DocumentException If any is encountered * @throws DocumentException If any is encountered
*/ */
public static function update(string $tableName, mixed $docId, array|object $document): void public static function update(string $tableName, mixed $docId, array|object $document): void

23
src/DocumentList.php
View File

@ -35,10 +35,12 @@ class DocumentList
*/ */
private function __construct(private ?PDOStatement &$result, private readonly Mapper $mapper) private function __construct(private ?PDOStatement &$result, private readonly Mapper $mapper)
{ {
if ($row = $this->result->fetch(PDO::FETCH_ASSOC)) { if (!is_null($this->result)) {
$this->first = $this->mapper->map($row); if ($row = $this->result->fetch(PDO::FETCH_ASSOC)) {
} else { $this->first = $this->mapper->map($row);
$this->result = null; } else {
$this->result = null;
}
} }
} }
@ -67,6 +69,11 @@ class DocumentList
$this->isConsumed = true; $this->isConsumed = true;
return; return;
} }
if (!$this->first) {
$this->isConsumed = true;
$this->result = null;
return;
}
yield $this->first; yield $this->first;
while ($row = $this->result->fetch(PDO::FETCH_ASSOC)) { while ($row = $this->result->fetch(PDO::FETCH_ASSOC)) {
yield $this->mapper->map($row); yield $this->mapper->map($row);
@ -133,14 +140,14 @@ class DocumentList
* Construct a new document list * Construct a new document list
* *
* @param string $query The query to run to retrieve results * @param string $query The query to run to retrieve results
* @param array $parameters An associative array of parameters for the query * @param array<string, mixed> $parameters An associative array of parameters for the query
* @param Mapper<TDoc> $mapper A mapper to deserialize JSON documents * @param Mapper<TDoc> $mapper A mapper to deserialize JSON documents
* @return static The document list instance * @return self<TDoc> The document list instance
* @throws DocumentException If any is encountered * @throws DocumentException If any is encountered
*/ */
public static function create(string $query, array $parameters, Mapper $mapper): static public static function create(string $query, array $parameters, Mapper $mapper): self
{ {
$stmt = &Custom::runQuery($query, $parameters); $stmt = &Custom::runQuery($query, $parameters);
return new static($stmt, $mapper); return new self($stmt, $mapper);
} }
} }

8
src/Exists.php
View File

@ -39,16 +39,16 @@ class Exists
*/ */
public static function byFields(string $tableName, array $fields, ?FieldMatch $match = null): bool public static function byFields(string $tableName, array $fields, ?FieldMatch $match = null): bool
{ {
$namedFields = Parameters::nameFields($fields); Parameters::nameFields($fields);
return Custom::scalar(Query\Exists::byFields($tableName, $namedFields, $match), return Custom::scalar(Query\Exists::byFields($tableName, $fields, $match), Parameters::addFields($fields, []),
Parameters::addFields($namedFields, []), new ExistsMapper()); new ExistsMapper());
} }
/** /**
* Determine if documents exist by a JSON containment query (`@>`; PostgreSQL only) * Determine if documents exist by a JSON containment query (`@>`; PostgreSQL only)
* *
* @param string $tableName The name of the table in which document existence should be determined * @param string $tableName The name of the table in which document existence should be determined
* @param array|object $criteria The criteria for the JSON containment query * @param mixed[]|object $criteria The criteria for the JSON containment query
* @return bool True if any documents match the JSON containment query, false if not * @return bool True if any documents match the JSON containment query, false if not
* @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs * @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs
*/ */

300
src/Field.php
View File

@ -27,31 +27,67 @@ class Field
* @param string $paramName The name of the parameter to which this should be bound * @param string $paramName The name of the parameter to which this should be bound
* @param string $qualifier A table qualifier for the `data` column * @param string $qualifier A table qualifier for the `data` column
*/ */
public function __construct(public string $fieldName = '', public Op $op = Op::EQ, public mixed $value = '', public function __construct(public string $fieldName = '', public Op $op = Op::Equal, public mixed $value = '',
public string $paramName = '', public string $qualifier = '') { } public string $paramName = '', public string $qualifier = '') { }
/** /**
* Append the parameter name and value to the given associative array * Append the parameter name and value to the given associative array
* *
* @param array $existing The existing parameters * @param array<string, mixed> $existing The existing parameters
* @return array The given parameter array with this field's name and value appended * @return array<string, mixed> The given parameter array with this field's name and value(s) appended
*/ */
public function appendParameter(array $existing): array public function appendParameter(array $existing): array
{ {
switch ($this->op) { switch ($this->op) {
case Op::EX: case Op::Exists:
case Op::NEX: case Op::NotExists:
break; break;
case Op::BT: case Op::Between:
$existing["{$this->paramName}min"] = $this->value[0]; $existing["{$this->paramName}min"] = $this->value[0];
$existing["{$this->paramName}max"] = $this->value[1]; $existing["{$this->paramName}max"] = $this->value[1];
break; break;
case Op::In:
for ($idx = 0; $idx < count($this->value); $idx++) {
$existing["{$this->paramName}_$idx"] = $this->value[$idx];
}
break;
case Op::InArray:
$mkString = Configuration::mode("Append parameters for InArray condition") === Mode::PgSQL;
$values = $this->value['values'];
for ($idx = 0; $idx < count($values); $idx++) {
$existing["{$this->paramName}_$idx"] = $mkString ? "$values[$idx]" : $values[$idx];
}
break;
default: default:
$existing[$this->paramName] = $this->value; $existing[$this->paramName] = $this->value;
} }
return $existing; return $existing;
} }
/**
* Derive the path for this field
*
* @param bool $asJSON Whether the field should be treated as JSON in the query (optional, default false)
* @return string The path for this field
* @throws Exception If the database mode has not been set
*/
public function path(bool $asJSON = false): string
{
$extra = $asJSON ? '' : '>';
if (str_contains($this->fieldName, '.')) {
$mode = Configuration::mode('determine field path');
if ($mode === Mode::PgSQL) {
return "data#>$extra'{" . implode(',', explode('.', $this->fieldName)) . "}'";
}
if ($mode === Mode::SQLite) {
$parts = explode('.', $this->fieldName);
$last = array_pop($parts);
return "data->'" . implode("'->'", $parts) . "'->$extra'$last'";
}
}
return "data->$extra'$this->fieldName'";
}
/** /**
* Get the WHERE clause fragment for this parameter * Get the WHERE clause fragment for this parameter
* *
@ -60,26 +96,41 @@ class Field
*/ */
public function toWhere(): string public function toWhere(): string
{ {
$mode = Configuration::mode('make field WHERE clause'); $mode = Configuration::mode('make field WHERE clause');
$fieldName = (empty($this->qualifier) ? '' : "$this->qualifier.") . 'data' . match (true) { $fieldName = (empty($this->qualifier) ? '' : "$this->qualifier.") . $this->path($this->op === Op::InArray);
!str_contains($this->fieldName, '.') => "->>'$this->fieldName'", $fieldPath = match ($mode) {
$mode === Mode::PgSQL => "#>>'{" . implode(',', explode('.', $this->fieldName)) . "}'",
$mode === Mode::SQLite => "->>'" . implode("'->>'", explode('.', $this->fieldName)) . "'",
};
$fieldPath = match ($mode) {
Mode::PgSQL => match (true) { Mode::PgSQL => match (true) {
$this->op === Op::BT => is_numeric($this->value[0]) ? "($fieldName)::numeric" : $fieldName, $this->op === Op::Between,
is_numeric($this->value) => "($fieldName)::numeric", $this->op === Op::In => is_numeric($this->value[0]) ? "($fieldName)::numeric" : $fieldName,
default => $fieldName, is_numeric($this->value) => "($fieldName)::numeric",
default => $fieldName,
}, },
default => $fieldName, default => $fieldName,
}; };
$criteria = match ($this->op) { $criteria = match ($this->op) {
Op::EX, Op::NEX => '', Op::Exists,
Op::BT => " {$this->paramName}min AND {$this->paramName}max", Op::NotExists => '',
default => " $this->paramName", Op::Between => " {$this->paramName}min AND {$this->paramName}max",
Op::In => ' (' . $this->inParameterNames() . ')',
Op::InArray => $mode === Mode::PgSQL ? ' ARRAY[' . $this->inParameterNames() . ']' : '',
default => " $this->paramName",
}; };
return $fieldPath . ' ' . $this->op->toSQL() . $criteria; return $mode === Mode::SQLite && $this->op === Op::InArray
? "EXISTS (SELECT 1 FROM json_each({$this->value['table']}.data, '\$.$this->fieldName') WHERE value IN ("
. $this->inParameterNames() . '))'
: $fieldPath . ' ' . $this->op->toSQL() . $criteria;
}
/**
* Create parameter names for an IN clause
*
* @return string A comma-delimited string of parameter names
*/
private function inParameterNames(): string
{
$values = $this->op === Op::In ? $this->value : $this->value['values'];
return implode(', ',
array_map(fn($value, $key) => "{$this->paramName}_$key", $values, range(0, count($values) - 1)));
} }
/** /**
@ -88,11 +139,24 @@ class Field
* @param string $fieldName The name of the field against which the value will be compared * @param string $fieldName The name of the field against which the value will be compared
* @param mixed $value The value for which equality will be checked * @param mixed $value The value for which equality will be checked
* @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank) * @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
* @return static The field with the requested criterion * @return self The field with the requested criterion
*/ */
public static function EQ(string $fieldName, mixed $value, string $paramName = ''): static public static function equal(string $fieldName, mixed $value, string $paramName = ''): self
{ {
return new static($fieldName, Op::EQ, $value, $paramName); return new self($fieldName, Op::Equal, $value, $paramName);
}
/**
* Create an equals (=) field criterion _(alias for `Field.equal`)_
*
* @param string $fieldName The name of the field against which the value will be compared
* @param mixed $value The value for which equality will be checked
* @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
* @return self The field with the requested criterion
*/
public static function EQ(string $fieldName, mixed $value, string $paramName = ''): self
{
return self::equal($fieldName, $value, $paramName);
} }
/** /**
@ -101,11 +165,24 @@ class Field
* @param string $fieldName The name of the field against which the value will be compared * @param string $fieldName The name of the field against which the value will be compared
* @param mixed $value The value for the greater than comparison * @param mixed $value The value for the greater than comparison
* @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank) * @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
* @return static The field with the requested criterion * @return self The field with the requested criterion
*/ */
public static function GT(string $fieldName, mixed $value, string $paramName = ''): static public static function greater(string $fieldName, mixed $value, string $paramName = ''): self
{ {
return new static($fieldName, Op::GT, $value, $paramName); return new self($fieldName, Op::Greater, $value, $paramName);
}
/**
* Create a greater than (>) field criterion _(alias for `Field.greater`)_
*
* @param string $fieldName The name of the field against which the value will be compared
* @param mixed $value The value for the greater than comparison
* @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
* @return self The field with the requested criterion
*/
public static function GT(string $fieldName, mixed $value, string $paramName = ''): self
{
return self::greater($fieldName, $value, $paramName);
} }
/** /**
@ -114,11 +191,24 @@ class Field
* @param string $fieldName The name of the field against which the value will be compared * @param string $fieldName The name of the field against which the value will be compared
* @param mixed $value The value for the greater than or equal to comparison * @param mixed $value The value for the greater than or equal to comparison
* @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank) * @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
* @return static The field with the requested criterion * @return self The field with the requested criterion
*/ */
public static function GE(string $fieldName, mixed $value, string $paramName = ''): static public static function greaterOrEqual(string $fieldName, mixed $value, string $paramName = ''): self
{ {
return new static($fieldName, Op::GE, $value, $paramName); return new self($fieldName, Op::GreaterOrEqual, $value, $paramName);
}
/**
* Create a greater than or equal to (>=) field criterion _(alias for `Field.greaterOrEqual`)_
*
* @param string $fieldName The name of the field against which the value will be compared
* @param mixed $value The value for the greater than or equal to comparison
* @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
* @return self The field with the requested criterion
*/
public static function GE(string $fieldName, mixed $value, string $paramName = ''): self
{
return self::greaterOrEqual($fieldName, $value, $paramName);
} }
/** /**
@ -127,11 +217,24 @@ class Field
* @param string $fieldName The name of the field against which the value will be compared * @param string $fieldName The name of the field against which the value will be compared
* @param mixed $value The value for the less than comparison * @param mixed $value The value for the less than comparison
* @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank) * @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
* @return static The field with the requested criterion * @return self The field with the requested criterion
*/ */
public static function LT(string $fieldName, mixed $value, string $paramName = ''): static public static function less(string $fieldName, mixed $value, string $paramName = ''): self
{ {
return new static($fieldName, Op::LT, $value, $paramName); return new self($fieldName, Op::Less, $value, $paramName);
}
/**
* Create a less than (<) field criterion _(alias for `Field.less`)_
*
* @param string $fieldName The name of the field against which the value will be compared
* @param mixed $value The value for the less than comparison
* @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
* @return self The field with the requested criterion
*/
public static function LT(string $fieldName, mixed $value, string $paramName = ''): self
{
return self::less($fieldName, $value, $paramName);
} }
/** /**
@ -140,11 +243,24 @@ class Field
* @param string $fieldName The name of the field against which the value will be compared * @param string $fieldName The name of the field against which the value will be compared
* @param mixed $value The value for the less than or equal to comparison * @param mixed $value The value for the less than or equal to comparison
* @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank) * @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
* @return static The field with the requested criterion * @return self The field with the requested criterion
*/ */
public static function LE(string $fieldName, mixed $value, string $paramName = ''): static public static function lessOrEqual(string $fieldName, mixed $value, string $paramName = ''): self
{ {
return new static($fieldName, Op::LE, $value, $paramName); return new self($fieldName, Op::LessOrEqual, $value, $paramName);
}
/**
* Create a less than or equal to (<=) field criterion _(alias for `Field.lessOrEqual`)_
*
* @param string $fieldName The name of the field against which the value will be compared
* @param mixed $value The value for the less than or equal to comparison
* @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
* @return self The field with the requested criterion
*/
public static function LE(string $fieldName, mixed $value, string $paramName = ''): self
{
return self::lessOrEqual($fieldName, $value, $paramName);
} }
/** /**
@ -153,11 +269,24 @@ class Field
* @param string $fieldName The name of the field against which the value will be compared * @param string $fieldName The name of the field against which the value will be compared
* @param mixed $value The value for the not equals comparison * @param mixed $value The value for the not equals comparison
* @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank) * @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
* @return static The field with the requested criterion * @return self The field with the requested criterion
*/ */
public static function NE(string $fieldName, mixed $value, string $paramName = ''): static public static function notEqual(string $fieldName, mixed $value, string $paramName = ''): self
{ {
return new static($fieldName, Op::NE, $value, $paramName); return new self($fieldName, Op::NotEqual, $value, $paramName);
}
/**
* Create a not equals (<>) field criterion _(alias for `Field.notEqual`)_
*
* @param string $fieldName The name of the field against which the value will be compared
* @param mixed $value The value for the not equals comparison
* @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
* @return self The field with the requested criterion
*/
public static function NE(string $fieldName, mixed $value, string $paramName = ''): self
{
return self::notEqual($fieldName, $value, $paramName);
} }
/** /**
@ -167,32 +296,109 @@ class Field
* @param mixed $minValue The lower value for range * @param mixed $minValue The lower value for range
* @param mixed $maxValue The upper value for the range * @param mixed $maxValue The upper value for the range
* @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank) * @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
* @return static The field with the requested criterion * @return self The field with the requested criterion
*/ */
public static function BT(string $fieldName, mixed $minValue, mixed $maxValue, string $paramName = ''): static public static function between(string $fieldName, mixed $minValue, mixed $maxValue, string $paramName = ''): self
{ {
return new static($fieldName, Op::BT, [$minValue, $maxValue], $paramName); return new self($fieldName, Op::Between, [$minValue, $maxValue], $paramName);
}
/**
* Create a BETWEEN field criterion _(alias for `Field.between`)_
*
* @param string $fieldName The name of the field against which the value will be compared
* @param mixed $minValue The lower value for range
* @param mixed $maxValue The upper value for the range
* @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
* @return self The field with the requested criterion
*/
public static function BT(string $fieldName, mixed $minValue, mixed $maxValue, string $paramName = ''): self
{
return self::between($fieldName, $minValue, $maxValue, $paramName);
}
/**
* Create an IN field criterion
*
* @param string $fieldName The name of the field against which the values will be compared
* @param mixed[] $values The potential matching values for the field
* @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
* @return self The field with the requested criterion
*/
public static function in(string $fieldName, array $values, string $paramName = ''): self
{
return new self($fieldName, Op::In, $values, $paramName);
}
/**
* Create an IN ARRAY field criterion
*
* @param string $fieldName The name of the field against which the values will be compared
* @param string $tableName The table name where this field is located
* @param mixed[] $values The potential matching values for the field
* @param string $paramName The name of the parameter to which this should be bound (optional; generated if blank)
* @return self The field with the requested criterion
*/
public static function inArray(string $fieldName, string $tableName, array $values, string $paramName = ''): self
{
return new self($fieldName, Op::InArray, ['table' => $tableName, 'values' => $values], $paramName);
} }
/** /**
* Create an exists (IS NOT NULL) field criterion * Create an exists (IS NOT NULL) field criterion
* *
* @param string $fieldName The name of the field for which existence will be checked * @param string $fieldName The name of the field for which existence will be checked
* @return static The field with the requested criterion * @return self The field with the requested criterion
*/ */
public static function EX(string $fieldName): static public static function exists(string $fieldName): self
{ {
return new static($fieldName, Op::EX, '', ''); return new self($fieldName, Op::Exists, '', '');
}
/**
* Create an exists (IS NOT NULL) field criterion _(alias for `Field.exists`)_
*
* @param string $fieldName The name of the field for which existence will be checked
* @return self The field with the requested criterion
*/
public static function EX(string $fieldName): self
{
return self::exists($fieldName);
} }
/** /**
* Create a not exists (IS NULL) field criterion * Create a not exists (IS NULL) field criterion
* *
* @param string $fieldName The name of the field for which non-existence will be checked * @param string $fieldName The name of the field for which non-existence will be checked
* @return static The field with the requested criterion * @return self The field with the requested criterion
*/ */
public static function NEX(string $fieldName): static public static function notExists(string $fieldName): self
{ {
return new static($fieldName, Op::NEX, '', ''); return new self($fieldName, Op::NotExists, '', '');
}
/**
* Create a not exists (IS NULL) field criterion _(alias for `Field.notExists`)_
*
* @param string $fieldName The name of the field for which non-existence will be checked
* @return self The field with the requested criterion
*/
public static function NEX(string $fieldName): self
{
return self::notExists($fieldName);
}
/**
* Create a named fields (used for creating fields for ORDER BY clauses)
*
* Prepend the field name with 'n:' to treat the field as a number; prepend the field name with 'i:' to perform
* a case-insensitive ordering.
*
* @param string $name The name of the field, plus any direction for the ordering
* @return self
*/
public static function named(string $name): self
{
return new self($name, Op::Equal, '', '');
} }
} }

62
src/Find.php
View File

@ -22,12 +22,14 @@ class Find
* @template TDoc The type of document to be retrieved * @template TDoc The type of document to be retrieved
* @param string $tableName The table from which documents should be retrieved * @param string $tableName The table from which documents should be retrieved
* @param class-string<TDoc> $className The name of the class to be retrieved * @param class-string<TDoc> $className The name of the class to be retrieved
* @param Field[] $orderBy Fields by which the results should be ordered (optional, default no ordering)
* @return DocumentList<TDoc> A list of all documents from the table * @return DocumentList<TDoc> A list of all documents from the table
* @throws DocumentException If any is encountered * @throws DocumentException If any is encountered
*/ */
public static function all(string $tableName, string $className): DocumentList public static function all(string $tableName, string $className, array $orderBy = []): DocumentList
{ {
return Custom::list(Query::selectFromTable($tableName), [], new DocumentMapper($className)); return Custom::list(Query::selectFromTable($tableName) . Query::orderBy($orderBy), [],
new DocumentMapper($className));
} }
/** /**
@ -51,18 +53,19 @@ class Find
* *
* @template TDoc The type of document to be retrieved * @template TDoc The type of document to be retrieved
* @param string $tableName The table from which documents should be retrieved * @param string $tableName The table from which documents should be retrieved
* @param array|Field[] $fields The field comparison to match * @param Field[] $fields The field comparison to match
* @param class-string<TDoc> $className The name of the class to be retrieved * @param class-string<TDoc> $className The name of the class to be retrieved
* @param FieldMatch|null $match How to handle multiple conditions (optional; defaults to All) * @param FieldMatch|null $match How to handle multiple conditions (optional; defaults to All)
* @param Field[] $orderBy Fields by which the results should be ordered (optional, default no ordering)
* @return DocumentList<TDoc> A list of documents matching the given field comparison * @return DocumentList<TDoc> A list of documents matching the given field comparison
* @throws DocumentException If any is encountered * @throws DocumentException If any is encountered
*/ */
public static function byFields(string $tableName, array $fields, string $className, public static function byFields(string $tableName, array $fields, string $className,
?FieldMatch $match = null): DocumentList ?FieldMatch $match = null, array $orderBy = []): DocumentList
{ {
$namedFields = Parameters::nameFields($fields); Parameters::nameFields($fields);
return Custom::list(Query\Find::byFields($tableName, $namedFields, $match), return Custom::list(Query\Find::byFields($tableName, $fields, $match) . Query::orderBy($orderBy),
Parameters::addFields($namedFields, []), new DocumentMapper($className)); Parameters::addFields($fields, []), new DocumentMapper($className));
} }
/** /**
@ -70,15 +73,17 @@ class Find
* *
* @template TDoc The type of document to be retrieved * @template TDoc The type of document to be retrieved
* @param string $tableName The name of the table from which documents should be retrieved * @param string $tableName The name of the table from which documents should be retrieved
* @param array|object $criteria The criteria for the JSON containment query * @param mixed[]|object $criteria The criteria for the JSON containment query
* @param class-string<TDoc> $className The name of the class to be retrieved * @param class-string<TDoc> $className The name of the class to be retrieved
* @param Field[] $orderBy Fields by which the results should be ordered (optional, default no ordering)
* @return DocumentList<TDoc> A list of documents matching the JSON containment query * @return DocumentList<TDoc> A list of documents matching the JSON containment query
* @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs * @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs
*/ */
public static function byContains(string $tableName, array|object $criteria, string $className): DocumentList public static function byContains(string $tableName, array|object $criteria, string $className,
array $orderBy = []): DocumentList
{ {
return Custom::list(Query\Find::byContains($tableName), Parameters::json(':criteria', $criteria), return Custom::list(Query\Find::byContains($tableName) . Query::orderBy($orderBy),
new DocumentMapper($className)); Parameters::json(':criteria', $criteria), new DocumentMapper($className));
} }
/** /**
@ -88,12 +93,15 @@ class Find
* @param string $tableName The name of the table from which documents should be retrieved * @param string $tableName The name of the table from which documents should be retrieved
* @param string $path The JSON Path match string * @param string $path The JSON Path match string
* @param class-string<TDoc> $className The name of the class to be retrieved * @param class-string<TDoc> $className The name of the class to be retrieved
* @param Field[] $orderBy Fields by which the results should be ordered (optional, default no ordering)
* @return DocumentList<TDoc> A list of documents matching the JSON Path * @return DocumentList<TDoc> A list of documents matching the JSON Path
* @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs * @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs
*/ */
public static function byJsonPath(string $tableName, string $path, string $className): DocumentList public static function byJsonPath(string $tableName, string $path, string $className,
array $orderBy = []): DocumentList
{ {
return Custom::list(Query\Find::byJsonPath($tableName), [':path' => $path], new DocumentMapper($className)); return Custom::list(Query\Find::byJsonPath($tableName) . Query::orderBy($orderBy), [':path' => $path],
new DocumentMapper($className));
} }
/** /**
@ -101,18 +109,19 @@ class Find
* *
* @template TDoc The type of document to be retrieved * @template TDoc The type of document to be retrieved
* @param string $tableName The table from which the document should be retrieved * @param string $tableName The table from which the document should be retrieved
* @param array|Field[] $fields The field comparison to match * @param Field[] $fields The field comparison to match
* @param class-string<TDoc> $className The name of the class to be retrieved * @param class-string<TDoc> $className The name of the class to be retrieved
* @param FieldMatch|null $match How to handle multiple conditions (optional; defaults to All) * @param FieldMatch|null $match How to handle multiple conditions (optional; defaults to All)
* @param Field[] $orderBy Fields by which the results should be ordered (optional, default no ordering)
* @return Option<TDoc> A `Some` instance with the first document if any matches are found, `None` otherwise * @return Option<TDoc> A `Some` instance with the first document if any matches are found, `None` otherwise
* @throws DocumentException If any is encountered * @throws DocumentException If any is encountered
*/ */
public static function firstByFields(string $tableName, array $fields, string $className, public static function firstByFields(string $tableName, array $fields, string $className,
?FieldMatch $match = null): Option ?FieldMatch $match = null, array $orderBy = []): Option
{ {
$namedFields = Parameters::nameFields($fields); Parameters::nameFields($fields);
return Custom::single(Query\Find::byFields($tableName, $namedFields, $match), return Custom::single(Query\Find::byFields($tableName, $fields, $match) . Query::orderBy($orderBy),
Parameters::addFields($namedFields, []), new DocumentMapper($className)); Parameters::addFields($fields, []), new DocumentMapper($className));
} }
/** /**
@ -120,15 +129,17 @@ class Find
* *
* @template TDoc The type of document to be retrieved * @template TDoc The type of document to be retrieved
* @param string $tableName The name of the table from which documents should be retrieved * @param string $tableName The name of the table from which documents should be retrieved
* @param array|object $criteria The criteria for the JSON containment query * @param mixed[]|object $criteria The criteria for the JSON containment query
* @param class-string<TDoc> $className The name of the class to be retrieved * @param class-string<TDoc> $className The name of the class to be retrieved
* @param Field[] $orderBy Fields by which the results should be ordered (optional, default no ordering)
* @return Option<TDoc> A `Some` instance with the first document if any matches are found, `None` otherwise * @return Option<TDoc> A `Some` instance with the first document if any matches are found, `None` otherwise
* @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs * @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs
*/ */
public static function firstByContains(string $tableName, array|object $criteria, string $className): Option public static function firstByContains(string $tableName, array|object $criteria, string $className,
array $orderBy = []): Option
{ {
return Custom::single(Query\Find::byContains($tableName), Parameters::json(':criteria', $criteria), return Custom::single(Query\Find::byContains($tableName) . Query::orderBy($orderBy),
new DocumentMapper($className)); Parameters::json(':criteria', $criteria), new DocumentMapper($className));
} }
/** /**
@ -138,11 +149,14 @@ class Find
* @param string $tableName The name of the table from which documents should be retrieved * @param string $tableName The name of the table from which documents should be retrieved
* @param string $path The JSON Path match string * @param string $path The JSON Path match string
* @param class-string<TDoc> $className The name of the class to be retrieved * @param class-string<TDoc> $className The name of the class to be retrieved
* @param Field[] $orderBy Fields by which the results should be ordered (optional, default no ordering)
* @return Option<TDoc> A `Some` instance with the first document if any matches are found, `None` otherwise * @return Option<TDoc> A `Some` instance with the first document if any matches are found, `None` otherwise
* @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs * @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs
*/ */
public static function firstByJsonPath(string $tableName, string $path, string $className): Option public static function firstByJsonPath(string $tableName, string $path, string $className,
array $orderBy = []): Option
{ {
return Custom::single(Query\Find::byJsonPath($tableName), [':path' => $path], new DocumentMapper($className)); return Custom::single(Query\Find::byJsonPath($tableName) . Query::orderBy($orderBy), [':path' => $path],
new DocumentMapper($className));
} }
} }

7
src/Mapper/ArrayMapper.php
View File

@ -10,10 +10,15 @@ namespace BitBadger\PDODocument\Mapper;
/** /**
* A mapper that returns the associative array from the database * A mapper that returns the associative array from the database
*
* @implements Mapper<array<string|int, mixed>>
*/ */
class ArrayMapper implements Mapper class ArrayMapper implements Mapper
{ {
/** @inheritDoc */ /**
* @inheritDoc
* @return array<string|int, mixed> The array given as the parameter
*/
public function map(array $result): array public function map(array $result): array
{ {
return $result; return $result;

2
src/Mapper/CountMapper.php
View File

@ -10,6 +10,8 @@ namespace BitBadger\PDODocument\Mapper;
/** /**
* A mapper that returns the integer value of the first item in the results * A mapper that returns the integer value of the first item in the results
*
* @implements Mapper<int>
*/ */
class CountMapper implements Mapper class CountMapper implements Mapper
{ {

2
src/Mapper/DocumentMapper.php
View File

@ -31,7 +31,7 @@ class DocumentMapper implements Mapper
/** /**
* Map a result to a domain class instance * Map a result to a domain class instance
* *
* @param array $result An associative array representing a single database result * @param array<string|int, mixed> $result An associative array representing a single database result
* @return TDoc The document, deserialized from its JSON representation * @return TDoc The document, deserialized from its JSON representation
* @throws DocumentException If the JSON cannot be deserialized * @throws DocumentException If the JSON cannot be deserialized
*/ */

2
src/Mapper/ExistsMapper.php
View File

@ -13,6 +13,8 @@ use Exception;
/** /**
* Map an EXISTS result to a boolean value * Map an EXISTS result to a boolean value
*
* @implements Mapper<bool>
*/ */
class ExistsMapper implements Mapper class ExistsMapper implements Mapper
{ {

2
src/Mapper/Mapper.php
View File

@ -18,7 +18,7 @@ interface Mapper
/** /**
* Map a result to the specified type * Map a result to the specified type
* *
* @param array $result An associative array representing a single database result * @param array<string|int, mixed> $result An associative array representing a single database result
* @return T The item mapped from the given result * @return T The item mapped from the given result
*/ */
public function map(array $result): mixed; public function map(array $result): mixed;

44
src/Op.php
View File

@ -9,28 +9,32 @@ declare(strict_types=1);
namespace BitBadger\PDODocument; namespace BitBadger\PDODocument;
/** /**
* The types of logical operations allowed for JSON fields * The types of comparison operators allowed for JSON fields
*/ */
enum Op enum Op
{ {
/** Equals (=) */ /** Equals (=) */
case EQ; case Equal;
/** Greater Than (>) */ /** Greater Than (>) */
case GT; case Greater;
/** Greater Than or Equal To (>=) */ /** Greater Than or Equal To (>=) */
case GE; case GreaterOrEqual;
/** Less Than (<) */ /** Less Than (<) */
case LT; case Less;
/** Less Than or Equal To (<=) */ /** Less Than or Equal To (<=) */
case LE; case LessOrEqual;
/** Not Equal to (<>) */ /** Not Equal to (<>) */
case NE; case NotEqual;
/** Between (BETWEEN) */ /** Between (BETWEEN) */
case BT; case Between;
/** In (IN) */
case In;
/** In Array (PostgreSQL - ?|, SQLite - EXISTS / json_each / IN) */
case InArray;
/** Exists (IS NOT NULL) */ /** Exists (IS NOT NULL) */
case EX; case Exists;
/** Does Not Exist (IS NULL) */ /** Does Not Exist (IS NULL) */
case NEX; case NotExists;
/** /**
* Get the SQL representation of this operator * Get the SQL representation of this operator
@ -40,15 +44,17 @@ enum Op
public function toSQL(): string public function toSQL(): string
{ {
return match ($this) { return match ($this) {
Op::EQ => "=", Op::Equal => "=",
Op::GT => ">", Op::Greater => ">",
Op::GE => ">=", Op::GreaterOrEqual => ">=",
Op::LT => "<", Op::Less => "<",
Op::LE => "<=", Op::LessOrEqual => "<=",
Op::NE => "<>", Op::NotEqual => "<>",
Op::BT => "BETWEEN", Op::Between => "BETWEEN",
Op::EX => "IS NOT NULL", Op::In => "IN",
Op::NEX => "IS NULL", Op::InArray => "??|", // The actual operator is ?|, but needs to be escaped by doubling
Op::Exists => "IS NOT NULL",
Op::NotExists => "IS NULL",
}; };
} }
} }

20
src/Parameters.php
View File

@ -19,19 +19,19 @@ class Parameters
* Create an ID parameter (name ":id", key will be treated as a string) * Create an ID parameter (name ":id", key will be treated as a string)
* *
* @param mixed $key The key representing the ID of the document * @param mixed $key The key representing the ID of the document
* @return array|string[] An associative array with an "@id" parameter/value pair * @return array<string, mixed> An associative array with an "@id" parameter/value pair
*/ */
public static function id(mixed $key): array public static function id(mixed $key): array
{ {
return [':id' => is_int($key) || is_string($key) ? $key : "$key"]; return [':id' => ((is_int($key) || is_string($key)) ? $key : "$key")];
} }
/** /**
* Create a parameter with a JSON value * Create a parameter with a JSON value
* *
* @param string $name The name of the JSON parameter * @param string $name The name of the JSON parameter
* @param object|array $document The value that should be passed as a JSON string * @param mixed[]|object $document The value that should be passed as a JSON string
* @return array An associative array with the named parameter/value pair * @return array<string, string> An associative array with the named parameter/value pair
*/ */
public static function json(string $name, object|array $document): array public static function json(string $name, object|array $document): array
{ {
@ -59,23 +59,21 @@ class Parameters
/** /**
* Fill in parameter names for any fields missing one * Fill in parameter names for any fields missing one
* *
* @param Field[] $fields The fields for the query * @param Field[] $fields The fields for the query (entries with no names will be modified)
* @return Field[] The fields, all with non-blank parameter names
*/ */
public static function nameFields(array $fields): array public static function nameFields(array &$fields): void
{ {
array_walk($fields, function (Field $field, int $idx) { array_walk($fields, function (Field $field, int $idx) {
if (empty($field->paramName)) $field->paramName =":field$idx"; if (empty($field->paramName)) $field->paramName =":field$idx";
}); });
return $fields;
} }
/** /**
* Add field parameters to the given set of parameters * Add field parameters to the given set of parameters
* *
* @param Field[] $fields The fields being compared in the query * @param Field[] $fields The fields being compared in the query
* @param array $parameters An associative array of parameters to which the fields should be added * @param array<string, mixed> $parameters An associative array of parameters to which the fields should be added
* @return array An associative array of parameter names and values with the fields added * @return array<string, mixed> An associative array of parameter names and values with the fields added
*/ */
public static function addFields(array $fields, array $parameters): array public static function addFields(array $fields, array $parameters): array
{ {
@ -87,7 +85,7 @@ class Parameters
* *
* @param string $paramName The name of the parameter for the field names * @param string $paramName The name of the parameter for the field names
* @param string[] $fieldNames The names of the fields for the parameter * @param string[] $fieldNames The names of the fields for the parameter
* @return array An associative array of parameter/value pairs for the field names * @return array<string, string> An associative array of parameter/value pairs for the field names
* @throws Exception If the database mode has not been set * @throws Exception If the database mode has not been set
*/ */
public static function fieldNames(string $paramName, array $fieldNames): array public static function fieldNames(string $paramName, array $fieldNames): array

18
src/Patch.php
View File

@ -18,7 +18,7 @@ class Patch
* *
* @param string $tableName The table in which the document should be patched * @param string $tableName The table in which the document should be patched
* @param mixed $docId The ID of the document to be patched * @param mixed $docId The ID of the document to be patched
* @param array|object $patch The object with which the document should be patched (will be JSON-encoded) * @param mixed[]|object $patch The object with which the document should be patched (will be JSON-encoded)
* @throws DocumentException If any is encountered (database mode must be set) * @throws DocumentException If any is encountered (database mode must be set)
*/ */
public static function byId(string $tableName, mixed $docId, array|object $patch): void public static function byId(string $tableName, mixed $docId, array|object $patch): void
@ -31,25 +31,25 @@ class Patch
* Patch documents using a comparison on JSON fields * Patch documents using a comparison on JSON fields
* *
* @param string $tableName The table in which documents should be patched * @param string $tableName The table in which documents should be patched
* @param array|Field[] $fields The field comparison to match * @param Field[] $fields The field comparison to match
* @param array|object $patch The object with which the documents should be patched (will be JSON-encoded) * @param mixed[]|object $patch The object with which the documents should be patched (will be JSON-encoded)
* @param FieldMatch|null $match How to handle multiple conditions (optional; defaults to All) * @param FieldMatch|null $match How to handle multiple conditions (optional; defaults to All)
* @throws DocumentException If any is encountered * @throws DocumentException If any is encountered
*/ */
public static function byFields(string $tableName, array $fields, array|object $patch, public static function byFields(string $tableName, array $fields, array|object $patch,
?FieldMatch $match = null): void ?FieldMatch $match = null): void
{ {
$namedFields = Parameters::nameFields($fields); Parameters::nameFields($fields);
Custom::nonQuery(Query\Patch::byFields($tableName, $namedFields, $match), Custom::nonQuery(Query\Patch::byFields($tableName, $fields, $match),
Parameters::addFields($namedFields, Parameters::json(':data', $patch))); Parameters::addFields($fields, Parameters::json(':data', $patch)));
} }
/** /**
* Patch documents using a JSON containment query (`@>`; PostgreSQL only) * Patch documents using a JSON containment query (`@>`; PostgreSQL only)
* *
* @param string $tableName The table in which documents should be patched * @param string $tableName The table in which documents should be patched
* @param array|object $criteria The JSON containment query values to match * @param mixed[]|object $criteria The JSON containment query values to match
* @param array|object $patch The object with which the documents should be patched (will be JSON-encoded) * @param mixed[]|object $patch The object with which the documents should be patched (will be JSON-encoded)
* @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs * @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs
*/ */
public static function byContains(string $tableName, array|object $criteria, array|object $patch): void public static function byContains(string $tableName, array|object $criteria, array|object $patch): void
@ -63,7 +63,7 @@ class Patch
* *
* @param string $tableName The table in which documents should be patched * @param string $tableName The table in which documents should be patched
* @param string $path The JSON Path match string * @param string $path The JSON Path match string
* @param array|object $patch The object with which the documents should be patched (will be JSON-encoded) * @param mixed[]|object $patch The object with which the documents should be patched (will be JSON-encoded)
* @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs * @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs
*/ */
public static function byJsonPath(string $tableName, string $path, array|object $patch): void public static function byJsonPath(string $tableName, string $path, array|object $patch): void

44
src/Query.php
View File

@ -51,7 +51,7 @@ class Query
*/ */
public static function whereById(string $paramName = ':id', mixed $docId = null): string public static function whereById(string $paramName = ':id', mixed $docId = null): string
{ {
return self::whereByFields([Field::EQ(Configuration::$idField, $docId ?? '', $paramName)]); return self::whereByFields([Field::equal(Configuration::$idField, $docId ?? '', $paramName)]);
} }
/** /**
@ -142,4 +142,46 @@ class Query
{ {
return "UPDATE $tableName SET data = :data WHERE " . self::whereById(); return "UPDATE $tableName SET data = :data WHERE " . self::whereById();
} }
/**
* Create an `ORDER BY` clause ('n:' treats field as number, 'i:' does case-insensitive ordering)
*
* @param Field[] $fields The fields, named for the field plus directions (ex. 'field DESC NULLS FIRST')
* @return string The ORDER BY clause with the given fields
* @throws Exception If the database mode has not been set
*/
public static function orderBy(array $fields): string
{
if (empty($fields)) return "";
$mode = Configuration::mode('render ORDER BY clause');
$sqlFields = array_map(function (Field $it) use ($mode) {
if (str_contains($it->fieldName, ' ')) {
$parts = explode(' ', $it->fieldName);
$it->fieldName = array_shift($parts);
$direction = ' ' . implode(' ', $parts);
} else {
$direction = '';
}
if (str_starts_with($it->fieldName, 'n:')) {
$it->fieldName = substr($it->fieldName, 2);
$value = match ($mode) {
Mode::PgSQL => '(' . $it->path() . ')::numeric',
Mode::SQLite => $it->path()
};
} elseif (str_starts_with($it->fieldName, 'i:')) {
$it->fieldName = substr($it->fieldName, 2);
$value = match ($mode) {
Mode::PgSQL => 'LOWER(' . $it->path() . ')',
Mode::SQLite => $it->path() . ' COLLATE NOCASE'
};
} else {
$value = $it->path();
}
return $value . $direction;
}, $fields);
return ' ORDER BY ' . implode(', ', $sqlFields);
}
} }

2
src/Query/Definition.php
View File

@ -49,7 +49,7 @@ class Definition
* *
* @param string $tableName The name of the table which should be indexed * @param string $tableName The name of the table which should be indexed
* @param string $indexName The name of the index to create * @param string $indexName The name of the index to create
* @param array $fields An array of fields to be indexed; may contain direction (ex. 'salary DESC') * @param string[] $fields An array of fields to be indexed; may contain direction (ex. 'salary DESC')
* @return string The CREATE INDEX statement to ensure the index exists * @return string The CREATE INDEX statement to ensure the index exists
*/ */
public static function ensureIndexOn(string $tableName, string $indexName, array $fields): string public static function ensureIndexOn(string $tableName, string $indexName, array $fields): string

12
src/Query/RemoveFields.php
View File

@ -24,7 +24,7 @@ class RemoveFields
* Create an UPDATE statement to remove fields from a JSON document * Create an UPDATE statement to remove fields from a JSON document
* *
* @param string $tableName The name of the table in which documents should be manipulated * @param string $tableName The name of the table in which documents should be manipulated
* @param array $parameters The parameter list for the query * @param array<string, mixed> $parameters The parameter list for the query
* @param string $whereClause The body of the WHERE clause for the update * @param string $whereClause The body of the WHERE clause for the update
* @return string The UPDATE statement to remove fields from a JSON document * @return string The UPDATE statement to remove fields from a JSON document
* @throws Exception If the database mode has not been set * @throws Exception If the database mode has not been set
@ -43,7 +43,7 @@ class RemoveFields
* Query to remove fields from a document by the document's ID * Query to remove fields from a document by the document's ID
* *
* @param string $tableName The name of the table in which the document should be manipulated * @param string $tableName The name of the table in which the document should be manipulated
* @param array $parameters The parameter list for the query * @param array<string, mixed> $parameters The parameter list for the query
* @param mixed $docId The ID of the document from which fields should be removed (optional; string ID assumed) * @param mixed $docId The ID of the document from which fields should be removed (optional; string ID assumed)
* @return string The UPDATE statement to remove fields from a document by its ID * @return string The UPDATE statement to remove fields from a document by its ID
* @throws DocumentException If the database mode has not been set * @throws DocumentException If the database mode has not been set
@ -57,8 +57,8 @@ class RemoveFields
* Query to remove fields from documents via a comparison on JSON fields within the document * Query to remove fields from documents via a comparison on JSON fields within the document
* *
* @param string $tableName The name of the table in which documents should be manipulated * @param string $tableName The name of the table in which documents should be manipulated
* @param array|Field[] $fields The field comparison to match * @param Field[] $fields The field comparison to match
* @param array $parameters The parameter list for the query * @param array<string, mixed> $parameters The parameter list for the query
* @param FieldMatch|null $match How to handle multiple conditions (optional; defaults to All) * @param FieldMatch|null $match How to handle multiple conditions (optional; defaults to All)
* @return string The UPDATE statement to remove fields from documents via field comparison * @return string The UPDATE statement to remove fields from documents via field comparison
* @throws DocumentException If the database mode has not been set * @throws DocumentException If the database mode has not been set
@ -73,7 +73,7 @@ class RemoveFields
* Query to remove fields from documents via a JSON containment query (PostgreSQL only) * Query to remove fields from documents via a JSON containment query (PostgreSQL only)
* *
* @param string $tableName The name of the table in which documents should be manipulated * @param string $tableName The name of the table in which documents should be manipulated
* @param array $parameters The parameter list for the query * @param array<string, mixed> $parameters The parameter list for the query
* @return string The UPDATE statement to remove fields from documents via a JSON containment query * @return string The UPDATE statement to remove fields from documents via a JSON containment query
* @throws DocumentException If the database mode is not PostgreSQL * @throws DocumentException If the database mode is not PostgreSQL
*/ */
@ -86,7 +86,7 @@ class RemoveFields
* Query to remove fields from documents via a JSON Path match query (PostgreSQL only) * Query to remove fields from documents via a JSON Path match query (PostgreSQL only)
* *
* @param string $tableName The name of the table in which documents should be manipulated * @param string $tableName The name of the table in which documents should be manipulated
* @param array $parameters The parameter list for the query * @param array<string, mixed> $parameters The parameter list for the query
* @return string The UPDATE statement to remove fields from documents via a JSON Path match * @return string The UPDATE statement to remove fields from documents via a JSON Path match
* @throws DocumentException * @throws DocumentException
*/ */

18
src/RemoveFields.php
View File

@ -18,7 +18,7 @@ class RemoveFields
* *
* @param string $tableName The table in which the document should have fields removed * @param string $tableName The table in which the document should have fields removed
* @param mixed $docId The ID of the document from which fields should be removed * @param mixed $docId The ID of the document from which fields should be removed
* @param array|string[] $fieldNames The names of the fields to be removed * @param string[] $fieldNames The names of the fields to be removed
* @throws DocumentException If any is encountered * @throws DocumentException If any is encountered
*/ */
public static function byId(string $tableName, mixed $docId, array $fieldNames): void public static function byId(string $tableName, mixed $docId, array $fieldNames): void
@ -32,8 +32,8 @@ class RemoveFields
* Remove fields from documents via a comparison on a JSON field in the document * Remove fields from documents via a comparison on a JSON field in the document
* *
* @param string $tableName The table in which documents should have fields removed * @param string $tableName The table in which documents should have fields removed
* @param array|Field[] $fields The field comparison to match * @param Field[] $fields The field comparison to match
* @param array|string[] $fieldNames The names of the fields to be removed * @param string[] $fieldNames The names of the fields to be removed
* @param FieldMatch|null $match How to handle multiple conditions (optional; defaults to All) * @param FieldMatch|null $match How to handle multiple conditions (optional; defaults to All)
* @throws DocumentException If any is encountered * @throws DocumentException If any is encountered
*/ */
@ -41,17 +41,17 @@ class RemoveFields
?FieldMatch $match = null): void ?FieldMatch $match = null): void
{ {
$nameParams = Parameters::fieldNames(':name', $fieldNames); $nameParams = Parameters::fieldNames(':name', $fieldNames);
$namedFields = Parameters::nameFields($fields); Parameters::nameFields($fields);
Custom::nonQuery(Query\RemoveFields::byFields($tableName, $namedFields, $nameParams, $match), Custom::nonQuery(Query\RemoveFields::byFields($tableName, $fields, $nameParams, $match),
Parameters::addFields($namedFields, $nameParams)); Parameters::addFields($fields, $nameParams));
} }
/** /**
* Remove fields from documents via a JSON containment query (`@>`; PostgreSQL only) * Remove fields from documents via a JSON containment query (`@>`; PostgreSQL only)
* *
* @param string $tableName The table in which documents should have fields removed * @param string $tableName The table in which documents should have fields removed
* @param array|object $criteria The JSON containment query values * @param mixed[]|object $criteria The JSON containment query values
* @param array|string[] $fieldNames The names of the fields to be removed * @param string[] $fieldNames The names of the fields to be removed
* @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs * @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs
*/ */
public static function byContains(string $tableName, array|object $criteria, array $fieldNames): void public static function byContains(string $tableName, array|object $criteria, array $fieldNames): void
@ -66,7 +66,7 @@ class RemoveFields
* *
* @param string $tableName The table in which documents should have fields removed * @param string $tableName The table in which documents should have fields removed
* @param string $path The JSON Path match string * @param string $path The JSON Path match string
* @param array|string[] $fieldNames The names of the fields to be removed * @param string[] $fieldNames The names of the fields to be removed
* @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs * @throws DocumentException If the database mode is not PostgreSQL, or if an error occurs
*/ */
public static function byJsonPath(string $tableName, string $path, array $fieldNames): void public static function byJsonPath(string $tableName, string $path, array $fieldNames): void

7
tests/PjsonId.php
View File

@ -13,7 +13,7 @@ use Square\Pjson\JsonDataSerializable;
/** /**
* A serializable ID wrapper class * A serializable ID wrapper class
*/ */
class PjsonId implements JsonDataSerializable final class PjsonId implements JsonDataSerializable
{ {
public function __construct(protected string $value) { } public function __construct(protected string $value) { }
@ -22,6 +22,11 @@ class PjsonId implements JsonDataSerializable
return $this->value; return $this->value;
} }
/**
* @param mixed $jd JSON data
* @param mixed[]|string $path path segments
* @return static
*/
public static function fromJsonData($jd, array|string $path = []): static public static function fromJsonData($jd, array|string $path = []): static
{ {
return new static($jd); return new static($jd);

35
tests/integration/ArrayDocument.php Normal file
View File

@ -0,0 +1,35 @@
<?php
/**
* @author Daniel J. Summers <daniel@bitbadger.solutions>
* @license MIT
*/
declare(strict_types=1);
namespace Test\Integration;
/**
* A document with an array of values
*/
class ArrayDocument
{
/**
* @param string $id The ID of the document
* @param string[] $values The values for the document
*/
public function __construct(public string $id = '', public array $values = []) { }
/**
* A set of documents used for integration tests
*
* @return ArrayDocument[] Test documents for InArray tests
*/
public static function testDocuments(): array
{
return [
new ArrayDocument('first', ['a', 'b', 'c']),
new ArrayDocument('second', ['c', 'd', 'e']),
new ArrayDocument('third', ['x', 'y', 'z'])
];
}
}

13
tests/integration/postgresql/CountTest.php
View File

@ -33,44 +33,49 @@ class CountTest extends TestCase
parent::tearDown(); parent::tearDown();
} }
#[TestDox('all() succeeds')]
public function testAllSucceeds(): void public function testAllSucceeds(): void
{ {
$count = Count::all(ThrowawayDb::TABLE); $count = Count::all(ThrowawayDb::TABLE);
$this->assertEquals(5, $count, 'There should have been 5 matching documents'); $this->assertEquals(5, $count, 'There should have been 5 matching documents');
} }
#[TestDox('byFields() succeeds for a numeric range')]
public function testByFieldsSucceedsForANumericRange(): void public function testByFieldsSucceedsForANumericRange(): void
{ {
$count = Count::byFields(ThrowawayDb::TABLE, [Field::BT('num_value', 10, 20)]); $count = Count::byFields(ThrowawayDb::TABLE, [Field::between('num_value', 10, 20)]);
$this->assertEquals(3, $count, 'There should have been 3 matching documents'); $this->assertEquals(3, $count, 'There should have been 3 matching documents');
} }
#[TestDox('byFields() succeeds for a non-numeric range')]
public function testByFieldsSucceedsForANonNumericRange(): void public function testByFieldsSucceedsForANonNumericRange(): void
{ {
$count = Count::byFields(ThrowawayDb::TABLE, [Field::BT('value', 'aardvark', 'apple')]); $count = Count::byFields(ThrowawayDb::TABLE, [Field::between('value', 'aardvark', 'apple')]);
$this->assertEquals(1, $count, 'There should have been 1 matching document'); $this->assertEquals(1, $count, 'There should have been 1 matching document');
} }
#[TestDox('byContains() succeeds when documents match')]
public function testByContainsSucceedsWhenDocumentsMatch(): void public function testByContainsSucceedsWhenDocumentsMatch(): void
{ {
$this->assertEquals(2, Count::byContains(ThrowawayDb::TABLE, ['value' => 'purple']), $this->assertEquals(2, Count::byContains(ThrowawayDb::TABLE, ['value' => 'purple']),
'There should have been 2 matching documents'); 'There should have been 2 matching documents');
} }
#[TestDox('byContains() succeeds when no documents match')]
public function testByContainsSucceedsWhenNoDocumentsMatch(): void public function testByContainsSucceedsWhenNoDocumentsMatch(): void
{ {
$this->assertEquals(0, Count::byContains(ThrowawayDb::TABLE, ['value' => 'magenta']), $this->assertEquals(0, Count::byContains(ThrowawayDb::TABLE, ['value' => 'magenta']),
'There should have been no matching documents'); 'There should have been no matching documents');
} }
#[TestDox('By JSON Path succeeds when documents match')] #[TestDox('byJsonPath() succeeds when documents match')]
public function testByJsonPathSucceedsWhenDocumentsMatch(): void public function testByJsonPathSucceedsWhenDocumentsMatch(): void
{ {
$this->assertEquals(2, Count::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ < 5)'), $this->assertEquals(2, Count::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ < 5)'),
'There should have been 2 matching documents'); 'There should have been 2 matching documents');
} }
#[TestDox('By JSON Path succeeds when no documents match')] #[TestDox('byJsonPath() succeeds when no documents match')]
public function testByJsonPathSucceedsWhenNoDocumentsMatch(): void public function testByJsonPathSucceedsWhenNoDocumentsMatch(): void
{ {
$this->assertEquals(0, Count::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 100)'), $this->assertEquals(0, Count::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 100)'),

29
tests/integration/postgresql/CustomTest.php
View File

@ -34,7 +34,8 @@ class CustomTest extends TestCase
ThrowawayDb::destroy($this->dbName); ThrowawayDb::destroy($this->dbName);
} }
public function testRunQuerySucceedsWithAValidQuery() #[TestDox('runQuery() succeeds with a valid query')]
public function testRunQuerySucceedsWithAValidQuery(): void
{ {
$stmt = &Custom::runQuery('SELECT data FROM ' . ThrowawayDb::TABLE . ' LIMIT 1', []); $stmt = &Custom::runQuery('SELECT data FROM ' . ThrowawayDb::TABLE . ' LIMIT 1', []);
try { try {
@ -44,7 +45,8 @@ class CustomTest extends TestCase
} }
} }
public function testRunQueryFailsWithAnInvalidQuery() #[TestDox('runQuery() fails with an invalid query')]
public function testRunQueryFailsWithAnInvalidQuery(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);
$stmt = &Custom::runQuery('GRAB stuff FROM over_there UNTIL done', []); $stmt = &Custom::runQuery('GRAB stuff FROM over_there UNTIL done', []);
@ -55,7 +57,8 @@ class CustomTest extends TestCase
} }
} }
public function testListSucceedsWhenDataIsFound() #[TestDox('list() succeeds when data is found')]
public function testListSucceedsWhenDataIsFound(): void
{ {
$list = Custom::list(Query::selectFromTable(ThrowawayDb::TABLE), [], new DocumentMapper(TestDocument::class)); $list = Custom::list(Query::selectFromTable(ThrowawayDb::TABLE), [], new DocumentMapper(TestDocument::class));
$this->assertNotNull($list, 'The document list should not be null'); $this->assertNotNull($list, 'The document list should not be null');
@ -64,7 +67,8 @@ class CustomTest extends TestCase
$this->assertEquals(5, $count, 'There should have been 5 documents in the list'); $this->assertEquals(5, $count, 'There should have been 5 documents in the list');
} }
public function testListSucceedsWhenNoDataIsFound() #[TestDox('list() succeeds when no data is found')]
public function testListSucceedsWhenNoDataIsFound(): void
{ {
$list = Custom::list( $list = Custom::list(
Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE (data->>'num_value')::numeric > :value", Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE (data->>'num_value')::numeric > :value",
@ -73,7 +77,8 @@ class CustomTest extends TestCase
$this->assertFalse($list->hasItems(), 'There should have been no documents in the list'); $this->assertFalse($list->hasItems(), 'There should have been no documents in the list');
} }
public function testArraySucceedsWhenDataIsFound() #[TestDox('array() succeeds when data is found')]
public function testArraySucceedsWhenDataIsFound(): void
{ {
$array = Custom::array(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'sub' IS NOT NULL", [], $array = Custom::array(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'sub' IS NOT NULL", [],
new DocumentMapper(TestDocument::class)); new DocumentMapper(TestDocument::class));
@ -81,7 +86,8 @@ class CustomTest extends TestCase
$this->assertCount(2, $array, 'There should have been 2 documents in the array'); $this->assertCount(2, $array, 'There should have been 2 documents in the array');
} }
public function testArraySucceedsWhenNoDataIsFound() #[TestDox('array() succeeds when no data is found')]
public function testArraySucceedsWhenNoDataIsFound(): void
{ {
$array = Custom::array(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'value' = :value", $array = Custom::array(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'value' = :value",
[':value' => 'not there'], new DocumentMapper(TestDocument::class)); [':value' => 'not there'], new DocumentMapper(TestDocument::class));
@ -89,6 +95,7 @@ class CustomTest extends TestCase
$this->assertCount(0, $array, 'There should have been no documents in the array'); $this->assertCount(0, $array, 'There should have been no documents in the array');
} }
#[TestDox('single() succeeds when a row is found')]
public function testSingleSucceedsWhenARowIsFound(): void public function testSingleSucceedsWhenARowIsFound(): void
{ {
$doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE . " WHERE data->>'id' = :id", [':id' => 'one'], $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE . " WHERE data->>'id' = :id", [':id' => 'one'],
@ -97,6 +104,7 @@ class CustomTest extends TestCase
$this->assertEquals('one', $doc->get()->id, 'The incorrect document was returned'); $this->assertEquals('one', $doc->get()->id, 'The incorrect document was returned');
} }
#[TestDox('single() succeeds when a row is not found')]
public function testSingleSucceedsWhenARowIsNotFound(): void public function testSingleSucceedsWhenARowIsNotFound(): void
{ {
$doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE . " WHERE data->>'id' = :id", $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE . " WHERE data->>'id' = :id",
@ -104,14 +112,16 @@ class CustomTest extends TestCase
$this->assertTrue($doc->isNone(), 'There should not have been a document returned'); $this->assertTrue($doc->isNone(), 'There should not have been a document returned');
} }
public function testNonQuerySucceedsWhenOperatingOnData() #[TestDox('nonQuery() succeeds when operating on data')]
public function testNonQuerySucceedsWhenOperatingOnData(): void
{ {
Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []); Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
$remaining = Count::all(ThrowawayDb::TABLE); $remaining = Count::all(ThrowawayDb::TABLE);
$this->assertEquals(0, $remaining, 'There should be no documents remaining in the table'); $this->assertEquals(0, $remaining, 'There should be no documents remaining in the table');
} }
public function testNonQuerySucceedsWhenNoDataMatchesWhereClause() #[TestDox('nonQuery() succeeds when no data matches WHERE clause')]
public function testNonQuerySucceedsWhenNoDataMatchesWhereClause(): void
{ {
Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE . " WHERE (data->>'num_value')::numeric > :value", Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE . " WHERE (data->>'num_value')::numeric > :value",
[':value' => 100]); [':value' => 100]);
@ -119,7 +129,8 @@ class CustomTest extends TestCase
$this->assertEquals(5, $remaining, 'There should be 5 documents remaining in the table'); $this->assertEquals(5, $remaining, 'There should be 5 documents remaining in the table');
} }
public function testScalarSucceeds() #[TestDox('scalar() succeeds')]
public function testScalarSucceeds(): void
{ {
$value = Custom::scalar("SELECT 5 AS it", [], new CountMapper()); $value = Custom::scalar("SELECT 5 AS it", [], new CountMapper());
$this->assertEquals(5, $value, 'The scalar value was not returned correctly'); $this->assertEquals(5, $value, 'The scalar value was not returned correctly');

4
tests/integration/postgresql/DefinitionTest.php
View File

@ -47,6 +47,7 @@ class DefinitionTest extends TestCase
[':name' => $name], new ExistsMapper()); [':name' => $name], new ExistsMapper());
} }
#[TestDox('ensureTable() succeeds')]
public function testEnsureTableSucceeds(): void public function testEnsureTableSucceeds(): void
{ {
$this->assertFalse($this->itExists('ensured'), 'The table should not exist already'); $this->assertFalse($this->itExists('ensured'), 'The table should not exist already');
@ -56,6 +57,7 @@ class DefinitionTest extends TestCase
$this->assertTrue($this->itExists('idx_ensured_key'), 'The key index should now exist'); $this->assertTrue($this->itExists('idx_ensured_key'), 'The key index should now exist');
} }
#[TestDox('ensureFieldIndex() succeeds')]
public function testEnsureFieldIndexSucceeds(): void public function testEnsureFieldIndexSucceeds(): void
{ {
$this->assertFalse($this->itExists('idx_ensured_test'), 'The index should not exist already'); $this->assertFalse($this->itExists('idx_ensured_test'), 'The index should not exist already');
@ -64,6 +66,7 @@ class DefinitionTest extends TestCase
$this->assertTrue($this->itExists('idx_ensured_test'), 'The index should now exist'); $this->assertTrue($this->itExists('idx_ensured_test'), 'The index should now exist');
} }
#[TestDox('ensureDocumentIndex() succeeds for Full')]
public function testEnsureDocumentIndexSucceedsForFull(): void public function testEnsureDocumentIndexSucceedsForFull(): void
{ {
$docIdx = 'idx_' . ThrowawayDb::TABLE . '_document'; $docIdx = 'idx_' . ThrowawayDb::TABLE . '_document';
@ -73,6 +76,7 @@ class DefinitionTest extends TestCase
$this->assertTrue($this->itExists($docIdx), 'The document index should now exist'); $this->assertTrue($this->itExists($docIdx), 'The document index should now exist');
} }
#[TestDox('ensureDocumentIndex() succeeds for Optimized')]
public function testEnsureDocumentIndexSucceedsForOptimized(): void public function testEnsureDocumentIndexSucceedsForOptimized(): void
{ {
$docIdx = 'idx_' . ThrowawayDb::TABLE . '_document'; $docIdx = 'idx_' . ThrowawayDb::TABLE . '_document';

16
tests/integration/postgresql/DeleteTest.php
View File

@ -33,7 +33,7 @@ class DeleteTest extends TestCase
parent::tearDown(); parent::tearDown();
} }
#[TestDox('By ID succeeds when a document is deleted')] #[TestDox('byId() succeeds when a document is deleted')]
public function testByIdSucceedsWhenADocumentIsDeleted(): void public function testByIdSucceedsWhenADocumentIsDeleted(): void
{ {
$this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start'); $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
@ -41,7 +41,7 @@ class DeleteTest extends TestCase
$this->assertEquals(4, Count::all(ThrowawayDb::TABLE), 'There should have been 4 documents remaining'); $this->assertEquals(4, Count::all(ThrowawayDb::TABLE), 'There should have been 4 documents remaining');
} }
#[TestDox('By ID succeeds when a document is not deleted')] #[TestDox('byId() succeeds when a document is not deleted')]
public function testByIdSucceedsWhenADocumentIsNotDeleted(): void public function testByIdSucceedsWhenADocumentIsNotDeleted(): void
{ {
$this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start'); $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
@ -49,20 +49,23 @@ class DeleteTest extends TestCase
$this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents remaining'); $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents remaining');
} }
#[TestDox('byFields() succeeds when documents are deleted')]
public function testByFieldsSucceedsWhenDocumentsAreDeleted(): void public function testByFieldsSucceedsWhenDocumentsAreDeleted(): void
{ {
$this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start'); $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
Delete::byFields(ThrowawayDb::TABLE, [Field::NE('value', 'purple')]); Delete::byFields(ThrowawayDb::TABLE, [Field::notEqual('value', 'purple')]);
$this->assertEquals(2, Count::all(ThrowawayDb::TABLE), 'There should have been 2 documents remaining'); $this->assertEquals(2, Count::all(ThrowawayDb::TABLE), 'There should have been 2 documents remaining');
} }
#[TestDox('byFields() succeeds when documents are not deleted')]
public function testByFieldsSucceedsWhenDocumentsAreNotDeleted(): void public function testByFieldsSucceedsWhenDocumentsAreNotDeleted(): void
{ {
$this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start'); $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
Delete::byFields(ThrowawayDb::TABLE, [Field::EQ('value', 'crimson')]); Delete::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'crimson')]);
$this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents remaining'); $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents remaining');
} }
#[TestDox('byContains() succeeds when documents are deleted')]
public function testByContainsSucceedsWhenDocumentsAreDeleted(): void public function testByContainsSucceedsWhenDocumentsAreDeleted(): void
{ {
$this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start'); $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
@ -70,6 +73,7 @@ class DeleteTest extends TestCase
$this->assertEquals(3, Count::all(ThrowawayDb::TABLE), 'There should have been 3 documents remaining'); $this->assertEquals(3, Count::all(ThrowawayDb::TABLE), 'There should have been 3 documents remaining');
} }
#[TestDox('byContains() succeeds when documents are not deleted')]
public function testByContainsSucceedsWhenDocumentsAreNotDeleted(): void public function testByContainsSucceedsWhenDocumentsAreNotDeleted(): void
{ {
$this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start'); $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
@ -77,7 +81,7 @@ class DeleteTest extends TestCase
$this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents remaining'); $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents remaining');
} }
#[TestDox('By JSON Path succeeds when documents are deleted')] #[TestDox('byJsonPath() succeeds when documents are deleted')]
public function testByJsonPathSucceedsWhenDocumentsAreDeleted(): void public function testByJsonPathSucceedsWhenDocumentsAreDeleted(): void
{ {
$this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start'); $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
@ -85,7 +89,7 @@ class DeleteTest extends TestCase
$this->assertEquals(1, Count::all(ThrowawayDb::TABLE), 'There should have been 1 document remaining'); $this->assertEquals(1, Count::all(ThrowawayDb::TABLE), 'There should have been 1 document remaining');
} }
#[TestDox('By JSON Path succeeds when documents are not deleted')] #[TestDox('byJsonPath() succeeds when documents are not deleted')]
public function testByJsonPathSucceedsWhenDocumentsAreNotDeleted(): void public function testByJsonPathSucceedsWhenDocumentsAreNotDeleted(): void
{ {
$this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start'); $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');

8
tests/integration/postgresql/DocumentListTest.php
View File

@ -35,6 +35,7 @@ class DocumentListTest extends TestCase
parent::tearDown(); parent::tearDown();
} }
#[TestDox('create() succeeds')]
public function testCreateSucceeds(): void public function testCreateSucceeds(): void
{ {
$list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [], $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
@ -43,6 +44,7 @@ class DocumentListTest extends TestCase
$list = null; $list = null;
} }
#[TestDox('items() succeeds')]
public function testItemsSucceeds(): void public function testItemsSucceeds(): void
{ {
$list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [], $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
@ -57,6 +59,7 @@ class DocumentListTest extends TestCase
$this->assertEquals(5, $count, 'There should have been 5 documents returned'); $this->assertEquals(5, $count, 'There should have been 5 documents returned');
} }
#[TestDox('items() fails when already consumed')]
public function testItemsFailsWhenAlreadyConsumed(): void public function testItemsFailsWhenAlreadyConsumed(): void
{ {
$list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [], $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
@ -69,6 +72,7 @@ class DocumentListTest extends TestCase
iterator_to_array($list->items()); iterator_to_array($list->items());
} }
#[TestDox('hasItems() succeeds with empty results')]
public function testHasItemsSucceedsWithEmptyResults(): void public function testHasItemsSucceedsWithEmptyResults(): void
{ {
$list = DocumentList::create( $list = DocumentList::create(
@ -78,6 +82,7 @@ class DocumentListTest extends TestCase
$this->assertFalse($list->hasItems(), 'There should be no items in the list'); $this->assertFalse($list->hasItems(), 'There should be no items in the list');
} }
#[TestDox('hasItems() succeeds with non-empty results')]
public function testHasItemsSucceedsWithNonEmptyResults(): void public function testHasItemsSucceedsWithNonEmptyResults(): void
{ {
$list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [], $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
@ -90,6 +95,7 @@ class DocumentListTest extends TestCase
$this->assertFalse($list->hasItems(), 'There should be no remaining items in the list'); $this->assertFalse($list->hasItems(), 'There should be no remaining items in the list');
} }
#[TestDox('map() succeeds')]
public function testMapSucceeds(): void public function testMapSucceeds(): void
{ {
$list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [], $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
@ -102,6 +108,7 @@ class DocumentListTest extends TestCase
} }
} }
#[TestDox('iter() succeeds')]
public function testIterSucceeds(): void public function testIterSucceeds(): void
{ {
$list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [], $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
@ -114,6 +121,7 @@ class DocumentListTest extends TestCase
'Iteration did not have the expected result'); 'Iteration did not have the expected result');
} }
#[TestDox('mapToArray() succeeds')]
public function testMapToArraySucceeds(): void public function testMapToArraySucceeds(): void
{ {
$list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [], $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],

55
tests/integration/postgresql/DocumentTest.php
View File

@ -35,7 +35,7 @@ class DocumentTest extends TestCase
parent::tearDown(); parent::tearDown();
} }
#[TestDox('Insert succeeds for array no auto ID')] #[TestDox('insert() succeeds for array no auto ID')]
public function testInsertSucceedsForArrayNoAutoId(): void public function testInsertSucceedsForArrayNoAutoId(): void
{ {
Document::insert(ThrowawayDb::TABLE, ['id' => 'turkey', 'sub' => ['foo' => 'gobble', 'bar' => 'gobble']]); Document::insert(ThrowawayDb::TABLE, ['id' => 'turkey', 'sub' => ['foo' => 'gobble', 'bar' => 'gobble']]);
@ -50,7 +50,7 @@ class DocumentTest extends TestCase
$this->assertEquals('gobble', $doc->sub->bar, 'The sub-document bar property was incorrect'); $this->assertEquals('gobble', $doc->sub->bar, 'The sub-document bar property was incorrect');
} }
#[TestDox('Insert succeeds for array with auto number ID not provided')] #[TestDox('insert() succeeds for array with auto number ID not provided')]
public function testInsertSucceedsForArrayWithAutoNumberIdNotProvided(): void public function testInsertSucceedsForArrayWithAutoNumberIdNotProvided(): void
{ {
Configuration::$autoId = AutoId::Number; Configuration::$autoId = AutoId::Number;
@ -74,7 +74,7 @@ class DocumentTest extends TestCase
} }
} }
#[TestDox('Insert succeeds for array with auto number ID with ID provided')] #[TestDox('insert() succeeds for array with auto number ID with ID provided')]
public function testInsertSucceedsForArrayWithAutoNumberIdWithIdProvided(): void public function testInsertSucceedsForArrayWithAutoNumberIdWithIdProvided(): void
{ {
Configuration::$autoId = AutoId::Number; Configuration::$autoId = AutoId::Number;
@ -90,14 +90,14 @@ class DocumentTest extends TestCase
} }
} }
#[TestDox('Insert succeeds for array with auto UUID ID not provided')] #[TestDox('insert() succeeds for array with auto UUID ID not provided')]
public function testInsertSucceedsForArrayWithAutoUuidIdNotProvided(): void public function testInsertSucceedsForArrayWithAutoUuidIdNotProvided(): void
{ {
Configuration::$autoId = AutoId::UUID; Configuration::$autoId = AutoId::UUID;
try { try {
Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []); Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
Document::insert(ThrowawayDb::TABLE, ['id' => '', 'num_value' => 5]); Document::insert(ThrowawayDb::TABLE, ['id' => '', 'num_value' => 5]);
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 5)], TestDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 5)], TestDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertNotEmpty($doc->get()->id, 'The ID should have been auto-generated'); $this->assertNotEmpty($doc->get()->id, 'The ID should have been auto-generated');
} finally { } finally {
@ -105,7 +105,7 @@ class DocumentTest extends TestCase
} }
} }
#[TestDox('Insert succeeds for array with auto UUID ID with ID provided')] #[TestDox('insert() succeeds for array with auto UUID ID with ID provided')]
public function testInsertSucceedsForArrayWithAutoUuidIdWithIdProvided(): void public function testInsertSucceedsForArrayWithAutoUuidIdWithIdProvided(): void
{ {
Configuration::$autoId = AutoId::UUID; Configuration::$autoId = AutoId::UUID;
@ -113,7 +113,7 @@ class DocumentTest extends TestCase
Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []); Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
$uuid = AutoId::generateUUID(); $uuid = AutoId::generateUUID();
Document::insert(ThrowawayDb::TABLE, ['id' => $uuid, 'value' => 'uuid', 'num_value' => 12]); Document::insert(ThrowawayDb::TABLE, ['id' => $uuid, 'value' => 'uuid', 'num_value' => 12]);
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 12)], TestDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 12)], TestDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertEquals($uuid, $doc->get()->id, 'The ID should not have been changed'); $this->assertEquals($uuid, $doc->get()->id, 'The ID should not have been changed');
} finally { } finally {
@ -121,7 +121,7 @@ class DocumentTest extends TestCase
} }
} }
#[TestDox('Insert succeeds for array with auto string ID not provided')] #[TestDox('insert() succeeds for array with auto string ID not provided')]
public function testInsertSucceedsForArrayWithAutoStringIdNotProvided(): void public function testInsertSucceedsForArrayWithAutoStringIdNotProvided(): void
{ {
Configuration::$autoId = AutoId::RandomString; Configuration::$autoId = AutoId::RandomString;
@ -129,7 +129,7 @@ class DocumentTest extends TestCase
try { try {
Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []); Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
Document::insert(ThrowawayDb::TABLE, ['id' => '', 'value' => 'new', 'num_value' => 8]); Document::insert(ThrowawayDb::TABLE, ['id' => '', 'value' => 'new', 'num_value' => 8]);
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 8)], TestDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 8)], TestDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertEquals(6, strlen($doc->get()->id), $this->assertEquals(6, strlen($doc->get()->id),
'The ID should have been auto-generated and had 6 characters'); 'The ID should have been auto-generated and had 6 characters');
@ -139,14 +139,14 @@ class DocumentTest extends TestCase
} }
} }
#[TestDox('Insert succeeds for array with auto string ID with ID provided')] #[TestDox('insert() succeeds for array with auto string ID with ID provided')]
public function testInsertSucceedsForArrayWithAutoStringIdWithIdProvided(): void public function testInsertSucceedsForArrayWithAutoStringIdWithIdProvided(): void
{ {
Configuration::$autoId = AutoId::RandomString; Configuration::$autoId = AutoId::RandomString;
try { try {
Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []); Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
Document::insert(ThrowawayDb::TABLE, ['id' => 'my-key', 'value' => 'old', 'num_value' => 3]); Document::insert(ThrowawayDb::TABLE, ['id' => 'my-key', 'value' => 'old', 'num_value' => 3]);
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 3)], TestDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 3)], TestDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertEquals('my-key', $doc->get()->id, 'The ID should not have been changed'); $this->assertEquals('my-key', $doc->get()->id, 'The ID should not have been changed');
} finally { } finally {
@ -154,7 +154,7 @@ class DocumentTest extends TestCase
} }
} }
#[TestDox('Insert succeeds for object no auto ID')] #[TestDox('insert() succeeds for object no auto ID')]
public function testInsertSucceedsForObjectNoAutoId(): void public function testInsertSucceedsForObjectNoAutoId(): void
{ {
Document::insert(ThrowawayDb::TABLE, new TestDocument('turkey', sub: new SubDocument('gobble', 'gobble'))); Document::insert(ThrowawayDb::TABLE, new TestDocument('turkey', sub: new SubDocument('gobble', 'gobble')));
@ -169,7 +169,7 @@ class DocumentTest extends TestCase
$this->assertEquals('gobble', $doc->sub->bar, 'The sub-document bar property was incorrect'); $this->assertEquals('gobble', $doc->sub->bar, 'The sub-document bar property was incorrect');
} }
#[TestDox('Insert succeeds for object with auto number ID not provided')] #[TestDox('insert() succeeds for object with auto number ID not provided')]
public function testInsertSucceedsForObjectWithAutoNumberIdNotProvided(): void public function testInsertSucceedsForObjectWithAutoNumberIdNotProvided(): void
{ {
Configuration::$autoId = AutoId::Number; Configuration::$autoId = AutoId::Number;
@ -177,12 +177,12 @@ class DocumentTest extends TestCase
Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []); Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
Document::insert(ThrowawayDb::TABLE, new NumDocument(value: 'taco')); Document::insert(ThrowawayDb::TABLE, new NumDocument(value: 'taco'));
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('value', 'taco')], NumDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'taco')], NumDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertEquals(1, $doc->get()->id, 'The ID 1 should have been auto-generated'); $this->assertEquals(1, $doc->get()->id, 'The ID 1 should have been auto-generated');
Document::insert(ThrowawayDb::TABLE, new NumDocument(value: 'burrito')); Document::insert(ThrowawayDb::TABLE, new NumDocument(value: 'burrito'));
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('value', 'burrito')], NumDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'burrito')], NumDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertEquals(2, $doc->get()->id, 'The ID 2 should have been auto-generated'); $this->assertEquals(2, $doc->get()->id, 'The ID 2 should have been auto-generated');
} finally { } finally {
@ -190,14 +190,14 @@ class DocumentTest extends TestCase
} }
} }
#[TestDox('Insert succeeds for object with auto number ID with ID provided')] #[TestDox('insert() succeeds for object with auto number ID with ID provided')]
public function testInsertSucceedsForObjectWithAutoNumberIdWithIdProvided(): void public function testInsertSucceedsForObjectWithAutoNumberIdWithIdProvided(): void
{ {
Configuration::$autoId = AutoId::Number; Configuration::$autoId = AutoId::Number;
try { try {
Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []); Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
Document::insert(ThrowawayDb::TABLE, new NumDocument(64, 'large')); Document::insert(ThrowawayDb::TABLE, new NumDocument(64, 'large'));
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('value', 'large')], NumDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'large')], NumDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertEquals(64, $doc->get()->id, 'The ID 64 should have been stored'); $this->assertEquals(64, $doc->get()->id, 'The ID 64 should have been stored');
} finally { } finally {
@ -205,14 +205,14 @@ class DocumentTest extends TestCase
} }
} }
#[TestDox('Insert succeeds for object with auto UUID ID not provided')] #[TestDox('insert() succeeds for object with auto UUID ID not provided')]
public function testInsertSucceedsForObjectWithAutoUuidIdNotProvided(): void public function testInsertSucceedsForObjectWithAutoUuidIdNotProvided(): void
{ {
Configuration::$autoId = AutoId::UUID; Configuration::$autoId = AutoId::UUID;
try { try {
Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []); Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
Document::insert(ThrowawayDb::TABLE, new TestDocument(value: 'something', num_value: 9)); Document::insert(ThrowawayDb::TABLE, new TestDocument(value: 'something', num_value: 9));
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EX('value')], TestDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::exists('value')], TestDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertNotEmpty($doc->get()->id, 'The ID should have been auto-generated'); $this->assertNotEmpty($doc->get()->id, 'The ID should have been auto-generated');
} finally { } finally {
@ -220,7 +220,7 @@ class DocumentTest extends TestCase
} }
} }
#[TestDox('Insert succeeds for object with auto UUID ID with ID provided')] #[TestDox('insert() succeeds for object with auto UUID ID with ID provided')]
public function testInsertSucceedsForObjectWithAutoUuidIdWithIdProvided(): void public function testInsertSucceedsForObjectWithAutoUuidIdWithIdProvided(): void
{ {
Configuration::$autoId = AutoId::UUID; Configuration::$autoId = AutoId::UUID;
@ -228,7 +228,7 @@ class DocumentTest extends TestCase
Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []); Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
$uuid = AutoId::generateUUID(); $uuid = AutoId::generateUUID();
Document::insert(ThrowawayDb::TABLE, new TestDocument($uuid, num_value: 14)); Document::insert(ThrowawayDb::TABLE, new TestDocument($uuid, num_value: 14));
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 14)], TestDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 14)], TestDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertEquals($uuid, $doc->get()->id, 'The ID should not have been changed'); $this->assertEquals($uuid, $doc->get()->id, 'The ID should not have been changed');
} finally { } finally {
@ -236,7 +236,7 @@ class DocumentTest extends TestCase
} }
} }
#[TestDox('Insert succeeds for object with auto string ID not provided')] #[TestDox('insert() succeeds for object with auto string ID not provided')]
public function testInsertSucceedsForObjectWithAutoStringIdNotProvided(): void public function testInsertSucceedsForObjectWithAutoStringIdNotProvided(): void
{ {
Configuration::$autoId = AutoId::RandomString; Configuration::$autoId = AutoId::RandomString;
@ -244,7 +244,7 @@ class DocumentTest extends TestCase
try { try {
Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []); Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
Document::insert(ThrowawayDb::TABLE, new TestDocument(num_value: 55)); Document::insert(ThrowawayDb::TABLE, new TestDocument(num_value: 55));
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 55)], TestDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 55)], TestDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertEquals(40, strlen($doc->get()->id), $this->assertEquals(40, strlen($doc->get()->id),
'The ID should have been auto-generated and had 40 characters'); 'The ID should have been auto-generated and had 40 characters');
@ -254,14 +254,14 @@ class DocumentTest extends TestCase
} }
} }
#[TestDox('Insert succeeds for object with auto string ID with ID provided')] #[TestDox('insert() succeeds for object with auto string ID with ID provided')]
public function testInsertSucceedsForObjectWithAutoStringIdWithIdProvided(): void public function testInsertSucceedsForObjectWithAutoStringIdWithIdProvided(): void
{ {
Configuration::$autoId = AutoId::RandomString; Configuration::$autoId = AutoId::RandomString;
try { try {
Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []); Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
Document::insert(ThrowawayDb::TABLE, new TestDocument('my-key', num_value: 3)); Document::insert(ThrowawayDb::TABLE, new TestDocument('my-key', num_value: 3));
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 3)], TestDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 3)], TestDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertEquals('my-key', $doc->get()->id, 'The ID should not have been changed'); $this->assertEquals('my-key', $doc->get()->id, 'The ID should not have been changed');
} finally { } finally {
@ -269,12 +269,14 @@ class DocumentTest extends TestCase
} }
} }
#[TestDox('insert() fails for duplicate key')]
public function testInsertFailsForDuplicateKey(): void public function testInsertFailsForDuplicateKey(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);
Document::insert(ThrowawayDb::TABLE, new TestDocument('one')); Document::insert(ThrowawayDb::TABLE, new TestDocument('one'));
} }
#[TestDox('save() succeeds when a document is inserted')]
public function testSaveSucceedsWhenADocumentIsInserted(): void public function testSaveSucceedsWhenADocumentIsInserted(): void
{ {
Document::save(ThrowawayDb::TABLE, new TestDocument('test', sub: new SubDocument('a', 'b'))); Document::save(ThrowawayDb::TABLE, new TestDocument('test', sub: new SubDocument('a', 'b')));
@ -282,6 +284,7 @@ class DocumentTest extends TestCase
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
} }
#[TestDox('save() succeeds when a document is updated')]
public function testSaveSucceedsWhenADocumentIsUpdated(): void public function testSaveSucceedsWhenADocumentIsUpdated(): void
{ {
Document::save(ThrowawayDb::TABLE, new TestDocument('two', num_value: 44)); Document::save(ThrowawayDb::TABLE, new TestDocument('two', num_value: 44));
@ -292,6 +295,7 @@ class DocumentTest extends TestCase
$this->assertNull($doc->sub, 'The sub-document should have been null'); $this->assertNull($doc->sub, 'The sub-document should have been null');
} }
#[TestDox('update() succeeds when replacing a document')]
public function testUpdateSucceedsWhenReplacingADocument(): void public function testUpdateSucceedsWhenReplacingADocument(): void
{ {
Document::update(ThrowawayDb::TABLE, 'one', new TestDocument('one', 'howdy', 8, new SubDocument('y', 'z'))); Document::update(ThrowawayDb::TABLE, 'one', new TestDocument('one', 'howdy', 8, new SubDocument('y', 'z')));
@ -305,6 +309,7 @@ class DocumentTest extends TestCase
$this->assertEquals('z', $doc->sub->bar, 'The sub-document bar property was incorrect'); $this->assertEquals('z', $doc->sub->bar, 'The sub-document bar property was incorrect');
} }
#[TestDox('update() succeeds when no document is replaced')]
public function testUpdateSucceedsWhenNoDocumentIsReplaced(): void public function testUpdateSucceedsWhenNoDocumentIsReplaced(): void
{ {
Document::update(ThrowawayDb::TABLE, 'two-hundred', new TestDocument('200')); Document::update(ThrowawayDb::TABLE, 'two-hundred', new TestDocument('200'));

16
tests/integration/postgresql/ExistsTest.php
View File

@ -33,51 +33,55 @@ class ExistsTest extends TestCase
parent::tearDown(); parent::tearDown();
} }
#[TestDox('By ID succeeds when a document exists')] #[TestDox('byId() succeeds when a document exists')]
public function testByIdSucceedsWhenADocumentExists(): void public function testByIdSucceedsWhenADocumentExists(): void
{ {
$this->assertTrue(Exists::byId(ThrowawayDb::TABLE, 'three'), 'There should have been an existing document'); $this->assertTrue(Exists::byId(ThrowawayDb::TABLE, 'three'), 'There should have been an existing document');
} }
#[TestDox('By ID succeeds when a document does not exist')] #[TestDox('byId() succeeds when a document does not exist')]
public function testByIdSucceedsWhenADocumentDoesNotExist(): void public function testByIdSucceedsWhenADocumentDoesNotExist(): void
{ {
$this->assertFalse(Exists::byId(ThrowawayDb::TABLE, 'seven'), $this->assertFalse(Exists::byId(ThrowawayDb::TABLE, 'seven'),
'There should not have been an existing document'); 'There should not have been an existing document');
} }
#[TestDox('byFields() succeeds when documents exist')]
public function testByFieldsSucceedsWhenDocumentsExist(): void public function testByFieldsSucceedsWhenDocumentsExist(): void
{ {
$this->assertTrue(Exists::byFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 10)]), $this->assertTrue(Exists::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 10)]),
'There should have been existing documents'); 'There should have been existing documents');
} }
#[TestDox('byFields() succeeds when no matching documents exist')]
public function testByFieldsSucceedsWhenNoMatchingDocumentsExist(): void public function testByFieldsSucceedsWhenNoMatchingDocumentsExist(): void
{ {
$this->assertFalse(Exists::byFields(ThrowawayDb::TABLE, [Field::LT('nothing', 'none')]), $this->assertFalse(Exists::byFields(ThrowawayDb::TABLE, [Field::less('nothing', 'none')]),
'There should not have been any existing documents'); 'There should not have been any existing documents');
} }
#[TestDox('byContains() succeeds when documents exist')]
public function testByContainsSucceedsWhenDocumentsExist(): void public function testByContainsSucceedsWhenDocumentsExist(): void
{ {
$this->assertTrue(Exists::byContains(ThrowawayDb::TABLE, ['value' => 'purple']), $this->assertTrue(Exists::byContains(ThrowawayDb::TABLE, ['value' => 'purple']),
'There should have been existing documents'); 'There should have been existing documents');
} }
#[TestDox('byContains() succeeds when no matching documents exist')]
public function testByContainsSucceedsWhenNoMatchingDocumentsExist(): void public function testByContainsSucceedsWhenNoMatchingDocumentsExist(): void
{ {
$this->assertFalse(Exists::byContains(ThrowawayDb::TABLE, ['value' => 'violet']), $this->assertFalse(Exists::byContains(ThrowawayDb::TABLE, ['value' => 'violet']),
'There should not have been existing documents'); 'There should not have been existing documents');
} }
#[TestDox('By JSON Path succeeds when documents exist')] #[TestDox('byJsonPath() succeeds when documents exist')]
public function testByJsonPathSucceedsWhenDocumentsExist(): void public function testByJsonPathSucceedsWhenDocumentsExist(): void
{ {
$this->assertTrue(Exists::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ == 10)'), $this->assertTrue(Exists::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ == 10)'),
'There should have been existing documents'); 'There should have been existing documents');
} }
#[TestDox('By JSON Path succeeds when no matching documents exist')] #[TestDox('byJsonPath() succeeds when no matching documents exist')]
public function testByJsonPathSucceedsWhenNoMatchingDocumentsExist(): void public function testByJsonPathSucceedsWhenNoMatchingDocumentsExist(): void
{ {
$this->assertFalse(Exists::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ == 10.1)'), $this->assertFalse(Exists::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ == 10.1)'),

166
tests/integration/postgresql/FindTest.php
View File

@ -8,10 +8,10 @@ declare(strict_types=1);
namespace Test\Integration\PostgreSQL; namespace Test\Integration\PostgreSQL;
use BitBadger\PDODocument\{Custom, Delete, Document, Field, Find}; use BitBadger\PDODocument\{Custom, Delete, Document, Field, FieldMatch, Find};
use PHPUnit\Framework\Attributes\TestDox; use PHPUnit\Framework\Attributes\TestDox;
use PHPUnit\Framework\TestCase; use PHPUnit\Framework\TestCase;
use Test\Integration\{NumDocument, TestDocument}; use Test\Integration\{ArrayDocument, NumDocument, TestDocument};
/** /**
* PostgreSQL integration tests for the Find class * PostgreSQL integration tests for the Find class
@ -34,6 +34,7 @@ class FindTest extends TestCase
parent::tearDown(); parent::tearDown();
} }
#[TestDox('all() succeeds when there is data')]
public function testAllSucceedsWhenThereIsData(): void public function testAllSucceedsWhenThereIsData(): void
{ {
$docs = Find::all(ThrowawayDb::TABLE, TestDocument::class); $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class);
@ -43,6 +44,35 @@ class FindTest extends TestCase
$this->assertEquals(5, $count, 'There should have been 5 documents in the list'); $this->assertEquals(5, $count, 'There should have been 5 documents in the list');
} }
#[TestDox('all() succeeds when ordering data ascending')]
public function testAllSucceedsWhenOrderingDataAscending(): void
{
$docs = Find::all(ThrowawayDb::TABLE, TestDocument::class, [Field::named('id')]);
$this->assertNotNull($docs, 'There should have been a document list returned');
$ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
$this->assertEquals(['five', 'four', 'one', 'three', 'two'], $ids, 'The documents were not ordered correctly');
}
#[TestDox('all() succeeds when ordering data descending')]
public function testAllSucceedsWhenOrderingDataDescending(): void
{
$docs = Find::all(ThrowawayDb::TABLE, TestDocument::class, [Field::named('id DESC')]);
$this->assertNotNull($docs, 'There should have been a document list returned');
$ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
$this->assertEquals(['two', 'three', 'one', 'four', 'five'], $ids, 'The documents were not ordered correctly');
}
#[TestDox('all() succeeds when ordering data numerically')]
public function testAllSucceedsWhenOrderingDataNumerically(): void
{
$docs = Find::all(ThrowawayDb::TABLE, TestDocument::class,
[Field::named('sub.foo NULLS LAST'), Field::named('n:num_value')]);
$this->assertNotNull($docs, 'There should have been a document list returned');
$ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
$this->assertEquals(['two', 'four', 'one', 'three', 'five'], $ids, 'The documents were not ordered correctly');
}
#[TestDox('all() succeeds when there is no data')]
public function testAllSucceedsWhenThereIsNoData(): void public function testAllSucceedsWhenThereIsNoData(): void
{ {
Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []); Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
@ -51,7 +81,7 @@ class FindTest extends TestCase
$this->assertFalse($docs->hasItems(), 'There should have been no documents in the list'); $this->assertFalse($docs->hasItems(), 'There should have been no documents in the list');
} }
#[TestDox('By ID succeeds when a document is found')] #[TestDox('byId() succeeds when a document is found')]
public function testByIdSucceedsWhenADocumentIsFound(): void public function testByIdSucceedsWhenADocumentIsFound(): void
{ {
$doc = Find::byId(ThrowawayDb::TABLE, 'two', TestDocument::class); $doc = Find::byId(ThrowawayDb::TABLE, 'two', TestDocument::class);
@ -59,39 +89,87 @@ class FindTest extends TestCase
$this->assertEquals('two', $doc->get()->id, 'An incorrect document was returned'); $this->assertEquals('two', $doc->get()->id, 'An incorrect document was returned');
} }
#[TestDox('By ID succeeds when a document is found with numeric ID')] #[TestDox('byId() succeeds when a document is found with numeric ID')]
public function testByIdSucceedsWhenADocumentIsFoundWithNumericId(): void public function testByIdSucceedsWhenADocumentIsFoundWithNumericId(): void
{ {
Delete::byFields(ThrowawayDb::TABLE, [Field::NEX('absent')]); Delete::byFields(ThrowawayDb::TABLE, [Field::notExists('absent')]);
Document::insert(ThrowawayDb::TABLE, ['id' => 18, 'value' => 'howdy']); Document::insert(ThrowawayDb::TABLE, ['id' => 18, 'value' => 'howdy']);
$doc = Find::byId(ThrowawayDb::TABLE, 18, NumDocument::class); $doc = Find::byId(ThrowawayDb::TABLE, 18, NumDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertEquals(18, $doc->get()->id, 'An incorrect document was returned'); $this->assertEquals(18, $doc->get()->id, 'An incorrect document was returned');
} }
#[TestDox('By ID succeeds when a document is not found')] #[TestDox('byId() succeeds when a document is not found')]
public function testByIdSucceedsWhenADocumentIsNotFound(): void public function testByIdSucceedsWhenADocumentIsNotFound(): void
{ {
$doc = Find::byId(ThrowawayDb::TABLE, 'seventy-five', TestDocument::class); $doc = Find::byId(ThrowawayDb::TABLE, 'seventy-five', TestDocument::class);
$this->assertTrue($doc->isNone(), 'There should not have been a document returned'); $this->assertTrue($doc->isNone(), 'There should not have been a document returned');
} }
#[TestDox('byFields() succeeds when documents are found')]
public function testByFieldsSucceedsWhenDocumentsAreFound(): void public function testByFieldsSucceedsWhenDocumentsAreFound(): void
{ {
$docs = Find::byFields(ThrowawayDb::TABLE, [Field::GT('num_value', 15)], TestDocument::class); $docs = Find::byFields(ThrowawayDb::TABLE, [Field::in('value', ['blue', 'purple']), Field::exists('sub')],
TestDocument::class, FieldMatch::All);
$this->assertNotNull($docs, 'There should have been a document list returned');
$count = 0;
foreach ($docs->items() as $ignored) $count++;
$this->assertEquals(1, $count, 'There should have been 1 document in the list');
}
#[TestDox('byFields() succeeds when documents are found and ordered')]
public function testByFieldsSucceedsWhenDocumentsAreFoundAndOrdered(): void
{
$docs = Find::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'purple')], TestDocument::class,
FieldMatch::All, [Field::named('id')]);
$this->assertNotNull($docs, 'There should have been a document list returned');
$ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
$this->assertEquals(['five', 'four'], $ids, 'The documents were not ordered correctly');
}
#[TestDox('byFields() succeeds when documents are found using IN with numeric field')]
public function testByFieldsSucceedsWhenDocumentsAreFoundUsingInWithNumericField(): void
{
$docs = Find::byFields(ThrowawayDb::TABLE, [Field::in('num_value', [2, 4, 6, 8])], TestDocument::class);
$this->assertNotNull($docs, 'There should have been a document list returned');
$count = 0;
foreach ($docs->items() as $ignored) $count++;
$this->assertEquals(1, $count, 'There should have been 1 document in the list');
}
#[TestDox('byFields() succeeds when no documents are found')]
public function testByFieldsSucceedsWhenNoDocumentsAreFound(): void
{
$docs = Find::byFields(ThrowawayDb::TABLE, [Field::greater('num_value', 100)], TestDocument::class);
$this->assertNotNull($docs, 'There should have been a document list returned');
$this->assertFalse($docs->hasItems(), 'There should have been no documents in the list');
}
#[TestDox('byFields() succeeds for inArray when matching documents exist')]
public function testByFieldsSucceedsForInArrayWhenMatchingDocumentsExist(): void
{
Delete::byFields(ThrowawayDb::TABLE, [Field::notExists('absentField')]);
foreach (ArrayDocument::testDocuments() as $doc) Document::insert(ThrowawayDb::TABLE, $doc);
$docs = Find::byFields(ThrowawayDb::TABLE, [Field::inArray('values', ThrowawayDb::TABLE, ['c'])],
ArrayDocument::class);
$this->assertNotNull($docs, 'There should have been a document list returned'); $this->assertNotNull($docs, 'There should have been a document list returned');
$count = 0; $count = 0;
foreach ($docs->items() as $ignored) $count++; foreach ($docs->items() as $ignored) $count++;
$this->assertEquals(2, $count, 'There should have been 2 documents in the list'); $this->assertEquals(2, $count, 'There should have been 2 documents in the list');
} }
public function testByFieldsSucceedsWhenNoDocumentsAreFound(): void #[TestDox('byFields() succeeds for inArray when no matching documents exist')]
public function testByFieldsSucceedsForInArrayWhenNoMatchingDocumentsExist(): void
{ {
$docs = Find::byFields(ThrowawayDb::TABLE, [Field::GT('num_value', 100)], TestDocument::class); Delete::byFields(ThrowawayDb::TABLE, [Field::notExists('absentField')]);
foreach (ArrayDocument::testDocuments() as $doc) Document::insert(ThrowawayDb::TABLE, $doc);
$docs = Find::byFields(ThrowawayDb::TABLE, [Field::inArray('values', ThrowawayDb::TABLE, ['j'])],
ArrayDocument::class);
$this->assertNotNull($docs, 'There should have been a document list returned'); $this->assertNotNull($docs, 'There should have been a document list returned');
$this->assertFalse($docs->hasItems(), 'There should have been no documents in the list'); $this->assertFalse($docs->hasItems(), 'There should have been no documents in the list');
} }
#[TestDox('byContains() succeeds when documents are found')]
public function testByContainsSucceedsWhenDocumentsAreFound(): void public function testByContainsSucceedsWhenDocumentsAreFound(): void
{ {
$docs = Find::byContains(ThrowawayDb::TABLE, ['value' => 'purple'], TestDocument::class); $docs = Find::byContains(ThrowawayDb::TABLE, ['value' => 'purple'], TestDocument::class);
@ -101,6 +179,17 @@ class FindTest extends TestCase
$this->assertEquals(2, $count, 'There should have been 2 documents in the list'); $this->assertEquals(2, $count, 'There should have been 2 documents in the list');
} }
#[TestDox('byContains() succeeds when documents are found and ordered')]
public function testByContainsSucceedsWhenDocumentsAreFoundAndOrdered(): void
{
$docs = Find::byContains(ThrowawayDb::TABLE, ['sub' => ['foo' => 'green']], TestDocument::class,
[Field::named('value')]);
$this->assertNotNull($docs, 'There should have been a document list returned');
$ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
$this->assertEquals(['two', 'four'], $ids, 'The documents were not ordered correctly');
}
#[TestDox('byContains() succeeds when no documents are found')]
public function testByContainsSucceedsWhenNoDocumentsAreFound(): void public function testByContainsSucceedsWhenNoDocumentsAreFound(): void
{ {
$docs = Find::byContains(ThrowawayDb::TABLE, ['value' => 'indigo'], TestDocument::class); $docs = Find::byContains(ThrowawayDb::TABLE, ['value' => 'indigo'], TestDocument::class);
@ -108,7 +197,7 @@ class FindTest extends TestCase
$this->assertFalse($docs->hasItems(), 'The document list should be empty'); $this->assertFalse($docs->hasItems(), 'The document list should be empty');
} }
#[TestDox('By JSON Path succeeds when documents are found')] #[TestDox('byJsonPath() succeeds when documents are found')]
public function testByJsonPathSucceedsWhenDocumentsAreFound(): void public function testByJsonPathSucceedsWhenDocumentsAreFound(): void
{ {
$docs = Find::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 10)', TestDocument::class); $docs = Find::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 10)', TestDocument::class);
@ -118,7 +207,17 @@ class FindTest extends TestCase
$this->assertEquals(2, $count, 'There should have been 2 documents in the list'); $this->assertEquals(2, $count, 'There should have been 2 documents in the list');
} }
#[TestDox('By JSON Path succeeds when no documents are found')] #[TestDox('byJsonPath() succeeds when documents are found and ordered')]
public function testByJsonPathSucceedsWhenDocumentsAreFoundAndOrdered(): void
{
$docs = Find::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 10)', TestDocument::class,
[Field::named('id')]);
$this->assertNotNull($docs, 'There should have been a document list returned');
$ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
$this->assertEquals(['five', 'four'], $ids, 'The documents were not ordered correctly');
}
#[TestDox('byJsonPath() succeeds when no documents are found')]
public function testByJsonPathSucceedsWhenNoDocumentsAreFound(): void public function testByJsonPathSucceedsWhenNoDocumentsAreFound(): void
{ {
$docs = Find::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 100)', TestDocument::class); $docs = Find::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 100)', TestDocument::class);
@ -126,26 +225,39 @@ class FindTest extends TestCase
$this->assertFalse($docs->hasItems(), 'The document list should be empty'); $this->assertFalse($docs->hasItems(), 'The document list should be empty');
} }
#[TestDox('firstByFields() succeeds when a document is found')]
public function testFirstByFieldsSucceedsWhenADocumentIsFound(): void public function testFirstByFieldsSucceedsWhenADocumentIsFound(): void
{ {
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('value', 'another')], TestDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'another')], TestDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertEquals('two', $doc->get()->id, 'The incorrect document was returned'); $this->assertEquals('two', $doc->get()->id, 'The incorrect document was returned');
} }
#[TestDox('firstByFields() succeeds when multiple documents are found')]
public function testFirstByFieldsSucceedsWhenMultipleDocumentsAreFound(): void public function testFirstByFieldsSucceedsWhenMultipleDocumentsAreFound(): void
{ {
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('sub.foo', 'green')], TestDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('sub.foo', 'green')], TestDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertContains($doc->get()->id, ['two', 'four'], 'An incorrect document was returned'); $this->assertContains($doc->get()->id, ['two', 'four'], 'An incorrect document was returned');
} }
#[TestDox('firstByFields() succeeds when multiple ordered documents are found')]
public function testFirstByFieldsSucceedsWhenMultipleOrderedDocumentsAreFound(): void
{
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('sub.foo', 'green')], TestDocument::class,
orderBy: [Field::named('n:num_value DESC')]);
$this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertEquals('four', $doc->get()->id, 'The incorrect document was returned');
}
#[TestDox('firstByFields() succeeds when a document is not found')]
public function testFirstByFieldsSucceedsWhenADocumentIsNotFound(): void public function testFirstByFieldsSucceedsWhenADocumentIsNotFound(): void
{ {
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('value', 'absent')], TestDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'absent')], TestDocument::class);
$this->assertTrue($doc->isNone(), 'There should not have been a document returned'); $this->assertTrue($doc->isNone(), 'There should not have been a document returned');
} }
#[TestDox('firstByContains() succeeds when a document is found')]
public function testFirstByContainsSucceedsWhenADocumentIsFound(): void public function testFirstByContainsSucceedsWhenADocumentIsFound(): void
{ {
$doc = Find::firstByContains(ThrowawayDb::TABLE, ['value' => 'FIRST!'], TestDocument::class); $doc = Find::firstByContains(ThrowawayDb::TABLE, ['value' => 'FIRST!'], TestDocument::class);
@ -153,6 +265,7 @@ class FindTest extends TestCase
$this->assertEquals('one', $doc->get()->id, 'The incorrect document was returned'); $this->assertEquals('one', $doc->get()->id, 'The incorrect document was returned');
} }
#[TestDox('firstByContains() succeeds when multiple documents are found')]
public function testFirstByContainsSucceedsWhenMultipleDocumentsAreFound(): void public function testFirstByContainsSucceedsWhenMultipleDocumentsAreFound(): void
{ {
$doc = Find::firstByContains(ThrowawayDb::TABLE, ['value' => 'purple'], TestDocument::class); $doc = Find::firstByContains(ThrowawayDb::TABLE, ['value' => 'purple'], TestDocument::class);
@ -160,13 +273,23 @@ class FindTest extends TestCase
$this->assertContains($doc->get()->id, ['four', 'five'], 'An incorrect document was returned'); $this->assertContains($doc->get()->id, ['four', 'five'], 'An incorrect document was returned');
} }
#[TestDox('firstByContains() succeeds when multiple ordered documents are found')]
public function testFirstByContainsSucceedsWhenMultipleOrderedDocumentsAreFound(): void
{
$doc = Find::firstByContains(ThrowawayDb::TABLE, ['value' => 'purple'], TestDocument::class,
[Field::named('sub.bar NULLS FIRST')]);
$this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertEquals('five', $doc->get()->id, 'The incorrect document was returned');
}
#[TestDox('firstByContains() succeeds when a document is not found')]
public function testFirstByContainsSucceedsWhenADocumentIsNotFound(): void public function testFirstByContainsSucceedsWhenADocumentIsNotFound(): void
{ {
$doc = Find::firstByContains(ThrowawayDb::TABLE, ['value' => 'indigo'], TestDocument::class); $doc = Find::firstByContains(ThrowawayDb::TABLE, ['value' => 'indigo'], TestDocument::class);
$this->assertTrue($doc->isNone(), 'There should not have been a document returned'); $this->assertTrue($doc->isNone(), 'There should not have been a document returned');
} }
#[TestDox('First by JSON Path succeeds when a document is found')] #[TestDox('firstByJsonPath() succeeds when a document is found')]
public function testFirstByJsonPathSucceedsWhenADocumentIsFound(): void public function testFirstByJsonPathSucceedsWhenADocumentIsFound(): void
{ {
$doc = Find::firstByJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ == 10)', TestDocument::class); $doc = Find::firstByJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ == 10)', TestDocument::class);
@ -174,7 +297,7 @@ class FindTest extends TestCase
$this->assertEquals('two', $doc->get()->id, 'The incorrect document was returned'); $this->assertEquals('two', $doc->get()->id, 'The incorrect document was returned');
} }
#[TestDox('First by JSON Path succeeds when multiple documents are found')] #[TestDox('firstByJsonPath() succeeds when multiple documents are found')]
public function testFirstByJsonPathSucceedsWhenMultipleDocumentsAreFound(): void public function testFirstByJsonPathSucceedsWhenMultipleDocumentsAreFound(): void
{ {
$doc = Find::firstByJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 10)', TestDocument::class); $doc = Find::firstByJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 10)', TestDocument::class);
@ -182,7 +305,16 @@ class FindTest extends TestCase
$this->assertContains($doc->get()->id, ['four', 'five'], 'An incorrect document was returned'); $this->assertContains($doc->get()->id, ['four', 'five'], 'An incorrect document was returned');
} }
#[TestDox('First by JSON Path succeeds when a document is not found')] #[TestDox('firstByJsonPath() succeeds when multiple ordered documents are found')]
public function testFirstByJsonPathSucceedsWhenMultipleOrderedDocumentsAreFound(): void
{
$doc = Find::firstByJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 10)', TestDocument::class,
[Field::named('id DESC')]);
$this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertEquals('four', $doc->get()->id, 'The incorrect document was returned');
}
#[TestDox('firstByJsonPath() succeeds when a document is not found')]
public function testFirstByJsonPathSucceedsWhenADocumentIsNotFound(): void public function testFirstByJsonPathSucceedsWhenADocumentIsNotFound(): void
{ {
$doc = Find::firstByJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 100)', TestDocument::class); $doc = Find::firstByJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 100)', TestDocument::class);

18
tests/integration/postgresql/PatchTest.php
View File

@ -34,7 +34,7 @@ class PatchTest extends TestCase
parent::tearDown(); parent::tearDown();
} }
#[TestDox('By ID succeeds when a document is updated')] #[TestDox('byId() succeeds when a document is updated')]
public function testByIdSucceedsWhenADocumentIsUpdated(): void public function testByIdSucceedsWhenADocumentIsUpdated(): void
{ {
Patch::byId(ThrowawayDb::TABLE, 'one', ['num_value' => 44]); Patch::byId(ThrowawayDb::TABLE, 'one', ['num_value' => 44]);
@ -43,7 +43,7 @@ class PatchTest extends TestCase
$this->assertEquals(44, $doc->get()->num_value, 'The updated document is not correct'); $this->assertEquals(44, $doc->get()->num_value, 'The updated document is not correct');
} }
#[TestDox('By ID succeeds when no document is updated')] #[TestDox('byId() succeeds when no document is updated')]
public function testByIdSucceedsWhenNoDocumentIsUpdated(): void public function testByIdSucceedsWhenNoDocumentIsUpdated(): void
{ {
$id = 'forty-seven'; $id = 'forty-seven';
@ -52,21 +52,24 @@ class PatchTest extends TestCase
$this->assertTrue(true, 'The above not throwing an exception is the test'); $this->assertTrue(true, 'The above not throwing an exception is the test');
} }
#[TestDox('byFields() succeeds when a document is updated')]
public function testByFieldsSucceedsWhenADocumentIsUpdated(): void public function testByFieldsSucceedsWhenADocumentIsUpdated(): void
{ {
Patch::byFields(ThrowawayDb::TABLE, [Field::EQ('value', 'purple')], ['num_value' => 77]); Patch::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'purple')], ['num_value' => 77]);
$after = Count::byFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 77)]); $after = Count::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 77)]);
$this->assertEquals(2, $after, 'There should have been 2 documents updated'); $this->assertEquals(2, $after, 'There should have been 2 documents updated');
} }
#[TestDox('byFields() succeeds when no document is updated')]
public function testByFieldsSucceedsWhenNoDocumentIsUpdated(): void public function testByFieldsSucceedsWhenNoDocumentIsUpdated(): void
{ {
$fields = [Field::EQ('value', 'burgundy')]; $fields = [Field::equal('value', 'burgundy')];
$this->assertEquals(0, Count::byFields(ThrowawayDb::TABLE, $fields), 'There should be no matching documents'); $this->assertEquals(0, Count::byFields(ThrowawayDb::TABLE, $fields), 'There should be no matching documents');
Patch::byFields(ThrowawayDb::TABLE, $fields, ['foo' => 'green']); Patch::byFields(ThrowawayDb::TABLE, $fields, ['foo' => 'green']);
$this->assertTrue(true, 'The above not throwing an exception is the test'); $this->assertTrue(true, 'The above not throwing an exception is the test');
} }
#[TestDox('byContains() succeeds when documents are updated')]
public function testByContainsSucceedsWhenDocumentsAreUpdated(): void public function testByContainsSucceedsWhenDocumentsAreUpdated(): void
{ {
Patch::byContains(ThrowawayDb::TABLE, ['value' => 'another'], ['num_value' => 12]); Patch::byContains(ThrowawayDb::TABLE, ['value' => 'another'], ['num_value' => 12]);
@ -77,6 +80,7 @@ class PatchTest extends TestCase
$this->assertEquals(12, $doc->num_value, 'The document was not patched'); $this->assertEquals(12, $doc->num_value, 'The document was not patched');
} }
#[TestDox('byContains() succeeds when no documents are updated')]
public function testByContainsSucceedsWhenNoDocumentsAreUpdated(): void public function testByContainsSucceedsWhenNoDocumentsAreUpdated(): void
{ {
$criteria = ['value' => 'updated']; $criteria = ['value' => 'updated'];
@ -86,7 +90,7 @@ class PatchTest extends TestCase
$this->assertTrue(true, 'The above not throwing an exception is the test'); $this->assertTrue(true, 'The above not throwing an exception is the test');
} }
#[TestDox('By JSON Path succeeds when documents are updated')] #[TestDox('byJsonPath() succeeds when documents are updated')]
public function testByJsonPathSucceedsWhenDocumentsAreUpdated(): void public function testByJsonPathSucceedsWhenDocumentsAreUpdated(): void
{ {
Patch::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 10)', ['value' => 'blue']); Patch::byJsonPath(ThrowawayDb::TABLE, '$.num_value ? (@ > 10)', ['value' => 'blue']);
@ -99,7 +103,7 @@ class PatchTest extends TestCase
} }
} }
#[TestDox('By JSON Path succeeds when documents are not updated')] #[TestDox('byJsonPath() succeeds when documents are not updated')]
public function testByJsonPathSucceedsWhenDocumentsAreNotUpdated(): void public function testByJsonPathSucceedsWhenDocumentsAreNotUpdated(): void
{ {
$path = '$.num_value ? (@ > 100)'; $path = '$.num_value ? (@ > 100)';

26
tests/integration/postgresql/RemoveFieldsTest.php
View File

@ -34,7 +34,7 @@ class RemoveFieldsTest extends TestCase
parent::tearDown(); parent::tearDown();
} }
#[TestDox('By ID succeeds when fields are removed')] #[TestDox('byId() succeeds when fields are removed')]
public function testByIdSucceedsWhenFieldsAreRemoved(): void public function testByIdSucceedsWhenFieldsAreRemoved(): void
{ {
RemoveFields::byId(ThrowawayDb::TABLE, 'two', ['sub', 'value']); RemoveFields::byId(ThrowawayDb::TABLE, 'two', ['sub', 'value']);
@ -45,40 +45,44 @@ class RemoveFieldsTest extends TestCase
$this->assertNull($doc->sub, 'Sub-document should have been null'); $this->assertNull($doc->sub, 'Sub-document should have been null');
} }
#[TestDox('By ID succeeds when a field is not removed')] #[TestDox('byId() succeeds when a field is not removed')]
public function testByIdSucceedsWhenAFieldIsNotRemoved(): void public function testByIdSucceedsWhenAFieldIsNotRemoved(): void
{ {
RemoveFields::byId(ThrowawayDb::TABLE, 'one', ['a_field_that_does_not_exist']); RemoveFields::byId(ThrowawayDb::TABLE, 'one', ['a_field_that_does_not_exist']);
$this->assertTrue(true, 'The above not throwing an exception is the test'); $this->assertTrue(true, 'The above not throwing an exception is the test');
} }
#[TestDox('By ID succeeds when no document is matched')] #[TestDox('byId() succeeds when no document is matched')]
public function testByIdSucceedsWhenNoDocumentIsMatched(): void public function testByIdSucceedsWhenNoDocumentIsMatched(): void
{ {
RemoveFields::byId(ThrowawayDb::TABLE, 'fifty', ['sub']); RemoveFields::byId(ThrowawayDb::TABLE, 'fifty', ['sub']);
$this->assertTrue(true, 'The above not throwing an exception is the test'); $this->assertTrue(true, 'The above not throwing an exception is the test');
} }
#[TestDox('byFields() succeeds when a field is removed')]
public function testByFieldsSucceedsWhenAFieldIsRemoved(): void public function testByFieldsSucceedsWhenAFieldIsRemoved(): void
{ {
RemoveFields::byFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 17)], ['sub']); RemoveFields::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 17)], ['sub']);
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 17)], TestDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 17)], TestDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertNull($doc->get()->sub, 'Sub-document should have been null'); $this->assertNull($doc->get()->sub, 'Sub-document should have been null');
} }
#[TestDox('byFields() succeeds when a field is not removed')]
public function testByFieldsSucceedsWhenAFieldIsNotRemoved(): void public function testByFieldsSucceedsWhenAFieldIsNotRemoved(): void
{ {
RemoveFields::byFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 17)], ['nada']); RemoveFields::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 17)], ['nada']);
$this->assertTrue(true, 'The above not throwing an exception is the test'); $this->assertTrue(true, 'The above not throwing an exception is the test');
} }
#[TestDox('byFields() succeeds when no document is matched')]
public function testByFieldsSucceedsWhenNoDocumentIsMatched(): void public function testByFieldsSucceedsWhenNoDocumentIsMatched(): void
{ {
RemoveFields::byFields(ThrowawayDb::TABLE, [Field::NE('missing', 'nope')], ['value']); RemoveFields::byFields(ThrowawayDb::TABLE, [Field::notEqual('missing', 'nope')], ['value']);
$this->assertTrue(true, 'The above not throwing an exception is the test'); $this->assertTrue(true, 'The above not throwing an exception is the test');
} }
#[TestDox('byContains() succeeds when a field is removed')]
public function testByContainsSucceedsWhenAFieldIsRemoved(): void public function testByContainsSucceedsWhenAFieldIsRemoved(): void
{ {
$criteria = ['sub' => ['foo' => 'green']]; $criteria = ['sub' => ['foo' => 'green']];
@ -92,19 +96,21 @@ class RemoveFieldsTest extends TestCase
} }
} }
#[TestDox('byContains() succeeds when a field is not removed')]
public function testByContainsSucceedsWhenAFieldIsNotRemoved(): void public function testByContainsSucceedsWhenAFieldIsNotRemoved(): void
{ {
RemoveFields::byContains(ThrowawayDb::TABLE, ['sub' => ['foo' => 'green']], ['invalid_field']); RemoveFields::byContains(ThrowawayDb::TABLE, ['sub' => ['foo' => 'green']], ['invalid_field']);
$this->assertTrue(true, 'The above not throwing an exception is the test'); $this->assertTrue(true, 'The above not throwing an exception is the test');
} }
#[TestDox('byContains() succeeds when no document is matched')]
public function testByContainsSucceedsWhenNoDocumentIsMatched(): void public function testByContainsSucceedsWhenNoDocumentIsMatched(): void
{ {
RemoveFields::byContains(ThrowawayDb::TABLE, ['value' => 'substantial'], ['num_value']); RemoveFields::byContains(ThrowawayDb::TABLE, ['value' => 'substantial'], ['num_value']);
$this->assertTrue(true, 'The above not throwing an exception is the test'); $this->assertTrue(true, 'The above not throwing an exception is the test');
} }
#[TestDox('By JSON Path succeeds when a field is removed')] #[TestDox('byJsonPath() succeeds when a field is removed')]
public function testByJsonPathSucceedsWhenAFieldIsRemoved(): void public function testByJsonPathSucceedsWhenAFieldIsRemoved(): void
{ {
$path = '$.value ? (@ == "purple")'; $path = '$.value ? (@ == "purple")';
@ -118,14 +124,14 @@ class RemoveFieldsTest extends TestCase
} }
} }
#[TestDox('By JSON Path succeeds when a field is not removed')] #[TestDox('byJsonPath() succeeds when a field is not removed')]
public function testByJsonPathSucceedsWhenAFieldIsNotRemoved(): void public function testByJsonPathSucceedsWhenAFieldIsNotRemoved(): void
{ {
RemoveFields::byJsonPath(ThrowawayDb::TABLE, '$.value ? (@ == "purple")', ['submarine']); RemoveFields::byJsonPath(ThrowawayDb::TABLE, '$.value ? (@ == "purple")', ['submarine']);
$this->assertTrue(true, 'The above not throwing an exception is the test'); $this->assertTrue(true, 'The above not throwing an exception is the test');
} }
#[TestDox('By JSON Path succeeds when no document is matched')] #[TestDox('byJsonPath() succeeds when no document is matched')]
public function testByJsonPathSucceedsWhenNoDocumentIsMatched(): void public function testByJsonPathSucceedsWhenNoDocumentIsMatched(): void
{ {
RemoveFields::byJsonPath(ThrowawayDb::TABLE, '$.value ? (@ == "mauve")', ['value']); RemoveFields::byJsonPath(ThrowawayDb::TABLE, '$.value ? (@ == "mauve")', ['value']);

10
tests/integration/sqlite/CountTest.php
View File

@ -33,31 +33,35 @@ class CountTest extends TestCase
parent::tearDown(); parent::tearDown();
} }
#[TestDox('all() succeeds')]
public function testAllSucceeds(): void public function testAllSucceeds(): void
{ {
$count = Count::all(ThrowawayDb::TABLE); $count = Count::all(ThrowawayDb::TABLE);
$this->assertEquals(5, $count, 'There should have been 5 matching documents'); $this->assertEquals(5, $count, 'There should have been 5 matching documents');
} }
#[TestDox('byFields() succeeds for a numeric range')]
public function testByFieldsSucceedsForANumericRange(): void public function testByFieldsSucceedsForANumericRange(): void
{ {
$count = Count::byFields(ThrowawayDb::TABLE, [Field::BT('num_value', 10, 20)]); $count = Count::byFields(ThrowawayDb::TABLE, [Field::between('num_value', 10, 20)]);
$this->assertEquals(3, $count, 'There should have been 3 matching documents'); $this->assertEquals(3, $count, 'There should have been 3 matching documents');
} }
#[TestDox('byFields() succeeds for a non-numeric range')]
public function testByFieldsSucceedsForANonNumericRange(): void public function testByFieldsSucceedsForANonNumericRange(): void
{ {
$count = Count::byFields(ThrowawayDb::TABLE, [Field::BT('value', 'aardvark', 'apple')]); $count = Count::byFields(ThrowawayDb::TABLE, [Field::between('value', 'aardvark', 'apple')]);
$this->assertEquals(1, $count, 'There should have been 1 matching document'); $this->assertEquals(1, $count, 'There should have been 1 matching document');
} }
#[TestDox('byContains() fails')]
public function testByContainsFails(): void public function testByContainsFails(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);
Count::byContains('', []); Count::byContains('', []);
} }
#[TestDox('By JSON Path fails')] #[TestDox('byJsonPath() fails')]
public function testByJsonPathFails(): void public function testByJsonPathFails(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);

29
tests/integration/sqlite/CustomTest.php
View File

@ -34,7 +34,8 @@ class CustomTest extends TestCase
ThrowawayDb::destroy($this->dbName); ThrowawayDb::destroy($this->dbName);
} }
public function testRunQuerySucceedsWithAValidQuery() #[TestDox('runQuery() succeeds with a valid query')]
public function testRunQuerySucceedsWithAValidQuery(): void
{ {
$stmt = &Custom::runQuery('SELECT data FROM ' . ThrowawayDb::TABLE . ' LIMIT 1', []); $stmt = &Custom::runQuery('SELECT data FROM ' . ThrowawayDb::TABLE . ' LIMIT 1', []);
try { try {
@ -44,7 +45,8 @@ class CustomTest extends TestCase
} }
} }
public function testRunQueryFailsWithAnInvalidQuery() #[TestDox('runQuery() fails with an invalid query')]
public function testRunQueryFailsWithAnInvalidQuery(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);
$stmt = &Custom::runQuery('GRAB stuff FROM over_there UNTIL done', []); $stmt = &Custom::runQuery('GRAB stuff FROM over_there UNTIL done', []);
@ -55,7 +57,8 @@ class CustomTest extends TestCase
} }
} }
public function testListSucceedsWhenDataIsFound() #[TestDox('list() succeeds when data is found')]
public function testListSucceedsWhenDataIsFound(): void
{ {
$list = Custom::list(Query::selectFromTable(ThrowawayDb::TABLE), [], new DocumentMapper(TestDocument::class)); $list = Custom::list(Query::selectFromTable(ThrowawayDb::TABLE), [], new DocumentMapper(TestDocument::class));
$this->assertNotNull($list, 'The document list should not be null'); $this->assertNotNull($list, 'The document list should not be null');
@ -64,7 +67,8 @@ class CustomTest extends TestCase
$this->assertEquals(5, $count, 'There should have been 5 documents in the list'); $this->assertEquals(5, $count, 'There should have been 5 documents in the list');
} }
public function testListSucceedsWhenNoDataIsFound() #[TestDox('list() succeeds when no data is found')]
public function testListSucceedsWhenNoDataIsFound(): void
{ {
$list = Custom::list(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'num_value' > :value", $list = Custom::list(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'num_value' > :value",
[':value' => 100], new DocumentMapper(TestDocument::class)); [':value' => 100], new DocumentMapper(TestDocument::class));
@ -72,7 +76,8 @@ class CustomTest extends TestCase
$this->assertFalse($list->hasItems(), 'There should have been no documents in the list'); $this->assertFalse($list->hasItems(), 'There should have been no documents in the list');
} }
public function testArraySucceedsWhenDataIsFound() #[TestDox('array() succeeds when data is found')]
public function testArraySucceedsWhenDataIsFound(): void
{ {
$array = Custom::array(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'sub' IS NOT NULL", [], $array = Custom::array(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'sub' IS NOT NULL", [],
new DocumentMapper(TestDocument::class)); new DocumentMapper(TestDocument::class));
@ -80,7 +85,8 @@ class CustomTest extends TestCase
$this->assertCount(2, $array, 'There should have been 2 documents in the array'); $this->assertCount(2, $array, 'There should have been 2 documents in the array');
} }
public function testArraySucceedsWhenNoDataIsFound() #[TestDox('array() succeeds when no data is found')]
public function testArraySucceedsWhenNoDataIsFound(): void
{ {
$array = Custom::array(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'value' = :value", $array = Custom::array(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'value' = :value",
[':value' => 'not there'], new DocumentMapper(TestDocument::class)); [':value' => 'not there'], new DocumentMapper(TestDocument::class));
@ -88,6 +94,7 @@ class CustomTest extends TestCase
$this->assertCount(0, $array, 'There should have been no documents in the array'); $this->assertCount(0, $array, 'There should have been no documents in the array');
} }
#[TestDox('single() succeeds when a row is found')]
public function testSingleSucceedsWhenARowIsFound(): void public function testSingleSucceedsWhenARowIsFound(): void
{ {
$doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE . " WHERE data->>'id' = :id", [':id' => 'one'], $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE . " WHERE data->>'id' = :id", [':id' => 'one'],
@ -96,6 +103,7 @@ class CustomTest extends TestCase
$this->assertEquals('one', $doc->get()->id, 'The incorrect document was returned'); $this->assertEquals('one', $doc->get()->id, 'The incorrect document was returned');
} }
#[TestDox('single() succeeds when a row is not found')]
public function testSingleSucceedsWhenARowIsNotFound(): void public function testSingleSucceedsWhenARowIsNotFound(): void
{ {
$doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE . " WHERE data->>'id' = :id", $doc = Custom::single('SELECT data FROM ' . ThrowawayDb::TABLE . " WHERE data->>'id' = :id",
@ -103,21 +111,24 @@ class CustomTest extends TestCase
$this->assertTrue($doc->isNone(), 'There should not have been a document returned'); $this->assertTrue($doc->isNone(), 'There should not have been a document returned');
} }
public function testNonQuerySucceedsWhenOperatingOnData() #[TestDox('nonQuery() succeeds when operating on data')]
public function testNonQuerySucceedsWhenOperatingOnData(): void
{ {
Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []); Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
$remaining = Count::all(ThrowawayDb::TABLE); $remaining = Count::all(ThrowawayDb::TABLE);
$this->assertEquals(0, $remaining, 'There should be no documents remaining in the table'); $this->assertEquals(0, $remaining, 'There should be no documents remaining in the table');
} }
public function testNonQuerySucceedsWhenNoDataMatchesWhereClause() #[TestDox('nonQuery() succeeds when no data matches WHERE clause')]
public function testNonQuerySucceedsWhenNoDataMatchesWhereClause(): void
{ {
Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE . " WHERE data->>'num_value' > :value", [':value' => 100]); Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE . " WHERE data->>'num_value' > :value", [':value' => 100]);
$remaining = Count::all(ThrowawayDb::TABLE); $remaining = Count::all(ThrowawayDb::TABLE);
$this->assertEquals(5, $remaining, 'There should be 5 documents remaining in the table'); $this->assertEquals(5, $remaining, 'There should be 5 documents remaining in the table');
} }
public function testScalarSucceeds() #[TestDox('scalar() succeeds')]
public function testScalarSucceeds(): void
{ {
$value = Custom::scalar("SELECT 5 AS it", [], new CountMapper()); $value = Custom::scalar("SELECT 5 AS it", [], new CountMapper());
$this->assertEquals(5, $value, 'The scalar value was not returned correctly'); $this->assertEquals(5, $value, 'The scalar value was not returned correctly');

3
tests/integration/sqlite/DefinitionTest.php
View File

@ -47,6 +47,7 @@ class DefinitionTest extends TestCase
[':name' => $name], new ExistsMapper()); [':name' => $name], new ExistsMapper());
} }
#[TestDox('ensureTable() succeeds')]
public function testEnsureTableSucceeds(): void public function testEnsureTableSucceeds(): void
{ {
$this->assertFalse($this->itExists('ensured'), 'The table should not exist already'); $this->assertFalse($this->itExists('ensured'), 'The table should not exist already');
@ -56,6 +57,7 @@ class DefinitionTest extends TestCase
$this->assertTrue($this->itExists('idx_ensured_key'), 'The key index should now exist'); $this->assertTrue($this->itExists('idx_ensured_key'), 'The key index should now exist');
} }
#[TestDox('ensureFieldIndex() succeeds')]
public function testEnsureFieldIndexSucceeds(): void public function testEnsureFieldIndexSucceeds(): void
{ {
$this->assertFalse($this->itExists('idx_ensured_test'), 'The index should not exist already'); $this->assertFalse($this->itExists('idx_ensured_test'), 'The index should not exist already');
@ -64,6 +66,7 @@ class DefinitionTest extends TestCase
$this->assertTrue($this->itExists('idx_ensured_test'), 'The index should now exist'); $this->assertTrue($this->itExists('idx_ensured_test'), 'The index should now exist');
} }
#[TestDox('ensureDocumentIndex() fails')]
public function testEnsureDocumentIndexFails(): void public function testEnsureDocumentIndexFails(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);

13
tests/integration/sqlite/DeleteTest.php
View File

@ -33,7 +33,7 @@ class DeleteTest extends TestCase
parent::tearDown(); parent::tearDown();
} }
#[TestDox('By ID succeeds when a document is deleted')] #[TestDox('byId() succeeds when a document is deleted')]
public function testByIdSucceedsWhenADocumentIsDeleted(): void public function testByIdSucceedsWhenADocumentIsDeleted(): void
{ {
$this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start'); $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
@ -41,7 +41,7 @@ class DeleteTest extends TestCase
$this->assertEquals(4, Count::all(ThrowawayDb::TABLE), 'There should have been 4 documents remaining'); $this->assertEquals(4, Count::all(ThrowawayDb::TABLE), 'There should have been 4 documents remaining');
} }
#[TestDox('By ID succeeds when a document is not deleted')] #[TestDox('byId() succeeds when a document is not deleted')]
public function testByIdSucceedsWhenADocumentIsNotDeleted(): void public function testByIdSucceedsWhenADocumentIsNotDeleted(): void
{ {
$this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start'); $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
@ -49,27 +49,30 @@ class DeleteTest extends TestCase
$this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents remaining'); $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents remaining');
} }
#[TestDox('byFields() succeeds when documents are deleted')]
public function testByFieldsSucceedsWhenDocumentsAreDeleted(): void public function testByFieldsSucceedsWhenDocumentsAreDeleted(): void
{ {
$this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start'); $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
Delete::byFields(ThrowawayDb::TABLE, [Field::NE('value', 'purple')]); Delete::byFields(ThrowawayDb::TABLE, [Field::notEqual('value', 'purple')]);
$this->assertEquals(2, Count::all(ThrowawayDb::TABLE), 'There should have been 2 documents remaining'); $this->assertEquals(2, Count::all(ThrowawayDb::TABLE), 'There should have been 2 documents remaining');
} }
#[TestDox('byFields() succeeds when documents are not deleted')]
public function testByFieldsSucceedsWhenDocumentsAreNotDeleted(): void public function testByFieldsSucceedsWhenDocumentsAreNotDeleted(): void
{ {
$this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start'); $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents to start');
Delete::byFields(ThrowawayDb::TABLE, [Field::EQ('value', 'crimson')]); Delete::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'crimson')]);
$this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents remaining'); $this->assertEquals(5, Count::all(ThrowawayDb::TABLE), 'There should have been 5 documents remaining');
} }
#[TestDox('byContains() fails')]
public function testByContainsFails(): void public function testByContainsFails(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);
Delete::byContains('', []); Delete::byContains('', []);
} }
#[TestDox('By JSON Path fails')] #[TestDox('byJsonPath() fails')]
public function testByJsonPathFails(): void public function testByJsonPathFails(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);

9
tests/integration/sqlite/DocumentListTest.php
View File

@ -35,6 +35,7 @@ class DocumentListTest extends TestCase
parent::tearDown(); parent::tearDown();
} }
#[TestDox('create() succeeds')]
public function testCreateSucceeds(): void public function testCreateSucceeds(): void
{ {
$list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [], $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
@ -43,6 +44,7 @@ class DocumentListTest extends TestCase
$list = null; $list = null;
} }
#[TestDox('items() succeeds')]
public function testItemsSucceeds(): void public function testItemsSucceeds(): void
{ {
$list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [], $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
@ -57,6 +59,7 @@ class DocumentListTest extends TestCase
$this->assertEquals(5, $count, 'There should have been 5 documents returned'); $this->assertEquals(5, $count, 'There should have been 5 documents returned');
} }
#[TestDox('items() fails when already consumed')]
public function testItemsFailsWhenAlreadyConsumed(): void public function testItemsFailsWhenAlreadyConsumed(): void
{ {
$list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [], $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
@ -69,6 +72,7 @@ class DocumentListTest extends TestCase
iterator_to_array($list->items()); iterator_to_array($list->items());
} }
#[TestDox('hasItems() succeeds with empty results')]
public function testHasItemsSucceedsWithEmptyResults(): void public function testHasItemsSucceedsWithEmptyResults(): void
{ {
$list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'num_value' < 0", [], $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE) . " WHERE data->>'num_value' < 0", [],
@ -77,6 +81,7 @@ class DocumentListTest extends TestCase
$this->assertFalse($list->hasItems(), 'There should be no items in the list'); $this->assertFalse($list->hasItems(), 'There should be no items in the list');
} }
#[TestDox('hasItems() succeeds with non-empty results')]
public function testHasItemsSucceedsWithNonEmptyResults(): void public function testHasItemsSucceedsWithNonEmptyResults(): void
{ {
$list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [], $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
@ -88,6 +93,8 @@ class DocumentListTest extends TestCase
} }
$this->assertFalse($list->hasItems(), 'There should be no remaining items in the list'); $this->assertFalse($list->hasItems(), 'There should be no remaining items in the list');
} }
#[TestDox('map() succeeds')]
public function testMapSucceeds(): void public function testMapSucceeds(): void
{ {
$list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [], $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
@ -100,6 +107,7 @@ class DocumentListTest extends TestCase
} }
} }
#[TestDox('iter() succeeds')]
public function testIterSucceeds(): void public function testIterSucceeds(): void
{ {
$list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [], $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],
@ -112,6 +120,7 @@ class DocumentListTest extends TestCase
'Iteration did not have the expected result'); 'Iteration did not have the expected result');
} }
#[TestDox('mapToArray() succeeds')]
public function testMapToArraySucceeds(): void public function testMapToArraySucceeds(): void
{ {
$list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [], $list = DocumentList::create(Query::selectFromTable(ThrowawayDb::TABLE), [],

55
tests/integration/sqlite/DocumentTest.php
View File

@ -35,7 +35,7 @@ class DocumentTest extends TestCase
parent::tearDown(); parent::tearDown();
} }
#[TestDox('Insert succeeds for array no auto ID')] #[TestDox('insert() succeeds for array no auto ID')]
public function testInsertSucceedsForArrayNoAutoId(): void public function testInsertSucceedsForArrayNoAutoId(): void
{ {
Document::insert(ThrowawayDb::TABLE, ['id' => 'turkey', 'sub' => ['foo' => 'gobble', 'bar' => 'gobble']]); Document::insert(ThrowawayDb::TABLE, ['id' => 'turkey', 'sub' => ['foo' => 'gobble', 'bar' => 'gobble']]);
@ -50,7 +50,7 @@ class DocumentTest extends TestCase
$this->assertEquals('gobble', $doc->sub->bar, 'The sub-document bar property was incorrect'); $this->assertEquals('gobble', $doc->sub->bar, 'The sub-document bar property was incorrect');
} }
#[TestDox('Insert succeeds for array with auto number ID not provided')] #[TestDox('insert() succeeds for array with auto number ID not provided')]
public function testInsertSucceedsForArrayWithAutoNumberIdNotProvided(): void public function testInsertSucceedsForArrayWithAutoNumberIdNotProvided(): void
{ {
Configuration::$autoId = AutoId::Number; Configuration::$autoId = AutoId::Number;
@ -74,7 +74,7 @@ class DocumentTest extends TestCase
} }
} }
#[TestDox('Insert succeeds for array with auto number ID with ID provided')] #[TestDox('insert() succeeds for array with auto number ID with ID provided')]
public function testInsertSucceedsForArrayWithAutoNumberIdWithIdProvided(): void public function testInsertSucceedsForArrayWithAutoNumberIdWithIdProvided(): void
{ {
Configuration::$autoId = AutoId::Number; Configuration::$autoId = AutoId::Number;
@ -90,14 +90,14 @@ class DocumentTest extends TestCase
} }
} }
#[TestDox('Insert succeeds for array with auto UUID ID not provided')] #[TestDox('insert() succeeds for array with auto UUID ID not provided')]
public function testInsertSucceedsForArrayWithAutoUuidIdNotProvided(): void public function testInsertSucceedsForArrayWithAutoUuidIdNotProvided(): void
{ {
Configuration::$autoId = AutoId::UUID; Configuration::$autoId = AutoId::UUID;
try { try {
Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []); Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
Document::insert(ThrowawayDb::TABLE, ['id' => '', 'num_value' => 5]); Document::insert(ThrowawayDb::TABLE, ['id' => '', 'num_value' => 5]);
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 5)], TestDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 5)], TestDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertNotEmpty($doc->get()->id, 'The ID should have been auto-generated'); $this->assertNotEmpty($doc->get()->id, 'The ID should have been auto-generated');
} finally { } finally {
@ -105,7 +105,7 @@ class DocumentTest extends TestCase
} }
} }
#[TestDox('Insert succeeds for array with auto UUID ID with ID provided')] #[TestDox('insert() succeeds for array with auto UUID ID with ID provided')]
public function testInsertSucceedsForArrayWithAutoUuidIdWithIdProvided(): void public function testInsertSucceedsForArrayWithAutoUuidIdWithIdProvided(): void
{ {
Configuration::$autoId = AutoId::UUID; Configuration::$autoId = AutoId::UUID;
@ -113,7 +113,7 @@ class DocumentTest extends TestCase
Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []); Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
$uuid = AutoId::generateUUID(); $uuid = AutoId::generateUUID();
Document::insert(ThrowawayDb::TABLE, ['id' => $uuid, 'value' => 'uuid', 'num_value' => 12]); Document::insert(ThrowawayDb::TABLE, ['id' => $uuid, 'value' => 'uuid', 'num_value' => 12]);
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 12)], TestDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 12)], TestDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertEquals($uuid, $doc->get()->id, 'The ID should not have been changed'); $this->assertEquals($uuid, $doc->get()->id, 'The ID should not have been changed');
} finally { } finally {
@ -121,7 +121,7 @@ class DocumentTest extends TestCase
} }
} }
#[TestDox('Insert succeeds for array with auto string ID not provided')] #[TestDox('insert() succeeds for array with auto string ID not provided')]
public function testInsertSucceedsForArrayWithAutoStringIdNotProvided(): void public function testInsertSucceedsForArrayWithAutoStringIdNotProvided(): void
{ {
Configuration::$autoId = AutoId::RandomString; Configuration::$autoId = AutoId::RandomString;
@ -129,7 +129,7 @@ class DocumentTest extends TestCase
try { try {
Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []); Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
Document::insert(ThrowawayDb::TABLE, ['id' => '', 'value' => 'new', 'num_value' => 8]); Document::insert(ThrowawayDb::TABLE, ['id' => '', 'value' => 'new', 'num_value' => 8]);
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 8)], TestDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 8)], TestDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertEquals(6, strlen($doc->get()->id), $this->assertEquals(6, strlen($doc->get()->id),
'The ID should have been auto-generated and had 6 characters'); 'The ID should have been auto-generated and had 6 characters');
@ -139,14 +139,14 @@ class DocumentTest extends TestCase
} }
} }
#[TestDox('Insert succeeds for array with auto string ID with ID provided')] #[TestDox('insert() succeeds for array with auto string ID with ID provided')]
public function testInsertSucceedsForArrayWithAutoStringIdWithIdProvided(): void public function testInsertSucceedsForArrayWithAutoStringIdWithIdProvided(): void
{ {
Configuration::$autoId = AutoId::RandomString; Configuration::$autoId = AutoId::RandomString;
try { try {
Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []); Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
Document::insert(ThrowawayDb::TABLE, ['id' => 'my-key', 'value' => 'old', 'num_value' => 3]); Document::insert(ThrowawayDb::TABLE, ['id' => 'my-key', 'value' => 'old', 'num_value' => 3]);
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 3)], TestDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 3)], TestDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertEquals('my-key', $doc->get()->id, 'The ID should not have been changed'); $this->assertEquals('my-key', $doc->get()->id, 'The ID should not have been changed');
} finally { } finally {
@ -154,7 +154,7 @@ class DocumentTest extends TestCase
} }
} }
#[TestDox('Insert succeeds for object no auto ID')] #[TestDox('insert() succeeds for object no auto ID')]
public function testInsertSucceedsForObjectNoAutoId(): void public function testInsertSucceedsForObjectNoAutoId(): void
{ {
Document::insert(ThrowawayDb::TABLE, new TestDocument('turkey', sub: new SubDocument('gobble', 'gobble'))); Document::insert(ThrowawayDb::TABLE, new TestDocument('turkey', sub: new SubDocument('gobble', 'gobble')));
@ -169,7 +169,7 @@ class DocumentTest extends TestCase
$this->assertEquals('gobble', $doc->sub->bar, 'The sub-document bar property was incorrect'); $this->assertEquals('gobble', $doc->sub->bar, 'The sub-document bar property was incorrect');
} }
#[TestDox('Insert succeeds for object with auto number ID not provided')] #[TestDox('insert() succeeds for object with auto number ID not provided')]
public function testInsertSucceedsForObjectWithAutoNumberIdNotProvided(): void public function testInsertSucceedsForObjectWithAutoNumberIdNotProvided(): void
{ {
Configuration::$autoId = AutoId::Number; Configuration::$autoId = AutoId::Number;
@ -177,12 +177,12 @@ class DocumentTest extends TestCase
Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []); Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
Document::insert(ThrowawayDb::TABLE, new NumDocument(value: 'taco')); Document::insert(ThrowawayDb::TABLE, new NumDocument(value: 'taco'));
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('value', 'taco')], NumDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'taco')], NumDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertEquals(1, $doc->get()->id, 'The ID 1 should have been auto-generated'); $this->assertEquals(1, $doc->get()->id, 'The ID 1 should have been auto-generated');
Document::insert(ThrowawayDb::TABLE, new NumDocument(value: 'burrito')); Document::insert(ThrowawayDb::TABLE, new NumDocument(value: 'burrito'));
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('value', 'burrito')], NumDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'burrito')], NumDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertEquals(2, $doc->get()->id, 'The ID 2 should have been auto-generated'); $this->assertEquals(2, $doc->get()->id, 'The ID 2 should have been auto-generated');
} finally { } finally {
@ -190,14 +190,14 @@ class DocumentTest extends TestCase
} }
} }
#[TestDox('Insert succeeds for object with auto number ID with ID provided')] #[TestDox('insert() succeeds for object with auto number ID with ID provided')]
public function testInsertSucceedsForObjectWithAutoNumberIdWithIdProvided(): void public function testInsertSucceedsForObjectWithAutoNumberIdWithIdProvided(): void
{ {
Configuration::$autoId = AutoId::Number; Configuration::$autoId = AutoId::Number;
try { try {
Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []); Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
Document::insert(ThrowawayDb::TABLE, new NumDocument(64, 'large')); Document::insert(ThrowawayDb::TABLE, new NumDocument(64, 'large'));
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('value', 'large')], NumDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'large')], NumDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertEquals(64, $doc->get()->id, 'The ID 64 should have been stored'); $this->assertEquals(64, $doc->get()->id, 'The ID 64 should have been stored');
} finally { } finally {
@ -205,14 +205,14 @@ class DocumentTest extends TestCase
} }
} }
#[TestDox('Insert succeeds for object with auto UUID ID not provided')] #[TestDox('insert() succeeds for object with auto UUID ID not provided')]
public function testInsertSucceedsForObjectWithAutoUuidIdNotProvided(): void public function testInsertSucceedsForObjectWithAutoUuidIdNotProvided(): void
{ {
Configuration::$autoId = AutoId::UUID; Configuration::$autoId = AutoId::UUID;
try { try {
Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []); Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
Document::insert(ThrowawayDb::TABLE, new TestDocument(value: 'something', num_value: 9)); Document::insert(ThrowawayDb::TABLE, new TestDocument(value: 'something', num_value: 9));
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EX('value')], TestDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::exists('value')], TestDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertNotEmpty($doc->get()->id, 'The ID should have been auto-generated'); $this->assertNotEmpty($doc->get()->id, 'The ID should have been auto-generated');
} finally { } finally {
@ -220,7 +220,7 @@ class DocumentTest extends TestCase
} }
} }
#[TestDox('Insert succeeds for object with auto UUID ID with ID provided')] #[TestDox('insert() succeeds for object with auto UUID ID with ID provided')]
public function testInsertSucceedsForObjectWithAutoUuidIdWithIdProvided(): void public function testInsertSucceedsForObjectWithAutoUuidIdWithIdProvided(): void
{ {
Configuration::$autoId = AutoId::UUID; Configuration::$autoId = AutoId::UUID;
@ -228,7 +228,7 @@ class DocumentTest extends TestCase
Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []); Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
$uuid = AutoId::generateUUID(); $uuid = AutoId::generateUUID();
Document::insert(ThrowawayDb::TABLE, new TestDocument($uuid, num_value: 14)); Document::insert(ThrowawayDb::TABLE, new TestDocument($uuid, num_value: 14));
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 14)], TestDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 14)], TestDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertEquals($uuid, $doc->get()->id, 'The ID should not have been changed'); $this->assertEquals($uuid, $doc->get()->id, 'The ID should not have been changed');
} finally { } finally {
@ -236,7 +236,7 @@ class DocumentTest extends TestCase
} }
} }
#[TestDox('Insert succeeds for object with auto string ID not provided')] #[TestDox('insert() succeeds for object with auto string ID not provided')]
public function testInsertSucceedsForObjectWithAutoStringIdNotProvided(): void public function testInsertSucceedsForObjectWithAutoStringIdNotProvided(): void
{ {
Configuration::$autoId = AutoId::RandomString; Configuration::$autoId = AutoId::RandomString;
@ -244,7 +244,7 @@ class DocumentTest extends TestCase
try { try {
Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []); Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
Document::insert(ThrowawayDb::TABLE, new TestDocument(num_value: 55)); Document::insert(ThrowawayDb::TABLE, new TestDocument(num_value: 55));
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 55)], TestDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 55)], TestDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertEquals(40, strlen($doc->get()->id), $this->assertEquals(40, strlen($doc->get()->id),
'The ID should have been auto-generated and had 40 characters'); 'The ID should have been auto-generated and had 40 characters');
@ -254,14 +254,14 @@ class DocumentTest extends TestCase
} }
} }
#[TestDox('Insert succeeds for object with auto string ID with ID provided')] #[TestDox('insert() succeeds for object with auto string ID with ID provided')]
public function testInsertSucceedsForObjectWithAutoStringIdWithIdProvided(): void public function testInsertSucceedsForObjectWithAutoStringIdWithIdProvided(): void
{ {
Configuration::$autoId = AutoId::RandomString; Configuration::$autoId = AutoId::RandomString;
try { try {
Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []); Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
Document::insert(ThrowawayDb::TABLE, new TestDocument('my-key', num_value: 3)); Document::insert(ThrowawayDb::TABLE, new TestDocument('my-key', num_value: 3));
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 3)], TestDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 3)], TestDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertEquals('my-key', $doc->get()->id, 'The ID should not have been changed'); $this->assertEquals('my-key', $doc->get()->id, 'The ID should not have been changed');
} finally { } finally {
@ -269,12 +269,14 @@ class DocumentTest extends TestCase
} }
} }
#[TestDox('insert() fails for duplicate key')]
public function testInsertFailsForDuplicateKey(): void public function testInsertFailsForDuplicateKey(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);
Document::insert(ThrowawayDb::TABLE, new TestDocument('one')); Document::insert(ThrowawayDb::TABLE, new TestDocument('one'));
} }
#[TestDox('save() succeeds when a document is inserted')]
public function testSaveSucceedsWhenADocumentIsInserted(): void public function testSaveSucceedsWhenADocumentIsInserted(): void
{ {
Document::save(ThrowawayDb::TABLE, new TestDocument('test', sub: new SubDocument('a', 'b'))); Document::save(ThrowawayDb::TABLE, new TestDocument('test', sub: new SubDocument('a', 'b')));
@ -282,6 +284,7 @@ class DocumentTest extends TestCase
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
} }
#[TestDox('save() succeeds when a document is updated')]
public function testSaveSucceedsWhenADocumentIsUpdated(): void public function testSaveSucceedsWhenADocumentIsUpdated(): void
{ {
Document::save(ThrowawayDb::TABLE, new TestDocument('two', num_value: 44)); Document::save(ThrowawayDb::TABLE, new TestDocument('two', num_value: 44));
@ -292,6 +295,7 @@ class DocumentTest extends TestCase
$this->assertNull($doc->sub, 'The sub-document should have been null'); $this->assertNull($doc->sub, 'The sub-document should have been null');
} }
#[TestDox('update() succeeds when replacing a document')]
public function testUpdateSucceedsWhenReplacingADocument(): void public function testUpdateSucceedsWhenReplacingADocument(): void
{ {
Document::update(ThrowawayDb::TABLE, 'one', new TestDocument('one', 'howdy', 8, new SubDocument('y', 'z'))); Document::update(ThrowawayDb::TABLE, 'one', new TestDocument('one', 'howdy', 8, new SubDocument('y', 'z')));
@ -305,6 +309,7 @@ class DocumentTest extends TestCase
$this->assertEquals('z', $doc->sub->bar, 'The sub-document bar property was incorrect'); $this->assertEquals('z', $doc->sub->bar, 'The sub-document bar property was incorrect');
} }
#[TestDox('update() succeeds when no document is replaced')]
public function testUpdateSucceedsWhenNoDocumentIsReplaced(): void public function testUpdateSucceedsWhenNoDocumentIsReplaced(): void
{ {
Document::update(ThrowawayDb::TABLE, 'two-hundred', new TestDocument('200')); Document::update(ThrowawayDb::TABLE, 'two-hundred', new TestDocument('200'));

13
tests/integration/sqlite/ExistsTest.php
View File

@ -33,38 +33,41 @@ class ExistsTest extends TestCase
parent::tearDown(); parent::tearDown();
} }
#[TestDox('By ID succeeds when a document exists')] #[TestDox('byId() succeeds when a document exists')]
public function testByIdSucceedsWhenADocumentExists(): void public function testByIdSucceedsWhenADocumentExists(): void
{ {
$this->assertTrue(Exists::byId(ThrowawayDb::TABLE, 'three'), 'There should have been an existing document'); $this->assertTrue(Exists::byId(ThrowawayDb::TABLE, 'three'), 'There should have been an existing document');
} }
#[TestDox('By ID succeeds when a document does not exist')] #[TestDox('byId() succeeds when a document does not exist')]
public function testByIdSucceedsWhenADocumentDoesNotExist(): void public function testByIdSucceedsWhenADocumentDoesNotExist(): void
{ {
$this->assertFalse(Exists::byId(ThrowawayDb::TABLE, 'seven'), $this->assertFalse(Exists::byId(ThrowawayDb::TABLE, 'seven'),
'There should not have been an existing document'); 'There should not have been an existing document');
} }
#[TestDox('byFields() succeeds when documents exist')]
public function testByFieldsSucceedsWhenDocumentsExist(): void public function testByFieldsSucceedsWhenDocumentsExist(): void
{ {
$this->assertTrue(Exists::byFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 10)]), $this->assertTrue(Exists::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 10)]),
'There should have been existing documents'); 'There should have been existing documents');
} }
#[TestDox('byFields() succeeds when no matching documents exist')]
public function testByFieldsSucceedsWhenNoMatchingDocumentsExist(): void public function testByFieldsSucceedsWhenNoMatchingDocumentsExist(): void
{ {
$this->assertFalse(Exists::byFields(ThrowawayDb::TABLE, [Field::LT('nothing', 'none')]), $this->assertFalse(Exists::byFields(ThrowawayDb::TABLE, [Field::less('nothing', 'none')]),
'There should not have been any existing documents'); 'There should not have been any existing documents');
} }
#[TestDox('byContains() fails')]
public function testByContainsFails(): void public function testByContainsFails(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);
Exists::byContains('', []); Exists::byContains('', []);
} }
#[TestDox('By JSON Path fails')] #[TestDox('byJsonPath() fails')]
public function testByJsonPathFails(): void public function testByJsonPathFails(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);

116
tests/integration/sqlite/FindTest.php
View File

@ -8,9 +8,10 @@ declare(strict_types=1);
namespace Test\Integration\SQLite; namespace Test\Integration\SQLite;
use BitBadger\PDODocument\{Custom, Document, DocumentException, Field, Find}; use BitBadger\PDODocument\{Custom, Delete, Document, DocumentException, Field, FieldMatch, Find};
use PHPUnit\Framework\Attributes\TestDox; use PHPUnit\Framework\Attributes\TestDox;
use PHPUnit\Framework\TestCase; use PHPUnit\Framework\TestCase;
use Test\Integration\ArrayDocument;
use Test\Integration\TestDocument; use Test\Integration\TestDocument;
/** /**
@ -34,6 +35,7 @@ class FindTest extends TestCase
parent::tearDown(); parent::tearDown();
} }
#[TestDox('all() succeeds when there is data')]
public function testAllSucceedsWhenThereIsData(): void public function testAllSucceedsWhenThereIsData(): void
{ {
$docs = Find::all(ThrowawayDb::TABLE, TestDocument::class); $docs = Find::all(ThrowawayDb::TABLE, TestDocument::class);
@ -43,6 +45,35 @@ class FindTest extends TestCase
$this->assertEquals(5, $count, 'There should have been 5 documents in the list'); $this->assertEquals(5, $count, 'There should have been 5 documents in the list');
} }
#[TestDox('all() succeeds when ordering data ascending')]
public function testAllSucceedsWhenOrderingDataAscending(): void
{
$docs = Find::all(ThrowawayDb::TABLE, TestDocument::class, [Field::named('id')]);
$this->assertNotNull($docs, 'There should have been a document list returned');
$ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
$this->assertEquals(['five', 'four', 'one', 'three', 'two'], $ids, 'The documents were not ordered correctly');
}
#[TestDox('all() succeeds when ordering data descending')]
public function testAllSucceedsWhenOrderingDataDescending(): void
{
$docs = Find::all(ThrowawayDb::TABLE, TestDocument::class, [Field::named('id DESC')]);
$this->assertNotNull($docs, 'There should have been a document list returned');
$ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
$this->assertEquals(['two', 'three', 'one', 'four', 'five'], $ids, 'The documents were not ordered correctly');
}
#[TestDox('all() succeeds when ordering data numerically')]
public function testAllSucceedsWhenOrderingDataNumerically(): void
{
$docs = Find::all(ThrowawayDb::TABLE, TestDocument::class,
[Field::named('sub.foo NULLS LAST'), Field::named('n:num_value')]);
$this->assertNotNull($docs, 'There should have been a document list returned');
$ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
$this->assertEquals(['two', 'four', 'one', 'three', 'five'], $ids, 'The documents were not ordered correctly');
}
#[TestDox('all() succeeds when there is no data')]
public function testAllSucceedsWhenThereIsNoData(): void public function testAllSucceedsWhenThereIsNoData(): void
{ {
Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []); Custom::nonQuery('DELETE FROM ' . ThrowawayDb::TABLE, []);
@ -51,7 +82,7 @@ class FindTest extends TestCase
$this->assertFalse($docs->hasItems(), 'There should have been no documents in the list'); $this->assertFalse($docs->hasItems(), 'There should have been no documents in the list');
} }
#[TestDox('By ID succeeds when a document is found')] #[TestDox('byId() succeeds when a document is found')]
public function testByIdSucceedsWhenADocumentIsFound(): void public function testByIdSucceedsWhenADocumentIsFound(): void
{ {
$doc = Find::byId(ThrowawayDb::TABLE, 'two', TestDocument::class); $doc = Find::byId(ThrowawayDb::TABLE, 'two', TestDocument::class);
@ -59,7 +90,7 @@ class FindTest extends TestCase
$this->assertEquals('two', $doc->get()->id, 'An incorrect document was returned'); $this->assertEquals('two', $doc->get()->id, 'An incorrect document was returned');
} }
#[TestDox('By ID succeeds when a document is found with numeric ID')] #[TestDox('byId() succeeds when a document is found with numeric ID')]
public function testByIdSucceedsWhenADocumentIsFoundWithNumericId(): void public function testByIdSucceedsWhenADocumentIsFoundWithNumericId(): void
{ {
Document::insert(ThrowawayDb::TABLE, ['id' => 18, 'value' => 'howdy']); Document::insert(ThrowawayDb::TABLE, ['id' => 18, 'value' => 'howdy']);
@ -68,69 +99,130 @@ class FindTest extends TestCase
$this->assertEquals('18', $doc->get()->id, 'An incorrect document was returned'); $this->assertEquals('18', $doc->get()->id, 'An incorrect document was returned');
} }
#[TestDox('By ID succeeds when a document is not found')] #[TestDox('byId() succeeds when a document is not found')]
public function testByIdSucceedsWhenADocumentIsNotFound(): void public function testByIdSucceedsWhenADocumentIsNotFound(): void
{ {
$doc = Find::byId(ThrowawayDb::TABLE, 'seventy-five', TestDocument::class); $doc = Find::byId(ThrowawayDb::TABLE, 'seventy-five', TestDocument::class);
$this->assertTrue($doc->isNone(), 'There should not have been a document returned'); $this->assertTrue($doc->isNone(), 'There should not have been a document returned');
} }
#[TestDox('byFields() succeeds when documents are found')]
public function testByFieldsSucceedsWhenDocumentsAreFound(): void public function testByFieldsSucceedsWhenDocumentsAreFound(): void
{ {
$docs = Find::byFields(ThrowawayDb::TABLE, [Field::GT('num_value', 15)], TestDocument::class); $docs = Find::byFields(ThrowawayDb::TABLE, [Field::in('value', ['blue', 'purple']), Field::exists('sub')],
TestDocument::class, FieldMatch::All);
$this->assertNotNull($docs, 'There should have been a document list returned');
$count = 0;
foreach ($docs->items() as $ignored) $count++;
$this->assertEquals(1, $count, 'There should have been 1 document in the list');
}
#[TestDox('byFields() succeeds when documents are found and ordered')]
public function testByFieldsSucceedsWhenDocumentsAreFoundAndOrdered(): void
{
$docs = Find::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'purple')], TestDocument::class,
FieldMatch::All, [Field::named('id')]);
$this->assertNotNull($docs, 'There should have been a document list returned');
$ids = iterator_to_array($docs->map(fn ($it) => $it->id), false);
$this->assertEquals(['five', 'four'], $ids, 'The documents were not ordered correctly');
}
#[TestDox('byFields() succeeds when documents are found using IN with numeric field')]
public function testByFieldsSucceedsWhenDocumentsAreFoundUsingInWithNumericField(): void
{
$docs = Find::byFields(ThrowawayDb::TABLE, [Field::in('num_value', [2, 4, 6, 8])], TestDocument::class);
$this->assertNotNull($docs, 'There should have been a document list returned');
$count = 0;
foreach ($docs->items() as $ignored) $count++;
$this->assertEquals(1, $count, 'There should have been 1 document in the list');
}
#[TestDox('byFields() succeeds when no documents are found')]
public function testByFieldsSucceedsWhenNoDocumentsAreFound(): void
{
$docs = Find::byFields(ThrowawayDb::TABLE, [Field::greater('num_value', 100)], TestDocument::class);
$this->assertNotNull($docs, 'There should have been a document list returned');
$this->assertFalse($docs->hasItems(), 'There should have been no documents in the list');
}
#[TestDox('byFields() succeeds for inArray when matching documents exist')]
public function testByFieldsSucceedsForInArrayWhenMatchingDocumentsExist(): void
{
Delete::byFields(ThrowawayDb::TABLE, [Field::notExists('absentField')]);
foreach (ArrayDocument::testDocuments() as $doc) Document::insert(ThrowawayDb::TABLE, $doc);
$docs = Find::byFields(ThrowawayDb::TABLE, [Field::inArray('values', ThrowawayDb::TABLE, ['c'])],
ArrayDocument::class);
$this->assertNotNull($docs, 'There should have been a document list returned'); $this->assertNotNull($docs, 'There should have been a document list returned');
$count = 0; $count = 0;
foreach ($docs->items() as $ignored) $count++; foreach ($docs->items() as $ignored) $count++;
$this->assertEquals(2, $count, 'There should have been 2 documents in the list'); $this->assertEquals(2, $count, 'There should have been 2 documents in the list');
} }
public function testByFieldsSucceedsWhenNoDocumentsAreFound(): void #[TestDox('byFields() succeeds for inArray when no matching documents exist')]
public function testByFieldsSucceedsForInArrayWhenNoMatchingDocumentsExist(): void
{ {
$docs = Find::byFields(ThrowawayDb::TABLE, [Field::GT('num_value', 100)], TestDocument::class); Delete::byFields(ThrowawayDb::TABLE, [Field::notExists('absentField')]);
foreach (ArrayDocument::testDocuments() as $doc) Document::insert(ThrowawayDb::TABLE, $doc);
$docs = Find::byFields(ThrowawayDb::TABLE, [Field::inArray('values', ThrowawayDb::TABLE, ['j'])],
ArrayDocument::class);
$this->assertNotNull($docs, 'There should have been a document list returned'); $this->assertNotNull($docs, 'There should have been a document list returned');
$this->assertFalse($docs->hasItems(), 'There should have been no documents in the list'); $this->assertFalse($docs->hasItems(), 'There should have been no documents in the list');
} }
#[TestDox('byContains() fails')]
public function testByContainsFails(): void public function testByContainsFails(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);
Find::byContains('', [], TestDocument::class); Find::byContains('', [], TestDocument::class);
} }
#[TestDox('By JSON Path fails')] #[TestDox('byJsonPath() fails')]
public function testByJsonPathFails(): void public function testByJsonPathFails(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);
Find::byJsonPath('', '', TestDocument::class); Find::byJsonPath('', '', TestDocument::class);
} }
#[TestDox('firstByFields() succeeds when a document is found')]
public function testFirstByFieldsSucceedsWhenADocumentIsFound(): void public function testFirstByFieldsSucceedsWhenADocumentIsFound(): void
{ {
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('value', 'another')], TestDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'another')], TestDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertEquals('two', $doc->get()->id, 'The incorrect document was returned'); $this->assertEquals('two', $doc->get()->id, 'The incorrect document was returned');
} }
#[TestDox('firstByFields() succeeds when multiple documents are found')]
public function testFirstByFieldsSucceedsWhenMultipleDocumentsAreFound(): void public function testFirstByFieldsSucceedsWhenMultipleDocumentsAreFound(): void
{ {
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('sub.foo', 'green')], TestDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('sub.foo', 'green')], TestDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertContains($doc->get()->id, ['two', 'four'], 'An incorrect document was returned'); $this->assertContains($doc->get()->id, ['two', 'four'], 'An incorrect document was returned');
} }
#[TestDox('firstByFields() succeeds when multiple ordered documents are found')]
public function testFirstByFieldsSucceedsWhenMultipleOrderedDocumentsAreFound(): void
{
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('sub.foo', 'green')], TestDocument::class,
orderBy: [Field::named('n:num_value DESC')]);
$this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertEquals('four', $doc->get()->id, 'The incorrect document was returned');
}
#[TestDox('firstByFields() succeeds when a document is not found')]
public function testFirstByFieldsSucceedsWhenADocumentIsNotFound(): void public function testFirstByFieldsSucceedsWhenADocumentIsNotFound(): void
{ {
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('value', 'absent')], TestDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('value', 'absent')], TestDocument::class);
$this->assertTrue($doc->isNone(), 'There should not have been a document returned'); $this->assertTrue($doc->isNone(), 'There should not have been a document returned');
} }
#[TestDox('firstByContains() fails')]
public function testFirstByContainsFails(): void public function testFirstByContainsFails(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);
Find::firstByContains('', [], TestDocument::class); Find::firstByContains('', [], TestDocument::class);
} }
#[TestDox('First by JSON Path fails')] #[TestDox('firstByJsonPath() fails')]
public function testFirstByJsonPathFails(): void public function testFirstByJsonPathFails(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);

15
tests/integration/sqlite/PatchTest.php
View File

@ -34,7 +34,7 @@ class PatchTest extends TestCase
parent::tearDown(); parent::tearDown();
} }
#[TestDox('By ID succeeds when a document is updated')] #[TestDox('byId() succeeds when a document is updated')]
public function testByIdSucceedsWhenADocumentIsUpdated(): void public function testByIdSucceedsWhenADocumentIsUpdated(): void
{ {
Patch::byId(ThrowawayDb::TABLE, 'one', ['num_value' => 44]); Patch::byId(ThrowawayDb::TABLE, 'one', ['num_value' => 44]);
@ -43,33 +43,36 @@ class PatchTest extends TestCase
$this->assertEquals(44, $doc->get()->num_value, 'The updated document is not correct'); $this->assertEquals(44, $doc->get()->num_value, 'The updated document is not correct');
} }
#[TestDox('By ID succeeds when no document is updated')] #[TestDox('byId() succeeds when no document is updated')]
public function testByIdSucceedsWhenNoDocumentIsUpdated(): void public function testByIdSucceedsWhenNoDocumentIsUpdated(): void
{ {
Patch::byId(ThrowawayDb::TABLE, 'forty-seven', ['foo' => 'green']); Patch::byId(ThrowawayDb::TABLE, 'forty-seven', ['foo' => 'green']);
$this->assertTrue(true, 'The above not throwing an exception is the test'); $this->assertTrue(true, 'The above not throwing an exception is the test');
} }
#[TestDox('byFields() succeeds when a document is updated')]
public function testByFieldsSucceedsWhenADocumentIsUpdated(): void public function testByFieldsSucceedsWhenADocumentIsUpdated(): void
{ {
Patch::byFields(ThrowawayDb::TABLE, [Field::EQ('value', 'purple')], ['num_value' => 77]); Patch::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'purple')], ['num_value' => 77]);
$after = Count::byFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 77)]); $after = Count::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 77)]);
$this->assertEquals(2, $after, 'There should have been 2 documents updated'); $this->assertEquals(2, $after, 'There should have been 2 documents updated');
} }
#[TestDox('byFields() succeeds when no document is updated')]
public function testByFieldsSucceedsWhenNoDocumentIsUpdated(): void public function testByFieldsSucceedsWhenNoDocumentIsUpdated(): void
{ {
Patch::byFields(ThrowawayDb::TABLE, [Field::EQ('value', 'burgundy')], ['foo' => 'green']); Patch::byFields(ThrowawayDb::TABLE, [Field::equal('value', 'burgundy')], ['foo' => 'green']);
$this->assertTrue(true, 'The above not throwing an exception is the test'); $this->assertTrue(true, 'The above not throwing an exception is the test');
} }
#[TestDox('byContains() fails')]
public function testByContainsFails(): void public function testByContainsFails(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);
Patch::byContains('', [], []); Patch::byContains('', [], []);
} }
#[TestDox('By JSON Path fails')] #[TestDox('byJsonPath() fails')]
public function testByJsonPathFails(): void public function testByJsonPathFails(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);

20
tests/integration/sqlite/RemoveFieldsTest.php
View File

@ -34,7 +34,7 @@ class RemoveFieldsTest extends TestCase
parent::tearDown(); parent::tearDown();
} }
#[TestDox('By ID succeeds when fields are removed')] #[TestDox('byId() succeeds when fields are removed')]
public function testByIdSucceedsWhenFieldsAreRemoved(): void public function testByIdSucceedsWhenFieldsAreRemoved(): void
{ {
RemoveFields::byId(ThrowawayDb::TABLE, 'two', ['sub', 'value']); RemoveFields::byId(ThrowawayDb::TABLE, 'two', ['sub', 'value']);
@ -45,47 +45,51 @@ class RemoveFieldsTest extends TestCase
$this->assertNull($doc->sub, 'Sub-document should have been null'); $this->assertNull($doc->sub, 'Sub-document should have been null');
} }
#[TestDox('By ID succeeds when a field is not removed')] #[TestDox('byId() succeeds when a field is not removed')]
public function testByIdSucceedsWhenAFieldIsNotRemoved(): void public function testByIdSucceedsWhenAFieldIsNotRemoved(): void
{ {
RemoveFields::byId(ThrowawayDb::TABLE, 'one', ['a_field_that_does_not_exist']); RemoveFields::byId(ThrowawayDb::TABLE, 'one', ['a_field_that_does_not_exist']);
$this->assertTrue(true, 'The above not throwing an exception is the test'); $this->assertTrue(true, 'The above not throwing an exception is the test');
} }
#[TestDox('By ID succeeds when no document is matched')] #[TestDox('byId() succeeds when no document is matched')]
public function testByIdSucceedsWhenNoDocumentIsMatched(): void public function testByIdSucceedsWhenNoDocumentIsMatched(): void
{ {
RemoveFields::byId(ThrowawayDb::TABLE, 'fifty', ['sub']); RemoveFields::byId(ThrowawayDb::TABLE, 'fifty', ['sub']);
$this->assertTrue(true, 'The above not throwing an exception is the test'); $this->assertTrue(true, 'The above not throwing an exception is the test');
} }
#[TestDox('byFields() succeeds when a field is removed')]
public function testByFieldsSucceedsWhenAFieldIsRemoved(): void public function testByFieldsSucceedsWhenAFieldIsRemoved(): void
{ {
RemoveFields::byFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 17)], ['sub']); RemoveFields::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 17)], ['sub']);
$doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 17)], TestDocument::class); $doc = Find::firstByFields(ThrowawayDb::TABLE, [Field::equal('num_value', 17)], TestDocument::class);
$this->assertTrue($doc->isSome(), 'There should have been a document returned'); $this->assertTrue($doc->isSome(), 'There should have been a document returned');
$this->assertNull($doc->get()->sub, 'Sub-document should have been null'); $this->assertNull($doc->get()->sub, 'Sub-document should have been null');
} }
#[TestDox('byFields() succeeds when a field is not removed')]
public function testByFieldsSucceedsWhenAFieldIsNotRemoved(): void public function testByFieldsSucceedsWhenAFieldIsNotRemoved(): void
{ {
RemoveFields::byFields(ThrowawayDb::TABLE, [Field::EQ('num_value', 17)], ['nada']); RemoveFields::byFields(ThrowawayDb::TABLE, [Field::equal('num_value', 17)], ['nada']);
$this->assertTrue(true, 'The above not throwing an exception is the test'); $this->assertTrue(true, 'The above not throwing an exception is the test');
} }
#[TestDox('byFields() succeeds when no document is matched')]
public function testByFieldsSucceedsWhenNoDocumentIsMatched(): void public function testByFieldsSucceedsWhenNoDocumentIsMatched(): void
{ {
RemoveFields::byFields(ThrowawayDb::TABLE, [Field::NE('missing', 'nope')], ['value']); RemoveFields::byFields(ThrowawayDb::TABLE, [Field::notEqual('missing', 'nope')], ['value']);
$this->assertTrue(true, 'The above not throwing an exception is the test'); $this->assertTrue(true, 'The above not throwing an exception is the test');
} }
#[TestDox('byContains() fails')]
public function testByContainsFails(): void public function testByContainsFails(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);
RemoveFields::byContains('', [], []); RemoveFields::byContains('', [], []);
} }
#[TestDox('By JSON Path fails')] #[TestDox('byJsonPath() fails')]
public function testByJsonPathFails(): void public function testByJsonPathFails(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);

12
tests/unit/ConfigurationTest.php
View File

@ -18,14 +18,14 @@ use PHPUnit\Framework\TestCase;
#[TestDox('Configuration (Unit tests)')] #[TestDox('Configuration (Unit tests)')]
class ConfigurationTest extends TestCase class ConfigurationTest extends TestCase
{ {
#[TestDox('ID field default succeeds')] #[TestDox('id default succeeds')]
public function testIdFieldDefaultSucceeds(): void public function testIdFieldDefaultSucceeds(): void
{ {
$this->assertEquals('id', Configuration::$idField, 'Default ID field should be "id"'); $this->assertEquals('id', Configuration::$idField, 'Default ID field should be "id"');
} }
#[TestDox('ID field change succeeds')] #[TestDox('id change succeeds')]
public function testIdFieldChangeSucceeds() public function testIdFieldChangeSucceeds(): void
{ {
try { try {
Configuration::$idField = 'EyeDee'; Configuration::$idField = 'EyeDee';
@ -36,19 +36,19 @@ class ConfigurationTest extends TestCase
} }
} }
#[TestDox('Auto ID default succeeds')] #[TestDox('autoId default succeeds')]
public function testAutoIdDefaultSucceeds(): void public function testAutoIdDefaultSucceeds(): void
{ {
$this->assertEquals(AutoId::None, Configuration::$autoId, 'Auto ID should default to None'); $this->assertEquals(AutoId::None, Configuration::$autoId, 'Auto ID should default to None');
} }
#[TestDox('ID string length default succeeds')] #[TestDox('idStringLength default succeeds')]
public function testIdStringLengthDefaultSucceeds(): void public function testIdStringLengthDefaultSucceeds(): void
{ {
$this->assertEquals(16, Configuration::$idStringLength, 'ID string length should default to 16'); $this->assertEquals(16, Configuration::$idStringLength, 'ID string length should default to 16');
} }
#[TestDox("Db conn fails when no DSN specified")] #[TestDox("dbConn() fails when no DSN specified")]
public function testDbConnFailsWhenNoDSNSpecified(): void public function testDbConnFailsWhenNoDSNSpecified(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);

2
tests/unit/DocumentExceptionTest.php
View File

@ -38,6 +38,7 @@ class DocumentExceptionTest extends TestCase
$this->assertNull($ex->getPrevious(), 'Prior exception should have been null'); $this->assertNull($ex->getPrevious(), 'Prior exception should have been null');
} }
#[TestDox('toString() succeeds without code')]
public function testToStringSucceedsWithoutCode(): void public function testToStringSucceedsWithoutCode(): void
{ {
$ex = new DocumentException('Test failure'); $ex = new DocumentException('Test failure');
@ -45,6 +46,7 @@ class DocumentExceptionTest extends TestCase
'toString not generated correctly'); 'toString not generated correctly');
} }
#[TestDox('toString() succeeds with code')]
public function testToStringSucceedsWithCode(): void public function testToStringSucceedsWithCode(): void
{ {
$ex = new DocumentException('Oof', -6); $ex = new DocumentException('Oof', -6);

4
tests/unit/FieldMatchTest.php
View File

@ -18,13 +18,13 @@ use PHPUnit\Framework\TestCase;
#[TestDox('Field Match (Unit tests)')] #[TestDox('Field Match (Unit tests)')]
class FieldMatchTest extends TestCase class FieldMatchTest extends TestCase
{ {
#[TestDox('To SQL succeeds for all')] #[TestDox('toSQL() succeeds for All')]
public function testToSQLSucceedsForAll(): void public function testToSQLSucceedsForAll(): void
{ {
$this->assertEquals('AND', FieldMatch::All->toSQL(), 'All should have returned AND'); $this->assertEquals('AND', FieldMatch::All->toSQL(), 'All should have returned AND');
} }
#[TestDox('To SQL succeeds for any')] #[TestDox('toSQL() succeeds for Any')]
public function testToSQLSucceedsForAny(): void public function testToSQLSucceedsForAny(): void
{ {
$this->assertEquals('OR', FieldMatch::Any->toSQL(), 'Any should have returned OR'); $this->assertEquals('OR', FieldMatch::Any->toSQL(), 'Any should have returned OR');

524
tests/unit/FieldTest.php
View File

@ -18,121 +18,256 @@ use PHPUnit\Framework\TestCase;
#[TestDox('Field (Unit tests)')] #[TestDox('Field (Unit tests)')]
class FieldTest extends TestCase class FieldTest extends TestCase
{ {
#[TestDox('Append parameter succeeds for EX')] #[TestDox('appendParameter() succeeds for exists')]
public function testAppendParameterSucceedsForEX(): void public function testAppendParameterSucceedsForExists(): void
{ {
$this->assertEquals([], Field::EX('exists')->appendParameter([]), 'EX should not have appended a parameter'); $this->assertEquals([], Field::exists('exists')->appendParameter([]),
'exists should not have appended a parameter');
} }
#[TestDox('Append parameter succeeds for NEX')] #[TestDox('appendParameter() succeeds for notExists')]
public function testAppendParameterSucceedsForNEX(): void public function testAppendParameterSucceedsForNotExists(): void
{ {
$this->assertEquals([], Field::NEX('absent')->appendParameter([]), 'NEX should not have appended a parameter'); $this->assertEquals([], Field::notExists('absent')->appendParameter([]),
'notExists should not have appended a parameter');
} }
#[TestDox('Append parameter succeeds for BT')] #[TestDox('appendParameter() succeeds for between')]
public function testAppendParameterSucceedsForBT(): void public function testAppendParameterSucceedsForBetween(): void
{ {
$this->assertEquals(['@nummin' => 5, '@nummax' => 9], Field::BT('exists', 5, 9, '@num')->appendParameter([]), $this->assertEquals(['@nummin' => 5, '@nummax' => 9],
'BT should have appended min and max parameters'); Field::between('exists', 5, 9, '@num')->appendParameter([]),
'Between should have appended min and max parameters');
} }
#[TestDox('appendParameter() succeeds for in')]
public function testAppendParameterSucceedsForIn(): void
{
$this->assertEquals([':val_0' => 'test', ':val_1' => 'unit', ':val_2' => 'great'],
Field::in('it', ['test', 'unit', 'great'], ':val')->appendParameter([]),
'In should have appended 3 parameters for the input values');
}
#[TestDox('appendParameter() succeeds for inArray for PostgreSQL')]
public function testAppendParameterSucceedsForInArrayForPostgreSQL(): void
{
Configuration::overrideMode(Mode::PgSQL);
try {
$this->assertEquals([':bit_0' => '2', ':bit_1' => '8', ':bit_2' => '64'],
Field::inArray('it', 'table', [2, 8, 64], ':bit')->appendParameter([]),
'InArray should have appended 3 string parameters for the input values');
} finally {
Configuration::overrideMode(null);
}
}
#[TestDox('appendParameter() succeeds for inArray for SQLite')]
public function testAppendParameterSucceedsForInArrayForSQLite(): void
{
Configuration::overrideMode(Mode::SQLite);
try {
$this->assertEquals([':bit_0' => 2, ':bit_1' => 8, ':bit_2' => 64],
Field::inArray('it', 'table', [2, 8, 64], ':bit')->appendParameter([]),
'InArray should have appended 3 parameters for the input values');
} finally {
Configuration::overrideMode(null);
}
}
#[TestDox('appendParameter() succeeds for others')]
public function testAppendParameterSucceedsForOthers(): void public function testAppendParameterSucceedsForOthers(): void
{ {
$this->assertEquals(['@test' => 33], Field::EQ('the_field', 33, '@test')->appendParameter([]), $this->assertEquals(['@test' => 33], Field::equal('the_field', 33, '@test')->appendParameter([]),
'Field parameter not returned correctly'); 'Field parameter not returned correctly');
} }
#[TestDox('To where succeeds for EX without qualifier for PostgreSQL')] #[TestDox('path() succeeds for simple SQL path for PostgreSQL')]
public function testToWhereSucceedsForEXWithoutQualifierForPostgreSQL(): void public function testPathSucceedsForSimpleSqlPathForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
try { try {
$this->assertEquals("data->>'that_field' IS NOT NULL", Field::EX('that_field')->toWhere(), $this->assertEquals("data->>'it'", Field::equal('it', 'that')->path(),
'WHERE fragment not generated correctly'); 'SQL value path not generated correctly');
} finally { } finally {
Configuration::overrideMode(null); Configuration::overrideMode(null);
} }
} }
#[TestDox('To where succeeds for EX without qualifier for SQLite')] #[TestDox('path() succeeds for simple SQL path for SQLite')]
public function testToWhereSucceedsForEXWithoutQualifierForSQLite(): void public function testPathSucceedsForSimpleSqlPathForSQLite(): void
{ {
Configuration::overrideMode(Mode::SQLite); Configuration::overrideMode(Mode::SQLite);
try { try {
$this->assertEquals("data->>'that_field' IS NOT NULL", Field::EX('that_field')->toWhere(), $this->assertEquals("data->>'top'", Field::equal('top', 'that')->path(),
'WHERE fragment not generated correctly'); 'SQL value path not generated correctly');
} finally { } finally {
Configuration::overrideMode(null); Configuration::overrideMode(null);
} }
} }
#[TestDox('To where succeeds for NEX without qualifier for PostgreSQL')] #[TestDox('path() succeeds for nested SQL path for PostgreSQL')]
public function testToWhereSucceedsForNEXWithoutQualifierForPostgreSQL(): void public function testPathSucceedsForNestedSqlPathForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
try { try {
$this->assertEquals("data->>'a_field' IS NULL", Field::NEX('a_field')->toWhere(), $this->assertEquals("data#>>'{parts,to,the,path}'", Field::equal('parts.to.the.path', '')->path(),
'WHERE fragment not generated correctly'); 'SQL value path not generated correctly');
} finally { } finally {
Configuration::overrideMode(null); Configuration::overrideMode(null);
} }
} }
#[TestDox('To where succeeds for NEX without qualifier for SQLite')] #[TestDox('path() succeeds for nested SQL path for SQLite')]
public function testToWhereSucceedsForNEXWithoutQualifierForSQLite(): void public function testPathSucceedsForNestedSqlPathForSQLite(): void
{ {
Configuration::overrideMode(Mode::SQLite); Configuration::overrideMode(Mode::SQLite);
try { try {
$this->assertEquals("data->>'a_field' IS NULL", Field::NEX('a_field')->toWhere(), $this->assertEquals("data->'one'->'two'->>'three'", Field::equal('one.two.three', '')->path(),
'WHERE fragment not generated correctly'); 'SQL value path not generated correctly');
} finally { } finally {
Configuration::overrideMode(null); Configuration::overrideMode(null);
} }
} }
#[TestDox('To where succeeds for BT without qualifier for SQLite')] #[TestDox('path() succeeds for simple JSON path for PostgreSQL')]
public function testToWhereSucceedsForBTWithoutQualifierForSQLite(): void public function testPathSucceedsForSimpleJsonPathForPostgreSQL(): void
{
Configuration::overrideMode(Mode::PgSQL);
try {
$this->assertEquals("data->'it'", Field::equal('it', 'that')->path(true),
'JSON value path not generated correctly');
} finally {
Configuration::overrideMode(null);
}
}
#[TestDox('path() succeeds for simple JSON path for SQLite')]
public function testPathSucceedsForSimpleJsonPathForSQLite(): void
{ {
Configuration::overrideMode(Mode::SQLite); Configuration::overrideMode(Mode::SQLite);
try { try {
$this->assertEquals("data->>'age' BETWEEN @agemin AND @agemax", Field::BT('age', 13, 17, '@age')->toWhere(), $this->assertEquals("data->'top'", Field::equal('top', 'that')->path(true),
'JSON value path not generated correctly');
} finally {
Configuration::overrideMode(null);
}
}
#[TestDox('path() succeeds for nested JSON path for PostgreSQL')]
public function testPathSucceedsForNestedJsonPathForPostgreSQL(): void
{
Configuration::overrideMode(Mode::PgSQL);
try {
$this->assertEquals("data#>'{parts,to,the,path}'", Field::equal('parts.to.the.path', '')->path(true),
'JSON value path not generated correctly');
} finally {
Configuration::overrideMode(null);
}
}
#[TestDox('path() succeeds for nested JSON path for SQLite')]
public function testPathSucceedsForNestedJsonPathForSQLite(): void
{
Configuration::overrideMode(Mode::SQLite);
try {
$this->assertEquals("data->'one'->'two'->'three'", Field::equal('one.two.three', '')->path(true),
'SQL value path not generated correctly');
} finally {
Configuration::overrideMode(null);
}
}
#[TestDox('toWhere() succeeds for exists without qualifier for PostgreSQL')]
public function testToWhereSucceedsForExistsWithoutQualifierForPostgreSQL(): void
{
Configuration::overrideMode(Mode::PgSQL);
try {
$this->assertEquals("data->>'that_field' IS NOT NULL", Field::exists('that_field')->toWhere(),
'WHERE fragment not generated correctly'); 'WHERE fragment not generated correctly');
} finally { } finally {
Configuration::overrideMode(null); Configuration::overrideMode(null);
} }
} }
#[TestDox('To where succeeds for BT without qualifier for PostgreSQL with numeric range')] #[TestDox('toWhere() succeeds for exists without qualifier for SQLite')]
public function testToWhereSucceedsForBTWithoutQualifierForPostgreSQLWithNumericRange(): void public function testToWhereSucceedsForExistsWithoutQualifierForSQLite(): void
{
Configuration::overrideMode(Mode::SQLite);
try {
$this->assertEquals("data->>'that_field' IS NOT NULL", Field::exists('that_field')->toWhere(),
'WHERE fragment not generated correctly');
} finally {
Configuration::overrideMode(null);
}
}
#[TestDox('toWhere() succeeds for notExists without qualifier for PostgreSQL')]
public function testToWhereSucceedsForNotExistsWithoutQualifierForPostgreSQL(): void
{
Configuration::overrideMode(Mode::PgSQL);
try {
$this->assertEquals("data->>'a_field' IS NULL", Field::notExists('a_field')->toWhere(),
'WHERE fragment not generated correctly');
} finally {
Configuration::overrideMode(null);
}
}
#[TestDox('toWhere() succeeds for notExists without qualifier for SQLite')]
public function testToWhereSucceedsForNotExistsWithoutQualifierForSQLite(): void
{
Configuration::overrideMode(Mode::SQLite);
try {
$this->assertEquals("data->>'a_field' IS NULL", Field::notExists('a_field')->toWhere(),
'WHERE fragment not generated correctly');
} finally {
Configuration::overrideMode(null);
}
}
#[TestDox('toWhere() succeeds for between without qualifier for SQLite')]
public function testToWhereSucceedsForBetweenWithoutQualifierForSQLite(): void
{
Configuration::overrideMode(Mode::SQLite);
try {
$this->assertEquals("data->>'age' BETWEEN @agemin AND @agemax",
Field::between('age', 13, 17, '@age')->toWhere(), 'WHERE fragment not generated correctly');
} finally {
Configuration::overrideMode(null);
}
}
#[TestDox('toWhere() succeeds for between without qualifier for PostgreSQL with numeric range')]
public function testToWhereSucceedsForBetweenWithoutQualifierForPostgreSQLWithNumericRange(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
try { try {
$this->assertEquals("(data->>'age')::numeric BETWEEN @agemin AND @agemax", $this->assertEquals("(data->>'age')::numeric BETWEEN @agemin AND @agemax",
Field::BT('age', 13, 17, '@age')->toWhere(), 'WHERE fragment not generated correctly'); Field::between('age', 13, 17, '@age')->toWhere(), 'WHERE fragment not generated correctly');
} finally { } finally {
Configuration::overrideMode(null); Configuration::overrideMode(null);
} }
} }
#[TestDox('To where succeeds for BT without qualifier for PostgreSQL with non-numeric range')] #[TestDox('toWhere() succeeds for between without qualifier for PostgreSQL with non-numeric range')]
public function testToWhereSucceedsForBTWithoutQualifierForPostgreSQLWithNonNumericRange(): void public function testToWhereSucceedsForBetweenWithoutQualifierForPostgreSQLWithNonNumericRange(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
try { try {
$this->assertEquals("data->>'city' BETWEEN :citymin AND :citymax", $this->assertEquals("data->>'city' BETWEEN :citymin AND :citymax",
Field::BT('city', 'Atlanta', 'Chicago', ':city')->toWhere(), 'WHERE fragment not generated correctly'); Field::between('city', 'Atlanta', 'Chicago', ':city')->toWhere(),
'WHERE fragment not generated correctly');
} finally { } finally {
Configuration::overrideMode(null); Configuration::overrideMode(null);
} }
} }
#[TestDox('To where succeeds for BT with qualifier for SQLite')] #[TestDox('toWhere() succeeds for between with qualifier for SQLite')]
public function testToWhereSucceedsForBTWithQualifierForSQLite(): void public function testToWhereSucceedsForBetweenWithQualifierForSQLite(): void
{ {
Configuration::overrideMode(Mode::SQLite); Configuration::overrideMode(Mode::SQLite);
try { try {
$field = Field::BT('age', 13, 17, '@age'); $field = Field::between('age', 13, 17, '@age');
$field->qualifier = 'me'; $field->qualifier = 'me';
$this->assertEquals("me.data->>'age' BETWEEN @agemin AND @agemax", $field->toWhere(), $this->assertEquals("me.data->>'age' BETWEEN @agemin AND @agemax", $field->toWhere(),
'WHERE fragment not generated correctly'); 'WHERE fragment not generated correctly');
@ -141,12 +276,12 @@ class FieldTest extends TestCase
} }
} }
#[TestDox('To where succeeds for BT with qualifier for PostgreSQL with numeric range')] #[TestDox('toWhere() succeeds for between with qualifier for PostgreSQL with numeric range')]
public function testToWhereSucceedsForBTWithQualifierForPostgreSQLWithNumericRange(): void public function testToWhereSucceedsForBetweenWithQualifierForPostgreSQLWithNumericRange(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
try { try {
$field = Field::BT('age', 13, 17, '@age'); $field = Field::between('age', 13, 17, '@age');
$field->qualifier = 'me'; $field->qualifier = 'me';
$this->assertEquals("(me.data->>'age')::numeric BETWEEN @agemin AND @agemax", $field->toWhere(), $this->assertEquals("(me.data->>'age')::numeric BETWEEN @agemin AND @agemax", $field->toWhere(),
'WHERE fragment not generated correctly'); 'WHERE fragment not generated correctly');
@ -155,12 +290,12 @@ class FieldTest extends TestCase
} }
} }
#[TestDox('To where succeeds for BT with qualifier for PostgreSQL with non-numeric range')] #[TestDox('toWhere() succeeds for between with qualifier for PostgreSQL with non-numeric range')]
public function testToWhereSucceedsForBTWithQualifierForPostgreSQLWithNonNumericRange(): void public function testToWhereSucceedsForBetweenWithQualifierForPostgreSQLWithNonNumericRange(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
try { try {
$field = Field::BT('city', 'Atlanta', 'Chicago', ':city'); $field = Field::between('city', 'Atlanta', 'Chicago', ':city');
$field->qualifier = 'me'; $field->qualifier = 'me';
$this->assertEquals("me.data->>'city' BETWEEN :citymin AND :citymax", $field->toWhere(), $this->assertEquals("me.data->>'city' BETWEEN :citymin AND :citymax", $field->toWhere(),
'WHERE fragment not generated correctly'); 'WHERE fragment not generated correctly');
@ -169,36 +304,102 @@ class FieldTest extends TestCase
} }
} }
#[TestDox('To where succeeds for others without qualifier for PostgreSQL')] #[TestDox('toWhere() succeeds for in for PostgreSQL with non-numeric values')]
public function testToWhereSucceedsForInForPostgreSQLWithNonNumericValues(): void
{
Configuration::overrideMode(Mode::PgSQL);
try {
$field = Field::in('test', ['Atlanta', 'Chicago'], ':city');
$this->assertEquals("data->>'test' IN (:city_0, :city_1)", $field->toWhere(),
'WHERE fragment not generated correctly');
} finally {
Configuration::overrideMode(null);
}
}
#[TestDox('toWhere() succeeds for in for PostgreSQL with numeric values')]
public function testToWhereSucceedsForInForPostgreSQLWithNumericValues(): void
{
Configuration::overrideMode(Mode::PgSQL);
try {
$field = Field::in('even', [2, 4, 6], ':nbr');
$this->assertEquals("(data->>'even')::numeric IN (:nbr_0, :nbr_1, :nbr_2)", $field->toWhere(),
'WHERE fragment not generated correctly');
} finally {
Configuration::overrideMode(null);
}
}
#[TestDox('toWhere() succeeds for in for SQLite')]
public function testToWhereSucceedsForInForSQLite(): void
{
Configuration::overrideMode(Mode::SQLite);
try {
$field = Field::in('test', ['Atlanta', 'Chicago'], ':city');
$this->assertEquals("data->>'test' IN (:city_0, :city_1)", $field->toWhere(),
'WHERE fragment not generated correctly');
} finally {
Configuration::overrideMode(null);
}
}
#[TestDox('toWhere() succeeds for inArray for PostgreSQL')]
public function testToWhereSucceedsForInArrayForPostgreSQL(): void
{
Configuration::overrideMode(Mode::PgSQL);
try {
$field = Field::inArray('even', 'tbl', [2, 4, 6, 8], ':it');
$this->assertEquals("data->'even' ??| ARRAY[:it_0, :it_1, :it_2, :it_3]", $field->toWhere(),
'WHERE fragment not generated correctly');
} finally {
Configuration::overrideMode(null);
}
}
#[TestDox('toWhere() succeeds for inArray for SQLite')]
public function testToWhereSucceedsForInArrayForSQLite(): void
{
Configuration::overrideMode(Mode::SQLite);
try {
$field = Field::inArray('test', 'tbl', ['Atlanta', 'Chicago'], ':city');
$this->assertEquals(
"EXISTS (SELECT 1 FROM json_each(tbl.data, '\$.test') WHERE value IN (:city_0, :city_1))",
$field->toWhere(), 'WHERE fragment not generated correctly');
} finally {
Configuration::overrideMode(null);
}
}
#[TestDox('toWhere() succeeds for others without qualifier for PostgreSQL')]
public function testToWhereSucceedsForOthersWithoutQualifierForPostgreSQL(): void public function testToWhereSucceedsForOthersWithoutQualifierForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
try { try {
$this->assertEquals("data->>'some_field' = @value", Field::EQ('some_field', '', '@value')->toWhere(), $this->assertEquals("data->>'some_field' = @value", Field::equal('some_field', '', '@value')->toWhere(),
'WHERE fragment not generated correctly'); 'WHERE fragment not generated correctly');
} finally { } finally {
Configuration::overrideMode(null); Configuration::overrideMode(null);
} }
} }
#[TestDox('To where succeeds for others without qualifier for SQLite')] #[TestDox('toWhere() succeeds for others without qualifier for SQLite')]
public function testToWhereSucceedsForOthersWithoutQualifierForSQLite(): void public function testToWhereSucceedsForOthersWithoutQualifierForSQLite(): void
{ {
Configuration::overrideMode(Mode::SQLite); Configuration::overrideMode(Mode::SQLite);
try { try {
$this->assertEquals("data->>'some_field' = @value", Field::EQ('some_field', '', '@value')->toWhere(), $this->assertEquals("data->>'some_field' = @value", Field::equal('some_field', '', '@value')->toWhere(),
'WHERE fragment not generated correctly'); 'WHERE fragment not generated correctly');
} finally { } finally {
Configuration::overrideMode(null); Configuration::overrideMode(null);
} }
} }
#[TestDox('To where succeeds with qualifier no parameter for PostgreSQL')] #[TestDox('toWhere() succeeds with qualifier no parameter for PostgreSQL')]
public function testToWhereSucceedsWithQualifierNoParameterForPostgreSQL(): void public function testToWhereSucceedsWithQualifierNoParameterForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
try { try {
$field = Field::EX('no_field'); $field = Field::exists('no_field');
$field->qualifier = 'test'; $field->qualifier = 'test';
$this->assertEquals("test.data->>'no_field' IS NOT NULL", $field->toWhere(), $this->assertEquals("test.data->>'no_field' IS NOT NULL", $field->toWhere(),
'WHERE fragment not generated correctly'); 'WHERE fragment not generated correctly');
@ -207,12 +408,12 @@ class FieldTest extends TestCase
} }
} }
#[TestDox('To where succeeds with qualifier no parameter for SQLite')] #[TestDox('toWhere() succeeds with qualifier no parameter for SQLite')]
public function testToWhereSucceedsWithQualifierNoParameterForSQLite(): void public function testToWhereSucceedsWithQualifierNoParameterForSQLite(): void
{ {
Configuration::overrideMode(Mode::SQLite); Configuration::overrideMode(Mode::SQLite);
try { try {
$field = Field::EX('no_field'); $field = Field::exists('no_field');
$field->qualifier = 'test'; $field->qualifier = 'test';
$this->assertEquals("test.data->>'no_field' IS NOT NULL", $field->toWhere(), $this->assertEquals("test.data->>'no_field' IS NOT NULL", $field->toWhere(),
'WHERE fragment not generated correctly'); 'WHERE fragment not generated correctly');
@ -221,12 +422,12 @@ class FieldTest extends TestCase
} }
} }
#[TestDox('To where succeeds with qualifier and parameter for PostgreSQL')] #[TestDox('toWhere() succeeds with qualifier and parameter for PostgreSQL')]
public function testToWhereSucceedsWithQualifierAndParameterForPostgreSQL(): void public function testToWhereSucceedsWithQualifierAndParameterForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
try { try {
$field = Field::LE('le_field', 18, '@it'); $field = Field::lessOrEqual('le_field', 18, '@it');
$field->qualifier = 'q'; $field->qualifier = 'q';
$this->assertEquals("(q.data->>'le_field')::numeric <= @it", $field->toWhere(), $this->assertEquals("(q.data->>'le_field')::numeric <= @it", $field->toWhere(),
'WHERE fragment not generated correctly'); 'WHERE fragment not generated correctly');
@ -235,12 +436,12 @@ class FieldTest extends TestCase
} }
} }
#[TestDox('To where succeeds with qualifier and parameter for SQLite')] #[TestDox('toWhere() succeeds with qualifier and parameter for SQLite')]
public function testToWhereSucceedsWithQualifierAndParameterForSQLite(): void public function testToWhereSucceedsWithQualifierAndParameterForSQLite(): void
{ {
Configuration::overrideMode(Mode::SQLite); Configuration::overrideMode(Mode::SQLite);
try { try {
$field = Field::LE('le_field', 18, '@it'); $field = Field::lessOrEqual('le_field', 18, '@it');
$field->qualifier = 'q'; $field->qualifier = 'q';
$this->assertEquals("q.data->>'le_field' <= @it", $field->toWhere(), $this->assertEquals("q.data->>'le_field' <= @it", $field->toWhere(),
'WHERE fragment not generated correctly'); 'WHERE fragment not generated correctly');
@ -249,204 +450,233 @@ class FieldTest extends TestCase
} }
} }
#[TestDox('To where succeeds with sub-document for PostgreSQL')] #[TestDox('equal() succeeds without parameter')]
public function testToWhereSucceedsWithSubDocumentForPostgreSQL(): void public function testEqualSucceedsWithoutParameter(): void
{ {
Configuration::overrideMode(Mode::PgSQL); $field = Field::equal('my_test', 9);
try {
$field = Field::EQ('sub.foo.bar', 22, '@it');
$this->assertEquals("(data#>>'{sub,foo,bar}')::numeric = @it", $field->toWhere(),
'WHERE fragment not generated correctly');
} finally {
Configuration::overrideMode(null);
}
}
#[TestDox('To where succeeds with sub-document for SQLite')]
public function testToWhereSucceedsWithSubDocumentForSQLite(): void
{
Configuration::overrideMode(Mode::SQLite);
try {
$field = Field::EQ('sub.foo.bar', 22, '@it');
$this->assertEquals("data->>'sub'->>'foo'->>'bar' = @it", $field->toWhere(),
'WHERE fragment not generated correctly');
} finally {
Configuration::overrideMode(null);
}
}
#[TestDox('EQ succeeds without parameter')]
public function testEQSucceedsWithoutParameter(): void
{
$field = Field::EQ('my_test', 9);
$this->assertNotNull($field, 'The field should not have been null'); $this->assertNotNull($field, 'The field should not have been null');
$this->assertEquals('my_test', $field->fieldName, 'Field name not filled correctly'); $this->assertEquals('my_test', $field->fieldName, 'Field name not filled correctly');
$this->assertEquals(Op::EQ, $field->op, 'Operation not filled correctly'); $this->assertEquals(Op::Equal, $field->op, 'Operation not filled correctly');
$this->assertEquals(9, $field->value, 'Value not filled correctly'); $this->assertEquals(9, $field->value, 'Value not filled correctly');
$this->assertEquals('', $field->paramName, 'Parameter name should have been blank'); $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
} }
#[TestDox('EQ succeeds with parameter')] #[TestDox('equal() succeeds with parameter')]
public function testEQSucceedsWithParameter(): void public function testEqualSucceedsWithParameter(): void
{ {
$field = Field::EQ('another_test', 'turkey', '@test'); $field = Field::equal('another_test', 'turkey', '@test');
$this->assertNotNull($field, 'The field should not have been null'); $this->assertNotNull($field, 'The field should not have been null');
$this->assertEquals('another_test', $field->fieldName, 'Field name not filled correctly'); $this->assertEquals('another_test', $field->fieldName, 'Field name not filled correctly');
$this->assertEquals(Op::EQ, $field->op, 'Operation not filled correctly'); $this->assertEquals(Op::Equal, $field->op, 'Operation not filled correctly');
$this->assertEquals('turkey', $field->value, 'Value not filled correctly'); $this->assertEquals('turkey', $field->value, 'Value not filled correctly');
$this->assertEquals('@test', $field->paramName, 'Parameter name not filled correctly'); $this->assertEquals('@test', $field->paramName, 'Parameter name not filled correctly');
} }
#[TestDox('GT succeeds without parameter')] #[TestDox('greater() succeeds without parameter')]
public function testGTSucceedsWithoutParameter(): void public function testGreaterSucceedsWithoutParameter(): void
{ {
$field = Field::GT('your_test', 4); $field = Field::greater('your_test', 4);
$this->assertNotNull($field, 'The field should not have been null'); $this->assertNotNull($field, 'The field should not have been null');
$this->assertEquals('your_test', $field->fieldName, 'Field name not filled correctly'); $this->assertEquals('your_test', $field->fieldName, 'Field name not filled correctly');
$this->assertEquals(Op::GT, $field->op, 'Operation not filled correctly'); $this->assertEquals(Op::Greater, $field->op, 'Operation not filled correctly');
$this->assertEquals(4, $field->value, 'Value not filled correctly'); $this->assertEquals(4, $field->value, 'Value not filled correctly');
$this->assertEquals('', $field->paramName, 'Parameter name should have been blank'); $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
} }
#[TestDox('GT succeeds with parameter')] #[TestDox('greater() succeeds with parameter')]
public function testGTSucceedsWithParameter(): void public function testGreaterSucceedsWithParameter(): void
{ {
$field = Field::GT('more_test', 'chicken', '@value'); $field = Field::greater('more_test', 'chicken', '@value');
$this->assertNotNull($field, 'The field should not have been null'); $this->assertNotNull($field, 'The field should not have been null');
$this->assertEquals('more_test', $field->fieldName, 'Field name not filled correctly'); $this->assertEquals('more_test', $field->fieldName, 'Field name not filled correctly');
$this->assertEquals(Op::GT, $field->op, 'Operation not filled correctly'); $this->assertEquals(Op::Greater, $field->op, 'Operation not filled correctly');
$this->assertEquals('chicken', $field->value, 'Value not filled correctly'); $this->assertEquals('chicken', $field->value, 'Value not filled correctly');
$this->assertEquals('@value', $field->paramName, 'Parameter name not filled correctly'); $this->assertEquals('@value', $field->paramName, 'Parameter name not filled correctly');
} }
#[TestDox('GE succeeds without parameter')] #[TestDox('greaterOrEqual() succeeds without parameter')]
public function testGESucceedsWithoutParameter(): void public function testGreaterOrEqualSucceedsWithoutParameter(): void
{ {
$field = Field::GE('their_test', 6); $field = Field::greaterOrEqual('their_test', 6);
$this->assertNotNull($field, 'The field should not have been null'); $this->assertNotNull($field, 'The field should not have been null');
$this->assertEquals('their_test', $field->fieldName, 'Field name not filled correctly'); $this->assertEquals('their_test', $field->fieldName, 'Field name not filled correctly');
$this->assertEquals(Op::GE, $field->op, 'Operation not filled correctly'); $this->assertEquals(Op::GreaterOrEqual, $field->op, 'Operation not filled correctly');
$this->assertEquals(6, $field->value, 'Value not filled correctly'); $this->assertEquals(6, $field->value, 'Value not filled correctly');
$this->assertEquals('', $field->paramName, 'Parameter name should have been blank'); $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
} }
#[TestDox('GE succeeds with parameter')] #[TestDox('greaterOrEqual() succeeds with parameter')]
public function testGESucceedsWithParameter(): void public function testGreaterOrEqualSucceedsWithParameter(): void
{ {
$field = Field::GE('greater_test', 'poultry', '@cluck'); $field = Field::greaterOrEqual('greater_test', 'poultry', '@cluck');
$this->assertNotNull($field, 'The field should not have been null'); $this->assertNotNull($field, 'The field should not have been null');
$this->assertEquals('greater_test', $field->fieldName, 'Field name not filled correctly'); $this->assertEquals('greater_test', $field->fieldName, 'Field name not filled correctly');
$this->assertEquals(Op::GE, $field->op, 'Operation not filled correctly'); $this->assertEquals(Op::GreaterOrEqual, $field->op, 'Operation not filled correctly');
$this->assertEquals('poultry', $field->value, 'Value not filled correctly'); $this->assertEquals('poultry', $field->value, 'Value not filled correctly');
$this->assertEquals('@cluck', $field->paramName, 'Parameter name not filled correctly'); $this->assertEquals('@cluck', $field->paramName, 'Parameter name not filled correctly');
} }
#[TestDox('LT succeeds without parameter')] #[TestDox('less() succeeds without parameter')]
public function testLTSucceedsWithoutParameter(): void public function testLessSucceedsWithoutParameter(): void
{ {
$field = Field::LT('z', 32); $field = Field::less('z', 32);
$this->assertNotNull($field, 'The field should not have been null'); $this->assertNotNull($field, 'The field should not have been null');
$this->assertEquals('z', $field->fieldName, 'Field name not filled correctly'); $this->assertEquals('z', $field->fieldName, 'Field name not filled correctly');
$this->assertEquals(Op::LT, $field->op, 'Operation not filled correctly'); $this->assertEquals(Op::Less, $field->op, 'Operation not filled correctly');
$this->assertEquals(32, $field->value, 'Value not filled correctly'); $this->assertEquals(32, $field->value, 'Value not filled correctly');
$this->assertEquals('', $field->paramName, 'Parameter name should have been blank'); $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
} }
#[TestDox('LT succeeds with parameter')] #[TestDox('less() succeeds with parameter')]
public function testLTSucceedsWithParameter(): void public function testLessSucceedsWithParameter(): void
{ {
$field = Field::LT('additional_test', 'fowl', '@boo'); $field = Field::less('additional_test', 'fowl', '@boo');
$this->assertNotNull($field, 'The field should not have been null'); $this->assertNotNull($field, 'The field should not have been null');
$this->assertEquals('additional_test', $field->fieldName, 'Field name not filled correctly'); $this->assertEquals('additional_test', $field->fieldName, 'Field name not filled correctly');
$this->assertEquals(Op::LT, $field->op, 'Operation not filled correctly'); $this->assertEquals(Op::Less, $field->op, 'Operation not filled correctly');
$this->assertEquals('fowl', $field->value, 'Value not filled correctly'); $this->assertEquals('fowl', $field->value, 'Value not filled correctly');
$this->assertEquals('@boo', $field->paramName, 'Parameter name not filled correctly'); $this->assertEquals('@boo', $field->paramName, 'Parameter name not filled correctly');
} }
#[TestDox('LE succeeds without parameter')] #[TestDox('lessOrEqual() succeeds without parameter')]
public function testLESucceedsWithoutParameter(): void public function testLessOrEqualSucceedsWithoutParameter(): void
{ {
$field = Field::LE('g', 87); $field = Field::lessOrEqual('g', 87);
$this->assertNotNull($field, 'The field should not have been null'); $this->assertNotNull($field, 'The field should not have been null');
$this->assertEquals('g', $field->fieldName, 'Field name not filled correctly'); $this->assertEquals('g', $field->fieldName, 'Field name not filled correctly');
$this->assertEquals(Op::LE, $field->op, 'Operation not filled correctly'); $this->assertEquals(Op::LessOrEqual, $field->op, 'Operation not filled correctly');
$this->assertEquals(87, $field->value, 'Value not filled correctly'); $this->assertEquals(87, $field->value, 'Value not filled correctly');
$this->assertEquals('', $field->paramName, 'Parameter name should have been blank'); $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
} }
#[TestDox('LE succeeds with parameter')] #[TestDox('lessOrEqual() succeeds with parameter')]
public function testLESucceedsWithParameter(): void public function testLessOrEqualSucceedsWithParameter(): void
{ {
$field = Field::LE('lesser_test', 'hen', '@woo'); $field = Field::lessOrEqual('lesser_test', 'hen', '@woo');
$this->assertNotNull($field, 'The field should not have been null'); $this->assertNotNull($field, 'The field should not have been null');
$this->assertEquals('lesser_test', $field->fieldName, 'Field name not filled correctly'); $this->assertEquals('lesser_test', $field->fieldName, 'Field name not filled correctly');
$this->assertEquals(Op::LE, $field->op, 'Operation not filled correctly'); $this->assertEquals(Op::LessOrEqual, $field->op, 'Operation not filled correctly');
$this->assertEquals('hen', $field->value, 'Value not filled correctly'); $this->assertEquals('hen', $field->value, 'Value not filled correctly');
$this->assertEquals('@woo', $field->paramName, 'Parameter name not filled correctly'); $this->assertEquals('@woo', $field->paramName, 'Parameter name not filled correctly');
} }
#[TestDox('NE succeeds without parameter')] #[TestDox('notEqual() succeeds without parameter')]
public function testNESucceedsWithoutParameter(): void public function testNotEqualSucceedsWithoutParameter(): void
{ {
$field = Field::NE('j', 65); $field = Field::notEqual('j', 65);
$this->assertNotNull($field, 'The field should not have been null'); $this->assertNotNull($field, 'The field should not have been null');
$this->assertEquals('j', $field->fieldName, 'Field name not filled correctly'); $this->assertEquals('j', $field->fieldName, 'Field name not filled correctly');
$this->assertEquals(Op::NE, $field->op, 'Operation not filled correctly'); $this->assertEquals(Op::NotEqual, $field->op, 'Operation not filled correctly');
$this->assertEquals(65, $field->value, 'Value not filled correctly'); $this->assertEquals(65, $field->value, 'Value not filled correctly');
$this->assertEquals('', $field->paramName, 'Parameter name should have been blank'); $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
} }
#[TestDox('NE succeeds with parameter')] #[TestDox('notEqual() succeeds with parameter')]
public function testNESucceedsWithParameter(): void public function testNotEqualSucceedsWithParameter(): void
{ {
$field = Field::NE('unequal_test', 'egg', '@zoo'); $field = Field::notEqual('unequal_test', 'egg', '@zoo');
$this->assertNotNull($field, 'The field should not have been null'); $this->assertNotNull($field, 'The field should not have been null');
$this->assertEquals('unequal_test', $field->fieldName, 'Field name not filled correctly'); $this->assertEquals('unequal_test', $field->fieldName, 'Field name not filled correctly');
$this->assertEquals(Op::NE, $field->op, 'Operation not filled correctly'); $this->assertEquals(Op::NotEqual, $field->op, 'Operation not filled correctly');
$this->assertEquals('egg', $field->value, 'Value not filled correctly'); $this->assertEquals('egg', $field->value, 'Value not filled correctly');
$this->assertEquals('@zoo', $field->paramName, 'Parameter name not filled correctly'); $this->assertEquals('@zoo', $field->paramName, 'Parameter name not filled correctly');
} }
#[TestDox('BT succeeds without parameter')] #[TestDox('between() succeeds without parameter')]
public function testBTSucceedsWithoutParameter(): void public function testBetweenSucceedsWithoutParameter(): void
{ {
$field = Field::BT('k', 'alpha', 'zed'); $field = Field::between('k', 'alpha', 'zed');
$this->assertNotNull($field, 'The field should not have been null'); $this->assertNotNull($field, 'The field should not have been null');
$this->assertEquals('k', $field->fieldName, 'Field name not filled correctly'); $this->assertEquals('k', $field->fieldName, 'Field name not filled correctly');
$this->assertEquals(Op::BT, $field->op, 'Operation not filled correctly'); $this->assertEquals(Op::Between, $field->op, 'Operation not filled correctly');
$this->assertEquals(['alpha', 'zed'], $field->value, 'Value not filled correctly'); $this->assertEquals(['alpha', 'zed'], $field->value, 'Value not filled correctly');
$this->assertEquals('', $field->paramName, 'Parameter name should have been blank'); $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
} }
#[TestDox('BT succeeds with parameter')] #[TestDox('between() succeeds with parameter')]
public function testBTSucceedsWithParameter(): void public function testBetweenSucceedsWithParameter(): void
{ {
$field = Field::BT('between_test', 18, 49, '@count'); $field = Field::between('between_test', 18, 49, '@count');
$this->assertNotNull($field, 'The field should not have been null'); $this->assertNotNull($field, 'The field should not have been null');
$this->assertEquals('between_test', $field->fieldName, 'Field name not filled correctly'); $this->assertEquals('between_test', $field->fieldName, 'Field name not filled correctly');
$this->assertEquals(Op::BT, $field->op, 'Operation not filled correctly'); $this->assertEquals(Op::Between, $field->op, 'Operation not filled correctly');
$this->assertEquals([18, 49], $field->value, 'Value not filled correctly'); $this->assertEquals([18, 49], $field->value, 'Value not filled correctly');
$this->assertEquals('@count', $field->paramName, 'Parameter name not filled correctly'); $this->assertEquals('@count', $field->paramName, 'Parameter name not filled correctly');
} }
#[TestDox('EX succeeds')] #[TestDox('in() succeeds without parameter')]
public function testEXSucceeds(): void public function testInSucceedsWithoutParameter(): void
{ {
$field = Field::EX('be_there'); $field = Field::in('test', [1, 2, 3]);
$this->assertNotNull($field, 'The field should not have been null');
$this->assertEquals('test', $field->fieldName, 'Field name not filled correctly');
$this->assertEquals(Op::In, $field->op, 'Operation not filled correctly');
$this->assertEquals([1, 2, 3], $field->value, 'Value not filled correctly');
$this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
}
#[TestDox('in() succeeds with parameter')]
public function testInSucceedsWithParameter(): void
{
$field = Field::in('unit', ['a', 'b'], '@inParam');
$this->assertNotNull($field, 'The field should not have been null');
$this->assertEquals('unit', $field->fieldName, 'Field name not filled correctly');
$this->assertEquals(Op::In, $field->op, 'Operation not filled correctly');
$this->assertEquals(['a', 'b'], $field->value, 'Value not filled correctly');
$this->assertEquals('@inParam', $field->paramName, 'Parameter name not filled correctly');
}
#[TestDox('inArray() succeeds without parameter')]
public function testInArraySucceedsWithoutParameter(): void
{
$field = Field::inArray('test', 'tbl', [1, 2, 3]);
$this->assertNotNull($field, 'The field should not have been null');
$this->assertEquals('test', $field->fieldName, 'Field name not filled correctly');
$this->assertEquals(Op::InArray, $field->op, 'Operation not filled correctly');
$this->assertEquals(['table' => 'tbl', 'values' => [1, 2, 3]], $field->value, 'Value not filled correctly');
$this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
}
#[TestDox('inArray() succeeds with parameter')]
public function testInArraySucceedsWithParameter(): void
{
$field = Field::inArray('unit', 'tab', ['a', 'b'], '@inAParam');
$this->assertNotNull($field, 'The field should not have been null');
$this->assertEquals('unit', $field->fieldName, 'Field name not filled correctly');
$this->assertEquals(Op::InArray, $field->op, 'Operation not filled correctly');
$this->assertEquals(['table' => 'tab', 'values' => ['a', 'b']], $field->value, 'Value not filled correctly');
$this->assertEquals('@inAParam', $field->paramName, 'Parameter name not filled correctly');
}
#[TestDox('exists() succeeds')]
public function testExistsSucceeds(): void
{
$field = Field::exists('be_there');
$this->assertNotNull($field, 'The field should not have been null'); $this->assertNotNull($field, 'The field should not have been null');
$this->assertEquals('be_there', $field->fieldName, 'Field name not filled correctly'); $this->assertEquals('be_there', $field->fieldName, 'Field name not filled correctly');
$this->assertEquals(Op::EX, $field->op, 'Operation not filled correctly'); $this->assertEquals(Op::Exists, $field->op, 'Operation not filled correctly');
$this->assertEquals('', $field->value, 'Value should have been blank'); $this->assertEquals('', $field->value, 'Value should have been blank');
$this->assertEquals('', $field->paramName, 'Parameter name should have been blank'); $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
} }
#[TestDox('NEX succeeds')] #[TestDox('notExists() succeeds')]
public function testNEXSucceeds(): void public function testNotExistsSucceeds(): void
{ {
$field = Field::NEX('be_absent'); $field = Field::notExists('be_absent');
$this->assertNotNull($field, 'The field should not have been null'); $this->assertNotNull($field, 'The field should not have been null');
$this->assertEquals('be_absent', $field->fieldName, 'Field name not filled correctly'); $this->assertEquals('be_absent', $field->fieldName, 'Field name not filled correctly');
$this->assertEquals(Op::NEX, $field->op, 'Operation not filled correctly'); $this->assertEquals(Op::NotExists, $field->op, 'Operation not filled correctly');
$this->assertEquals('', $field->value, 'Value should have been blank');
$this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
}
#[TestDox('named() succeeds')]
public function testNamedSucceeds(): void
{
$field = Field::named('the_field');
$this->assertNotNull($field, 'The field should not have been null');
$this->assertEquals('the_field', $field->fieldName, 'Field name not filled correctly');
$this->assertEquals(Op::Equal, $field->op, 'Operation not filled correctly');
$this->assertEquals('', $field->value, 'Value should have been blank'); $this->assertEquals('', $field->value, 'Value should have been blank');
$this->assertEquals('', $field->paramName, 'Parameter name should have been blank'); $this->assertEquals('', $field->paramName, 'Parameter name should have been blank');
} }

1
tests/unit/Mapper/ArrayMapperTest.php
View File

@ -18,6 +18,7 @@ use PHPUnit\Framework\TestCase;
#[TestDox('Array Mapper (Unit tests)')] #[TestDox('Array Mapper (Unit tests)')]
class ArrayMapperTest extends TestCase class ArrayMapperTest extends TestCase
{ {
#[TestDox('map() succeeds')]
public function testMapSucceeds(): void public function testMapSucceeds(): void
{ {
$result = ['one' => 2, 'three' => 4, 'eight' => 'five']; $result = ['one' => 2, 'three' => 4, 'eight' => 'five'];

1
tests/unit/Mapper/CountMapperTest.php
View File

@ -18,6 +18,7 @@ use PHPUnit\Framework\TestCase;
#[TestDox('Count Mapper (Unit tests)')] #[TestDox('Count Mapper (Unit tests)')]
class CountMapperTest extends TestCase class CountMapperTest extends TestCase
{ {
#[TestDox('map() succeeds')]
public function testMapSucceeds(): void public function testMapSucceeds(): void
{ {
$this->assertEquals(5, (new CountMapper())->map([5, 8, 10]), 'Count not correct'); $this->assertEquals(5, (new CountMapper())->map([5, 8, 10]), 'Count not correct');

8
tests/unit/Mapper/DocumentMapperTest.php
View File

@ -44,7 +44,7 @@ class DocumentMapperTest extends TestCase
$this->assertEquals('json', $mapper->fieldName, 'Field name not recorded correctly'); $this->assertEquals('json', $mapper->fieldName, 'Field name not recorded correctly');
} }
#[TestDox('Map succeeds with valid JSON')] #[TestDox('map() succeeds with valid JSON')]
public function testMapSucceedsWithValidJSON(): void public function testMapSucceedsWithValidJSON(): void
{ {
$doc = (new DocumentMapper(TestDocument::class))->map(['data' => '{"id":7,"subDoc":{"id":22,"name":"tester"}}']); $doc = (new DocumentMapper(TestDocument::class))->map(['data' => '{"id":7,"subDoc":{"id":22,"name":"tester"}}']);
@ -55,7 +55,7 @@ class DocumentMapperTest extends TestCase
$this->assertEquals('tester', $doc->subDoc->name, 'Sub-document name not filled correctly'); $this->assertEquals('tester', $doc->subDoc->name, 'Sub-document name not filled correctly');
} }
#[TestDox('Map succeeds with valid JSON for pjson class')] #[TestDox('map() succeeds with valid JSON for Pjson class')]
public function testMapSucceedsWithValidJSONForPjsonClass(): void public function testMapSucceedsWithValidJSONForPjsonClass(): void
{ {
$doc = (new DocumentMapper(PjsonDocument::class))->map(['data' => '{"id":"seven","name":"bob","num_value":8}']); $doc = (new DocumentMapper(PjsonDocument::class))->map(['data' => '{"id":"seven","name":"bob","num_value":8}']);
@ -66,14 +66,14 @@ class DocumentMapperTest extends TestCase
$this->assertFalse(isset($doc->skipped), 'Non-JSON field has not been set'); $this->assertFalse(isset($doc->skipped), 'Non-JSON field has not been set');
} }
#[TestDox('Map fails with invalid JSON')] #[TestDox('map() fails with invalid JSON')]
public function testMapFailsWithInvalidJSON(): void public function testMapFailsWithInvalidJSON(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);
(new DocumentMapper(TestDocument::class))->map(['data' => 'this is not valid']); (new DocumentMapper(TestDocument::class))->map(['data' => 'this is not valid']);
} }
#[TestDox('Map fails with invalid JSON for pjson class')] #[TestDox('map() fails with invalid JSON for Pjson class')]
public function testMapFailsWithInvalidJSONForPjsonClass(): void public function testMapFailsWithInvalidJSONForPjsonClass(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);

5
tests/unit/Mapper/ExistsMapperTest.php
View File

@ -19,7 +19,7 @@ use PHPUnit\Framework\TestCase;
#[TestDox('Exists Mapper (Unit tests)')] #[TestDox('Exists Mapper (Unit tests)')]
class ExistsMapperTest extends TestCase class ExistsMapperTest extends TestCase
{ {
#[TestDox('Map succeeds for PostgreSQL')] #[TestDox('map() succeeds for PostgreSQL')]
public function testMapSucceedsForPostgreSQL(): void public function testMapSucceedsForPostgreSQL(): void
{ {
try { try {
@ -30,7 +30,7 @@ class ExistsMapperTest extends TestCase
} }
} }
#[TestDox('Map succeeds for SQLite')] #[TestDox('map() succeeds for SQLite')]
public function testMapSucceedsForSQLite(): void public function testMapSucceedsForSQLite(): void
{ {
try { try {
@ -41,6 +41,7 @@ class ExistsMapperTest extends TestCase
} }
} }
#[TestDox('map() fails when mode not set')]
public function testMapFailsWhenModeNotSet(): void public function testMapFailsWhenModeNotSet(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);

9
tests/unit/Mapper/StringMapperTest.php
View File

@ -18,21 +18,24 @@ use PHPUnit\Framework\TestCase;
#[TestDox('String Mapper (Unit tests)')] #[TestDox('String Mapper (Unit tests)')]
class StringMapperTest extends TestCase class StringMapperTest extends TestCase
{ {
public function testMapSucceedsWhenFieldIsPresentAndString() #[TestDox('map() succeeds when field is present and string')]
public function testMapSucceedsWhenFieldIsPresentAndString(): void
{ {
$result = ['test_field' => 'test_value']; $result = ['test_field' => 'test_value'];
$mapper = new StringMapper('test_field'); $mapper = new StringMapper('test_field');
$this->assertEquals('test_value', $mapper->map($result), 'String value not returned correctly'); $this->assertEquals('test_value', $mapper->map($result), 'String value not returned correctly');
} }
public function testMapSucceedsWhenFieldIsPresentAndNotString() #[TestDox('map() succeeds when field is present and not string')]
public function testMapSucceedsWhenFieldIsPresentAndNotString(): void
{ {
$result = ['a_number' => 6.7]; $result = ['a_number' => 6.7];
$mapper = new StringMapper('a_number'); $mapper = new StringMapper('a_number');
$this->assertEquals('6.7', $mapper->map($result), 'Number value not returned correctly'); $this->assertEquals('6.7', $mapper->map($result), 'Number value not returned correctly');
} }
public function testMapSucceedsWhenFieldIsNotPresent() #[TestDox('map() succeeds when field is not present')]
public function testMapSucceedsWhenFieldIsNotPresent(): void
{ {
$mapper = new StringMapper('something_else'); $mapper = new StringMapper('something_else');
$this->assertNull($mapper->map([]), 'Missing value not returned correctly'); $this->assertNull($mapper->map([]), 'Missing value not returned correctly');

6
tests/unit/ModeTest.php
View File

@ -18,19 +18,19 @@ use PHPUnit\Framework\TestCase;
#[TestDox('Mode (Unit tests)')] #[TestDox('Mode (Unit tests)')]
class ModeTest extends TestCase class ModeTest extends TestCase
{ {
#[TestDox('Derive from DSN succeeds for PostgreSQL')] #[TestDox('deriveFromDSN() succeeds for PostgreSQL')]
public function testDeriveFromDSNSucceedsForPostgreSQL(): void public function testDeriveFromDSNSucceedsForPostgreSQL(): void
{ {
$this->assertEquals(Mode::PgSQL, Mode::deriveFromDSN('pgsql:Host=localhost'), 'PostgreSQL mode incorrect'); $this->assertEquals(Mode::PgSQL, Mode::deriveFromDSN('pgsql:Host=localhost'), 'PostgreSQL mode incorrect');
} }
#[TestDox('Derive from DSN succeeds for SQLite')] #[TestDox('deriveFromDSN() succeeds for SQLite')]
public function testDeriveFromDSNSucceedsForSQLite(): void public function testDeriveFromDSNSucceedsForSQLite(): void
{ {
$this->assertEquals(Mode::SQLite, Mode::deriveFromDSN('sqlite:data.db'), 'SQLite mode incorrect'); $this->assertEquals(Mode::SQLite, Mode::deriveFromDSN('sqlite:data.db'), 'SQLite mode incorrect');
} }
#[TestDox('Derive from DSN fails for MySQL')] #[TestDox('deriveFromDSN() fails for MySQL')]
public function testDeriveFromDSNFailsForMySQL(): void public function testDeriveFromDSNFailsForMySQL(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);

64
tests/unit/OpTest.php
View File

@ -18,57 +18,69 @@ use PHPUnit\Framework\TestCase;
#[TestDox('Op (Unit tests)')] #[TestDox('Op (Unit tests)')]
class OpTest extends TestCase class OpTest extends TestCase
{ {
#[TestDox('To SQL succeeds for EQ')] #[TestDox('toSQL() succeeds for Equal')]
public function testToSQLSucceedsForEQ(): void public function testToSQLSucceedsForEqual(): void
{ {
$this->assertEquals('=', Op::EQ->toSQL(), 'EQ operator incorrect'); $this->assertEquals('=', Op::Equal->toSQL(), 'Equal SQL operator incorrect');
} }
#[TestDox('To SQL succeeds for GT')] #[TestDox('toSQL() succeeds for Greater')]
public function testToSQLSucceedsForGT(): void public function testToSQLSucceedsForGreater(): void
{ {
$this->assertEquals('>', Op::GT->toSQL(), 'GT operator incorrect'); $this->assertEquals('>', Op::Greater->toSQL(), 'Greater SQL operator incorrect');
} }
#[TestDox('To SQL succeeds for GE')] #[TestDox('toSQL() succeeds for GreaterOrEqual')]
public function testToSQLSucceedsForGE(): void public function testToSQLSucceedsForGreaterOrEqual(): void
{ {
$this->assertEquals('>=', Op::GE->toSQL(), 'GE operator incorrect'); $this->assertEquals('>=', Op::GreaterOrEqual->toSQL(), 'GreaterOrEqual SQL operator incorrect');
} }
#[TestDox('To SQL succeeds for LT')] #[TestDox('toSQL() succeeds for Less')]
public function testToSQLSucceedsForLT(): void public function testToSQLSucceedsForLess(): void
{ {
$this->assertEquals('<', Op::LT->toSQL(), 'LT operator incorrect'); $this->assertEquals('<', Op::Less->toSQL(), 'Less SQL operator incorrect');
} }
#[TestDox('To SQL succeeds for LE')] #[TestDox('toSQL() succeeds for LessOrEqual')]
public function testToSQLSucceedsForLE(): void public function testToSQLSucceedsForLessOrEqual(): void
{ {
$this->assertEquals('<=', Op::LE->toSQL(), 'LE operator incorrect'); $this->assertEquals('<=', Op::LessOrEqual->toSQL(), 'LessOrEqual SQL operator incorrect');
} }
#[TestDox('To SQL succeeds for NE')] #[TestDox('toSQL() succeeds for NotEqual')]
public function testToSQLSucceedsForNE(): void public function testToSQLSucceedsForNotEqual(): void
{ {
$this->assertEquals('<>', Op::NE->toSQL(), 'NE operator incorrect'); $this->assertEquals('<>', Op::NotEqual->toSQL(), 'NotEqual SQL operator incorrect');
} }
#[TestDox('To SQL succeeds for BT')] #[TestDox('toSQL() succeeds for Between')]
public function testToSQLSucceedsForBT(): void public function testToSQLSucceedsForBetween(): void
{ {
$this->assertEquals('BETWEEN', Op::BT->toSQL(), 'BT operator incorrect'); $this->assertEquals('BETWEEN', Op::Between->toSQL(), 'Between SQL operator incorrect');
} }
#[TestDox('To SQL succeeds for EX')] #[TestDox('toSQL() succeeds for In')]
public function testToSQLSucceedsForEX(): void public function testToSQLSucceedsForIn(): void
{ {
$this->assertEquals('IS NOT NULL', Op::EX->toSQL(), 'EX operator incorrect'); $this->assertEquals('IN', Op::In->toSQL(), 'In SQL operator incorrect');
} }
#[TestDox('To SQL succeeds for NEX')] #[TestDox('toSQL() succeeds for InArray')]
public function testToSQLSucceedsForInArray(): void
{
$this->assertEquals('??|', Op::InArray->toSQL(), 'InArray SQL operator incorrect');
}
#[TestDox('toSQL() succeeds for Exists')]
public function testToSQLSucceedsForExists(): void
{
$this->assertEquals('IS NOT NULL', Op::Exists->toSQL(), 'Exists SQL operator incorrect');
}
#[TestDox('toSQL() succeeds for NotExists')]
public function testToSQLSucceedsForNEX(): void public function testToSQLSucceedsForNEX(): void
{ {
$this->assertEquals('IS NULL', Op::NEX->toSQL(), 'NEX operator incorrect'); $this->assertEquals('IS NULL', Op::NotExists->toSQL(), 'NotExists SQL operator incorrect');
} }
} }

24
tests/unit/ParametersTest.php
View File

@ -20,18 +20,19 @@ use Test\{PjsonDocument, PjsonId};
#[TestDox('Parameters (Unit tests)')] #[TestDox('Parameters (Unit tests)')]
class ParametersTest extends TestCase class ParametersTest extends TestCase
{ {
#[TestDox('ID succeeds with string')] #[TestDox('id() succeeds with string')]
public function testIdSucceedsWithString(): void public function testIdSucceedsWithString(): void
{ {
$this->assertEquals([':id' => 'key'], Parameters::id('key'), 'ID parameter not constructed correctly'); $this->assertEquals([':id' => 'key'], Parameters::id('key'), 'ID parameter not constructed correctly');
} }
#[TestDox('ID succeeds with non string')] #[TestDox('id() succeeds with non string')]
public function testIdSucceedsWithNonString(): void public function testIdSucceedsWithNonString(): void
{ {
$this->assertEquals([':id' => '7'], Parameters::id(7), 'ID parameter not constructed correctly'); $this->assertEquals([':id' => '7'], Parameters::id(7), 'ID parameter not constructed correctly');
} }
#[TestDox('json() succeeds for array')]
public function testJsonSucceedsForArray(): void public function testJsonSucceedsForArray(): void
{ {
$this->assertEquals([':it' => '{"id":18,"url":"https://www.unittest.com"}'], $this->assertEquals([':it' => '{"id":18,"url":"https://www.unittest.com"}'],
@ -39,20 +40,21 @@ class ParametersTest extends TestCase
'JSON parameter not constructed correctly'); 'JSON parameter not constructed correctly');
} }
#[TestDox('json() succeeds for array with empty array parameter')]
public function testJsonSucceedsForArrayWithEmptyArrayParameter(): void public function testJsonSucceedsForArrayWithEmptyArrayParameter(): void
{ {
$this->assertEquals([':it' => '{"id":18,"urls":[]}'], Parameters::json(':it', ['id' => 18, 'urls' => []]), $this->assertEquals([':it' => '{"id":18,"urls":[]}'], Parameters::json(':it', ['id' => 18, 'urls' => []]),
'JSON parameter not constructed correctly'); 'JSON parameter not constructed correctly');
} }
#[TestDox('json succeeds for 1D array with empty array parameter')] #[TestDox('json() succeeds for 1D array with empty array parameter')]
public function testJsonSucceedsFor1DArrayWithEmptyArrayParameter(): void public function testJsonSucceedsFor1DArrayWithEmptyArrayParameter(): void
{ {
$this->assertEquals([':it' => '{"urls":[]}'], Parameters::json(':it', ['urls' => []]), $this->assertEquals([':it' => '{"urls":[]}'], Parameters::json(':it', ['urls' => []]),
'JSON parameter not constructed correctly'); 'JSON parameter not constructed correctly');
} }
#[TestDox('json succeeds for stdClass')] #[TestDox('json() succeeds for stdClass')]
public function testJsonSucceedsForStdClass(): void public function testJsonSucceedsForStdClass(): void
{ {
$obj = new stdClass(); $obj = new stdClass();
@ -62,6 +64,7 @@ class ParametersTest extends TestCase
'JSON parameter not constructed correctly'); 'JSON parameter not constructed correctly');
} }
#[TestDox('json() succeeds for Pjson class')]
public function testJsonSucceedsForPjsonClass(): void public function testJsonSucceedsForPjsonClass(): void
{ {
$this->assertEquals([':it' => '{"id":"999","name":"a test","num_value":98}'], $this->assertEquals([':it' => '{"id":"999","name":"a test","num_value":98}'],
@ -69,6 +72,7 @@ class ParametersTest extends TestCase
'JSON parameter not constructed correctly'); 'JSON parameter not constructed correctly');
} }
#[TestDox('json() succeeds for array of Pjson class')]
public function testJsonSucceedsForArrayOfPjsonClass(): void public function testJsonSucceedsForArrayOfPjsonClass(): void
{ {
$this->assertEquals([':it' => '{"pjson":[{"id":"997","name":"another test","num_value":94}]}'], $this->assertEquals([':it' => '{"pjson":[{"id":"997","name":"another test","num_value":94}]}'],
@ -77,23 +81,26 @@ class ParametersTest extends TestCase
'JSON parameter not constructed correctly'); 'JSON parameter not constructed correctly');
} }
#[TestDox('nameFields() succeeds')]
public function testNameFieldsSucceeds(): void public function testNameFieldsSucceeds(): void
{ {
$named = Parameters::nameFields([Field::EQ('it', 17), Field::EQ('also', 22, ':also'), Field::EQ('other', 24)]); $named = [Field::equal('it', 17), Field::equal('also', 22, ':also'), Field::equal('other', 24)];
Parameters::nameFields($named);
$this->assertCount(3, $named, 'There should be 3 parameters in the array'); $this->assertCount(3, $named, 'There should be 3 parameters in the array');
$this->assertEquals(':field0', $named[0]->paramName, 'Parameter 1 not named correctly'); $this->assertEquals(':field0', $named[0]->paramName, 'Parameter 1 not named correctly');
$this->assertEquals(':also', $named[1]->paramName, 'Parameter 2 not named correctly'); $this->assertEquals(':also', $named[1]->paramName, 'Parameter 2 not named correctly');
$this->assertEquals(':field2', $named[2]->paramName, 'Parameter 3 not named correctly'); $this->assertEquals(':field2', $named[2]->paramName, 'Parameter 3 not named correctly');
} }
#[TestDox('addFields() succeeds')]
public function testAddFieldsSucceeds(): void public function testAddFieldsSucceeds(): void
{ {
$this->assertEquals([':a' => 1, ':b' => 'two', ':z' => 18], $this->assertEquals([':a' => 1, ':b' => 'two', ':z' => 18],
Parameters::addFields([Field::EQ('b', 'two', ':b'), Field::EQ('z', 18, ':z')], [':a' => 1]), Parameters::addFields([Field::equal('b', 'two', ':b'), Field::equal('z', 18, ':z')], [':a' => 1]),
'Field parameters not added correctly'); 'Field parameters not added correctly');
} }
#[TestDox('Field names succeeds for PostgreSQL')] #[TestDox('fieldNames() succeeds for PostgreSQL')]
public function testFieldNamesSucceedsForPostgreSQL(): void public function testFieldNamesSucceedsForPostgreSQL(): void
{ {
try { try {
@ -105,7 +112,7 @@ class ParametersTest extends TestCase
} }
} }
#[TestDox('Field names succeeds for SQLite')] #[TestDox('fieldNames() succeeds for SQLite')]
public function testFieldNamesSucceedsForSQLite(): void public function testFieldNamesSucceedsForSQLite(): void
{ {
try { try {
@ -117,6 +124,7 @@ class ParametersTest extends TestCase
} }
} }
#[TestDox('fieldNames() fails when mode not set')]
public function testFieldNamesFailsWhenModeNotSet(): void public function testFieldNamesFailsWhenModeNotSet(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);

12
tests/unit/Query/CountTest.php
View File

@ -25,21 +25,23 @@ class CountTest extends TestCase
parent::tearDown(); parent::tearDown();
} }
#[TestDox('all() succeeds')]
public function testAllSucceeds(): void public function testAllSucceeds(): void
{ {
$this->assertEquals('SELECT COUNT(*) FROM a_table', Count::all('a_table'), $this->assertEquals('SELECT COUNT(*) FROM a_table', Count::all('a_table'),
'SELECT statement not generated correctly'); 'SELECT statement not generated correctly');
} }
#[TestDox('byFields() succeeds')]
public function testByFieldsSucceeds(): void public function testByFieldsSucceeds(): void
{ {
Configuration::overrideMode(Mode::SQLite); Configuration::overrideMode(Mode::SQLite);
$this->assertEquals("SELECT COUNT(*) FROM somewhere WHERE data->>'errors' > :errors", $this->assertEquals("SELECT COUNT(*) FROM somewhere WHERE data->>'errors' > :errors",
Count::byFields('somewhere', [Field::GT('errors', 10, ':errors')]), Count::byFields('somewhere', [Field::greater('errors', 10, ':errors')]),
'SELECT statement not generated correctly'); 'SELECT statement not generated correctly');
} }
#[TestDox('By contains succeeds for PostgreSQL')] #[TestDox('byContains() succeeds for PostgreSQL')]
public function testByContainsSucceedsForPostgreSQL(): void public function testByContainsSucceedsForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
@ -47,14 +49,14 @@ class CountTest extends TestCase
'SELECT statement not generated correctly'); 'SELECT statement not generated correctly');
} }
#[TestDox('By contains fails for non PostgreSQL')] #[TestDox('byContains() fails for non PostgreSQL')]
public function testByContainsFailsForNonPostgreSQL(): void public function testByContainsFailsForNonPostgreSQL(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);
Count::byContains(''); Count::byContains('');
} }
#[TestDox('By JSON Path succeeds for PostgreSQL')] #[TestDox('byJsonPath() succeeds for PostgreSQL')]
public function testByJsonPathSucceedsForPostgreSQL(): void public function testByJsonPathSucceedsForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
@ -62,7 +64,7 @@ class CountTest extends TestCase
Count::byJsonPath('a_table'), 'SELECT statement not generated correctly'); Count::byJsonPath('a_table'), 'SELECT statement not generated correctly');
} }
#[TestDox('By JSON Path fails for non PostgreSQL')] #[TestDox('byJsonPath() fails for non PostgreSQL')]
public function testByJsonPathFailsForNonPostgreSQL(): void public function testByJsonPathFailsForNonPostgreSQL(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);

12
tests/unit/Query/DefinitionTest.php
View File

@ -25,7 +25,7 @@ class DefinitionTest extends TestCase
parent::tearDown(); parent::tearDown();
} }
#[TestDox('Ensure table succeeds for PosgtreSQL')] #[TestDox('ensureTable() succeeds for PosgtreSQL')]
public function testEnsureTableSucceedsForPostgreSQL(): void public function testEnsureTableSucceedsForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
@ -33,7 +33,7 @@ class DefinitionTest extends TestCase
Definition::ensureTable('documents'), 'CREATE TABLE statement not generated correctly'); Definition::ensureTable('documents'), 'CREATE TABLE statement not generated correctly');
} }
#[TestDox('Ensure table succeeds for SQLite')] #[TestDox('ensureTable() succeeds for SQLite')]
public function testEnsureTableSucceedsForSQLite(): void public function testEnsureTableSucceedsForSQLite(): void
{ {
Configuration::overrideMode(Mode::SQLite); Configuration::overrideMode(Mode::SQLite);
@ -41,18 +41,21 @@ class DefinitionTest extends TestCase
'CREATE TABLE statement not generated correctly'); 'CREATE TABLE statement not generated correctly');
} }
#[TestDox('ensureTable() fails when mode not set')]
public function testEnsureTableFailsWhenModeNotSet(): void public function testEnsureTableFailsWhenModeNotSet(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);
Definition::ensureTable('boom'); Definition::ensureTable('boom');
} }
#[TestDox('ensureIndexOn() succeeds without schema single ascending field')]
public function testEnsureIndexOnSucceedsWithoutSchemaSingleAscendingField(): void public function testEnsureIndexOnSucceedsWithoutSchemaSingleAscendingField(): void
{ {
$this->assertEquals("CREATE INDEX IF NOT EXISTS idx_test_fields ON test ((data->>'details'))", $this->assertEquals("CREATE INDEX IF NOT EXISTS idx_test_fields ON test ((data->>'details'))",
Definition::ensureIndexOn('test', 'fields', ['details']), 'CREATE INDEX statement not generated correctly'); Definition::ensureIndexOn('test', 'fields', ['details']), 'CREATE INDEX statement not generated correctly');
} }
#[TestDox('ensureIndexOn() succeeds with schema multiple fields')]
public function testEnsureIndexOnSucceedsWithSchemaMultipleFields(): void public function testEnsureIndexOnSucceedsWithSchemaMultipleFields(): void
{ {
$this->assertEquals( $this->assertEquals(
@ -61,12 +64,14 @@ class DefinitionTest extends TestCase
'CREATE INDEX statement not generated correctly'); 'CREATE INDEX statement not generated correctly');
} }
#[TestDox('ensureKey() succeeds')]
public function testEnsureKeySucceeds(): void public function testEnsureKeySucceeds(): void
{ {
$this->assertEquals("CREATE UNIQUE INDEX IF NOT EXISTS idx_tbl_key ON tbl ((data->>'id'))", $this->assertEquals("CREATE UNIQUE INDEX IF NOT EXISTS idx_tbl_key ON tbl ((data->>'id'))",
Definition::ensureKey('tbl'), 'CREATE INDEX statement for document key not generated correctly'); Definition::ensureKey('tbl'), 'CREATE INDEX statement for document key not generated correctly');
} }
#[TestDox('ensureDocumentIndexOn() succeeds for schema and Full')]
public function testEnsureDocumentIndexOnSucceedsForSchemaAndFull(): void public function testEnsureDocumentIndexOnSucceedsForSchemaAndFull(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
@ -74,6 +79,7 @@ class DefinitionTest extends TestCase
Definition::ensureDocumentIndexOn('my.tbl', DocumentIndex::Full)); Definition::ensureDocumentIndexOn('my.tbl', DocumentIndex::Full));
} }
#[TestDox('ensureDocumentIndexOn() succeeds for no schema and Optimized')]
public function testEnsureDocumentIndexOnSucceedsForNoSchemaAndOptimized(): void public function testEnsureDocumentIndexOnSucceedsForNoSchemaAndOptimized(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
@ -81,7 +87,7 @@ class DefinitionTest extends TestCase
Definition::ensureDocumentIndexOn('it', DocumentIndex::Optimized)); Definition::ensureDocumentIndexOn('it', DocumentIndex::Optimized));
} }
#[TestDox('Ensure document index on fails for non PostgreSQL')] #[TestDox('ensureDocumentIndexOn() fails for non PostgreSQL')]
public function testEnsureDocumentIndexOnFailsForNonPostgreSQL(): void public function testEnsureDocumentIndexOnFailsForNonPostgreSQL(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);

14
tests/unit/Query/DeleteTest.php
View File

@ -24,7 +24,7 @@ class DeleteTest extends TestCase
Configuration::overrideMode(null); Configuration::overrideMode(null);
} }
#[TestDox('By ID succeeds')] #[TestDox('byId() succeeds')]
public function testByIdSucceeds(): void public function testByIdSucceeds(): void
{ {
Configuration::overrideMode(Mode::SQLite); Configuration::overrideMode(Mode::SQLite);
@ -32,15 +32,17 @@ class DeleteTest extends TestCase
'DELETE statement not constructed correctly'); 'DELETE statement not constructed correctly');
} }
#[TestDox('byFields() succeeds')]
public function testByFieldsSucceeds(): void public function testByFieldsSucceeds(): void
{ {
Configuration::overrideMode(Mode::SQLite); Configuration::overrideMode(Mode::SQLite);
$this->assertEquals("DELETE FROM my_table WHERE data->>'value' < :max AND data->>'value' >= :min", $this->assertEquals("DELETE FROM my_table WHERE data->>'value' < :max AND data->>'value' >= :min",
Delete::byFields('my_table', [Field::LT('value', 99, ':max'), Field::GE('value', 18, ':min')]), Delete::byFields('my_table',
[Field::less('value', 99, ':max'), Field::greaterOrEqual('value', 18, ':min')]),
'DELETE statement not constructed correctly'); 'DELETE statement not constructed correctly');
} }
#[TestDox('By contains succeeds for PostgreSQL')] #[TestDox('byContains() succeeds for PostgreSQL')]
public function testByContainsSucceedsForPostgreSQL(): void public function testByContainsSucceedsForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
@ -48,14 +50,14 @@ class DeleteTest extends TestCase
'DELETE statement not constructed correctly'); 'DELETE statement not constructed correctly');
} }
#[TestDox('By contains fails for non PostgreSQL')] #[TestDox('byContains() fails for non PostgreSQL')]
public function testByContainsFailsForNonPostgreSQL(): void public function testByContainsFailsForNonPostgreSQL(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);
Delete::byContains(''); Delete::byContains('');
} }
#[TestDox('By JSON Path succeeds for PostgreSQL')] #[TestDox('byJsonPath() succeeds for PostgreSQL')]
public function testByJsonPathSucceedsForPostgreSQL(): void public function testByJsonPathSucceedsForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
@ -63,7 +65,7 @@ class DeleteTest extends TestCase
Delete::byJsonPath('here'), 'DELETE statement not constructed correctly'); Delete::byJsonPath('here'), 'DELETE statement not constructed correctly');
} }
#[TestDox('By JSON Path fails for non PostgreSQL')] #[TestDox('byJsonPath() fails for non PostgreSQL')]
public function testByJsonPathFailsForNonPostgreSQL(): void public function testByJsonPathFailsForNonPostgreSQL(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);

14
tests/unit/Query/ExistsTest.php
View File

@ -24,6 +24,7 @@ class ExistsTest extends TestCase
Configuration::overrideMode(null); Configuration::overrideMode(null);
} }
#[TestDox('query() succeeds')]
public function testQuerySucceeds(): void public function testQuerySucceeds(): void
{ {
Configuration::overrideMode(Mode::SQLite); Configuration::overrideMode(Mode::SQLite);
@ -31,7 +32,7 @@ class ExistsTest extends TestCase
'Existence query not generated correctly'); 'Existence query not generated correctly');
} }
#[TestDox('By ID succeeds')] #[TestDox('byId() succeeds')]
public function testByIdSucceeds(): void public function testByIdSucceeds(): void
{ {
Configuration::overrideMode(Mode::SQLite); Configuration::overrideMode(Mode::SQLite);
@ -39,15 +40,16 @@ class ExistsTest extends TestCase
'Existence query not generated correctly'); 'Existence query not generated correctly');
} }
#[TestDox('byFields() succeeds')]
public function testByFieldsSucceeds(): void public function testByFieldsSucceeds(): void
{ {
Configuration::overrideMode(Mode::SQLite); Configuration::overrideMode(Mode::SQLite);
$this->assertEquals("SELECT EXISTS (SELECT 1 FROM box WHERE data->>'status' <> :status)", $this->assertEquals("SELECT EXISTS (SELECT 1 FROM box WHERE data->>'status' <> :status)",
Exists::byFields('box', [Field::NE('status', 'occupied', ':status')]), Exists::byFields('box', [Field::notEqual('status', 'occupied', ':status')]),
'Existence query not generated correctly'); 'Existence query not generated correctly');
} }
#[TestDox('By contains succeeds for PostgreSQL')] #[TestDox('byContains() succeeds for PostgreSQL')]
public function testByContainsSucceedsForPostgreSQL(): void public function testByContainsSucceedsForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
@ -55,14 +57,14 @@ class ExistsTest extends TestCase
Exists::byContains('pocket'), 'Existence query not generated correctly'); Exists::byContains('pocket'), 'Existence query not generated correctly');
} }
#[TestDox('By contains fails for non PostgreSQL')] #[TestDox('byContains() fails for non PostgreSQL')]
public function testByContainsFailsForNonPostgreSQL(): void public function testByContainsFailsForNonPostgreSQL(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);
Exists::byContains(''); Exists::byContains('');
} }
#[TestDox('By JSON Path succeeds for PostgreSQL')] #[TestDox('byJsonPath() succeeds for PostgreSQL')]
public function testByJsonPathSucceedsForPostgreSQL(): void public function testByJsonPathSucceedsForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
@ -70,7 +72,7 @@ class ExistsTest extends TestCase
Exists::byJsonPath('lint'), 'Existence query not generated correctly'); Exists::byJsonPath('lint'), 'Existence query not generated correctly');
} }
#[TestDox('By JSON Path fails for non PostgreSQL')] #[TestDox('byJsonPath() fails for non PostgreSQL')]
public function testByJsonPathFailsForNonPostgreSQL(): void public function testByJsonPathFailsForNonPostgreSQL(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);

13
tests/unit/Query/FindTest.php
View File

@ -24,7 +24,7 @@ class FindTest extends TestCase
Configuration::overrideMode(null); Configuration::overrideMode(null);
} }
#[TestDox('By ID succeeds')] #[TestDox('byId() succeeds')]
public function testByIdSucceeds(): void public function testByIdSucceeds(): void
{ {
Configuration::overrideMode(Mode::SQLite); Configuration::overrideMode(Mode::SQLite);
@ -32,16 +32,17 @@ class FindTest extends TestCase
'SELECT query not generated correctly'); 'SELECT query not generated correctly');
} }
#[TestDox('byFields() succeeds')]
public function testByFieldsSucceeds(): void public function testByFieldsSucceeds(): void
{ {
Configuration::overrideMode(Mode::SQLite); Configuration::overrideMode(Mode::SQLite);
$this->assertEquals("SELECT data FROM there WHERE data->>'active' = :act OR data->>'locked' = :lock", $this->assertEquals("SELECT data FROM there WHERE data->>'active' = :act OR data->>'locked' = :lock",
Find::byFields('there', [Field::EQ('active', true, ':act'), Field::EQ('locked', true, ':lock')], Find::byFields('there', [Field::equal('active', true, ':act'), Field::equal('locked', true, ':lock')],
FieldMatch::Any), FieldMatch::Any),
'SELECT query not generated correctly'); 'SELECT query not generated correctly');
} }
#[TestDox('By contains succeeds for PostgreSQL')] #[TestDox('byContains() succeeds for PostgreSQL')]
public function testByContainsSucceedsForPostgreSQL(): void public function testByContainsSucceedsForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
@ -49,14 +50,14 @@ class FindTest extends TestCase
'SELECT query not generated correctly'); 'SELECT query not generated correctly');
} }
#[TestDox('By contains fails for non PostgreSQL')] #[TestDox('byContains() fails for non PostgreSQL')]
public function testByContainsFailsForNonPostgreSQL(): void public function testByContainsFailsForNonPostgreSQL(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);
Find::byContains(''); Find::byContains('');
} }
#[TestDox('By JSON Path succeeds for PostgreSQL')] #[TestDox('byJsonPath() succeeds for PostgreSQL')]
public function testByJsonPathSucceedsForPostgreSQL(): void public function testByJsonPathSucceedsForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
@ -64,7 +65,7 @@ class FindTest extends TestCase
Find::byJsonPath('light'), 'SELECT query not generated correctly'); Find::byJsonPath('light'), 'SELECT query not generated correctly');
} }
#[TestDox('By JSON Path fails for non PostgreSQL')] #[TestDox('byJsonPath() fails for non PostgreSQL')]
public function testByJsonPathFailsForNonPostgreSQL(): void public function testByJsonPathFailsForNonPostgreSQL(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);

24
tests/unit/Query/PatchTest.php
View File

@ -24,7 +24,7 @@ class PatchTest extends TestCase
Configuration::overrideMode(null); Configuration::overrideMode(null);
parent::tearDown(); parent::tearDown();
} }
#[TestDox('By ID succeeds for PostgreSQL')] #[TestDox('byId() succeeds for PostgreSQL')]
public function testByIdSucceedsForPostgreSQL(): void public function testByIdSucceedsForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
@ -32,7 +32,7 @@ class PatchTest extends TestCase
Patch::byId('doc_table'), 'Patch UPDATE statement is not correct'); Patch::byId('doc_table'), 'Patch UPDATE statement is not correct');
} }
#[TestDox('By ID succeeds for SQLite')] #[TestDox('byId() succeeds for SQLite')]
public function testByIdSucceedsForSQLite(): void public function testByIdSucceedsForSQLite(): void
{ {
Configuration::overrideMode(Mode::SQLite); Configuration::overrideMode(Mode::SQLite);
@ -40,37 +40,39 @@ class PatchTest extends TestCase
Patch::byId('my_table'), 'Patch UPDATE statement is not correct'); Patch::byId('my_table'), 'Patch UPDATE statement is not correct');
} }
#[TestDox('By ID fails when mode not set')] #[TestDox('byId() fails when mode not set')]
public function testByIdFailsWhenModeNotSet(): void public function testByIdFailsWhenModeNotSet(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);
Patch::byId('oof'); Patch::byId('oof');
} }
#[TestDox('By fields succeeds for PostgreSQL')] #[TestDox('byFields() succeeds for PostgreSQL')]
public function testByFieldsSucceedsForPostgreSQL(): void public function testByFieldsSucceedsForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
$this->assertEquals("UPDATE that SET data = data || :data WHERE (data->>'something')::numeric < :some", $this->assertEquals("UPDATE that SET data = data || :data WHERE (data->>'something')::numeric < :some",
Patch::byFields('that', [Field::LT('something', 17, ':some')]), 'Patch UPDATE statement is not correct'); Patch::byFields('that', [Field::less('something', 17, ':some')]), 'Patch UPDATE statement is not correct');
} }
#[TestDox('By fields succeeds for SQLite')] #[TestDox('byFields() succeeds for SQLite')]
public function testByFieldsSucceedsForSQLite(): void public function testByFieldsSucceedsForSQLite(): void
{ {
Configuration::overrideMode(Mode::SQLite); Configuration::overrideMode(Mode::SQLite);
$this->assertEquals( $this->assertEquals(
"UPDATE a_table SET data = json_patch(data, json(:data)) WHERE data->>'something' > :it", "UPDATE a_table SET data = json_patch(data, json(:data)) WHERE data->>'something' > :it",
Patch::byFields('a_table', [Field::GT('something', 17, ':it')]), 'Patch UPDATE statement is not correct'); Patch::byFields('a_table', [Field::greater('something', 17, ':it')]),
'Patch UPDATE statement is not correct');
} }
#[TestDox('byFields() fails when mode not set')]
public function testByFieldsFailsWhenModeNotSet(): void public function testByFieldsFailsWhenModeNotSet(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);
Patch::byFields('oops', []); Patch::byFields('oops', []);
} }
#[TestDox('By contains succeeds for PostgreSQL')] #[TestDox('byContains() succeeds for PostgreSQL')]
public function testByContainsSucceedsForPostgreSQL(): void public function testByContainsSucceedsForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
@ -78,14 +80,14 @@ class PatchTest extends TestCase
'Patch UPDATE statement is not correct'); 'Patch UPDATE statement is not correct');
} }
#[TestDox('By contains fails for non PostgreSQL')] #[TestDox('byContains() fails for non PostgreSQL')]
public function testByContainsFailsForNonPostgreSQL(): void public function testByContainsFailsForNonPostgreSQL(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);
Patch::byContains(''); Patch::byContains('');
} }
#[TestDox('By JSON Path succeeds for PostgreSQL')] #[TestDox('byJsonPath() succeeds for PostgreSQL')]
public function testByJsonPathSucceedsForPostgreSQL(): void public function testByJsonPathSucceedsForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
@ -93,7 +95,7 @@ class PatchTest extends TestCase
Patch::byJsonPath('that'), 'Patch UPDATE statement is not correct'); Patch::byJsonPath('that'), 'Patch UPDATE statement is not correct');
} }
#[TestDox('By JSON Path fails for non PostgreSQL')] #[TestDox('byJsonPath() fails for non PostgreSQL')]
public function testByJsonPathFailsForNonPostgreSQL(): void public function testByJsonPathFailsForNonPostgreSQL(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);

36
tests/unit/Query/RemoveFieldsTest.php
View File

@ -24,7 +24,7 @@ class RemoveFieldsTest extends TestCase
Configuration::overrideMode(null); Configuration::overrideMode(null);
} }
#[TestDox('Update succeeds for PostgreSQL')] #[TestDox('update() succeeds for PostgreSQL')]
public function testUpdateSucceedsForPostgreSQL(): void public function testUpdateSucceedsForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
@ -32,7 +32,7 @@ class RemoveFieldsTest extends TestCase
RemoveFields::update('taco', [':names' => "{one,two}"], 'it = true'), 'UPDATE statement not correct'); RemoveFields::update('taco', [':names' => "{one,two}"], 'it = true'), 'UPDATE statement not correct');
} }
#[TestDox('Update succeeds for SQLite')] #[TestDox('update() succeeds for SQLite')]
public function testUpdateSucceedsForSQLite(): void public function testUpdateSucceedsForSQLite(): void
{ {
Configuration::overrideMode(Mode::SQLite); Configuration::overrideMode(Mode::SQLite);
@ -41,22 +41,23 @@ class RemoveFieldsTest extends TestCase
'UPDATE statement not correct'); 'UPDATE statement not correct');
} }
#[TestDox('update() fails when mode not set')]
public function testUpdateFailsWhenModeNotSet(): void public function testUpdateFailsWhenModeNotSet(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);
RemoveFields::update('wow', [], ''); RemoveFields::update('wow', [], '');
} }
#[TestDox('By ID succeeds for PostgreSQL')] #[TestDox('byId() succeeds for PostgreSQL')]
public function testByIdSucceedsForPostgreSQL() public function testByIdSucceedsForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
$this->assertEquals("UPDATE churro SET data = data - :bite::text[] WHERE data->>'id' = :id", $this->assertEquals("UPDATE churro SET data = data - :bite::text[] WHERE data->>'id' = :id",
RemoveFields::byId('churro', Parameters::fieldNames(':bite', ['byte'])), 'UPDATE statement not correct'); RemoveFields::byId('churro', Parameters::fieldNames(':bite', ['byte'])), 'UPDATE statement not correct');
} }
#[TestDox('By ID succeeds for SQLite')] #[TestDox('byId() succeeds for SQLite')]
public function testByIdSucceedsForSQLite() public function testByIdSucceedsForSQLite(): void
{ {
Configuration::overrideMode(Mode::SQLite); Configuration::overrideMode(Mode::SQLite);
$this->assertEquals("UPDATE quesadilla SET data = json_remove(data, :bite0) WHERE data->>'id' = :id", $this->assertEquals("UPDATE quesadilla SET data = json_remove(data, :bite0) WHERE data->>'id' = :id",
@ -64,41 +65,42 @@ class RemoveFieldsTest extends TestCase
'UPDATE statement not correct'); 'UPDATE statement not correct');
} }
#[TestDox('By ID fails when mode not set')] #[TestDox('byId() fails when mode not set')]
public function testByIdFailsWhenModeNotSet(): void public function testByIdFailsWhenModeNotSet(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);
RemoveFields::byId('oof', []); RemoveFields::byId('oof', []);
} }
#[TestDox('By fields succeeds for PostgreSQL')] #[TestDox('byFields() succeeds for PostgreSQL')]
public function testByFieldsSucceedsForPostgreSQL() public function testByFieldsSucceedsForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
$this->assertEquals("UPDATE enchilada SET data = data - :sauce::text[] WHERE data->>'cheese' = :queso", $this->assertEquals("UPDATE enchilada SET data = data - :sauce::text[] WHERE data->>'cheese' = :queso",
RemoveFields::byFields('enchilada', [Field::EQ('cheese', 'jack', ':queso')], RemoveFields::byFields('enchilada', [Field::equal('cheese', 'jack', ':queso')],
Parameters::fieldNames(':sauce', ['white'])), Parameters::fieldNames(':sauce', ['white'])),
'UPDATE statement not correct'); 'UPDATE statement not correct');
} }
#[TestDox('By fields succeeds for SQLite')] #[TestDox('byFields() succeeds for SQLite')]
public function testByFieldsSucceedsForSQLite() public function testByFieldsSucceedsForSQLite(): void
{ {
Configuration::overrideMode(Mode::SQLite); Configuration::overrideMode(Mode::SQLite);
$this->assertEquals( $this->assertEquals(
"UPDATE chimichanga SET data = json_remove(data, :filling0) WHERE data->>'side' = :rice", "UPDATE chimichanga SET data = json_remove(data, :filling0) WHERE data->>'side' = :rice",
RemoveFields::byFields('chimichanga', [Field::EQ('side', 'beans', ':rice')], RemoveFields::byFields('chimichanga', [Field::equal('side', 'beans', ':rice')],
Parameters::fieldNames(':filling', ['beef'])), Parameters::fieldNames(':filling', ['beef'])),
'UPDATE statement not correct'); 'UPDATE statement not correct');
} }
#[TestDox('byFields() fails when mode not set')]
public function testByFieldsFailsWhenModeNotSet(): void public function testByFieldsFailsWhenModeNotSet(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);
RemoveFields::byFields('boing', [], []); RemoveFields::byFields('boing', [], []);
} }
#[TestDox('By contains succeeds for PostgreSQL')] #[TestDox('byContains() succeeds for PostgreSQL')]
public function testByContainsSucceedsForPostgreSQL(): void public function testByContainsSucceedsForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
@ -107,14 +109,14 @@ class RemoveFieldsTest extends TestCase
'UPDATE statement not correct'); 'UPDATE statement not correct');
} }
#[TestDox('By contains fails for non PostgreSQL')] #[TestDox('byContains() fails for non PostgreSQL')]
public function testByContainsFailsForNonPostgreSQL(): void public function testByContainsFailsForNonPostgreSQL(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);
RemoveFields::byContains('', []); RemoveFields::byContains('', []);
} }
#[TestDox('By JSON Path succeeds for PostgreSQL')] #[TestDox('byJsonPath() succeeds for PostgreSQL')]
public function testByJsonPathSucceedsForPostgreSQL(): void public function testByJsonPathSucceedsForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
@ -124,7 +126,7 @@ class RemoveFieldsTest extends TestCase
'UPDATE statement not correct'); 'UPDATE statement not correct');
} }
#[TestDox('By JSON Path fails for non PostgreSQL')] #[TestDox('byJsonPath() fails for non PostgreSQL')]
public function testByJsonPathFailsForNonPostgreSQL(): void public function testByJsonPathFailsForNonPostgreSQL(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);

135
tests/unit/QueryTest.php
View File

@ -28,45 +28,53 @@ class QueryTest extends TestCase
Configuration::overrideMode(null); Configuration::overrideMode(null);
} }
#[TestDox('selectFromTable() succeeds')]
public function testSelectFromTableSucceeds(): void public function testSelectFromTableSucceeds(): void
{ {
$this->assertEquals('SELECT data FROM testing', Query::selectFromTable('testing'), $this->assertEquals('SELECT data FROM testing', Query::selectFromTable('testing'),
'Query not constructed correctly'); 'Query not constructed correctly');
} }
#[TestDox('whereByFields() succeeds for single field')]
public function testWhereByFieldsSucceedsForSingleField(): void public function testWhereByFieldsSucceedsForSingleField(): void
{ {
$this->assertEquals("data->>'test_field' <= :it", $this->assertEquals("data->>'test_field' <= :it",
Query::whereByFields([Field::LE('test_field', '', ':it')]), 'WHERE fragment not constructed correctly'); Query::whereByFields([Field::lessOrEqual('test_field', '', ':it')]),
}
public function testWhereByFieldsSucceedsForMultipleFieldsAll(): void
{
$this->assertEquals("data->>'test_field' <= :it AND data->>'other_field' = :other",
Query::whereByFields([Field::LE('test_field', '', ':it'), Field::EQ('other_field', '', ':other')]),
'WHERE fragment not constructed correctly'); 'WHERE fragment not constructed correctly');
} }
#[TestDox('whereByFields() succeeds for multiple fields All')]
public function testWhereByFieldsSucceedsForMultipleFieldsAll(): void
{
$this->assertEquals("data->>'test_field' <= :it AND data->>'other_field' = :other",
Query::whereByFields(
[Field::lessOrEqual('test_field', '', ':it'), Field::equal('other_field', '', ':other')]),
'WHERE fragment not constructed correctly');
}
#[TestDox('whereByFields() succeeds for multiple fields Any')]
public function testWhereByFieldsSucceedsForMultipleFieldsAny(): void public function testWhereByFieldsSucceedsForMultipleFieldsAny(): void
{ {
$this->assertEquals("data->>'test_field' <= :it OR data->>'other_field' = :other", $this->assertEquals("data->>'test_field' <= :it OR data->>'other_field' = :other",
Query::whereByFields([Field::LE('test_field', '', ':it'), Field::EQ('other_field', '', ':other')], Query::whereByFields(
[Field::lessOrEqual('test_field', '', ':it'), Field::equal('other_field', '', ':other')],
FieldMatch::Any), FieldMatch::Any),
'WHERE fragment not constructed correctly'); 'WHERE fragment not constructed correctly');
} }
#[TestDox('Where by ID succeeds with default parameter')] #[TestDox('whereById() succeeds with default parameter')]
public function testWhereByIdSucceedsWithDefaultParameter(): void public function testWhereByIdSucceedsWithDefaultParameter(): void
{ {
$this->assertEquals("data->>'id' = :id", Query::whereById(), 'WHERE fragment not constructed correctly'); $this->assertEquals("data->>'id' = :id", Query::whereById(), 'WHERE fragment not constructed correctly');
} }
#[TestDox('Where by ID succeeds with specific parameter')] #[TestDox('whereById() succeeds with specific parameter')]
public function testWhereByIdSucceedsWithSpecificParameter(): void public function testWhereByIdSucceedsWithSpecificParameter(): void
{ {
$this->assertEquals("data->>'id' = :di", Query::whereById(':di'), 'WHERE fragment not constructed correctly'); $this->assertEquals("data->>'id' = :di", Query::whereById(':di'), 'WHERE fragment not constructed correctly');
} }
#[TestDox('whereDataContains() succeeds with default parameter')]
public function testWhereDataContainsSucceedsWithDefaultParameter(): void public function testWhereDataContainsSucceedsWithDefaultParameter(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
@ -74,13 +82,14 @@ class QueryTest extends TestCase
'WHERE fragment not constructed correctly'); 'WHERE fragment not constructed correctly');
} }
#[TestDox('whereDataContains() succeeds with specific parameter')]
public function testWhereDataContainsSucceedsWithSpecifiedParameter(): void public function testWhereDataContainsSucceedsWithSpecifiedParameter(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
$this->assertEquals('data @> :it', Query::whereDataContains(':it'), 'WHERE fragment not constructed correctly'); $this->assertEquals('data @> :it', Query::whereDataContains(':it'), 'WHERE fragment not constructed correctly');
} }
#[TestDox('Where data contains fails if not PostgreSQL')] #[TestDox('whereDataContains() fails if not PostgreSQL')]
public function testWhereDataContainsFailsIfNotPostgreSQL(): void public function testWhereDataContainsFailsIfNotPostgreSQL(): void
{ {
Configuration::overrideMode(null); Configuration::overrideMode(null);
@ -88,7 +97,7 @@ class QueryTest extends TestCase
Query::whereDataContains(); Query::whereDataContains();
} }
#[TestDox('Where JSON Path matches succeeds with default parameter')] #[TestDox('whereJsonPathMatches() succeeds with default parameter')]
public function testWhereJsonPathMatchesSucceedsWithDefaultParameter(): void public function testWhereJsonPathMatchesSucceedsWithDefaultParameter(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
@ -96,7 +105,7 @@ class QueryTest extends TestCase
'WHERE fragment not constructed correctly'); 'WHERE fragment not constructed correctly');
} }
#[TestDox('Where JSON Path matches succeeds with specified parameter')] #[TestDox('whereJsonPathMatches() succeeds with specified parameter')]
public function testWhereJsonPathMatchesSucceedsWithSpecifiedParameter(): void public function testWhereJsonPathMatchesSucceedsWithSpecifiedParameter(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
@ -104,7 +113,7 @@ class QueryTest extends TestCase
'WHERE fragment not constructed correctly'); 'WHERE fragment not constructed correctly');
} }
#[TestDox('Where JSON Path matches fails if not PostgreSQL')] #[TestDox('whereJsonPathMatches() fails if not PostgreSQL')]
public function testWhereJsonPathMatchesFailsIfNotPostgreSQL(): void public function testWhereJsonPathMatchesFailsIfNotPostgreSQL(): void
{ {
Configuration::overrideMode(null); Configuration::overrideMode(null);
@ -112,7 +121,7 @@ class QueryTest extends TestCase
Query::whereJsonPathMatches(); Query::whereJsonPathMatches();
} }
#[TestDox('Insert succeeds with no auto-ID for PostgreSQL')] #[TestDox('insert() succeeds with no auto-ID for PostgreSQL')]
public function testInsertSucceedsWithNoAutoIdForPostgreSQL(): void public function testInsertSucceedsWithNoAutoIdForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
@ -120,14 +129,14 @@ class QueryTest extends TestCase
'INSERT statement not constructed correctly'); 'INSERT statement not constructed correctly');
} }
#[TestDox('Insert succeeds with no auto-ID for SQLite')] #[TestDox('insert() succeeds with no auto-ID for SQLite')]
public function testInsertSucceedsWithNoAutoIdForSQLite(): void public function testInsertSucceedsWithNoAutoIdForSQLite(): void
{ {
$this->assertEquals('INSERT INTO test_tbl VALUES (:data)', Query::insert('test_tbl'), $this->assertEquals('INSERT INTO test_tbl VALUES (:data)', Query::insert('test_tbl'),
'INSERT statement not constructed correctly'); 'INSERT statement not constructed correctly');
} }
#[TestDox('Insert succeeds with auto numeric ID for PostgreSQL')] #[TestDox('insert() succeeds with auto numeric ID for PostgreSQL')]
public function testInsertSucceedsWithAutoNumericIdForPostgreSQL(): void public function testInsertSucceedsWithAutoNumericIdForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
@ -137,7 +146,7 @@ class QueryTest extends TestCase
Query::insert('test_tbl', AutoId::Number), 'INSERT statement not constructed correctly'); Query::insert('test_tbl', AutoId::Number), 'INSERT statement not constructed correctly');
} }
#[TestDox('Insert succeeds with auto numeric ID for SQLite')] #[TestDox('insert() succeeds with auto numeric ID for SQLite')]
public function testInsertSucceedsWithAutoNumericIdForSQLite(): void public function testInsertSucceedsWithAutoNumericIdForSQLite(): void
{ {
$this->assertEquals( $this->assertEquals(
@ -146,7 +155,7 @@ class QueryTest extends TestCase
Query::insert('test_tbl', AutoId::Number), 'INSERT statement not constructed correctly'); Query::insert('test_tbl', AutoId::Number), 'INSERT statement not constructed correctly');
} }
#[TestDox('Insert succeeds with auto UUID for PostgreSQL')] #[TestDox('insert() succeeds with auto UUID for PostgreSQL')]
public function testInsertSucceedsWithAutoUuidForPostgreSQL(): void public function testInsertSucceedsWithAutoUuidForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
@ -156,7 +165,7 @@ class QueryTest extends TestCase
$this->assertStringEndsWith("\"}')", $query, 'INSERT statement not constructed correctly'); $this->assertStringEndsWith("\"}')", $query, 'INSERT statement not constructed correctly');
} }
#[TestDox('Insert succeeds with auto UUID for SQLite')] #[TestDox('insert() succeeds with auto UUID for SQLite')]
public function testInsertSucceedsWithAutoUuidForSQLite(): void public function testInsertSucceedsWithAutoUuidForSQLite(): void
{ {
$query = Query::insert('test_tbl', AutoId::UUID); $query = Query::insert('test_tbl', AutoId::UUID);
@ -165,7 +174,7 @@ class QueryTest extends TestCase
$this->assertStringEndsWith("'))", $query, 'INSERT statement not constructed correctly'); $this->assertStringEndsWith("'))", $query, 'INSERT statement not constructed correctly');
} }
#[TestDox('Insert succeeds with auto random string for PostgreSQL')] #[TestDox('insert() succeeds with auto random string for PostgreSQL')]
public function testInsertSucceedsWithAutoRandomStringForPostgreSQL(): void public function testInsertSucceedsWithAutoRandomStringForPostgreSQL(): void
{ {
Configuration::overrideMode(Mode::PgSQL); Configuration::overrideMode(Mode::PgSQL);
@ -182,7 +191,7 @@ class QueryTest extends TestCase
} }
} }
#[TestDox('Insert succeeds with auto random string for SQLite')] #[TestDox('insert() succeeds with auto random string for SQLite')]
public function testInsertSucceedsWithAutoRandomStringForSQLite(): void public function testInsertSucceedsWithAutoRandomStringForSQLite(): void
{ {
$query = Query::insert('test_tbl', AutoId::RandomString); $query = Query::insert('test_tbl', AutoId::RandomString);
@ -193,6 +202,7 @@ class QueryTest extends TestCase
$this->assertEquals(16, strlen($id), "Generated ID [$id] should have been 16 characters long"); $this->assertEquals(16, strlen($id), "Generated ID [$id] should have been 16 characters long");
} }
#[TestDox('insert() fails when mode not set')]
public function testInsertFailsWhenModeNotSet(): void public function testInsertFailsWhenModeNotSet(): void
{ {
$this->expectException(DocumentException::class); $this->expectException(DocumentException::class);
@ -200,6 +210,7 @@ class QueryTest extends TestCase
Query::insert('kaboom'); Query::insert('kaboom');
} }
#[TestDox('save() succeeds')]
public function testSaveSucceeds(): void public function testSaveSucceeds(): void
{ {
$this->assertEquals( $this->assertEquals(
@ -207,9 +218,87 @@ class QueryTest extends TestCase
Query::save('test_tbl'), 'INSERT ON CONFLICT statement not constructed correctly'); Query::save('test_tbl'), 'INSERT ON CONFLICT statement not constructed correctly');
} }
public function testUpdateSucceeds() #[TestDox('update() succeeds')]
public function testUpdateSucceeds(): void
{ {
$this->assertEquals("UPDATE testing SET data = :data WHERE data->>'id' = :id", Query::update('testing'), $this->assertEquals("UPDATE testing SET data = :data WHERE data->>'id' = :id", Query::update('testing'),
'UPDATE statement not constructed correctly'); 'UPDATE statement not constructed correctly');
} }
#[TestDox('orderBy() succeeds with no fields for PostgreSQL')]
public function testOrderBySucceedsWithNoFieldsForPostgreSQL(): void
{
Configuration::overrideMode(Mode::PgSQL);
$this->assertEquals('', Query::orderBy([]), 'ORDER BY should have been blank');
}
#[TestDox('orderBy() succeeds with no fields for SQLite')]
public function testOrderBySucceedsWithNoFieldsForSQLite(): void
{
$this->assertEquals('', Query::orderBy([]), 'ORDER BY should have been blank');
}
#[TestDox('orderBy() succeeds with one field and no direction for PostgreSQL')]
public function testOrderBySucceedsWithOneFieldAndNoDirectionForPostgreSQL(): void
{
Configuration::overrideMode(Mode::PgSQL);
$this->assertEquals(" ORDER BY data->>'TestField'", Query::orderBy([Field::named('TestField')]),
'ORDER BY not constructed correctly');
}
#[TestDox('orderBy() succeeds with one field and no direction for SQLite')]
public function testOrderBySucceedsWithOneFieldAndNoDirectionForSQLite(): void
{
$this->assertEquals(" ORDER BY data->>'TestField'", Query::orderBy([Field::named('TestField')]),
'ORDER BY not constructed correctly');
}
#[TestDox('orderBy() succeeds with multiple fields and direction for PostgreSQL')]
public function testOrderBySucceedsWithMultipleFieldsAndDirectionForPostgreSQL(): void
{
Configuration::overrideMode(Mode::PgSQL);
$this->assertEquals(" ORDER BY data#>>'{Nested,Test,Field}' DESC, data->>'AnotherField', data->>'It' DESC",
Query::orderBy(
[Field::named('Nested.Test.Field DESC'), Field::named('AnotherField'), Field::named('It DESC')]),
'ORDER BY not constructed correctly');
}
#[TestDox('orderBy() succeeds with multiple fields and direction for SQLite')]
public function testOrderBySucceedsWithMultipleFieldsAndDirectionForSQLite(): void
{
$this->assertEquals(" ORDER BY data->'Nested'->'Test'->>'Field' DESC, data->>'AnotherField', data->>'It' DESC",
Query::orderBy(
[Field::named('Nested.Test.Field DESC'), Field::named('AnotherField'), Field::named('It DESC')]),
'ORDER BY not constructed correctly');
}
#[TestDox('orderBy() succeeds with numeric field for PostgreSQL')]
public function testOrderBySucceedsWithNumericFieldForPostgreSQL(): void
{
Configuration::overrideMode(Mode::PgSQL);
$this->assertEquals(" ORDER BY (data->>'Test')::numeric", Query::orderBy([Field::named('n:Test')]),
'ORDER BY not constructed correctly');
}
#[TestDox('orderBy() succeeds with numeric field for SQLite')]
public function testOrderBySucceedsWithNumericFieldForSQLite(): void
{
$this->assertEquals(" ORDER BY data->>'Test'", Query::orderBy([Field::named('n:Test')]),
'ORDER BY not constructed correctly');
}
#[TestDox('orderBy() succeeds with case-insensitive ordering for PostgreSQL')]
public function testOrderBySucceedsWithCaseInsensitiveOrderingForPostgreSQL(): void
{
Configuration::overrideMode(Mode::PgSQL);
$this->assertEquals(" ORDER BY LOWER(data#>>'{Test,Field}') DESC NULLS FIRST",
Query::orderBy([Field::named('i:Test.Field DESC NULLS FIRST')]), 'ORDER BY not constructed correctly');
}
#[TestDox('orderBy() succeeds with case-insensitive ordering for SQLite')]
public function testOrderBySucceedsWithCaseInsensitiveOrderingForSQLite(): void
{
$this->assertEquals(" ORDER BY data->'Test'->>'Field' COLLATE NOCASE ASC NULLS LAST",
Query::orderBy([Field::named('i:Test.Field ASC NULLS LAST')]), 'ORDER BY not constructed correctly');
}
} }