test: verify schema reload on unicode names

In Python 2 a binary string and a Unicode string with the same
ASCII characters are considered equal:

 | >>> 'x' == u'x'
 | True
 | >>> u'x' == 'x'
 | True

It works seamlessly with dictionary keys too:

 | >>> d = dict()
 | >>> d[u'x'] = 42
 | >>> d['x']
 | 42

This, however, does not work for non-ASCII characters:

 | >>> 'ч' == u'ч'
 | False
 | >>> u'ч' == 'ч'
 | False

 | >>> d = dict()
 | >>> d[u'ч'] = 42
 | >>> d['ч']
 | Traceback (most recent call last):
 |   File "<stdin>", line 1, in <module>
 | KeyError: '\xd1\x87'

The implemented test cases verify schema loading for a space or an index
with a non-ASCII name, when it is passed just as a literal: say, '∞'.

The main purpose of the commit is to add test cases that verify that no
extra schema fetch is performed for a space / index name given as
non-ASCII string literal (which is binary string on Python 2). If a
cache is implemented without taking care to this, an already cached
value may be missed.

unit/suites/test_schema.py

@@ -49,6 +49,23 @@ def setUpClass(self):
                                         encoding=self.encoding)
         self.sch = self.con.schema
 
+        # The relevant test cases mainly target Python 2, where
+        # a user may want to pass a string literal as a space or
+        # an index name and don't bother whether all symbols in it
+        # are ASCII.
+        self.unicode_space_name_literal = '∞'
+        self.unicode_index_name_literal = '→'
+
+        self.unicode_space_name_u = u'∞'
+        self.unicode_index_name_u = u'→'
+        self.unicode_space_id, self.unicode_index_id = self.srv.admin("""
+            do
+                local space = box.schema.create_space('\\xe2\\x88\\x9e')
+                local index = space:create_index('\\xe2\\x86\\x92')
+                return space.id, index.id
+            end
+        """)
+
     def setUp(self):
         # prevent a remote tarantool from clean our session
         if self.srv.is_started():
@@ -73,6 +90,17 @@ def fetch_count(self):
         res += self.fetch_index_counter.call_count()
         return res
 
+    def verify_unicode_space(self, space):
+        self.assertEqual(space.sid, self.unicode_space_id)
+        self.assertEqual(space.name, self.unicode_space_name_u)
+        self.assertEqual(space.arity, 1)
+
+    def verify_unicode_index(self, index):
+        self.assertEqual(index.space.name, self.unicode_space_name_u)
+        self.assertEqual(index.iid, self.unicode_index_id)
+        self.assertEqual(index.name, self.unicode_index_name_u)
+        self.assertEqual(len(index.parts), 1)
+
     def test_00_authenticate(self):
         self.assertIsNone(self.srv.admin("box.schema.user.create('test', { password = 'test' })"))
         self.assertIsNone(self.srv.admin("box.schema.user.grant('test', 'read,write', 'space', '_space')"))
@@ -122,6 +150,9 @@ def test_03_01_space_name__(self):
         self.assertEqual(space.name, '_index')
         self.assertEqual(space.arity, 1)
 
+        space = self.sch.get_space(self.unicode_space_name_literal)
+        self.verify_unicode_space(space)
+
     def test_03_02_space_number(self):
         self.con.flush_schema()
         space = self.sch.get_space(272)
@@ -137,6 +168,9 @@ def test_03_02_space_number(self):
         self.assertEqual(space.name, '_index')
         self.assertEqual(space.arity, 1)
 
+        space = self.sch.get_space(self.unicode_space_id)
+        self.verify_unicode_space(space)
+
     def test_04_space_cached(self):
         space = self.sch.get_space('_schema')
         self.assertEqual(space.sid, 272)
@@ -154,6 +188,12 @@ def test_04_space_cached(self):
         # Verify that no schema fetches occurs.
         self.assertEqual(self.fetch_count, 0)
 
+        space = self.sch.get_space(self.unicode_space_name_literal)
+        self.verify_unicode_space(space)
+
+        # Verify that no schema fetches occurs.
+        self.assertEqual(self.fetch_count, 0)
+
     def test_05_01_index_name___name__(self):
         self.con.flush_schema()
         index = self.sch.get_index('_index', 'primary')
@@ -177,6 +217,10 @@ def test_05_01_index_name___name__(self):
         self.assertEqual(index.name, 'name')
         self.assertEqual(len(index.parts), 1)
 
+        index = self.sch.get_index(self.unicode_space_name_literal,
+                                   self.unicode_index_name_literal)
+        self.verify_unicode_index(index)
+
     def test_05_02_index_name___number(self):
         self.con.flush_schema()
         index = self.sch.get_index('_index', 0)
@@ -200,6 +244,10 @@ def test_05_02_index_name___number(self):
         self.assertEqual(index.name, 'name')
         self.assertEqual(len(index.parts), 1)
 
+        index = self.sch.get_index(self.unicode_space_name_literal,
+                                   self.unicode_index_id)
+        self.verify_unicode_index(index)
+
     def test_05_03_index_number_name__(self):
         self.con.flush_schema()
         index = self.sch.get_index(288, 'primary')
@@ -223,6 +271,10 @@ def test_05_03_index_number_name__(self):
         self.assertEqual(index.name, 'name')
         self.assertEqual(len(index.parts), 1)
 
+        index = self.sch.get_index(self.unicode_space_id,
+                                   self.unicode_index_name_literal)
+        self.verify_unicode_index(index)
+
     def test_05_04_index_number_number(self):
         self.con.flush_schema()
         index = self.sch.get_index(288, 0)
@@ -246,6 +298,10 @@ def test_05_04_index_number_number(self):
         self.assertEqual(index.name, 'name')
         self.assertEqual(len(index.parts), 1)
 
+        index = self.sch.get_index(self.unicode_space_id,
+                                   self.unicode_index_id)
+        self.verify_unicode_index(index)
+
     def test_06_index_cached(self):
         index = self.sch.get_index('_index', 'primary')
         self.assertEqual(index.space.name, '_index')
@@ -271,6 +327,19 @@ def test_06_index_cached(self):
         # Verify that no schema fetches occurs.
         self.assertEqual(self.fetch_count, 0)
 
+        cases = (
+            (self.unicode_space_name_literal, self.unicode_index_name_literal),
+            (self.unicode_space_name_literal, self.unicode_index_id),
+            (self.unicode_space_id, self.unicode_index_name_literal),
+            (self.unicode_space_id, self.unicode_index_id),
+        )
+        for s, i in cases:
+            index = self.sch.get_index(s, i)
+            self.verify_unicode_index(index)
+
+        # Verify that no schema fetches occurs.
+        self.assertEqual(self.fetch_count, 0)
+
     def test_07_schema_version_update(self):
         _space_len = len(self.con.select('_space'))
         self.srv.admin("box.schema.create_space('ttt22')")