diff --git a/.github/workflows/packing.yml b/.github/workflows/packing.yml
index eabf5096..b5b84f32 100644
--- a/.github/workflows/packing.yml
+++ b/.github/workflows/packing.yml
@@ -148,16 +148,16 @@ jobs:
       - name: Setup WSL for tarantool
         uses: Vampire/setup-wsl@v1
         with:
-          distribution: Ubuntu-20.04
+          distribution: Ubuntu-22.04
 
       - name: Install tarantool
-        shell: wsl-bash_Ubuntu-20.04 {0}
+        shell: wsl-bash_Ubuntu-22.04 {0}
         run: |
           curl -L https://tarantool.io/release/2/installer.sh | bash -s
           sudo apt install -y tarantool tarantool-dev
 
       - name: Setup test tarantool instance
-        shell: wsl-bash_Ubuntu-20.04 {0}
+        shell: wsl-bash_Ubuntu-22.04 {0}
         run: |
           rm -f ./tarantool.pid ./tarantool.log
           TNT_PID=$(tarantool ./test/suites/lib/tarantool_python_ci.lua > tarantool.log 2>&1 & echo $!)
@@ -172,7 +172,7 @@ jobs:
 
       - name: Stop test tarantool instance
         if: ${{ always() }}
-        shell: wsl-bash_Ubuntu-20.04 {0}
+        shell: wsl-bash_Ubuntu-22.04 {0}
         run: |
           cat tarantool.log || true
           kill $(cat tarantool.pid) || true
diff --git a/.github/workflows/testing.yml b/.github/workflows/testing.yml
index 199744f2..88fa08d7 100644
--- a/.github/workflows/testing.yml
+++ b/.github/workflows/testing.yml
@@ -262,16 +262,16 @@ jobs:
       - name: Setup WSL for tarantool
         uses: Vampire/setup-wsl@v2
         with:
-          distribution: Ubuntu-20.04
+          distribution: Ubuntu-22.04
 
       - name: Install tarantool ${{ matrix.tarantool }} for WSL (2.10 and newer)
-        shell: wsl-bash_Ubuntu-20.04 {0}
+        shell: wsl-bash_Ubuntu-22.04 {0}
         run: |
           curl -L https://tarantool.io/release/2/installer.sh | bash -s
           sudo apt install -y tarantool=${{ matrix.tarantool }} tarantool-dev=${{ matrix.tarantool }}
 
       - name: Setup test tarantool instance
-        shell: wsl-bash_Ubuntu-20.04 {0}
+        shell: wsl-bash_Ubuntu-22.04 {0}
         run: |
           rm -f ./tarantool.pid ./tarantool.log
           TNT_PID=$(tarantool ./test/suites/lib/tarantool_python_ci.lua > tarantool.log 2>&1 & echo $!)
@@ -286,7 +286,7 @@ jobs:
 
       - name: Stop test tarantool instance
         if: ${{ always() }}
-        shell: wsl-bash_Ubuntu-20.04 {0}
+        shell: wsl-bash_Ubuntu-22.04 {0}
         run: |
           cat tarantool.log || true
           kill $(cat tarantool.pid) || true
@@ -334,16 +334,16 @@ jobs:
       - name: Setup WSL for tarantool
         uses: Vampire/setup-wsl@v2
         with:
-          distribution: Ubuntu-20.04
+          distribution: Ubuntu-22.04
 
       - name: Install tarantool ${{ matrix.tarantool }} for WSL
-        shell: wsl-bash_Ubuntu-20.04 {0}
+        shell: wsl-bash_Ubuntu-22.04 {0}
         run: |
           curl -L https://tarantool.io/release/2/installer.sh | bash -s
           sudo apt install -y tarantool=${{ matrix.tarantool }} tarantool-dev=${{ matrix.tarantool }}
 
       - name: Setup test tarantool instance
-        shell: wsl-bash_Ubuntu-20.04 {0}
+        shell: wsl-bash_Ubuntu-22.04 {0}
         run: |
           rm -f ./tarantool.pid ./tarantool.log
           TNT_PID=$(tarantool ./test/suites/lib/tarantool_python_ci.lua > tarantool.log 2>&1 & echo $!)
@@ -358,7 +358,7 @@ jobs:
 
       - name: Stop test tarantool instance
         if: ${{ always() }}
-        shell: wsl-bash_Ubuntu-20.04 {0}
+        shell: wsl-bash_Ubuntu-22.04 {0}
         run: |
           cat tarantool.log || true
           kill $(cat tarantool.pid) || true
diff --git a/test/suites/box.lua b/test/suites/box.lua
index eb4330dd..c8110d18 100644
--- a/test/suites/box.lua
+++ b/test/suites/box.lua
@@ -19,3 +19,5 @@ box.cfg{
     pid_file     = "box.pid",
     auth_type    = (auth_type:len() > 0) and auth_type or nil,
 }
+
+rawset(_G, 'ready', true)
diff --git a/test/suites/crud_server.lua b/test/suites/crud_server.lua
index 8bb58fcb..f939818a 100644
--- a/test/suites/crud_server.lua
+++ b/test/suites/crud_server.lua
@@ -91,3 +91,5 @@ if crud_imported == false or vshard_imported == false then
 else
     configure_crud_instance(primary_listen, crud, vshard)
 end
+
+rawset(_G, 'ready', true)
diff --git a/test/suites/lib/tarantool_server.py b/test/suites/lib/tarantool_server.py
index 1dd5e053..c8f34b37 100644
--- a/test/suites/lib/tarantool_server.py
+++ b/test/suites/lib/tarantool_server.py
@@ -302,27 +302,22 @@ def prepare_args(self):
 
         return shlex.split(self.binary if not self.script else self.script_dst)
 
-    def wait_until_started(self):
+    def wait_until_ready(self):
         """
-        Wait until server is started.
+        Wait until server is configured and ready to work.
 
         Server consists of two parts:
         1) wait until server is listening on sockets
-        2) wait until server tells us his status
+        2) wait until server finishes executing its script
         """
 
         while True:
             try:
                 temp = TarantoolAdmin('0.0.0.0', self.args['admin'])
-                while True:
-                    ans = temp('box.info.status')[0]
-                    if ans in ('running', 'hot_standby', 'orphan') or ans.startswith('replica'):
-                        temp.disconnect()
-                        return True
-                    if ans in ('loading',):
-                        continue
-
-                    raise ValueError(f"Strange output for `box.info.status`: {ans}")
+                ans = temp('ready')[0]
+                temp.disconnect()
+                if isinstance(ans, bool) and ans:
+                    return True
             except socket.error as exc:
                 if exc.errno == errno.ECONNREFUSED:
                     time.sleep(0.1)
@@ -352,7 +347,7 @@ def start(self):
                                         cwd=self.vardir,
                                         stdout=self.log_des,
                                         stderr=self.log_des)
-        self.wait_until_started()
+        self.wait_until_ready()
 
     def stop(self):
         """
diff --git a/test/suites/test_connection.py b/test/suites/test_connection.py
index 52234608..4402f0b0 100644
--- a/test/suites/test_connection.py
+++ b/test/suites/test_connection.py
@@ -5,8 +5,9 @@
 
 import sys
 import unittest
-
 import decimal
+
+import pkg_resources
 import msgpack
 
 import tarantool
@@ -14,6 +15,7 @@
 
 from .lib.skip import skip_or_run_decimal_test, skip_or_run_varbinary_test
 from .lib.tarantool_server import TarantoolServer
+from .utils import assert_admin_success
 
 
 class TestSuiteConnection(unittest.TestCase):
@@ -26,35 +28,48 @@ def setUpClass(cls):
         cls.srv.start()
 
         cls.adm = cls.srv.admin
-        cls.adm(r"""
+        resp = cls.adm("""
             box.schema.user.create('test', {password = 'test', if_not_exists = true})
-            box.schema.user.grant('test', 'read,write,execute', 'universe')
-
-            box.schema.create_space('space_varbin')
-
-            box.space['space_varbin']:format({
-                {
-                    'id',
-                    type = 'number',
-                    is_nullable = false
-                },
-                {
-                    'varbin',
-                    type = 'varbinary',
-                    is_nullable = false,
-                }
-            })
-
-            box.space['space_varbin']:create_index('id', {
-                type = 'tree',
-                parts = {1, 'number'},
-                unique = true})
-
-            box.space['space_varbin']:create_index('varbin', {
-                type = 'tree',
-                parts = {2, 'varbinary'},
-                unique = true})
+            box.schema.user.grant('test', 'read,write,execute', 'universe',
+                                  nil, {if_not_exists = true})
+
+            return true
         """)
+        assert_admin_success(resp)
+
+        if cls.srv.admin.tnt_version >= pkg_resources.parse_version('2.2.1'):
+            resp = cls.adm("""
+                box.schema.create_space('space_varbin', {if_not_exists = true})
+
+                box.space['space_varbin']:format({
+                    {
+                        'id',
+                        type = 'number',
+                        is_nullable = false
+                    },
+                    {
+                        'varbin',
+                        type = 'varbinary',
+                        is_nullable = false,
+                    }
+                })
+
+                box.space['space_varbin']:create_index('id', {
+                    type = 'tree',
+                    parts = {1, 'number'},
+                    unique = true,
+                    if_not_exists = true})
+
+                box.space['space_varbin']:create_index('varbin', {
+                    type = 'tree',
+                    parts = {2, 'varbinary'},
+                    unique = true,
+                    if_not_exists = true})
+
+                return true
+            """)
+            assert_admin_success(resp)
+
         cls.con = None
 
     def setUp(self):
diff --git a/test/suites/test_datetime.py b/test/suites/test_datetime.py
index ae22dcfc..9f250804 100644
--- a/test/suites/test_datetime.py
+++ b/test/suites/test_datetime.py
@@ -16,6 +16,7 @@
 
 from .lib.tarantool_server import TarantoolServer
 from .lib.skip import skip_or_run_datetime_test, skip_or_run_datetime_2_11_test
+from .utils import assert_admin_success
 
 
 class TestSuiteDatetime(unittest.TestCase):
@@ -28,25 +29,28 @@ def setUpClass(cls):
         cls.srv.start()
 
         cls.adm = cls.srv.admin
-        cls.adm(r"""
+        resp = cls.adm("""
             _, datetime = pcall(require, 'datetime')
 
-            box.schema.space.create('test')
+            box.schema.space.create('test', {if_not_exists = true})
             box.space['test']:create_index('primary', {
                 type = 'tree',
                 parts = {1, 'string'},
-                unique = true})
+                unique = true,
+                if_not_exists = true})
 
             pcall(function()
                 box.schema.space.create('test_pk')
                 box.space['test_pk']:create_index('primary', {
                     type = 'tree',
                     parts = {1, 'datetime'},
-                    unique = true})
+                    unique = true,
+                if_not_exists = true})
             end)
 
             box.schema.user.create('test', {password = 'test', if_not_exists = true})
-            box.schema.user.grant('test', 'read,write,execute', 'universe')
+            box.schema.user.grant('test', 'read,write,execute', 'universe',
+                                  nil, {if_not_exists = true})
 
             local function add(arg1, arg2)
                 return arg1 + arg2
@@ -57,7 +61,10 @@ def setUpClass(cls):
                 return arg1 - arg2
             end
             rawset(_G, 'sub', sub)
+
+            return true
         """)
+        assert_admin_success(resp)
 
         cls.con = tarantool.Connection(cls.srv.host, cls.srv.args['primary'],
                                        user='test', password='test')
@@ -67,7 +74,11 @@ def setUp(self):
         if self.srv.is_started():
             self.srv.touch_lock()
 
-        self.adm("box.space['test']:truncate()")
+        resp = self.adm("""
+            box.space['test']:truncate()
+            return true
+        """)
+        assert_admin_success(resp)
 
     def test_datetime_class_api(self):
         datetime = tarantool.Datetime(year=2022, month=8, day=31, hour=18, minute=7, sec=54,
diff --git a/test/suites/test_dbapi.py b/test/suites/test_dbapi.py
index 83156b39..bd8c7487 100644
--- a/test/suites/test_dbapi.py
+++ b/test/suites/test_dbapi.py
@@ -12,6 +12,7 @@
 from tarantool import dbapi
 from .lib.tarantool_server import TarantoolServer
 from .lib.skip import skip_or_run_sql_test
+from .utils import assert_admin_success
 
 
 class TestSuiteDBAPI(dbapi20.DatabaseAPI20Test):
@@ -39,6 +40,14 @@ def setUpClass(cls):
             "port": cls.srv.args['primary']
         }
 
+        # grant full access to guest
+        resp = cls.srv.admin("""
+            box.schema.user.grant('guest', 'create,read,write,execute', 'universe',
+                                  nil, {if_not_exists = true})
+            return true
+        """)
+        assert_admin_success(resp)
+
     @skip_or_run_sql_test
     def setUp(self):
         # prevent a remote tarantool from clean our session
@@ -46,10 +55,6 @@ def setUp(self):
             self.srv.touch_lock()
         self.con.flush_schema()
 
-        # grant full access to guest
-        self.srv.admin("box.schema.user.grant('guest', 'create,read,write,"
-                       "execute', 'universe')")
-
     @classmethod
     def tearDownClass(cls):
         cls.con.close()
diff --git a/test/suites/test_decimal.py b/test/suites/test_decimal.py
index b880eaa3..2875a7da 100644
--- a/test/suites/test_decimal.py
+++ b/test/suites/test_decimal.py
@@ -16,6 +16,7 @@
 
 from .lib.tarantool_server import TarantoolServer
 from .lib.skip import skip_or_run_decimal_test
+from .utils import assert_admin_success
 
 
 class TestSuiteDecimal(unittest.TestCase):
@@ -28,26 +29,32 @@ def setUpClass(cls):
         cls.srv.start()
 
         cls.adm = cls.srv.admin
-        cls.adm(r"""
-            _, decimal = pcall(require, 'decimal')
+        resp = cls.adm("""
+            decimal_supported, decimal = pcall(require, 'decimal')
 
-            box.schema.space.create('test')
+            box.schema.space.create('test', {if_not_exists = true})
             box.space['test']:create_index('primary', {
                 type = 'tree',
                 parts = {1, 'string'},
-                unique = true})
+                unique = true,
+                if_not_exists = true})
 
-            pcall(function()
+            if decimal_supported then
                 box.schema.space.create('test_pk')
                 box.space['test_pk']:create_index('primary', {
                     type = 'tree',
                     parts = {1, 'decimal'},
-                    unique = true})
-            end)
+                    unique = true,
+                    if_not_exists = true})
+            end
 
             box.schema.user.create('test', {password = 'test', if_not_exists = true})
-            box.schema.user.grant('test', 'read,write,execute', 'universe')
+            box.schema.user.grant('test', 'read,write,execute', 'universe',
+                                  nil, {if_not_exists = true})
+
+            return true
         """)
+        assert_admin_success(resp)
 
         cls.con = tarantool.Connection(cls.srv.host, cls.srv.args['primary'],
                                        user='test', password='test')
@@ -57,7 +64,11 @@ def setUp(self):
         if self.srv.is_started():
             self.srv.touch_lock()
 
-        self.adm("box.space['test']:truncate()")
+        resp = self.adm("""
+            box.space['test']:truncate()
+            return true
+        """)
+        assert_admin_success(resp)
 
     valid_cases = {
         'simple_decimal_1': {
diff --git a/test/suites/test_dml.py b/test/suites/test_dml.py
index 69293b55..f557451e 100644
--- a/test/suites/test_dml.py
+++ b/test/suites/test_dml.py
@@ -10,6 +10,7 @@
 
 from .lib.tarantool_server import TarantoolServer
 from .lib.skip import skip_or_run_error_extra_info_test
+from .utils import assert_admin_success
 
 
 class TestSuiteRequest(unittest.TestCase):
@@ -22,29 +23,35 @@ def setUpClass(cls):
         cls.srv.start()
         cls.con = tarantool.Connection(cls.srv.host, cls.srv.args['primary'])
         cls.adm = cls.srv.admin
-        cls.space_created = cls.adm("box.schema.create_space('space_1')")
-        cls.adm("""
-        box.space['space_1']:create_index('primary', {
-            type = 'tree',
-            parts = {1, 'num'},
-            unique = true})
-        """.replace('\n', ' '))
-        cls.adm("""
-        box.space['space_1']:create_index('secondary', {
-            type = 'tree',
-            parts = {2, 'num', 3, 'str'},
-            unique = false})
-        """.replace('\n', ' '))
-        cls.space_created = cls.adm("box.schema.create_space('space_2')")
-        cls.adm("""
-        box.space['space_2']:create_index('primary', {
-            type = 'hash',
-            parts = {1, 'num'},
-            unique = true})
-        """.replace('\n', ' '))
-        cls.adm("json = require('json')")
-        cls.adm("fiber = require('fiber')")
-        cls.adm("uuid = require('uuid')")
+        cls.space_created = cls.adm("box.schema.create_space('space_1', {if_not_exists = true})")
+        resp = cls.adm("""
+            box.space['space_1']:create_index('primary', {
+                type = 'tree',
+                parts = {1, 'num'},
+                unique = true,
+                if_not_exists = true})
+
+            box.space['space_1']:create_index('secondary', {
+                type = 'tree',
+                parts = {2, 'num', 3, 'str'},
+                unique = false,
+                if_not_exists = true})
+
+            box.schema.create_space('space_2', {if_not_exists = true})
+
+            box.space['space_2']:create_index('primary', {
+                type = 'hash',
+                parts = {1, 'num'},
+                unique = true,
+                if_not_exists = true})
+
+            json = require('json')
+            fiber = require('fiber')
+            uuid = require('uuid')
+
+            return true
+        """)
+        assert_admin_success(resp)
 
         if not sys.platform.startswith("win"):
             cls.sock_srv = TarantoolServer(create_unix_socket=True)
@@ -60,10 +67,11 @@ def setUp(self):
 
     def test_00_00_authenticate(self):
         self.assertIsNone(self.srv.admin("""
-        box.schema.user.create('test', { password = 'test' })
+        box.schema.user.create('test', { password = 'test', if_not_exists = true })
         """))
         self.assertIsNone(self.srv.admin("""
-        box.schema.user.grant('test', 'execute,read,write', 'universe')
+        box.schema.user.grant('test', 'execute,read,write', 'universe',
+                              nil, {if_not_exists = true})
         """))
         self.assertEqual(self.con.authenticate('test', 'test')._data, None)
 
@@ -311,7 +319,7 @@ def test_11_select_all_hash(self):
             space.select((), iterator=tarantool.const.ITERATOR_EQ)
 
     def test_12_update_fields(self):
-        self.srv.admin(
+        resp = self.srv.admin(
             """
             do
                 local sp = box.schema.create_space('sp', {
@@ -325,7 +333,9 @@ def test_12_update_fields(self):
                     parts = {1, 'unsigned'}
                 })
             end
+            return true
             """)
+        assert_admin_success(resp)
         self.con.insert('sp', [2, 'help', 4])
         self.assertSequenceEqual(
             self.con.update('sp', (2,), [('+', 'thi', 3)]),
diff --git a/test/suites/test_encoding.py b/test/suites/test_encoding.py
index 14a08f54..dcda5983 100644
--- a/test/suites/test_encoding.py
+++ b/test/suites/test_encoding.py
@@ -1,16 +1,18 @@
 """
 This module tests various type encoding cases.
 """
-# pylint: disable=missing-class-docstring,missing-function-docstring
+# pylint: disable=missing-class-docstring,missing-function-docstring,duplicate-code
 
 import sys
 import unittest
+import pkg_resources
 
 import tarantool
 from tarantool.error import DatabaseError
 
 from .lib.skip import skip_or_run_varbinary_test, skip_or_run_error_extra_info_test
 from .lib.tarantool_server import TarantoolServer
+from .utils import assert_admin_success
 
 
 class TestSuiteEncoding(unittest.TestCase):
@@ -24,10 +26,14 @@ def setUpClass(cls):
         cls.srv.script = 'test/suites/box.lua'
         cls.srv.start()
 
-        cls.srv.admin("""
-            box.schema.user.create('test', { password = 'test' })
-            box.schema.user.grant('test', 'execute,read,write', 'universe')
+        resp = cls.srv.admin("""
+            box.schema.user.create('test', { password = 'test', if_not_exists = true })
+            box.schema.user.grant('test', 'execute,read,write', 'universe',
+                                  nil, {if_not_exists = true})
+
+            return true
         """)
+        assert_admin_success(resp)
 
         args = [cls.srv.host, cls.srv.args['primary']]
         kwargs = {'user': 'test', 'password': 'test'}
@@ -35,41 +41,47 @@ def setUpClass(cls):
         cls.con_encoding_none = tarantool.Connection(*args, encoding=None, **kwargs)
         cls.conns = [cls.con_encoding_utf8, cls.con_encoding_none]
 
-        cls.srv.admin("box.schema.create_space('space_str')")
-        cls.srv.admin("""
+        resp = cls.srv.admin("""
+            box.schema.create_space('space_str', {if_not_exists = true})
             box.space['space_str']:create_index('primary', {
                 type = 'tree',
                 parts = {1, 'str'},
-                unique = true})
-        """.replace('\n', ' '))
-
-        cls.srv.admin("box.schema.create_space('space_varbin')")
-        cls.srv.admin(r"""
-            box.space['space_varbin']:format({
-                {
-                    'id',
-                    type = 'number',
-                    is_nullable = false
-                },
-                {
-                    'varbin',
-                    type = 'varbinary',
-                    is_nullable = false,
-                }
-            })
-        """.replace('\n', ' '))
-        cls.srv.admin("""
-            box.space['space_varbin']:create_index('id', {
-                type = 'tree',
-                parts = {1, 'number'},
-                unique = true})
-        """.replace('\n', ' '))
-        cls.srv.admin("""
-            box.space['space_varbin']:create_index('varbin', {
-                type = 'tree',
-                parts = {2, 'varbinary'},
-                unique = true})
-        """.replace('\n', ' '))
+                unique = true,
+                if_not_exists = true})
+
+            return true
+        """)
+        assert_admin_success(resp)
+
+        if cls.srv.admin.tnt_version >= pkg_resources.parse_version('2.2.1'):
+            resp = cls.srv.admin("""
+                box.schema.create_space('space_varbin', {if_not_exists = true})
+                box.space['space_varbin']:format({
+                    {
+                        'id',
+                        type = 'number',
+                        is_nullable = false
+                    },
+                    {
+                        'varbin',
+                        type = 'varbinary',
+                        is_nullable = false,
+                    }
+                })
+                box.space['space_varbin']:create_index('id', {
+                    type = 'tree',
+                    parts = {1, 'number'},
+                    unique = true,
+                    if_not_exists = true})
+                box.space['space_varbin']:create_index('varbin', {
+                    type = 'tree',
+                    parts = {2, 'varbinary'},
+                    unique = true,
+                    if_not_exists = true})
+
+                    return true
+            """)
+            assert_admin_success(resp)
 
     def assertNotRaises(self, func, *args, **kwargs):
         try:
diff --git a/test/suites/test_error_ext.py b/test/suites/test_error_ext.py
index 8d1a63cf..52622794 100644
--- a/test/suites/test_error_ext.py
+++ b/test/suites/test_error_ext.py
@@ -15,6 +15,7 @@
 
 from .lib.tarantool_server import TarantoolServer
 from .lib.skip import skip_or_run_error_ext_type_test
+from .utils import assert_admin_success
 
 
 class TestSuiteErrorExt(unittest.TestCase):
@@ -27,18 +28,23 @@ def setUpClass(cls):
         cls.srv.start()
 
         cls.adm = cls.srv.admin
-        cls.adm(r"""
-            box.schema.space.create('test')
+        resp = cls.adm("""
+            box.schema.space.create('test', {if_not_exists = true})
             box.space['test']:create_index('primary', {
                 type = 'tree',
                 parts = {1, 'string'},
-                unique = true})
+                unique = true,
+                if_not_exists = true})
 
             box.schema.user.create('test', {password = 'test', if_not_exists = true})
-            box.schema.user.grant('test', 'read,write,execute,create', 'universe')
+            box.schema.user.grant('test', 'read,write,execute,create', 'universe',
+                                  nil, {if_not_exists = true})
 
             box.schema.user.create('no_grants', {if_not_exists = true})
+
+            return true
         """)
+        assert_admin_success(resp)
 
         cls.conn_encoding_utf8 = tarantool.Connection(
             cls.srv.host, cls.srv.args['primary'],
@@ -78,7 +84,11 @@ def setUp(self):
         if self.srv.is_started():
             self.srv.touch_lock()
 
-        self.adm("box.space['test']:truncate()")
+        resp = self.adm("""
+            box.space['test']:truncate()
+            return true
+        """)
+        assert_admin_success(resp)
 
     # msgpack data for different encodings are actually the same,
     # but sometimes python msgpack module use different string
diff --git a/test/suites/test_execute.py b/test/suites/test_execute.py
index 66fe0982..46e85ce7 100644
--- a/test/suites/test_execute.py
+++ b/test/suites/test_execute.py
@@ -9,6 +9,7 @@
 import tarantool
 from .lib.tarantool_server import TarantoolServer
 from .lib.skip import skip_or_run_sql_test
+from .utils import assert_admin_success
 
 
 class TestSuiteExecute(unittest.TestCase):
@@ -32,6 +33,14 @@ def setUpClass(cls):
         cls.srv.start()
         cls.con = tarantool.Connection(cls.srv.host, cls.srv.args['primary'])
 
+        # grant full access to guest
+        resp = cls.srv.admin("""
+            box.schema.user.grant('guest', 'create,read,write,execute', 'universe',
+                                  nil, {if_not_exists = true})
+            return true
+        """)
+        assert_admin_success(resp)
+
     @skip_or_run_sql_test
     def setUp(self):
         # prevent a remote tarantool from clean our session
@@ -39,10 +48,6 @@ def setUp(self):
             self.srv.touch_lock()
         self.con.flush_schema()
 
-        # grant full access to guest
-        self.srv.admin("box.schema.user.grant('guest', 'create,read,write,"
-                       "execute', 'universe')")
-
     @classmethod
     def tearDownClass(cls):
         cls.con.close()
diff --git a/test/suites/test_interval.py b/test/suites/test_interval.py
index b2726776..c241b312 100644
--- a/test/suites/test_interval.py
+++ b/test/suites/test_interval.py
@@ -26,6 +26,7 @@
 
 from .lib.tarantool_server import TarantoolServer
 from .lib.skip import skip_or_run_datetime_test
+from .utils import assert_admin_success
 
 
 class TestSuiteInterval(unittest.TestCase):
@@ -38,17 +39,19 @@ def setUpClass(cls):
         cls.srv.start()
 
         cls.adm = cls.srv.admin
-        cls.adm(r"""
+        resp = cls.adm("""
             _, datetime = pcall(require, 'datetime')
 
-            box.schema.space.create('test')
+            box.schema.space.create('test', {if_not_exists = true})
             box.space['test']:create_index('primary', {
                 type = 'tree',
                 parts = {1, 'string'},
-                unique = true})
+                unique = true,
+                if_not_exists = true})
 
             box.schema.user.create('test', {password = 'test', if_not_exists = true})
-            box.schema.user.grant('test', 'read,write,execute', 'universe')
+            box.schema.user.grant('test', 'read,write,execute', 'universe',
+                                  nil, {if_not_exists = true})
 
             local function add(arg1, arg2)
                 return arg1 + arg2
@@ -59,7 +62,10 @@ def setUpClass(cls):
                 return arg1 - arg2
             end
             rawset(_G, 'sub', sub)
+
+            return true
         """)
+        assert_admin_success(resp)
 
         cls.con = tarantool.Connection(cls.srv.host, cls.srv.args['primary'],
                                        user='test', password='test')
@@ -69,7 +75,11 @@ def setUp(self):
         if self.srv.is_started():
             self.srv.touch_lock()
 
-        self.adm("box.space['test']:truncate()")
+        resp = self.adm("""
+            box.space['test']:truncate()
+            return true
+        """)
+        assert_admin_success(resp)
 
     def test_interval_positional_init(self):
         self.assertRaisesRegex(
diff --git a/test/suites/test_mesh.py b/test/suites/test_mesh.py
index b82ccc0e..606cc7d1 100644
--- a/test/suites/test_mesh.py
+++ b/test/suites/test_mesh.py
@@ -16,18 +16,23 @@
     ClusterDiscoveryWarning,
 )
 from .lib.tarantool_server import TarantoolServer
+from .utils import assert_admin_success
 
 
 def create_server(_id):
     srv = TarantoolServer()
     srv.script = 'test/suites/box.lua'
     srv.start()
-    srv.admin("box.schema.user.create('test', {password = 'test', "
-              "if_not_exists = true})")
-    srv.admin("box.schema.user.grant('test', 'execute', 'universe')")
+    resp = srv.admin(f"""
+        box.schema.user.create('test', {{password = 'test', if_not_exists = true}})
+        box.schema.user.grant('test', 'execute', 'universe',
+                              nil, {{if_not_exists = true}})
 
-    # Create srv_id function (for testing purposes).
-    srv.admin(f"function srv_id() return {_id} end")
+        function srv_id() return {_id} end
+
+        return true
+    """)
+    assert_admin_success(resp)
     return srv
 
 
@@ -43,18 +48,22 @@ def define_cluster_function(self, func_name, servers):
             function {func_name}()
                 return {{{addresses_lua}}}
             end
+            return true
         """
         for srv in self.servers:
-            srv.admin(func_body)
+            resp = srv.admin(func_body)
+            assert_admin_success(resp)
 
     def define_custom_cluster_function(self, func_name, retval):
         func_body = f"""
             function {func_name}()
                 return {retval}
             end
+            return true
         """
         for srv in self.servers:
-            srv.admin(func_body)
+            resp = srv.admin(func_body)
+            assert_admin_success(resp)
 
     @classmethod
     def setUpClass(cls):
@@ -99,7 +108,11 @@ def assert_srv_id(con, srv_id):
             # Start instance#1, stop instance#2 -- response from
             # instance#1 again.
             self.srv.start()
-            self.srv.admin('function srv_id() return 1 end')
+            resp = self.srv.admin("""
+                function srv_id() return 1 end
+                return true
+            """)
+            assert_admin_success(resp)
             self.srv2.stop()
             assert_srv_id(con, 1)
 
diff --git a/test/suites/test_pool.py b/test/suites/test_pool.py
index 7134f220..e15bcbbf 100644
--- a/test/suites/test_pool.py
+++ b/test/suites/test_pool.py
@@ -20,31 +20,46 @@
 
 from .lib.skip import skip_or_run_sql_test
 from .lib.tarantool_server import TarantoolServer
+from .utils import assert_admin_success
 
 
 def create_server(_id):
     srv = TarantoolServer()
     srv.script = 'test/suites/box.lua'
     srv.start()
-    srv.admin("box.schema.user.create('test', {password = 'test', "
-              "if_not_exists = true})")
-    srv.admin("box.schema.user.grant('test', 'execute', 'universe')")
-    srv.admin("box.schema.space.create('test')")
-    srv.admin(r"box.space.test:format({"
-              r" { name = 'pk', type = 'string' },"
-              r" { name = 'id', type = 'number', is_nullable = true }"
-              r"})")
-    srv.admin(r"box.space.test:create_index('pk',"
-              r"{ unique = true,"
-              r"  parts = {{field = 1, type = 'string'}}})")
-    srv.admin(r"box.space.test:create_index('id',"
-              r"{ unique = true,"
-              r"  parts = {{field = 2, type = 'number', is_nullable=true}}})")
-    srv.admin("box.schema.user.grant('test', 'read,write', 'space', 'test')")
-    srv.admin("json = require('json')")
-
-    # Create srv_id function (for testing purposes).
-    srv.admin(f"function srv_id() return {_id} end")
+    resp = srv.admin(f"""
+        box.schema.user.create('test', {{password = 'test', if_not_exists = true}})
+        box.schema.user.grant('test', 'execute', 'universe',
+                              nil, {{if_not_exists = true}})
+        box.schema.space.create('test', {{if_not_exists = true}})
+        box.space.test:format({{
+            {{ name = 'pk', type = 'string' }},
+            {{ name = 'id', type = 'number', is_nullable = true }}
+        }})
+        box.space.test:create_index('pk',
+            {{
+                unique = true,
+                parts = {{
+                    {{field = 1, type = 'string'}}
+                }},
+                if_not_exists = true,
+            }})
+        box.space.test:create_index('id',
+            {{
+                unique = true,
+                parts = {{
+                    {{field = 2, type = 'number', is_nullable=true}}
+                }},
+                if_not_exists = true,
+            }})
+        box.schema.user.grant('test', 'read,write', 'space', 'test', {{if_not_exists = true}})
+        json = require('json')
+
+        function srv_id() return {_id} end
+
+        return true
+    """)
+    assert_admin_success(resp)
     return srv
 
 
@@ -53,11 +68,12 @@ def create_server(_id):
 class TestSuitePool(unittest.TestCase):
     def set_ro(self, srv, read_only):
         if read_only:
-            req = r'box.cfg{read_only = true}'
+            req = r'box.cfg{read_only = true}; return true'
         else:
-            req = r'box.cfg{read_only = false}'
+            req = r'box.cfg{read_only = false}; return true'
 
-        srv.admin(req)
+        resp = srv.admin(req)
+        assert_admin_success(resp)
 
     def set_cluster_ro(self, read_only_list):
         assert len(self.servers) == len(read_only_list)
diff --git a/test/suites/test_push.py b/test/suites/test_push.py
index bd14455b..24a1ae7d 100644
--- a/test/suites/test_push.py
+++ b/test/suites/test_push.py
@@ -7,68 +7,58 @@
 import unittest
 import tarantool
 from .lib.tarantool_server import TarantoolServer
+from .utils import assert_admin_success
 
 
 def create_server():
     srv = TarantoolServer()
     srv.script = 'test/suites/box.lua'
     srv.start()
-    srv.admin("box.schema.user.create('test', {password = 'test', "
-              "if_not_exists = true})")
-    srv.admin("box.schema.user.grant('test', 'read,write,execute', 'universe')")
-
-    # Create server_function (for testing purposes).
-    srv.admin("""
-    function server_function()
-        x = {0,0}
-        while x[1] < 3 do
-            x[1] = x[1] + 1
-            box.session.push(x)
+    resp = srv.admin("""
+        box.schema.user.create('test', {password = 'test', if_not_exists = true})
+        box.schema.user.grant('test', 'read,write,execute', 'universe',
+                              nil, {if_not_exists = true})
+
+        function server_function()
+            x = {0,0}
+            while x[1] < 3 do
+                x[1] = x[1] + 1
+                box.session.push(x)
+            end
+            return x
         end
-        return x
-    end
-    """)
 
-    # Create tester space and on_replace trigger (for testing purposes).
-    srv.admin("""
-    box.schema.create_space(
-        'tester', {
-        format = {
-            {name = 'id', type = 'unsigned'},
-            {name = 'name', type = 'string'},
-        }
-    })
-    """)
-    srv.admin("""
-    box.space.tester:create_index(
-        'primary_index', {
-        parts = {
-            {field = 1, type = 'unsigned'},
-        }
-    })
-    """)
-    srv.admin("""
-    box.space.tester:create_index(
-        'primary_index', {
-        parts = {
-            {field = 1, type = 'unsigned'},
-        }
-    })
-    """)
-    srv.admin("""
-    function on_replace_callback()
-        x = {0,0}
-        while x[1] < 300 do
-            x[1] = x[1] + 100
-            box.session.push(x)
+        box.schema.create_space(
+            'tester', {
+            format = {
+                {name = 'id', type = 'unsigned'},
+                {name = 'name', type = 'string'},
+            }
+        })
+
+        box.space.tester:create_index(
+            'primary_index', {
+            parts = {
+                {field = 1, type = 'unsigned'},
+            },
+            if_not_exists = true,
+        })
+
+        function on_replace_callback()
+            x = {0,0}
+            while x[1] < 300 do
+                x[1] = x[1] + 100
+                box.session.push(x)
+            end
         end
-    end
-    """)
-    srv.admin("""
-    box.space.tester:on_replace(
-        on_replace_callback
-    )
+
+        box.space.tester:on_replace(
+            on_replace_callback
+        )
+
+        return true
     """)
+    assert_admin_success(resp)
 
     return srv
 
diff --git a/test/suites/test_schema.py b/test/suites/test_schema.py
index 1402616d..c90ddbff 100644
--- a/test/suites/test_schema.py
+++ b/test/suites/test_schema.py
@@ -1,7 +1,7 @@
 """
 This module tests space and index schema fetch.
 """
-# pylint: disable=missing-class-docstring,missing-function-docstring,fixme,too-many-public-methods,too-many-branches,too-many-statements
+# pylint: disable=missing-class-docstring,missing-function-docstring,fixme,too-many-public-methods,too-many-branches,too-many-statements,duplicate-code
 
 import sys
 import unittest
@@ -12,6 +12,7 @@
 
 from .lib.tarantool_server import TarantoolServer
 from .lib.skip import skip_or_run_constraints_test
+from .utils import assert_admin_success
 
 
 # FIXME: I'm quite sure that there is a simpler way to count
@@ -54,29 +55,35 @@ def setUpClass(cls):
         cls.srv = TarantoolServer()
         cls.srv.script = 'test/suites/box.lua'
         cls.srv.start()
-        cls.srv.admin("box.schema.user.create('test', {password = 'test', if_not_exists = true})")
-        cls.srv.admin("box.schema.user.grant('test', 'read,write,execute', 'universe')")
-
-        # Create server_function and tester space (for fetch_schema opt testing purposes).
-        cls.srv.admin("function server_function() return 2+2 end")
-        cls.srv.admin("""
-        box.schema.create_space(
-            'tester', {
-            format = {
-                {name = 'id', type = 'unsigned'},
-                {name = 'name', type = 'string', is_nullable = true},
-            }
-        })
-        """)
-        cls.srv.admin("""
-        box.space.tester:create_index(
-            'primary_index', {
-            parts = {
-                {field = 1, type = 'unsigned'},
-            }
-        })
+        resp = cls.srv.admin("""
+            box.schema.user.create('test', {password = 'test', if_not_exists = true})
+            box.schema.user.grant('test', 'read,write,execute', 'universe',
+                                  nil, {if_not_exists = true})
+
+            function server_function() return 2+2 end
+
+            box.schema.create_space(
+                'tester', {
+                format = {
+                    {name = 'id', type = 'unsigned'},
+                    {name = 'name', type = 'string', is_nullable = true},
+                },
+                if_not_exists = true,
+            })
+
+            box.space.tester:create_index(
+                'primary_index', {
+                parts = {
+                    {field = 1, type = 'unsigned'},
+                },
+                if_not_exists = true,
+            })
+
+            box.space.tester:insert({1, nil})
+
+            return true
         """)
-        cls.srv.admin("box.space.tester:insert({1, null})")
+        assert_admin_success(resp)
 
         cls.con = tarantool.Connection(cls.srv.host, cls.srv.args['primary'],
                                        encoding=cls.encoding, user='test', password='test')
@@ -112,31 +119,34 @@ def setUpClass(cls):
         """)
 
         if cls.srv.admin.tnt_version >= pkg_resources.parse_version('2.10.0'):
-            cls.srv.admin("""
-            box.schema.create_space(
-                'constr_tester_1', {
-                format = {
-                    { name = 'id', type = 'unsigned' },
-                    { name = 'payload', type = 'number' },
-                }
-            })
-            box.space.constr_tester_1:create_index('I1', { parts = {'id'} })
-
-            box.space.constr_tester_1:replace({1, 999})
-
-            box.schema.create_space(
-                'constr_tester_2', {
-                format = {
-                    { name = 'id', type = 'unsigned' },
-                    { name = 'table1_id', type = 'unsigned',
-                      foreign_key = { fk_video = { space = 'constr_tester_1', field = 'id' } },
-                    },
-                    { name = 'payload', type = 'number' },
-                }
-            })
-            box.space.constr_tester_2:create_index('I1', { parts = {'id'} })
-            box.space.constr_tester_2:create_index('I2', { parts = {'table1_id'} })
+            resp = cls.srv.admin("""
+                box.schema.create_space(
+                    'constr_tester_1', {
+                    format = {
+                        { name = 'id', type = 'unsigned' },
+                        { name = 'payload', type = 'number' },
+                    }
+                })
+                box.space.constr_tester_1:create_index('I1', { parts = {'id'} })
+
+                box.space.constr_tester_1:replace({1, 999})
+
+                box.schema.create_space(
+                    'constr_tester_2', {
+                    format = {
+                        { name = 'id', type = 'unsigned' },
+                        { name = 'table1_id', type = 'unsigned',
+                          foreign_key = { fk_video = { space = 'constr_tester_1', field = 'id' } },
+                        },
+                        { name = 'payload', type = 'number' },
+                    }
+                })
+                box.space.constr_tester_2:create_index('I1', { parts = {'id'} })
+                box.space.constr_tester_2:create_index('I2', { parts = {'table1_id'} })
+
+                return true
             """)
+            assert_admin_success(resp)
 
     def setUp(self):
         # prevent a remote tarantool from clean our session
@@ -603,10 +613,13 @@ def tearDownClass(cls):
         # We need to drop spaces with foreign keys with predetermined order,
         # otherwise remote server clean() will fail to clean up resources.
         if cls.srv.admin.tnt_version >= pkg_resources.parse_version('2.10.0'):
-            cls.srv.admin("""
-            box.space.constr_tester_2:drop()
-            box.space.constr_tester_1:drop()
+            resp = cls.srv.admin("""
+                box.space.constr_tester_2:drop()
+                box.space.constr_tester_1:drop()
+
+                return true
             """)
+            assert_admin_success(resp)
 
         cls.con.close()
         cls.con_schema_disable.close()
diff --git a/test/suites/test_uuid.py b/test/suites/test_uuid.py
index 0a9ef06b..90943fcb 100644
--- a/test/suites/test_uuid.py
+++ b/test/suites/test_uuid.py
@@ -7,6 +7,7 @@
 import unittest
 import uuid
 
+import pkg_resources
 import msgpack
 
 import tarantool
@@ -15,6 +16,7 @@
 
 from .lib.tarantool_server import TarantoolServer
 from .lib.skip import skip_or_run_uuid_test
+from .utils import assert_admin_success
 
 
 class TestSuiteUUID(unittest.TestCase):
@@ -27,26 +29,35 @@ def setUpClass(cls):
         cls.srv.start()
 
         cls.adm = cls.srv.admin
-        cls.adm(r"""
+        resp = cls.adm("""
             _, uuid = pcall(require, 'uuid')
 
-            box.schema.space.create('test')
+            box.schema.space.create('test', {if_not_exists = true})
             box.space['test']:create_index('primary', {
                 type = 'tree',
                 parts = {1, 'string'},
-                unique = true})
+                unique = true,
+                if_not_exists = true})
 
-            pcall(function()
-                box.schema.space.create('test_pk')
+            box.schema.user.create('test', {password = 'test', if_not_exists = true})
+            box.schema.user.grant('test', 'read,write,execute', 'universe',
+                                  nil, {if_not_exists = true})
+
+            return true
+        """)
+        assert_admin_success(resp)
+
+        if cls.srv.admin.tnt_version >= pkg_resources.parse_version('2.4.1'):
+            resp = cls.adm("""
+                box.schema.space.create('test_pk', {if_not_exists = true})
                 box.space['test_pk']:create_index('primary', {
                     type = 'tree',
                     parts = {1, 'uuid'},
-                    unique = true})
-            end)
-
-            box.schema.user.create('test', {password = 'test', if_not_exists = true})
-            box.schema.user.grant('test', 'read,write,execute', 'universe')
-        """)
+                    unique = true,
+                    if_not_exists = true})
+                return true
+            """)
+            assert_admin_success(resp)
 
         cls.con = tarantool.Connection(cls.srv.host, cls.srv.args['primary'],
                                        user='test', password='test')
@@ -56,7 +67,11 @@ def setUp(self):
         if self.srv.is_started():
             self.srv.touch_lock()
 
-        self.adm("box.space['test']:truncate()")
+        resp = self.adm("""
+            box.space['test']:truncate()
+            return true
+        """)
+        assert_admin_success(resp)
 
     cases = {
         'uuid_1': {
diff --git a/test/suites/utils.py b/test/suites/utils.py
new file mode 100644
index 00000000..65e68b4c
--- /dev/null
+++ b/test/suites/utils.py
@@ -0,0 +1,16 @@
+"""
+Various test utilities.
+"""
+
+
+def assert_admin_success(resp):
+    """
+    Util to assert admin text request response.
+    It is expected that request last line is `return true`.
+    If something went wrong on executing, Tarantool throws an error
+    which would be a part of return values.
+    """
+
+    assert isinstance(resp, list), f'got unexpected resp type: {type(resp)}'
+    assert len(resp) > 0, 'got unexpected empty resp'
+    assert resp[0] is True, f'got unexpected resp: {resp}'