Fix ydb cli tests in parallel

Fix ydb cli tests in parallel

Pull Request resolved: #345

4 files changed, 274 insertions, 263 deletions

diff --git a/.github/config/muted_functest.txt b/.github/config/muted_functest.txt
index b0bdec5c8a4..b312f2e4dcb 100644
--- a/.github/config/muted_functest.txt
+++ b/.github/config/muted_functest.txt
@@ -13,5 +13,3 @@ ydb/tests/functional/suite_tests/test_stream_query.py::TestStreamQuery::test_sql
 ydb/tests/functional/tenants/test_dynamic_tenants.py::*
 ydb/tests/functional/tenants/test_storage_config.py::TestStorageConfig::*
 ydb/tests/functional/tenants/test_tenants.py::*
-ydb/tests/functional/ydb_cli/test_ydb_impex.py::TestImpex::*
-ydb/tests/functional/ydb_cli/test_ydb_scripting.py::TestExecuteScriptWithParamsFromStdin::test_batching_full_tsv[stream]
\ No newline at end of file
diff --git a/ydb/tests/functional/ydb_cli/test_ydb_impex.py b/ydb/tests/functional/ydb_cli/test_ydb_impex.py
index d952a5c0626..e048d501579 100644
--- a/ydb/tests/functional/ydb_cli/test_ydb_impex.py
+++ b/ydb/tests/functional/ydb_cli/test_ydb_impex.py
@@ -190,19 +190,17 @@ class TestImpex(BaseTestTableService):
     @classmethod
     def setup_class(cls):
         BaseTestTableService.setup_class()
-
         cls.session = cls.driver.table_client.session().create()
-        cls.table_path = cls.root_dir + "/impex_table"
-        create_table(cls.session, cls.table_path, "row")
 
-    def clear_table(self):
-        self.session.drop_table(self.table_path)
+    def init_test(self, tmp_path, table_type, name):
+        self.tmp_path = tmp_path
+        self.table_type = table_type
+        self.table_path = self.root_dir + "/" + name
         create_table(self.session, self.table_path, self.table_type)
 
-    @staticmethod
-    def write_array_to_files(arr, ftype):
+    def write_array_to_files(self, arr, ftype):
         for i in range(len(arr)):
-            with open("tempinput{}.{}".format(i, ftype), "w") as f:
+            with (self.tmp_path / "tempinput{}.{}".format(i, ftype)).open("w") as f:
                 f.writelines(arr[i])
 
     @staticmethod
@@ -229,118 +227,114 @@ class TestImpex(BaseTestTableService):
             return '{' + '"key": {}, "id": {}, "value":"{}"'.format(key, id, value) + '}\n'
         raise RuntimeError("Not supported format used")
 
-    @staticmethod
-    def gen_dataset(rows, files, ftype):
+    def gen_dataset(self, rows, files, ftype):
         id_set = [10, 200, 300, 400, 500, 600, 700, 800, 900, 1000, 1100, 1200]
         value_set = ["", "aaaaaaaaaa", "bbbbbbbbbb", "ccccccccc", "ddddddd", "eeeeeeeee", "fffffffff"]
         for i in range(files):
-            with open("tempinput{}.{}".format(i, ftype), "w") as f:
+            with (self.tmp_path / "tempinput{}.{}".format(i, ftype)).open("w") as f:
                 f.write(TestImpex.get_header(ftype))
                 for key in range(i * rows, (i + 1) * rows):
                     f.write(TestImpex.get_row_in_format(ftype, key, id_set[key % len(id_set)], value_set[key % len(value_set)]))
 
     def run_import(self, ftype, data, additional_args=[]):
-        self.clear_table()
-        with open("tempinput.{}".format(ftype), "w") as f:
+        path = self.tmp_path / "tempinput.{}".format(ftype)
+        with path.open("w") as f:
             f.writelines(data)
-        self.execute_ydb_cli_command(["import", "file", ftype, "-p", self.table_path, "-i", "tempinput.{}".format(ftype)] + self.get_header_flag(ftype) + additional_args)
+        self.execute_ydb_cli_command(["import", "file", ftype, "-p", self.table_path, "-i", str(path)] + self.get_header_flag(ftype) + additional_args)
 
     def run_import_from_stdin(self, ftype, data, additional_args=[]):
-        self.clear_table()
-        with open("tempinput.{}".format(ftype), "w") as f:
+        with (self.tmp_path / "tempinput.{}".format(ftype)).open("w") as f:
             f.writelines(data)
-        with open("tempinput.{}".format(ftype), "r") as f:
+        with (self.tmp_path / "tempinput.{}".format(ftype)).open("r") as f:
             self.execute_ydb_cli_command(["import", "file", ftype, "-p", self.table_path] + self.get_header_flag(ftype) + additional_args, stdin=f)
 
     def run_import_multiple_files(self, ftype, files_count, additional_args=[]):
-        self.clear_table()
         args = ["import", "file", ftype, "-p", self.table_path] + self.get_header_flag(ftype) + additional_args
         for i in range(files_count):
-            args.append("tempinput{}.{}".format(i, ftype))
+            args.append(str(self.tmp_path / "tempinput{}.{}".format(i, ftype)))
         self.execute_ydb_cli_command(args)
 
     def run_import_multiple_files_and_stdin(self, ftype, files_count, additional_args=[]):
-        self.clear_table()
         args = ["import", "file", ftype, "-p", self.table_path] + self.get_header_flag(ftype) + additional_args
         for i in range(1, files_count):
-            args.append("tempinput{}.{}".format(i, ftype))
-        with open("tempinput0.{}".format(ftype), "r") as f:
+            args.append(str(self.tmp_path / "tempinput{}.{}".format(i, ftype)))
+        with (self.tmp_path / "tempinput0.{}".format(ftype)).open("r") as f:
             self.execute_ydb_cli_command(args, stdin=f)
 
     def run_import_parquet(self, data):
-        self.clear_table()
-        with open("tempinput.parquet", "w"):
-            pq.write_table(data, "tempinput.parquet", version="2.4")
-        self.execute_ydb_cli_command(["import", "file", "parquet", "-p", self.table_path, "-i", "tempinput.parquet"])
+        path = self.tmp_path / "tempinput.parquet"
+        with path.open("w"):
+            pq.write_table(data, str(path), version="2.4")
+        self.execute_ydb_cli_command(["import", "file", "parquet", "-p", self.table_path, "-i", str(path)])
 
     def run_export(self, format):
         if format == "json":
             format = "json-unicode"
         query = "SELECT `key`, `id`, `value` FROM `{}` ORDER BY `key`".format(self.table_path)
-        output_file_name = "result.output"
+        output_file_name = str(self.tmp_path / "result.output")
         self.execute_ydb_cli_command(["table", "query", "execute", "-q", query, "-t", "scan", "--format", format], stdout=output_file_name)
         return yatest_common.canonical_file(output_file_name, local=True, universal_lines=True)
 
     def validate_gen_data(self):
         query = "SELECT count(*) FROM `{}`".format(self.table_path)
-        output_file_name = "result.output"
+        output_file_name = str(self.tmp_path / "result.output")
         self.execute_ydb_cli_command(["table", "query", "execute", "-q", query, "-t", "scan"], stdout=output_file_name)
         return yatest_common.canonical_file(output_file_name, local=True, universal_lines=True)
 
     @pytest.mark.parametrize("ftype,additional_args", ALL_PARAMS)
-    def test_simple(self, table_type, ftype, additional_args):
-        self.table_type = table_type
+    def test_simple(self, tmp_path, request, table_type, ftype, additional_args):
+        self.init_test(tmp_path, table_type, request.node.name)
         self.run_import(ftype, DATA[ftype], additional_args)
         return self.run_export(ftype)
 
     @pytest.mark.parametrize("ftype,additional_args", ONLY_CSV_TSV_PARAMS)
-    def test_delimeter_at_end_of_lines(self, table_type, ftype, additional_args):
-        self.table_type = table_type
+    def test_delimeter_at_end_of_lines(self, tmp_path, request, table_type, ftype, additional_args):
+        self.init_test(tmp_path, table_type, request.node.name)
         self.run_import(ftype, DATA_END_LINES[ftype], additional_args)
         return self.run_export(ftype)
 
     @pytest.mark.parametrize("ftype,additional_args", ALL_PARAMS)
-    def test_excess_columns(self, table_type, ftype, additional_args):
-        self.table_type = table_type
+    def test_excess_columns(self, tmp_path, request, table_type, ftype, additional_args):
+        self.init_test(tmp_path, table_type, request.node.name)
         self.run_import(ftype, DATA_EXCESS[ftype], additional_args)
         return self.run_export(ftype)
 
     @pytest.mark.parametrize("ftype,additional_args", ALL_PARAMS)
-    def test_stdin(self, table_type, ftype, additional_args):
-        self.table_type = table_type
+    def test_stdin(self, tmp_path, request, table_type, ftype, additional_args):
+        self.init_test(tmp_path, table_type, request.node.name)
         self.run_import_from_stdin(ftype, DATA[ftype], additional_args)
         return self.run_export(ftype)
 
     @pytest.mark.parametrize("ftype,additional_args", ALL_PARAMS)
-    def test_multiple_files(self, table_type, ftype, additional_args):
-        self.table_type = table_type
+    def test_multiple_files(self, tmp_path, request, table_type, ftype, additional_args):
+        self.init_test(tmp_path, table_type, request.node.name)
         self.write_array_to_files(DATA_ARRAY[ftype], ftype)
         self.run_import_multiple_files(ftype, len(DATA_ARRAY[ftype]), additional_args)
         return self.run_export(ftype)
 
     @pytest.mark.parametrize("ftype,additional_args", ALL_PARAMS)
-    def test_multiple_files_and_stdin(self, table_type, ftype, additional_args):
-        self.table_type = table_type
+    def test_multiple_files_and_stdin(self, tmp_path, request, table_type, ftype, additional_args):
+        self.init_test(tmp_path, table_type, request.node.name)
         self.write_array_to_files(DATA_ARRAY[ftype], ftype)
         self.run_import_multiple_files(ftype, len(DATA_ARRAY[ftype]), additional_args)
         return self.run_export(ftype)
 
     @pytest.mark.parametrize("ftype,additional_args", ONLY_CSV_TSV_PARAMS)
-    def test_multiple_files_and_columns_opt(self, table_type, ftype, additional_args):
-        self.table_type = table_type
+    def test_multiple_files_and_columns_opt(self, tmp_path, request, table_type, ftype, additional_args):
+        self.init_test(tmp_path, table_type, request.node.name)
         self.write_array_to_files(DATA_ARRAY_BAD_HEADER[ftype], ftype)
         self.run_import_multiple_files(ftype, len(DATA_ARRAY_BAD_HEADER[ftype]), ["--columns", self.get_header(ftype)] + additional_args)
         return self.run_export(ftype)
 
     @pytest.mark.parametrize("ftype,additional_args", ALL_PARAMS)
-    def test_big_dataset(self, table_type, ftype, additional_args):
-        self.table_type = table_type
+    def test_big_dataset(self, tmp_path, request, table_type, ftype, additional_args):
+        self.init_test(tmp_path, table_type, request.node.name)
         self.gen_dataset(DATASET_SIZE, FILES_COUNT, ftype)
         self.run_import_multiple_files(ftype, FILES_COUNT, additional_args)
         return self.validate_gen_data()
 
     @pytest.mark.skip("test is failing right now")
-    def test_format_parquet(self, table_type):
-        self.table_type = table_type
+    def test_format_parquet(self, tmp_path, request, table_type):
+        self.init_test(tmp_path, table_type, request.node.name)
         self.run_import_parquet(DATA_PARQUET)
         return self.run_export("csv")
diff --git a/ydb/tests/functional/ydb_cli/test_ydb_scripting.py b/ydb/tests/functional/ydb_cli/test_ydb_scripting.py
index 60984a439a8..d9c1efcee55 100644
--- a/ydb/tests/functional/ydb_cli/test_ydb_scripting.py
+++ b/ydb/tests/functional/ydb_cli/test_ydb_scripting.py
@@ -56,11 +56,10 @@ class BaseTestScriptingService(object):
         return result
 
     @staticmethod
-    def canonical_result(output_result):
-        output_file_name = "result.output"
-        with open(output_file_name, "w") as f:
+    def canonical_result(output_result, tmp_path):
+        with (tmp_path / "result.output").open("w") as f:
             f.write(output_result.decode('utf-8'))
-        return yatest_common.canonical_file(output_file_name, local=True, universal_lines=True)
+        return yatest_common.canonical_file(str(tmp_path / "result.output"), local=True, universal_lines=True)
 
 
 class BaseTestScriptingServiceWithDatabase(BaseTestScriptingService):
@@ -96,15 +95,18 @@ class TestExecuteScriptWithParams(BaseTestScriptingServiceWithDatabase):
     @classmethod
     def setup_class(cls):
         BaseTestScriptingServiceWithDatabase.setup_class()
+        cls.session = cls.driver.table_client.session().create()
 
-        session = cls.driver.table_client.session().create()
-        cls.table_path = cls.root_dir + "/scripting_params"
-        create_table_with_data(session, cls.table_path)
+    @pytest.fixture(autouse=True, scope='function')
+    def init_test(self, tmp_path):
+        self.tmp_path = tmp_path
+        self.table_path = self.root_dir + "/" + self.tmp_path.name
+        create_table_with_data(self.session, self.table_path)
 
     def test_uint32(self):
         script = "DECLARE $par1 AS Uint32; SELECT * FROM `{}` WHERE key = $par1;".format(self.table_path)
         output = self.execute_ydb_cli_command_with_db(["scripting", "yql", "-s", script, "--param", "$par1=1"])
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def test_uint64_and_string(self):
         script = "DECLARE $id AS Uint64; "\
@@ -114,12 +116,12 @@ class TestExecuteScriptWithParams(BaseTestScriptingServiceWithDatabase):
             ["scripting", "yql", "-s", script, "--param", "$id=2222",
              "--param", "$value=\"seven\""]
         )
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def test_list(self):
         script = "DECLARE $values AS List<Uint64?>; SELECT $values AS values;"
         output = self.execute_ydb_cli_command_with_db(["scripting", "yql", "-s", script, "--param", "$values=[1,2,3]"])
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def test_struct(self):
         script = "DECLARE $values AS List<Struct<key:Uint64, value:Utf8>>; "\
@@ -131,41 +133,44 @@ class TestExecuteScriptWithParams(BaseTestScriptingServiceWithDatabase):
             ["scripting", "yql", "-s", script, "--param",
              "$values=[{\"key\":1,\"value\":\"one\"},{\"key\":2,\"value\":\"two\"}]"]
         )
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
 
 class TestScriptingServiceHelp(BaseTestScriptingService):
-    def test_help(self):
+    def test_help(self, tmp_path):
         output = self.execute_ydb_cli_command(["scripting", "yql", "--help"])
-        return self.canonical_result(output)
+        return self.canonical_result(output, tmp_path)
 
-    def test_help_ex(self):
+    def test_help_ex(self, tmp_path):
         output = self.execute_ydb_cli_command(["scripting", "yql", "--help-ex"])
-        return self.canonical_result(output)
+        return self.canonical_result(output, tmp_path)
 
 
 class TestExecuteScriptWithFormats(BaseTestScriptingServiceWithDatabase):
     @classmethod
     def setup_class(cls):
         BaseTestScriptingServiceWithDatabase.setup_class()
+        cls.session = cls.driver.table_client.session().create()
 
-        session = cls.driver.table_client.session().create()
-        cls.table_path = cls.root_dir + "/scripting_formats"
-        create_table_with_data(session, cls.table_path)
+    @pytest.fixture(autouse=True, scope='function')
+    def init_test(self, tmp_path):
+        self.tmp_path = tmp_path
+        self.table_path = self.root_dir + "/" + self.tmp_path.name
+        create_table_with_data(self.session, self.table_path)
 
     def yql_script(self, format):
         script = "SELECT * FROM `{path}` WHERE key < 4;" \
             "SELECT id FROM `{path}` WHERE key = 4;" \
             "SELECT value FROM `{path}` WHERE key > 5".format(path=self.table_path)
         output = self.execute_ydb_cli_command_with_db(["scripting", "yql", "-s", script, "--format", format])
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def stream_yql_script(self, format):
         script = "SELECT * FROM `{path}` WHERE key < 4;" \
             "SELECT id FROM `{path}` WHERE key = 4;" \
             "SELECT value FROM `{path}` WHERE key > 5".format(path=self.table_path)
         output = self.execute_ydb_cli_command_with_db(["yql", "-s", script, "--format", format])
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     # YqlScript
 
@@ -206,13 +211,16 @@ class TestExecuteScriptWithParamsFromJson(BaseTestScriptingServiceWithDatabase):
     @classmethod
     def setup_class(cls):
         BaseTestScriptingServiceWithDatabase.setup_class()
+        cls.session = cls.driver.table_client.session().create()
 
-        session = cls.driver.table_client.session().create()
-        cls.table_path = cls.root_dir + "/scripting_params_from_json"
-        create_table_with_data(session, cls.table_path)
+    @pytest.fixture(autouse=True, scope='function')
+    def init_test(self, tmp_path):
+        self.tmp_path = tmp_path
+        self.table_path = self.root_dir + "/" + self.tmp_path.name
+        create_table_with_data(self.session, self.table_path)
 
     @staticmethod
-    def write_data(data, filename="params.json"):
+    def write_data(data, filename):
         with open(filename, "w") as file:
             file.write(data)
 
@@ -221,9 +229,9 @@ class TestExecuteScriptWithParamsFromJson(BaseTestScriptingServiceWithDatabase):
             '   "par1": 1\n' \
             '}'
         script = "DECLARE $par1 AS Uint32; SELECT * FROM `{}` WHERE key = $par1;".format(self.table_path)
-        self.write_data(param_data)
-        output = self.execute_ydb_cli_command_with_db(command + ["--param-file", "params.json", "-s", script])
-        return self.canonical_result(output)
+        self.write_data(param_data, str(self.tmp_path / "params.json"))
+        output = self.execute_ydb_cli_command_with_db(command + ["--param-file", str(self.tmp_path / "params.json"), "-s", script])
+        return self.canonical_result(output, self.tmp_path)
 
     def uint64_and_string(self, command):
         param_data = '{\n' \
@@ -233,18 +241,18 @@ class TestExecuteScriptWithParamsFromJson(BaseTestScriptingServiceWithDatabase):
         script = "DECLARE $id AS Uint64; "\
                  "DECLARE $value AS String; "\
                  "SELECT * FROM `{}` WHERE id = $id OR value = $value;".format(self.table_path)
-        self.write_data(param_data)
-        output = self.execute_ydb_cli_command_with_db(command + ["--param-file", "params.json", "-s", script])
-        return self.canonical_result(output)
+        self.write_data(param_data, str(self.tmp_path / "params.json"))
+        output = self.execute_ydb_cli_command_with_db(command + ["--param-file", str(self.tmp_path / "params.json"), "-s", script])
+        return self.canonical_result(output, self.tmp_path)
 
     def list(self, command):
         param_data = '{\n' \
             '   "values": [1, 2, 3]\n' \
             '}'
         script = "DECLARE $values AS List<Uint64?>; SELECT $values AS values;"
-        self.write_data(param_data)
-        output = self.execute_ydb_cli_command_with_db(command + ["--param-file", "params.json", "-s", script])
-        return self.canonical_result(output)
+        self.write_data(param_data, str(self.tmp_path / "params.json"))
+        output = self.execute_ydb_cli_command_with_db(command + ["--param-file", str(self.tmp_path / "params.json"), "-s", script])
+        return self.canonical_result(output, self.tmp_path)
 
     def struct(self, command):
         param_data = '{\n' \
@@ -264,9 +272,9 @@ class TestExecuteScriptWithParamsFromJson(BaseTestScriptingServiceWithDatabase):
                  "Table.key AS key, "\
                  "Table.value AS value "\
                  "FROM (SELECT $values AS lst) FLATTEN BY lst AS Table;"
-        self.write_data(param_data)
-        output = self.execute_ydb_cli_command_with_db(command + ["--param-file", "params.json", "-s", script])
-        return self.canonical_result(output)
+        self.write_data(param_data, str(self.tmp_path / "params.json"))
+        output = self.execute_ydb_cli_command_with_db(command + ["--param-file", str(self.tmp_path / "params.json"), "-s", script])
+        return self.canonical_result(output, self.tmp_path)
 
     def multiple_files(self, command):
         param_data1 = '{\n' \
@@ -282,13 +290,14 @@ class TestExecuteScriptWithParamsFromJson(BaseTestScriptingServiceWithDatabase):
                  "DECLARE $num AS Uint64; "\
                  "DECLARE $date AS Date; "\
                  "SELECT $str AS str, $num as num, $date as date; "
-        self.write_data(param_data1, "param1.json")
-        self.write_data(param_data2, "param2.json")
-        self.write_data(param_data3, "param3.json")
+        self.write_data(param_data1, str(self.tmp_path / "param1.json"))
+        self.write_data(param_data2, str(self.tmp_path / "param2.json"))
+        self.write_data(param_data3, str(self.tmp_path / "param3.json"))
         output = self.execute_ydb_cli_command_with_db(
-            command + ["--param-file", "param1.json", "--param-file", "param2.json", "--param-file", "param3.json", "-s", script]
+            command + ["--param-file", str(self.tmp_path / "param1.json"), "--param-file", str(self.tmp_path / "param2.json"),
+                       "--param-file", str(self.tmp_path / "param3.json"), "-s", script]
         )
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def ignore_excess_parameters(self, command):
         param_data = '{\n' \
@@ -297,20 +306,20 @@ class TestExecuteScriptWithParamsFromJson(BaseTestScriptingServiceWithDatabase):
             '}'
         script = "DECLARE $a AS Uint64; " \
                  "SELECT $a AS a; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "params.json"))
         output = self.execute_ydb_cli_command_with_db(
-            command + ["-s", script, "--param-file", "params.json"]
+            command + ["-s", script, "--param-file", str(self.tmp_path / "params.json")]
         )
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def script_from_file(self, command):
         script = "DECLARE $a AS Uint64; " \
                  "SELECT $a AS a; "
-        self.write_data(script, "script.yql")
+        self.write_data(script, str(self.tmp_path / "script.yql"))
         output = self.execute_ydb_cli_command_with_db(
-            command + ["-f", "script.yql", "--param", "$a=3"]
+            command + ["-f", str(self.tmp_path / "script.yql"), "--param", "$a=3"]
         )
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def test_uint32(self):
         return self.uint32(["scripting", "yql"])
@@ -360,13 +369,16 @@ class TestExecuteScriptWithParamsFromStdin(BaseTestScriptingServiceWithDatabase)
     @classmethod
     def setup_class(cls):
         BaseTestScriptingServiceWithDatabase.setup_class()
+        cls.session = cls.driver.table_client.session().create()
 
-        session = cls.driver.table_client.session().create()
-        cls.table_path = cls.root_dir + "/scripting_params_from_stdin"
-        create_table_with_data(session, cls.table_path)
+    @pytest.fixture(autouse=True, scope='function')
+    def init_test(self, tmp_path):
+        self.tmp_path = tmp_path
+        self.table_path = self.root_dir + "/" + self.tmp_path.name
+        create_table_with_data(self.session, self.table_path)
 
     @staticmethod
-    def write_data(data, filename="stdin.txt"):
+    def write_data(data, filename):
         with open(filename, "w") as file:
             file.write(data)
 
@@ -386,14 +398,12 @@ class TestExecuteScriptWithParamsFromStdin(BaseTestScriptingServiceWithDatabase)
             return ["yql"]
         raise RuntimeError("Unknown command name: {}".format(name))
 
-    @classmethod
-    def get_stdin(cls):
-        cls.stdin = open("stdin.txt", "r")
-        return cls.stdin
+    def get_stdin(self):
+        self.stdin = (self.tmp_path / "stdin.txt").open("r")
+        return self.stdin
 
-    @classmethod
-    def close_stdin(cls):
-        cls.stdin.close()
+    def close_stdin(self):
+        self.stdin.close()
 
     def simple_json(self, command):
         param_data = '{\n' \
@@ -403,10 +413,10 @@ class TestExecuteScriptWithParamsFromStdin(BaseTestScriptingServiceWithDatabase)
         script = "DECLARE $s AS Utf8; " \
                  "DECLARE $val AS Uint64; " \
                  "SELECT $s AS s, $val AS val; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command_with_db(command + ["-s", script], self.get_stdin())
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def simple_csv_tsv(self, command, format):
         param_data = 's{0}val\n' \
@@ -415,10 +425,10 @@ class TestExecuteScriptWithParamsFromStdin(BaseTestScriptingServiceWithDatabase)
         script = "DECLARE $s AS Utf8; " \
                  "DECLARE $val AS Uint64; " \
                  "SELECT $s AS s, $val AS val; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command_with_db(command + ["-s", script, "--stdin-format", format], self.get_stdin())
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def stdin_par_raw(self, command):
         param_data = 'Line1\n' \
@@ -426,19 +436,19 @@ class TestExecuteScriptWithParamsFromStdin(BaseTestScriptingServiceWithDatabase)
             'Line3\n'
         script = "DECLARE $s AS Utf8; " \
                  "SELECT $s AS s; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command_with_db(command + ["-s", script, "--stdin-format", "raw", "--stdin-par", "s"], self.get_stdin())
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def stdin_par_json(self, command):
         param_data = "[1, 2, 3, 4]"
         script = "DECLARE $arr AS List<Uint64>; " \
                  "SELECT $arr AS arr; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command_with_db(command + ["-s", script, "--stdin-par", "arr"], self.get_stdin())
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def stdin_par_csv_tsv(self, command, format):
         param_data = 'id{0}value\n' \
@@ -446,10 +456,10 @@ class TestExecuteScriptWithParamsFromStdin(BaseTestScriptingServiceWithDatabase)
         param_data = param_data.format(self.get_delim(format))
         script = "DECLARE $s AS Struct<id:UInt64,value:Utf8>; " \
                  "SELECT $s AS s; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command_with_db(command + ["-s", script, "--stdin-format", format, "--stdin-par", "s"], self.get_stdin())
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def mix_json_and_binary(self, command):
         param_data1 = 'Строка номер 1\n' \
@@ -463,12 +473,12 @@ class TestExecuteScriptWithParamsFromStdin(BaseTestScriptingServiceWithDatabase)
                  "DECLARE $date AS Date; " \
                  "DECLARE $val AS Uint64; " \
                  "SELECT $s AS s, $date AS date, $val AS val; "
-        self.write_data(param_data1)
-        self.write_data(param_data2, "params.json")
-        output = self.execute_ydb_cli_command_with_db(command + ["-s", script, "--stdin-par", "s", "--stdin-format", "raw", "--param-file", "params.json"],
+        self.write_data(param_data1, str(self.tmp_path / "stdin.txt"))
+        self.write_data(param_data2, str(self.tmp_path / "params.json"))
+        output = self.execute_ydb_cli_command_with_db(command + ["-s", script, "--stdin-par", "s", "--stdin-format", "raw", "--param-file", str(self.tmp_path / "params.json")],
                                                       self.get_stdin())
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def different_sources_json(self, command):
         param_data1 = '{\n' \
@@ -481,11 +491,11 @@ class TestExecuteScriptWithParamsFromStdin(BaseTestScriptingServiceWithDatabase)
                  "DECLARE $date AS Date; " \
                  "DECLARE $val AS Uint64; " \
                  "SELECT $s AS s, $date AS date, $val AS val; "
-        self.write_data(param_data1)
-        self.write_data(param_data2, "params.json")
-        output = self.execute_ydb_cli_command_with_db(command + ["-s", script, "--param-file", "params.json", "--param", "$val=100"], self.get_stdin())
+        self.write_data(param_data1, str(self.tmp_path / "stdin.txt"))
+        self.write_data(param_data2, str(self.tmp_path / "params.json"))
+        output = self.execute_ydb_cli_command_with_db(command + ["-s", script, "--param-file", str(self.tmp_path / "params.json"), "--param", "$val=100"], self.get_stdin())
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def different_sources_csv_tsv(self, command, format):
         param_data1 = 's\n' \
@@ -498,12 +508,12 @@ class TestExecuteScriptWithParamsFromStdin(BaseTestScriptingServiceWithDatabase)
                  "DECLARE $date AS Date; " \
                  "DECLARE $val AS Uint64; " \
                  "SELECT $s AS s, $date AS date, $val AS val; "
-        self.write_data(param_data1)
-        self.write_data(param_data2, "params.json")
-        output = self.execute_ydb_cli_command_with_db(command + ["-s", script, "--stdin-format", format, "--param-file", "params.json", "--param", "$val=100"],
+        self.write_data(param_data1, str(self.tmp_path / "stdin.txt"))
+        self.write_data(param_data2, str(self.tmp_path / "params.json"))
+        output = self.execute_ydb_cli_command_with_db(command + ["-s", script, "--stdin-format", format, "--param-file", str(self.tmp_path / "params.json"), "--param", "$val=100"],
                                                       self.get_stdin())
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def framing_newline_delimited_json(self, command):
         param_data = '{"s": "Some text", "num": 1}\n' \
@@ -512,10 +522,10 @@ class TestExecuteScriptWithParamsFromStdin(BaseTestScriptingServiceWithDatabase)
         script = "DECLARE $s AS Utf8; " \
                  "DECLARE $num AS Uint64; " \
                  "SELECT $s AS s, $num AS num; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command_with_db(command + ["-s", script, "--stdin-format", "newline-delimited"], self.get_stdin())
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def framing_newline_delimited_csv_tsv(self, command, format):
         param_data = 's{0}num\n' \
@@ -526,11 +536,11 @@ class TestExecuteScriptWithParamsFromStdin(BaseTestScriptingServiceWithDatabase)
         script = "DECLARE $s AS Utf8; " \
                  "DECLARE $num AS Uint64; " \
                  "SELECT $s AS s, $num AS num; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command_with_db(command + ["-s", script, "--stdin-format", format, "--stdin-format", "newline-delimited"],
                                                       self.get_stdin())
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def framing_newline_delimited_raw(self, command):
         param_data = 'Line1\n' \
@@ -538,13 +548,13 @@ class TestExecuteScriptWithParamsFromStdin(BaseTestScriptingServiceWithDatabase)
             'Line3\n'
         script = "DECLARE $s AS Utf8; " \
                  "SELECT $s AS s; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command_with_db(
             command + ["-s", script, "--stdin-format", "raw", "--stdin-par", "s", "--stdin-format", "newline-delimited"],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def batching_full_raw(self, command):
         param_data = 'Line1\n' \
@@ -552,13 +562,13 @@ class TestExecuteScriptWithParamsFromStdin(BaseTestScriptingServiceWithDatabase)
             'Line3\n'
         script = "DECLARE $s AS List<Utf8>; " \
                  "SELECT $s AS s; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command_with_db(
             command + ["-s", script, "--stdin-format", "raw", "--stdin-par", "s", "--stdin-format", "newline-delimited", "--batch", "full"],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def batching_full_json(self, command):
         param_data = '{"s": "Line1", "id": 1}\n' \
@@ -572,13 +582,13 @@ class TestExecuteScriptWithParamsFromStdin(BaseTestScriptingServiceWithDatabase)
             '{"s": "Line9", "id": 9}\n'
         script = "DECLARE $arr as List<Struct<s:Utf8, id:Uint64>>; " \
                  "SELECT $arr as arr; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command_with_db(
             command + ["-s", script, "--stdin-par", "arr", "--stdin-format", "newline-delimited", "--batch", "full"],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def batching_full_csv_tsv(self, command, format):
         param_data = 's{0}id\n' \
@@ -594,13 +604,13 @@ class TestExecuteScriptWithParamsFromStdin(BaseTestScriptingServiceWithDatabase)
         param_data = param_data.format(self.get_delim(format))
         script = "DECLARE $arr as List<Struct<s:Utf8, id:Uint64>>; " \
                  "SELECT $arr as arr; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command_with_db(
             command + ["-s", script, "--stdin-format", format, "--stdin-par", "arr", "--stdin-format", "newline-delimited", "--batch", "full"],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def batching_adaptive_raw(self, command):
         param_data = 'Line1\n' \
@@ -614,13 +624,13 @@ class TestExecuteScriptWithParamsFromStdin(BaseTestScriptingServiceWithDatabase)
             'Line9\n'
         script = "DECLARE $s AS List<Utf8>; " \
                  "SELECT $s AS s; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command_with_db(
             command + ["-s", script, "--stdin-format", "raw", "--stdin-par", "s", "--stdin-format", "newline-delimited", "--batch", "adaptive", "--batch-max-delay", "0", "--batch-limit", "3"],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def batching_adaptive_json(self, command):
         param_data = '{"s": "Line1", "id": 1}\n' \
@@ -634,14 +644,14 @@ class TestExecuteScriptWithParamsFromStdin(BaseTestScriptingServiceWithDatabase)
             '{"s": "Line9", "id": 9}\n'
         script = "DECLARE $arr as List<Struct<s:Utf8, id:Uint64>>; " \
                  "SELECT $arr as arr; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command_with_db(
             command + ["-s", script, "--stdin-par", "arr", "--stdin-format", "newline-delimited",
                        "--batch", "adaptive", "--batch-max-delay", "0", "--batch-limit", "3"],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def batching_adaptive_csv_tsv(self, command, format):
         param_data = 's{0}id\n' \
@@ -657,14 +667,14 @@ class TestExecuteScriptWithParamsFromStdin(BaseTestScriptingServiceWithDatabase)
         param_data = param_data.format(self.get_delim(format))
         script = "DECLARE $arr as List<Struct<s:Utf8, id:Uint64>>; " \
                  "SELECT $arr as arr; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command_with_db(
             command + ["-s", script, "--stdin-format", format, "--stdin-par", "arr", "--stdin-format", "newline-delimited",
                                      "--batch", "adaptive", "--batch-max-delay", "0", "--batch-limit", "3"],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def ignore_excess_parameters_json(self, command):
         param_data = '{\n' \
@@ -673,10 +683,10 @@ class TestExecuteScriptWithParamsFromStdin(BaseTestScriptingServiceWithDatabase)
             '}'
         script = "DECLARE $a AS Uint64; " \
                  "SELECT $a AS a; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command_with_db(command + ["-s", script], self.get_stdin())
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def ignore_excess_parameters_csv_tsv(self, command, format):
         param_data = 'a{0}b\n' \
@@ -685,10 +695,10 @@ class TestExecuteScriptWithParamsFromStdin(BaseTestScriptingServiceWithDatabase)
         print(param_data)
         script = "DECLARE $a AS Uint64; " \
                  "SELECT $a AS a; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command_with_db(command + ["-s", script, "--stdin-format", format], self.get_stdin())
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def columns_bad_header(self, command, format):
         param_data = 'x{0}y\n' \
@@ -699,14 +709,14 @@ class TestExecuteScriptWithParamsFromStdin(BaseTestScriptingServiceWithDatabase)
         script = "DECLARE $a AS Uint64; " \
                  "DECLARE $b AS Uint64; " \
                  "SELECT $a AS a, $b AS b; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command_with_db(
             command + ["-s", script, "--stdin-format", format, "--stdin-format", "newline-delimited",
                        "--columns", "a{0}b".format(self.get_delim(format)), "--skip-rows", "1"],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def columns_no_header(self, command, format):
         param_data = '1{0}1\n' \
@@ -716,14 +726,14 @@ class TestExecuteScriptWithParamsFromStdin(BaseTestScriptingServiceWithDatabase)
         script = "DECLARE $a AS Uint64; " \
                  "DECLARE $b AS Uint64; " \
                  "SELECT $a AS a, $b AS b; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command_with_db(
             command + ["-s", script, "--stdin-format", format, "--stdin-format", "newline-delimited",
                        "--columns", "a{0}b".format(self.get_delim(format))],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def skip_rows(self, command, format):
         param_data = 'a{0}b\n' \
@@ -737,12 +747,12 @@ class TestExecuteScriptWithParamsFromStdin(BaseTestScriptingServiceWithDatabase)
         script = "DECLARE $a AS Uint64; " \
                  "DECLARE $b AS Uint64; " \
                  "SELECT $a AS a, $b AS b; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command_with_db(
             command + ["-s", script, "--stdin-format", format, "--stdin-format", "newline-delimited", "--skip-rows", "3"], self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def test_simple_json(self, command):
         return self.simple_json(self.get_command(command))
diff --git a/ydb/tests/functional/ydb_cli/test_ydb_table.py b/ydb/tests/functional/ydb_cli/test_ydb_table.py
index 442b12ff083..0987c720125 100644
--- a/ydb/tests/functional/ydb_cli/test_ydb_table.py
+++ b/ydb/tests/functional/ydb_cli/test_ydb_table.py
@@ -82,11 +82,10 @@ class BaseTestTableService(object):
         return result
 
     @staticmethod
-    def canonical_result(output_result):
-        output_file_name = "result.output"
-        with open(output_file_name, "w") as f:
+    def canonical_result(output_result, tmp_path):
+        with (tmp_path / "result.output").open("w") as f:
             f.write(output_result.decode('utf-8'))
-        return yatest_common.canonical_file(output_file_name, local=True, universal_lines=True)
+        return yatest_common.canonical_file(str(tmp_path / "result.output"), local=True, universal_lines=True)
 
 
 class TestExecuteQueryWithParams(BaseTestTableService):
@@ -94,15 +93,18 @@ class TestExecuteQueryWithParams(BaseTestTableService):
     @classmethod
     def setup_class(cls):
         BaseTestTableService.setup_class()
+        cls.session = cls.driver.table_client.session().create()
 
-        session = cls.driver.table_client.session().create()
-        cls.table_path = cls.root_dir + "/table_params"
-        create_table_with_data(session, cls.table_path)
+    @pytest.fixture(autouse=True, scope='function')
+    def init_test(self, tmp_path):
+        self.tmp_path = tmp_path
+        self.table_path = self.root_dir + "/" + self.tmp_path.name
+        create_table_with_data(self.session, self.table_path)
 
     def test_uint32(self):
         query = "DECLARE $par1 AS Uint32; SELECT * FROM `{}` WHERE key = $par1;".format(self.table_path)
         output = self.execute_ydb_cli_command(["table", "query", "execute", "-q", query, "--param", "$par1=1"])
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def test_uint64_and_string(self):
         query = "DECLARE $id AS Uint64; "\
@@ -110,12 +112,12 @@ class TestExecuteQueryWithParams(BaseTestTableService):
                 "SELECT * FROM `{}` WHERE id = $id OR value = $value;".format(self.table_path)
         output = self.execute_ydb_cli_command(["table", "query", "execute", "-q", query, "--param", "$id=2222",
                                                "--param", "$value=\"seven\""])
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def test_list(self):
         query = "DECLARE $values AS List<Uint64?>; SELECT $values AS values;"
         output = self.execute_ydb_cli_command(["table", "query", "execute", "-q", query, "--param", "$values=[1,2,3]"])
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def test_struct(self):
         query = "DECLARE $values AS List<Struct<key:Uint64, value:Utf8>>; "\
@@ -125,7 +127,7 @@ class TestExecuteQueryWithParams(BaseTestTableService):
                 "FROM (SELECT $values AS lst) FLATTEN BY lst AS Table;"
         output = self.execute_ydb_cli_command(["table", "query", "execute", "-q", query, "--param",
                                                "$values=[{\"key\":1,\"value\":\"one\"},{\"key\":2,\"value\":\"two\"}]"])
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def test_scan_query_with_parameters(self):
         query = "DECLARE $id AS Uint64; "\
@@ -134,7 +136,7 @@ class TestExecuteQueryWithParams(BaseTestTableService):
         output = self.execute_ydb_cli_command(["table", "query", "execute", "-t", "scan", "-q", query,
                                                "--param", "$id=2222",
                                                "--param", "$value=\"seven\""])
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
 
 class TestExecuteQueryWithFormats(BaseTestTableService):
@@ -142,26 +144,29 @@ class TestExecuteQueryWithFormats(BaseTestTableService):
     @classmethod
     def setup_class(cls):
         BaseTestTableService.setup_class()
+        cls.session = cls.driver.table_client.session().create()
 
-        session = cls.driver.table_client.session().create()
-        cls.table_path = cls.root_dir + "/table_formats"
-        create_table_with_data(session, cls.table_path)
+    @pytest.fixture(autouse=True, scope='function')
+    def init_test(self, tmp_path):
+        self.tmp_path = tmp_path
+        self.table_path = self.root_dir + "/" + self.tmp_path.name
+        create_table_with_data(self.session, self.table_path)
 
     def execute_data_query(self, format):
         query = "SELECT * FROM `{}` WHERE key < 4;".format(self.table_path)
         output = self.execute_ydb_cli_command(["table", "query", "execute", "-t", "data", "-q", query,
                                                "--format", format])
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def execute_scan_query(self, format):
         query = "SELECT * FROM `{}` WHERE key < 4;".format(self.table_path)
         output = self.execute_ydb_cli_command(["table", "query", "execute", "-t", "scan", "-q", query,
                                                "--format", format])
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def execute_read_table(self, format):
         output = self.execute_ydb_cli_command(["table", "readtable", self.table_path, "--format", format])
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     # DataQuery
 
@@ -238,13 +243,16 @@ class TestExecuteQueryWithParamsFromJson(BaseTestTableService):
     @classmethod
     def setup_class(cls):
         BaseTestTableService.setup_class()
+        cls.session = cls.driver.table_client.session().create()
 
-        session = cls.driver.table_client.session().create()
-        cls.table_path = cls.root_dir + "/table_params_from_json"
-        create_table_with_data(session, cls.table_path)
+    @pytest.fixture(autouse=True, scope='function')
+    def init_test(self, tmp_path):
+        self.tmp_path = tmp_path
+        self.table_path = self.root_dir + "/" + self.tmp_path.name
+        create_table_with_data(self.session, self.table_path)
 
     @staticmethod
-    def write_data(data, filename="params.json"):
+    def write_data(data, filename):
         with open(filename, "w") as file:
             file.write(data)
 
@@ -253,11 +261,11 @@ class TestExecuteQueryWithParamsFromJson(BaseTestTableService):
             '   "par1": 1\n' \
             '}'
         query = "DECLARE $par1 AS Uint32; SELECT * FROM `{}` WHERE key = $par1;".format(self.table_path)
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "params.json"))
         output = self.execute_ydb_cli_command(
-            ["table", "query", "execute", "-t", query_type, "--param-file", "params.json", "-q", query]
+            ["table", "query", "execute", "-t", query_type, "--param-file", str(self.tmp_path / "params.json"), "-q", query]
         )
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def uint64_and_string(self, query_type):
         param_data = '{\n' \
@@ -267,22 +275,22 @@ class TestExecuteQueryWithParamsFromJson(BaseTestTableService):
         query = "DECLARE $id AS Uint64; "\
                 "DECLARE $value AS String; "\
                 "SELECT * FROM `{}` WHERE id = $id OR value = $value;".format(self.table_path)
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "params.json"))
         output = self.execute_ydb_cli_command(
-            ["table", "query", "execute", "-t", query_type, "--param-file", "params.json", "-q", query]
+            ["table", "query", "execute", "-t", query_type, "--param-file", str(self.tmp_path / "params.json"), "-q", query]
         )
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def list(self, query_type):
         param_data = '{\n' \
             '   "values": [1, 2, 3]\n' \
             '}'
         query = "DECLARE $values AS List<Uint64?>; SELECT $values AS values;"
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "params.json"))
         output = self.execute_ydb_cli_command(
-            ["table", "query", "execute", "-t", query_type, "--param-file", "params.json", "-q", query]
+            ["table", "query", "execute", "-t", query_type, "--param-file", str(self.tmp_path / "params.json"), "-q", query]
         )
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def struct(self, query_type):
         param_data = '{\n' \
@@ -302,11 +310,11 @@ class TestExecuteQueryWithParamsFromJson(BaseTestTableService):
                 "Table.key AS key, "\
                 "Table.value AS value "\
                 "FROM (SELECT $values AS lst) FLATTEN BY lst AS Table;"
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "params.json"))
         output = self.execute_ydb_cli_command(
-            ["table", "query", "execute", "-t", query_type, "--param-file", "params.json", "-q", query]
+            ["table", "query", "execute", "-t", query_type, "--param-file", str(self.tmp_path / "params.json"), "-q", query]
         )
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def multiple_files(self, query_type):
         param_data1 = '{\n' \
@@ -322,14 +330,14 @@ class TestExecuteQueryWithParamsFromJson(BaseTestTableService):
                 "DECLARE $num AS Uint64; "\
                 "DECLARE $date AS Date; "\
                 "SELECT $str AS str, $num as num, $date as date; "
-        self.write_data(param_data1, "param1.json")
-        self.write_data(param_data2, "param2.json")
-        self.write_data(param_data3, "param3.json")
+        self.write_data(param_data1, str(self.tmp_path / "param1.json"))
+        self.write_data(param_data2, str(self.tmp_path / "param2.json"))
+        self.write_data(param_data3, str(self.tmp_path / "param3.json"))
         output = self.execute_ydb_cli_command(
-            ["table", "query", "execute", "-t", query_type, "--param-file", "param1.json", "--param-file",
-             "param2.json", "--param-file", "param3.json", "-q", query]
+            ["table", "query", "execute", "-t", query_type, "--param-file", str(self.tmp_path / "param1.json"), "--param-file",
+             str(self.tmp_path / "param2.json"), "--param-file", str(self.tmp_path / "param3.json"), "-q", query]
         )
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def ignore_excess_parameters(self, query_type):
         param_data = '{\n' \
@@ -338,20 +346,20 @@ class TestExecuteQueryWithParamsFromJson(BaseTestTableService):
             '}'
         query = "DECLARE $a AS Uint64; " \
                 "SELECT $a AS a; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "params.json"))
         output = self.execute_ydb_cli_command(
-            ["table", "query", "execute", "-t", query_type, "-q", query, "--param-file", "params.json"]
+            ["table", "query", "execute", "-t", query_type, "-q", query, "--param-file", str(self.tmp_path / "params.json")]
         )
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def script_from_file(self, query_type):
         query = "DECLARE $a AS Uint64; " \
                 "SELECT $a AS a; "
-        self.write_data(query, "query.yql")
+        self.write_data(query, str(self.tmp_path / "query.yql"))
         output = self.execute_ydb_cli_command(
-            ["table", "query", "execute", "-t", query_type, "-f", "query.yql", "--param", "$a=3"]
+            ["table", "query", "execute", "-t", query_type, "-f", str(self.tmp_path / "query.yql"), "--param", "$a=3"]
         )
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def test_uint32(self, query_type):
         return self.uint32(query_type)
@@ -380,13 +388,16 @@ class TestExecuteQueryWithParamsFromStdin(BaseTestTableService):
     @classmethod
     def setup_class(cls):
         BaseTestTableService.setup_class()
+        cls.session = cls.driver.table_client.session().create()
 
-        session = cls.driver.table_client.session().create()
-        cls.table_path = cls.root_dir + "/table_params_from_stdin"
-        create_table_with_data(session, cls.table_path)
+    @pytest.fixture(autouse=True, scope='function')
+    def init_test(self, tmp_path):
+        self.tmp_path = tmp_path
+        self.table_path = self.root_dir + "/" + self.tmp_path.name
+        create_table_with_data(self.session, self.table_path)
 
     @staticmethod
-    def write_data(data, filename="stdin.txt"):
+    def write_data(data, filename):
         with open(filename, "w") as file:
             file.write(data)
 
@@ -398,14 +409,12 @@ class TestExecuteQueryWithParamsFromStdin(BaseTestTableService):
             return "\t"
         raise RuntimeError("Unknown format: {}".format(format))
 
-    @classmethod
-    def get_stdin(cls):
-        cls.stdin = open("stdin.txt", "r")
-        return cls.stdin
+    def get_stdin(self):
+        self.stdin = (self.tmp_path / "stdin.txt").open("r")
+        return self.stdin
 
-    @classmethod
-    def close_stdin(cls):
-        cls.stdin.close()
+    def close_stdin(self):
+        self.stdin.close()
 
     def simple_json(self, query_type):
         param_data = '{\n' \
@@ -415,10 +424,10 @@ class TestExecuteQueryWithParamsFromStdin(BaseTestTableService):
         query = "DECLARE $s AS Utf8; "\
                 "DECLARE $val AS Uint64; "\
                 "SELECT $s AS s, $val AS val; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command(["table", "query", "execute", "-t", query_type, "-q", query], self.get_stdin())
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def simple_csv_tsv(self, query_type, format):
         param_data = 's{0}val\n' \
@@ -427,11 +436,11 @@ class TestExecuteQueryWithParamsFromStdin(BaseTestTableService):
         query = "DECLARE $s AS Utf8; "\
                 "DECLARE $val AS Uint64; "\
                 "SELECT $s AS s, $val AS val; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command(["table", "query", "execute", "-t", query_type,
                                                "-q", query, "--stdin-format", format], self.get_stdin())
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def stdin_par_raw(self, query_type):
         param_data = 'Line1\n' \
@@ -439,25 +448,25 @@ class TestExecuteQueryWithParamsFromStdin(BaseTestTableService):
             'Line3\n'
         query = "DECLARE $s AS Utf8; " \
                 "SELECT $s AS s; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command(
             ["table", "query", "execute", "-t", query_type, "-q", query, "--stdin-format", "raw", "--stdin-par", "s"],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def stdin_par_json(self, query_type):
         param_data = "[1, 2, 3, 4]"
         query = "DECLARE $arr AS List<Uint64>; "\
                 "SELECT $arr AS arr; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command(
             ["table", "query", "execute", "-t", query_type, "-q", query, "--stdin-par", "arr"],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def stdin_par_csv_tsv(self, query_type, format):
         param_data = 'id{0}value\n' \
@@ -465,13 +474,13 @@ class TestExecuteQueryWithParamsFromStdin(BaseTestTableService):
         param_data = param_data.format(self.get_delim(format))
         query = "DECLARE $s AS Struct<id:UInt64,value:Utf8>; " \
                 "SELECT $s AS s; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command(
             ["table", "query", "execute", "-t", query_type, "-q", query, "--stdin-format", format, "--stdin-par", "s"],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def mix_json_and_binary(self, query_type):
         param_data1 = 'Строка номер 1\n' \
@@ -485,15 +494,15 @@ class TestExecuteQueryWithParamsFromStdin(BaseTestTableService):
                 "DECLARE $date AS Date; " \
                 "DECLARE $val AS Uint64; " \
                 "SELECT $s AS s, $date AS date, $val AS val; "
-        self.write_data(param_data1)
-        self.write_data(param_data2, "params.json")
+        self.write_data(param_data1, str(self.tmp_path / "stdin.txt"))
+        self.write_data(param_data2, str(self.tmp_path / "params.json"))
         output = self.execute_ydb_cli_command(
             ["table", "query", "execute", "-t", query_type, "-q", query, "--stdin-par", "s",
-             "--stdin-format", "raw", "--param-file", "params.json"],
+             "--stdin-format", "raw", "--param-file", str(self.tmp_path / "params.json")],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def different_sources_json(self, query_type):
         param_data1 = '{\n' \
@@ -506,14 +515,14 @@ class TestExecuteQueryWithParamsFromStdin(BaseTestTableService):
                 "DECLARE $date AS Date; " \
                 "DECLARE $val AS Uint64; " \
                 "SELECT $s AS s, $date AS date, $val AS val; "
-        self.write_data(param_data1)
-        self.write_data(param_data2, "params.json")
+        self.write_data(param_data1, str(self.tmp_path / "stdin.txt"))
+        self.write_data(param_data2, str(self.tmp_path / "params.json"))
         output = self.execute_ydb_cli_command(
-            ["table", "query", "execute", "-t", query_type, "-q", query, "--param-file", "params.json", "--param", "$val=100"],
+            ["table", "query", "execute", "-t", query_type, "-q", query, "--param-file", str(self.tmp_path / "params.json"), "--param", "$val=100"],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def different_sources_csv_tsv(self, query_type, format):
         param_data1 = 's\n' \
@@ -526,14 +535,14 @@ class TestExecuteQueryWithParamsFromStdin(BaseTestTableService):
                 "DECLARE $date AS Date; " \
                 "DECLARE $val AS Uint64; " \
                 "SELECT $s AS s, $date AS date, $val AS val; "
-        self.write_data(param_data1)
-        self.write_data(param_data2, "params.json")
+        self.write_data(param_data1, str(self.tmp_path / "stdin.txt"))
+        self.write_data(param_data2, str(self.tmp_path / "params.json"))
         output = self.execute_ydb_cli_command(
-            ["table", "query", "execute", "-t", query_type, "-q", query, "--stdin-format", format, "--param-file", "params.json", "--param", "$val=100"],
+            ["table", "query", "execute", "-t", query_type, "-q", query, "--stdin-format", format, "--param-file", str(self.tmp_path / "params.json"), "--param", "$val=100"],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def framing_newline_delimited_json(self, query_type):
         param_data = '{"s": "Some text", "num": 1}\n' \
@@ -542,13 +551,13 @@ class TestExecuteQueryWithParamsFromStdin(BaseTestTableService):
         query = "DECLARE $s AS Utf8; " \
                 "DECLARE $num AS Uint64; " \
                 "SELECT $s AS s, $num AS num; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command(
             ["table", "query", "execute", "-t", query_type, "-q", query, "--stdin-format", "newline-delimited"],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def framing_newline_delimited_csv_tsv(self, query_type, format):
         param_data = 's{0}num\n' \
@@ -559,13 +568,13 @@ class TestExecuteQueryWithParamsFromStdin(BaseTestTableService):
         query = "DECLARE $s AS Utf8; " \
                 "DECLARE $num AS Uint64; " \
                 "SELECT $s AS s, $num AS num; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command(
             ["table", "query", "execute", "-t", query_type, "-q", query, "--stdin-format", format, "--stdin-format", "newline-delimited"],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def framing_newline_delimited_raw(self, query_type):
         param_data = 'Line1\n' \
@@ -573,14 +582,14 @@ class TestExecuteQueryWithParamsFromStdin(BaseTestTableService):
             'Line3\n'
         query = "DECLARE $s AS Utf8; " \
                 "SELECT $s AS s; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command(
             ["table", "query", "execute", "-t", query_type, "-q", query, "--stdin-format", "raw",
              "--stdin-par", "s", "--stdin-format", "newline-delimited"],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def batching_full_raw(self, query_type):
         param_data = 'Line1\n' \
@@ -588,14 +597,14 @@ class TestExecuteQueryWithParamsFromStdin(BaseTestTableService):
             'Line3\n'
         query = "DECLARE $s AS List<Utf8>; " \
                 "SELECT $s AS s; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command(
             ["table", "query", "execute", "-t", query_type, "-q", query, "--stdin-format", "raw", "--stdin-par", "s",
              "--stdin-format", "newline-delimited", "--batch", "full"],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def batching_full_json(self, query_type):
         param_data = '{"s": "Line1", "id": 1}\n' \
@@ -609,14 +618,14 @@ class TestExecuteQueryWithParamsFromStdin(BaseTestTableService):
             '{"s": "Line9", "id": 9}\n'
         query = "DECLARE $arr as List<Struct<s:Utf8, id:Uint64>>; " \
                 "SELECT $arr as arr; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command(
             ["table", "query", "execute", "-t", query_type, "-q", query, "--stdin-par", "arr",
              "--stdin-format", "newline-delimited", "--batch", "full"],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def batching_full_csv_tsv(self, query_type, format):
         param_data = 's{0}id\n' \
@@ -632,14 +641,14 @@ class TestExecuteQueryWithParamsFromStdin(BaseTestTableService):
         param_data = param_data.format(self.get_delim(format))
         query = "DECLARE $arr as List<Struct<s:Utf8, id:Uint64>>; " \
                 "SELECT $arr as arr; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command(
             ["table", "query", "execute", "-t", query_type, "-q", query, "--stdin-format", format, "--stdin-par", "arr",
              "--stdin-format", "newline-delimited", "--batch", "full"],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def batching_adaptive_raw(self, query_type):
         param_data = 'Line1\n' \
@@ -653,14 +662,14 @@ class TestExecuteQueryWithParamsFromStdin(BaseTestTableService):
             'Line9\n'
         query = "DECLARE $s AS List<Utf8>; " \
                 "SELECT $s AS s; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command(
             ["table", "query", "execute", "-t", query_type, "-q", query, "--stdin-format", "raw", "--stdin-par", "s",
              "--stdin-format", "newline-delimited", "--batch", "adaptive", "--batch-max-delay", "0", "--batch-limit", "3"],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def batching_adaptive_json(self, query_type):
         param_data = '{"s": "Line1", "id": 1}\n' \
@@ -674,14 +683,14 @@ class TestExecuteQueryWithParamsFromStdin(BaseTestTableService):
             '{"s": "Line9", "id": 9}\n'
         query = "DECLARE $arr as List<Struct<s:Utf8, id:Uint64>>; " \
                 "SELECT $arr as arr; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command(
             ["table", "query", "execute", "-t", query_type, "-q", query, "--stdin-par", "arr", "--stdin-format", "newline-delimited",
              "--batch", "adaptive", "--batch-max-delay", "0", "--batch-limit", "3"],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def batching_adaptive_csv_tsv(self, query_type, format):
         param_data = 's{0}id\n' \
@@ -697,14 +706,14 @@ class TestExecuteQueryWithParamsFromStdin(BaseTestTableService):
         param_data = param_data.format(self.get_delim(format))
         query = "DECLARE $arr as List<Struct<s:Utf8, id:Uint64>>; " \
                 "SELECT $arr as arr; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command(
             ["table", "query", "execute", "-t", query_type, "-q", query, "--stdin-format", format, "--stdin-par", "arr", "--stdin-format", "newline-delimited",
              "--batch", "adaptive", "--batch-max-delay", "0", "--batch-limit", "3"],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def ignore_excess_parameters_json(self, query_type):
         param_data = '{\n' \
@@ -713,13 +722,13 @@ class TestExecuteQueryWithParamsFromStdin(BaseTestTableService):
             '}'
         query = "DECLARE $a AS Uint64; " \
                 "SELECT $a AS a; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command(
             ["table", "query", "execute", "-t", query_type, "-q", query],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def ignore_excess_parameters_csv_tsv(self, query_type, format):
         param_data = 'a{0}b\n' \
@@ -727,13 +736,13 @@ class TestExecuteQueryWithParamsFromStdin(BaseTestTableService):
         param_data = param_data.format(self.get_delim(format))
         query = "DECLARE $a AS Uint64; " \
                 "SELECT $a AS a; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command(
             ["table", "query", "execute", "-t", query_type, "-q", query, "--stdin-format", format],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def columns_bad_header(self, query_type, format):
         param_data = 'x{0}y\n' \
@@ -744,14 +753,14 @@ class TestExecuteQueryWithParamsFromStdin(BaseTestTableService):
         query = "DECLARE $a AS Uint64; " \
                 "DECLARE $b AS Uint64; " \
                 "SELECT $a AS a, $b AS b; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command(
             ["table", "query", "execute", "-t", query_type, "-q", query, "--stdin-format", format, "--stdin-format", "newline-delimited",
              "--columns", "a{0}b".format(self.get_delim(format)), "--skip-rows", "1"],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def columns_no_header(self, query_type, format):
         param_data = '1{0}1\n' \
@@ -761,14 +770,14 @@ class TestExecuteQueryWithParamsFromStdin(BaseTestTableService):
         query = "DECLARE $a AS Uint64; " \
                 "DECLARE $b AS Uint64; " \
                 "SELECT $a AS a, $b AS b; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command(
             ["table", "query", "execute", "-t", query_type, "-q", query, "--stdin-format", format, "--stdin-format", "newline-delimited",
              "--columns", "a{0}b".format(self.get_delim(format))],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def skip_rows(self, query_type, format):
         param_data = 'a{0}b\n' \
@@ -782,14 +791,14 @@ class TestExecuteQueryWithParamsFromStdin(BaseTestTableService):
         query = "DECLARE $a AS Uint64; " \
                 "DECLARE $b AS Uint64; " \
                 "SELECT $a AS a, $b AS b; "
-        self.write_data(param_data)
+        self.write_data(param_data, str(self.tmp_path / "stdin.txt"))
         output = self.execute_ydb_cli_command(
             ["table", "query", "execute", "-t", query_type, "-q", query, "--stdin-format", format, "--stdin-format", "newline-delimited",
              "--skip-rows", "3"],
             self.get_stdin()
         )
         self.close_stdin()
-        return self.canonical_result(output)
+        return self.canonical_result(output, self.tmp_path)
 
     def test_simple_json(self, query_type):
         return self.simple_json(query_type)