cql-pytest: tests for fromJson() not accepting empty string as integer

When writing to an integer column, Cassandra's fromJson() function allows
not just JSON number constants, it also allows a string containing a
number. Strings which do not hold a number fail with a FunctionFailure.
In particular, the empty string "" is an invalid number, and should fail.

The tests in this patch check this for two integer types: int and
varint.

Curiously, Cassandra and Scylla have opposite bugs here: Scylla fails
to recognize the error for varint, while Cassandra fails to recognize
the error for int. The tests in this patch reproduce these bugs.

The tests demonstrating Scylla's bug are marked xfail, and the tests
demonstrating Cassandra's bug is marked "cassandra_bug" (which means
it is marked xfail only when running against Cassandra, but expected
to succeed on Scylla.

Refs #7944.

Signed-off-by: Nadav Har'El <nyh@scylladb.com>
Message-Id: <20210121133833.66075-1-nyh@scylladb.com>

test/cql-pytest/conftest.py

@@ -86,5 +86,17 @@ def scylla_only(cql):
     if not any('scylla' in name for name in names):
         pytest.skip('Scylla-only test skipped')
 
+# "cassandra_bug" is similar to "scylla_only", except instead of skipping
+# the test, it is expected to fail (xfail) on Cassandra. It should be used
+# in rare cases where we consider Scylla's behavior to be the correct one,
+# and Cassandra's to be the bug.
+@pytest.fixture(scope="session")
+def cassandra_bug(cql):
+    # We recognize Scylla by checking if there is any system table whose name
+    # contains the word "scylla":
+    names = [row.table_name for row in cql.execute("SELECT * FROM system_schema.tables WHERE keyspace_name = 'system'")]
+    if not any('scylla' in name for name in names):
+        pytest.xfail('A known Cassandra bug')
+
 # TODO: use new_test_table and "yield from" to make shared test_table
 # fixtures with some common schemas.

test/cql-pytest/test_json.py

@@ -34,7 +34,7 @@ import random
 @pytest.fixture(scope="session")
 def table1(cql, test_keyspace):
     table = test_keyspace + "." + unique_name()
-    cql.execute(f"CREATE TABLE {table} (p int PRIMARY KEY, v int, a ascii, b boolean)")
+    cql.execute(f"CREATE TABLE {table} (p int PRIMARY KEY, v int, a ascii, b boolean, vi varint)")
     yield table
     cql.execute("DROP TABLE " + table)
 
@@ -111,6 +111,35 @@ def test_fromjson_int_overflow_prepared(cql, table1):
     with pytest.raises(FunctionFailure):
         cql.execute(stmt, [p, '2147483648'])
 
+# When writing to an integer column, Cassandra's fromJson() function allows
+# not just JSON number constants, it also allows a string containing a number.
+# Strings which do not hold a number fail with a FunctionFailure. In
+# particular, the empty string "" is not a valid number, and should report an
+# error, but both Scylla and Cassandra have bugs that allow it for some types
+# and not for others. The following tests reproduce #7944. Where Cassandra
+# has (what we consider to be) a bug, it is marked with "cassandra_bug"
+# which causes it to xfail when testing against Cassandra.
+def test_fromjson_int_empty_string_unprepared(cql, table1, cassandra_bug):
+    p = random.randint(1,1000000000)
+    with pytest.raises(FunctionFailure):
+        cql.execute(f"INSERT INTO {table1} (p, v) VALUES ({p}, fromJson('\"\"'))")
+def test_fromjson_int_empty_string_prepared(cql, table1, cassandra_bug):
+    p = random.randint(1,1000000000)
+    stmt = cql.prepare(f"INSERT INTO {table1} (p, v) VALUES (?, fromJson(?))")
+    with pytest.raises(FunctionFailure):
+        cql.execute(stmt, [p, '""'])
+@pytest.mark.xfail(reason="issue #7944")
+def test_fromjson_varint_empty_string_unprepared(cql, table1):
+    p = random.randint(1,1000000000)
+    with pytest.raises(FunctionFailure):
+        cql.execute(f"INSERT INTO {table1} (p, vi) VALUES ({p}, fromJson('\"\"'))")
+@pytest.mark.xfail(reason="issue #7944")
+def test_fromjson_varint_empty_string_prepared(cql, table1):
+    p = random.randint(1,1000000000)
+    stmt = cql.prepare(f"INSERT INTO {table1} (p, vi) VALUES (?, fromJson(?))")
+    with pytest.raises(FunctionFailure):
+        cql.execute(stmt, [p, '""'])
+
 # Cassandra allows the strings "true" and "false", not just the JSON constants
 # true and false, to be assigned to a boolean column. However, very strangely,
 # it only allows this for prepared statements, and *not* for unprepared