namespace Slack\SQLFake;

use function Facebook\FBExpect\expect;

use type Facebook\HackTest\{DataProvider, HackTest};

type JSONValidExpectedType = shape(?'exception' => classname<SQLFakeException>, ?'value' => ?int);

type JSONQuoteExpectedType = shape(?'exception' => classname<SQLFakeException>, ?'value' => ?string);

type JSONUnquoteExpectedType = shape(?'exception' => classname<SQLFakeException>, ?'value' => ?string);

type JSONExtractExpectedType = shape(?'exception' => classname<SQLFakeException>, ?'value' => ?string);

type JSONReplaceExpectedType = shape(?'exception' => classname<SQLFakeException>, ?'value' => ?string);

type JSONKeysExpectedType = shape(?'exception' => classname<SQLFakeException>, ?'value' => ?string);

type JSONLengthExpectedType = shape(?'exception' => classname<SQLFakeException>, ?'value' => ?int);

type JSONDepthExpectedType = shape(?'exception' => classname<SQLFakeException>, ?'value' => ?int);

type JSONFunctionCompositionExpectedType = shape(?'exception' => classname<SQLFakeException>, ?'value' => mixed);

type JSONContainsExpectedType = shape(?'exception' => classname<SQLFakeException>, ?'value' => ?int);

final class JSONFunctionTest extends HackTest {

private static ?AsyncMysqlConnection $conn;

<<__Override>>

public static async function beforeFirstTestAsync(): Awaitable<void> {

static::$conn = await SharedSetup::initAsync();

// block hole logging

Logger::setHandle(new \HH\Lib\IO\MemoryHandle());

}

<<__Override>>

public async function beforeEachTestAsync(): Awaitable<void> {

restore('setup');

QueryContext::$strictSchemaMode = false;

QueryContext::$strictSQLMode = false;

}

public static async function testJSONValidProvider(): Awaitable<vec<(string, JSONValidExpectedType)>> {

return vec[

// Invalid input

tuple('JSON_VALID()', shape('exception' => SQLFakeRuntimeException::class)),

tuple('JSON_VALID(1, 2)', shape('exception' => SQLFakeRuntimeException::class)),

// NULL input

tuple('JSON_VALID(NULL)', shape('value' => null)),

// Valid

tuple("JSON_VALID('null')", shape('value' => 1)),

tuple("JSON_VALID('{\"key\": \"value\"}')", shape('value' => 1)),

tuple("JSON_VALID('[{\"key\": \"value\"}]')", shape('value' => 1)),

tuple("JSON_VALID('\"\"')", shape('value' => 1)),

tuple("JSON_VALID('true')", shape('value' => 1)),

tuple("JSON_VALID('false')", shape('value' => 1)),

tuple("JSON_VALID('2')", shape('value' => 1)),

// Invalid

tuple("JSON_VALID(' ')", shape('value' => 0)),

tuple("JSON_VALID('arbitrary_string')", shape('value' => 0)),

tuple('JSON_VALID(2)', shape('value' => 0)),

tuple('JSON_VALID(TRUE)', shape('value' => 0)),

];

}

<<DataProvider('testJSONValidProvider')>>

public async function testJSONValid(string $select, JSONValidExpectedType $expected): Awaitable<void> {

await $this->simpleSelectTestCase($select, $expected);

}

public static async function testJSONQuoteProvider(): Awaitable<vec<(string, JSONQuoteExpectedType)>> {

return vec[

tuple('JSON_QUOTE(NULL)', shape('value' => null)),

tuple("JSON_QUOTE('null')", shape('value' => '"null"')),

tuple("JSON_QUOTE('a')", shape('value' => '"a"')),

tuple("JSON_QUOTE('{\"a\":\"c\"}')", shape('value' => '"{\"a\":\"c\"}"')),

tuple("JSON_QUOTE('[1, \"\"\"]')", shape('value' => '"[1, \"\"\"]"')),

tuple(

"JSON_QUOTE('[1, \"\\\\\"]')",

shape('value' => '"[1, \"\\\\\"]"'),

), // In PHP \\ represents \ in single & double quoted strings

tuple("JSON_QUOTE('►')", shape('value' => '"►"')), // MySQL doesn't seem to escape these

tuple("JSON_QUOTE('2\n2')", shape('value' => '"2\\n2"')), // Escapes newline

tuple("JSON_QUOTE('".'22'.\chr(8)."')", shape('value' => '"22\\b"')), // Escapes backspace character

// invalid

tuple('JSON_QUOTE(TRUE)', shape('exception' => SQLFakeRuntimeException::class)),

tuple('JSON_QUOTE(45)', shape('exception' => SQLFakeRuntimeException::class)),

];

}

<<DataProvider('testJSONQuoteProvider')>>

public async function testJSONQuote(string $select, JSONQuoteExpectedType $expected): Awaitable<void> {

await $this->simpleSelectTestCase($select, $expected);

}

public static async function testJSONUnquoteProvider(): Awaitable<vec<(string, JSONUnquoteExpectedType)>> {

return vec[

tuple('JSON_UNQUOTE(NULL)', shape('value' => null)),

tuple('JSON_UNQUOTE("null")', shape('value' => 'null')),

tuple('JSON_UNQUOTE("a")', shape('value' => 'a')),

tuple("JSON_UNQUOTE('\\\\')", shape('value' => '\\')), // no-op

tuple('JSON_UNQUOTE(\'"{\\\\\"a\\\\\":\\\\\"c\\\\\"}"\')', shape('value' => '{"a":"c"}')),

tuple('JSON_UNQUOTE(\'[1, """]\')', shape('value' => '[1, """]')), // no-op

tuple('JSON_UNQUOTE(\'"[1, \\\"\\\"\\\"]"\')', shape('value' => '[1, """]')),

tuple('JSON_UNQUOTE(\'"\\\\\\\\"\')', shape('value' => '\\')),

tuple('JSON_UNQUOTE(\'"\\\u25ba"\')', shape('value' => '►')),

tuple('JSON_UNQUOTE(\'"\\\\n"\')', shape('value' => "\n")),

tuple('JSON_UNQUOTE(\'"2\\\\b"\')', shape('value' => '2'.\chr(8))),

// invalid

tuple(

'JSON_UNQUOTE(\'"\\\\"\')',

shape('exception' => SQLFakeRuntimeException::class),

), // inner function receive '"\"'

tuple('JSON_UNQUOTE(2)', shape('exception' => SQLFakeRuntimeException::class)),

];

}

<<DataProvider('testJSONUnquoteProvider')>>

public async function testJSONUnquote(string $select, JSONUnquoteExpectedType $expected): Awaitable<void> {

await $this->simpleSelectTestCase($select, $expected);

}

public static async function testJSONExtractProvider(): Awaitable<vec<(string, JSONExtractExpectedType)>> {

return vec[

// invalid input

tuple('JSON_EXTRACT()', shape('exception' => SQLFakeRuntimeException::class)),

tuple("JSON_EXTRACT('[]')", shape('exception' => SQLFakeRuntimeException::class)),

tuple("JSON_EXTRACT('[}', '$.a')", shape('exception' => SQLFakeRuntimeException::class)),

tuple("JSON_EXTRACT('[]', 'a.b')", shape('exception' => SQLFakeRuntimeException::class)),

tuple("JSON_EXTRACT('[]', 2)", shape('exception' => SQLFakeRuntimeException::class)),

tuple("JSON_EXTRACT('[]', TRUE)", shape('exception' => SQLFakeRuntimeException::class)),

// NULL input

tuple("JSON_EXTRACT(NULL, '$.a')", shape('value' => null)),

tuple("JSON_EXTRACT('{\"a\": {\"b\": \"test\"}}', NULL)", shape('value' => null)),

// valid

tuple("JSON_EXTRACT('{\"a\": {\"b\": \"test\"}}', '$.a.b')", shape('value' => '"test"')),

tuple("JSON_EXTRACT('{\"a\": {\"b\": 2}}', '$.a.b')", shape('value' => '2')),

tuple("JSON_EXTRACT('{\"a\": {\"b\": true}}', '$.a.b')", shape('value' => 'true')),

tuple(

"JSON_EXTRACT('{\"a\": {\"b\": 2, \"c\": \"test\"}}', '$.a.b', '$.\"a\".\"c\"')",

shape('value' => '[2,"test"]'),

),

tuple("JSON_EXTRACT('[{\"a\": [{\"b\": \"test\"}]}]', '$[0].a')", shape('value' => '[{"b":"test"}]')),

tuple("JSON_EXTRACT('[{\"a\": [{\"b\": \"test\"}]}]', '$[0].a[0]')", shape('value' => '{"b":"test"}')),

tuple("JSON_EXTRACT('[{\"a\": [{\"b\": \"test\"}]}]', '$**.\"b\"')", shape('value' => '["test"]')),

tuple(

"JSON_EXTRACT('[{\"a\": [{\"b\": \"test\", \"c\":false}]}]', '$**.*')",

shape('value' => '[[{"b":"test","c":false}],"test",false]'),

),

tuple("JSON_EXTRACT('{\"a\": {\"b\": [\"test\",10]}}', '$**[1]')", shape('value' => '[10]')),

tuple("JSON_EXTRACT('{\"a\":2}', '$.a', '$.b')", shape('value' => '[2]')),

tuple("JSON_EXTRACT('\"a\"', '$')", shape('value' => '"a"')),

// non-existent

tuple("JSON_EXTRACT('2', '$**[1]')", shape('value' => null)),

tuple("JSON_EXTRACT('{\"a\": 2}', '$.b')", shape('value' => null)),

tuple("JSON_EXTRACT('{\"a\": 2}', '$.b', '$[0]')", shape('value' => null)),

];

}

<<DataProvider('testJSONExtractProvider')>>

public async function testJSONExtract(string $select, JSONExtractExpectedType $expected): Awaitable<void> {

await $this->simpleSelectTestCase($select, $expected);

}

public static async function testJSONReplaceProvider(): Awaitable<vec<(string, JSONReplaceExpectedType)>> {

return vec[

// NULL inputs

tuple("JSON_REPLACE(NULL, '$.a', 2)", shape('value' => null)),

tuple("JSON_REPLACE('{}', NULL, 2)", shape('value' => null)),

// bad input

tuple("JSON_REPLACE('{}')", shape('exception' => SQLFakeRuntimeException::class)),

tuple("JSON_REPLACE('', '$', 2)", shape('exception' => SQLFakeRuntimeException::class)),

tuple("JSON_REPLACE('{}', '$', 2, '$')", shape('exception' => SQLFakeRuntimeException::class)),

tuple("JSON_REPLACE('{}', '\$fd', 2)", shape('exception' => SQLFakeRuntimeException::class)),

// non-existent path (no-op)

tuple("JSON_REPLACE('null', '$.a', 2)", shape('value' => 'null')),

tuple("JSON_REPLACE('2', '$.a', 45)", shape('value' => '2')),

tuple("JSON_REPLACE('{\"a\": {\"b\":\"test\"}}', '$.b', 45)", shape('value' => '{"a":{"b":"test"}}')),

// existent path

tuple("JSON_REPLACE('{}', '$', TRUE)", shape('value' => 'true')),

tuple("JSON_REPLACE('[1]', '$[0]', NULL)", shape('value' => '[null]')),

tuple("JSON_REPLACE('{\"a\":{\"b\":\"test\"}}', '$.a.b', 2)", shape('value' => '{"a":{"b":2}}')),

// multiple

tuple("JSON_REPLACE('{\"a\": [1,2]}', '$.a[0]', 3, '$.a[1]', 4)", shape('value' => '{"a":[3,4]}')),

// successive replacements work off interim object

tuple("JSON_REPLACE('{\"a\": [1,2]}', '$.a[0]', 3, '$.a[0]', 4)", shape('value' => '{"a":[4,2]}')),

];

}

<<DataProvider('testJSONReplaceProvider')>>

public async function testJSONReplace(string $select, JSONReplaceExpectedType $expected): Awaitable<void> {

await $this->simpleSelectTestCase($select, $expected);

}

public static async function testJSONKeysProvider(): Awaitable<vec<(string, JSONKeysExpectedType)>> {

return vec[

// invalid input

tuple("JSON_KEYS('{]')", shape('exception' => SQLFakeRuntimeException::class)),

tuple('JSON_KEYS(2)', shape('exception' => SQLFakeRuntimeException::class)),

tuple("JSON_KEYS('{}', 2)", shape('exception' => SQLFakeRuntimeException::class)),

// null inputs

tuple('JSON_KEYS(NULL)', shape('value' => null)),

tuple("JSON_KEYS('{}', NULL)", shape('value' => null)),

// points to non-object

tuple("JSON_KEYS('[]')", shape('value' => null)),

tuple("JSON_KEYS('2')", shape('value' => null)),

tuple("JSON_KEYS('true')", shape('value' => null)),

tuple("JSON_KEYS('null')", shape('value' => null)),

tuple("JSON_KEYS('{\"a\":2}', '$.a')", shape('value' => null)),

tuple("JSON_KEYS('[2]', '$[0]')", shape('value' => null)),

// path is divergent

tuple("JSON_KEYS('{}', '$[*]')", shape('exception' => SQLFakeRuntimeException::class)),

tuple("JSON_KEYS('{}', '$**.a')", shape('exception' => SQLFakeRuntimeException::class)),

// points to object

tuple("JSON_KEYS('{}')", shape('value' => '[]')),

tuple("JSON_KEYS('{\"a\": {\"b\": 2, \"c\": true}}')", shape('value' => '["a"]')),

tuple("JSON_KEYS('{\"a\": {\"b\": 2, \"c\": true}}', '$.a')", shape('value' => '["b","c"]')),

tuple("JSON_KEYS('[{\"a\": {\"b\": 2, \"c\": true}}]', '$[0]')", shape('value' => '["a"]')),

tuple("JSON_KEYS('[{\"a\": {\"b\": 2, \"c\": true}}]', '$[0].a')", shape('value' => '["b","c"]')),

];

}

<<DataProvider('testJSONKeysProvider')>>

public async function testJSONKeys(string $select, JSONKeysExpectedType $expected): Awaitable<void> {

await $this->simpleSelectTestCase($select, $expected);

}

public static async function testJSONLengthProvider(): Awaitable<vec<(string, JSONLengthExpectedType)>> {

return vec[

// invalid input

tuple("JSON_LENGTH('{]')", shape('exception' => SQLFakeRuntimeException::class)),

tuple('JSON_LENGTH(2)', shape('exception' => SQLFakeRuntimeException::class)),

tuple("JSON_LENGTH('{}', 2)", shape('exception' => SQLFakeRuntimeException::class)),

// null inputs

tuple('JSON_LENGTH(NULL)', shape('value' => null)),

tuple("JSON_LENGTH('{}', NULL)", shape('value' => null)),

// path is divergent

tuple("JSON_LENGTH('{}', '$[*]')", shape('exception' => SQLFakeRuntimeException::class)),

tuple("JSON_LENGTH('{}', '$**.a')", shape('exception' => SQLFakeRuntimeException::class)),

// points to object

tuple("JSON_LENGTH('{}')", shape('value' => 0)),

tuple("JSON_LENGTH('{\"a\": {\"b\": 2, \"c\": true}}')", shape('value' => 1)),

tuple("JSON_LENGTH('{\"a\": {\"b\": 2, \"c\": true}}', '$.a')", shape('value' => 2)),

tuple("JSON_LENGTH('[{\"a\": {\"b\": 2, \"c\": true}}]', '$[0]')", shape('value' => 1)),

tuple("JSON_LENGTH('[{\"a\": {\"b\": 2, \"c\": true}}]', '$[0].a')", shape('value' => 2)),

// points to vec

tuple("JSON_LENGTH('[]')", shape('value' => 0)),

tuple("JSON_LENGTH('[{\"a\": 2}]')", shape('value' => 1)),

tuple("JSON_LENGTH('{\"a\": [true, 1]}', '$.a')", shape('value' => 2)),

tuple("JSON_LENGTH('[[1], 3]', '$[0]')", shape('value' => 1)),

tuple("JSON_LENGTH('[{\"a\": [{\"b\": true}, false, 4]}]', '$[0].a')", shape('value' => 3)),

// points to scalar

tuple("JSON_LENGTH('\"string\"')", shape('value' => 1)),

tuple("JSON_LENGTH('1')", shape('value' => 1)),

tuple("JSON_LENGTH('true')", shape('value' => 1)),

tuple("JSON_LENGTH('null')", shape('value' => 1)),

tuple("JSON_LENGTH('{\"a\": \"string\", \"b\": 2}', '$.a')", shape('value' => 1)),

tuple("JSON_LENGTH('{\"a\": \"string\", \"b\": 2}', '$.b')", shape('value' => 1)),

tuple("JSON_LENGTH('{\"a\": \"string\", \"b\": true}', '$.b')", shape('value' => 1)),

tuple("JSON_LENGTH('{\"a\": \"string\", \"b\": null}', '$.b')", shape('value' => 1)),

];

}

<<DataProvider('testJSONLengthProvider')>>

public async function testJSONLength(string $select, JSONLengthExpectedType $expected): Awaitable<void> {

await $this->simpleSelectTestCase($select, $expected);

}

public static async function testJSONDepthProvider(): Awaitable<vec<(string, JSONDepthExpectedType)>> {

return vec[

// invalid input

tuple('JSON_DEPTH()', shape('exception' => SQLFakeRuntimeException::class)),

tuple("JSON_DEPTH('{]')", shape('exception' => SQLFakeRuntimeException::class)),

tuple('JSON_DEPTH(2)', shape('exception' => SQLFakeRuntimeException::class)),

tuple('JSON_DEPTH(TRUE)', shape('exception' => SQLFakeRuntimeException::class)),

// null input

tuple('JSON_DEPTH(NULL)', shape('value' => null)),

// depth 1

tuple("JSON_DEPTH('2')", shape('value' => 1)),

tuple("JSON_DEPTH('true')", shape('value' => 1)),

tuple("JSON_DEPTH('false')", shape('value' => 1)),

tuple("JSON_DEPTH('null')", shape('value' => 1)),

tuple("JSON_DEPTH('\"string\"')", shape('value' => 1)),

tuple("JSON_DEPTH('{}')", shape('value' => 1)),

tuple("JSON_DEPTH('[]')", shape('value' => 1)),

// depth 2

tuple(

"JSON_DEPTH('{\"a\": 2, \"b\": [], \"c\": \"string\", \"d\": null, \"e\": true, \"f\": {}}')",

shape('value' => 2),

),

tuple("JSON_DEPTH('[2, {}, [], \"string\", null, false]')", shape('value' => 2)),

// depth > 2

tuple("JSON_DEPTH('[[2]]')", shape('value' => 3)),

tuple("JSON_DEPTH('{\"a\": {\"b\": []}}')", shape('value' => 3)),

tuple("JSON_DEPTH('{\"a\": {\"b\": [true]}}')", shape('value' => 4)),

tuple("JSON_DEPTH('[2, 1, [{\"a\": [3, 4]}]]')", shape('value' => 5)),

tuple("JSON_DEPTH('[2, 1, [{\"a\": [3, [{\"a\": [2]}]]}]]')", shape('value' => 8)),

];

}

<<DataProvider('testJSONDepthProvider')>>

public async function testJSONDepth(string $select, JSONDepthExpectedType $expected): Awaitable<void> {

await $this->simpleSelectTestCase($select, $expected);

}

public static async function testJSONFunctionCompositionProvider(

): Awaitable<vec<(string, JSONFunctionCompositionExpectedType)>> {

return vec[

// JSON as doc for JSON_EXTRACT

tuple("JSON_EXTRACT(JSON_EXTRACT('{\"a\":true}', '$'), '$.a')", shape('value' => 'true')),

tuple("JSON_EXTRACT(JSON_EXTRACT('[true]', '$[0]'), '$')", shape('value' => 'true')),

// JSON as doc for JSON_REPLACE

tuple("JSON_REPLACE(JSON_EXTRACT('{\"a\":{\"b\": 2}}', '$.a'), '$.b', true)", shape('value' => '{"b":true}')),

tuple("JSON_REPLACE(JSON_EXTRACT(\"[false]\", '$[0]'), '$.a', 'test')", shape('value' => 'false')),

tuple(

"JSON_REPLACE('[0,1]', '$[1]', REPLACE(JSON_UNQUOTE(JSON_EXTRACT('{\"a\":{\"b\": \"test\"}}', '$.a.b')), 'te', 're'))",

shape('value' => '[0,"rest"]'),

),

tuple("JSON_REPLACE('{\"b\":2}', '$.b', 1 < 2)", shape('value' => '{"b":true}')),

// JSON value as replacement in JSON_REPLACE

tuple("JSON_REPLACE('[0,1]', '$[1]', JSON_EXTRACT('{\"a\": \"test\"}', '$.a'))", shape('value' => '[0,"test"]')),

tuple(

"JSON_REPLACE('{\"a\":2}', JSON_UNQUOTE(JSON_EXTRACT('{\"b\":\"$.a\"}', '$.b')), 4)",

shape('value' => '{"a":4}'),

),

tuple("JSON_UNQUOTE(JSON_EXTRACT('{\"a\": true}', '$.a'))", shape('value' => 'true')),

tuple("JSON_UNQUOTE(JSON_EXTRACT('{\"a\": \"test\"}', '$.a'))", shape('value' => 'test')),

tuple("JSON_UNQUOTE(JSON_EXTRACT('{\"a\": 5}', '$.a'))", shape('value' => '5')),

// exceptional

// JSON_EXTRACT output as JSON_QUOTE arg

tuple(

"JSON_QUOTE(JSON_EXTRACT('{\"a\":\"test\"}', '$.a'))",

shape('exception' => SQLFakeRuntimeException::class),

),

// JSON as path for JSON_EXTRACT

tuple(

"JSON_EXTRACT('[true]', JSON_EXTRACT('[\"$[0]\"]', '$[0]'))",

shape('exception' => SQLFakeRuntimeException::class),

),

// JSON as path for JSON_REPLACE

tuple(

"JSON_REPLACE('{\"a\":2}', JSON_EXTRACT('{\"b\":\"$.a\"}', '$.b'), 2)",

shape('exception' => SQLFakeRuntimeException::class),

),

];

}

<<DataProvider('testJSONFunctionCompositionProvider')>>

public async function testJSONFunctionComposition(

string $select,

JSONFunctionCompositionExpectedType $expected,

): Awaitable<void> {

await $this->simpleSelectTestCase($select, $expected);

}

public static async function testJSONContainsProvider(): Awaitable<vec<(string, JSONContainsExpectedType)>> {

return vec[

// NULL inputs

tuple("JSON_CONTAINS(NULL, '{}', '$')", shape('value' => null)),

tuple("JSON_CONTAINS('{}', NULL, '$')", shape('value' => null)),

// bad input

tuple("JSON_CONTAINS('{}')", shape('exception' => SQLFakeRuntimeException::class)),

tuple("JSON_CONTAINS('', 2, '$')", shape('exception' => SQLFakeRuntimeException::class)),

tuple("JSON_CONTAINS('{}', 2, '$', '$')", shape('exception' => SQLFakeRuntimeException::class)),

tuple("JSON_CONTAINS('{}', '\$fd', 2)", shape('exception' => SQLFakeRuntimeException::class)),

// non-existent path

tuple("JSON_CONTAINS('null', '2', '$.a')", shape('exception' => SQLFakeRuntimeException::class)),

tuple("JSON_CONTAINS('[]', 45, '$.a')", shape('exception' => SQLFakeRuntimeException::class)),

tuple("JSON_CONTAINS('2', 45, '$.a')", shape('exception' => SQLFakeRuntimeException::class)),

tuple(

"JSON_CONTAINS('{\"a\": {\"b\":\"test\"}}', '45', '$.b')",

shape('exception' => SQLFakeRuntimeException::class),

),

// existent path - array

tuple("JSON_CONTAINS('[]', '4', '$')", shape('value' => 0)),

tuple("JSON_CONTAINS('[1, 2, 3, 4]', '1', '$')", shape('value' => 1)),

tuple("JSON_CONTAINS('[\"blue\", \"green\", \"red\", \"yellow\"]', '\"red\"', '$')", shape('value' => 1)),

// existent path - object

tuple("JSON_CONTAINS('{}', '4', '$')", shape('value' => 0)),

tuple("JSON_CONTAINS('{\"a\": {\"b\":\"test\"}}', '\"test\"', '$.a.b')", shape('value' => 1)),

tuple("JSON_CONTAINS('{\"a\": {\"b\":\"test\"}}', '{\"b\":\"test\"}', '$.a')", shape('value' => 1)),

tuple("JSON_CONTAINS('{\"a\": {\"b\":\"test\"}}', '\"test\"', '$.a')", shape('value' => 1)),

// no path - array

tuple("JSON_CONTAINS('[]', '4')", shape('value' => 0)),

tuple("JSON_CONTAINS('[1, 2, 3, 4]', '1')", shape('value' => 1)),

tuple("JSON_CONTAINS('[\"blue\", \"green\", \"red\", \"yellow\"]', '\"red\"')", shape('value' => 1)),

// no path - object

tuple("JSON_CONTAINS('{}', '4')", shape('value' => 0)),

tuple("JSON_CONTAINS('{\"a\": {\"b\":\"test\"}}', '\"test\"')", shape('value' => 0)),

tuple("JSON_CONTAINS('{\"a\": {\"b\":\"test\"}}', '{\"a\": {\"b\":\"test\"}}')", shape('value' => 1)),

tuple("JSON_CONTAINS('{\"a\": {\"b\":\"test\"}}', '{\"b\":\"test\"}')", shape('value' => 1)),

];

}

<<DataProvider('testJSONContainsProvider')>>

public async function testJSONContains(string $select, JSONContainsExpectedType $expected): Awaitable<void> {

await $this->simpleSelectTestCase($select, $expected);

}

private async function simpleSelectTestCase(

string $select,

shape(?'exception' => classname<SQLFakeException>, ?'value' => mixed) $expected,

): Awaitable<void> {

$exception = $expected['exception'] ?? null;

$conn = static::$conn as nonnull;

$sql = 'SELECT '.$select.' AS expected';

if (!$exception) {

$results = await $conn->query($sql);

$expectedValue = $expected['value'] ?? null;

expect($results->rows())->toBeSame(vec[dict['expected' => $expectedValue]], $sql);

return;

}

expect(async () ==> await $conn->query($sql))->toThrow($exception);

}

}