Fix some tests.

Author: methane

Diff for: runtests.py

@@ -1,7 +1,8 @@
 #!/usr/bin/env python
 import unittest
 
-from tornado_mysql import PYPY, JYTHON, IRONPYTHON
+from tornado_mysql._compat import PYPY, JYTHON, IRONPYTHON
+import tornado_mysql.tests
 
 if not (PYPY or JYTHON or IRONPYTHON):
     import atexit
@@ -22,5 +23,4 @@ def report_uncollectable():
                 print("referrer:", ref)
             print('---')
 
-import pymysql.tests
-unittest.main(pymysql.tests)
+unittest.main(tornado_mysql.tests)

Diff for: setup.py

@@ -1,12 +1,7 @@
 #!/usr/bin/env python
 from setuptools import setup, find_packages
 
-version_tuple = __import__('tornado_mysql').VERSION
-
-if version_tuple[3] is not None:
-    version = "%d.%d.%d_%s" % version_tuple
-else:
-    version = "%d.%d.%d" % version_tuple[:3]
+version = "0.1dev1"
 
 try:
     with open('README.rst') as f:
@@ -15,13 +10,11 @@
     readme = ''
 
 setup(
-    name="PyMySQL",
+    name="Tornado-MySQL",
     version=version,
     url='https://github.com/PyMySQL/Tornado-MySQL',
-    author='yutaka.matsubara',
-    author_email='[email protected]',
-    maintainer='INADA Naoki',
-    maintainer_email='[email protected]',
+    author='INADA Naoki',
+    author_email='[email protected]',
     description='Pure-Python MySQL Driver for Tornado',
     install_requires=['tornado>=4.0'],
     long_description=readme,
@@ -39,5 +32,5 @@
         'Intended Audience :: Developers',
         'License :: OSI Approved :: MIT License',
         'Topic :: Database',
-    ]
+    ],
 )

Diff for: tornado_mysql/connections.py

@@ -576,7 +576,7 @@ def close(self):
     @gen.coroutine
     def close_async(self):
         send_data = struct.pack('<i', 1) + int2byte(COM_QUIT)
-        yield stream.write(send_data)
+        yield self._stream.write(send_data)
         self.close()
 
     @property
@@ -632,6 +632,7 @@ def rollback(self):
         yield self._execute_command(COM_QUERY, "ROLLBACK")
         yield self._read_ok_packet()
 
+    @gen.coroutine
     def select_db(self, db):
         '''Set current db'''
         yield self._execute_command(COM_INIT_DB, db)
@@ -673,7 +674,7 @@ def query(self, sql, unbuffered=False):
     @gen.coroutine
     def next_result(self):
         yield self._read_query_result()
-        return self._affected_rows
+        raise gen.Return(self._affected_rows)
 
     def affected_rows(self):
         return self._affected_rows
@@ -687,7 +688,7 @@ def kill(self, thread_id):
     @gen.coroutine
     def ping(self, reconnect=True):
         """Check if the server is alive"""
-        if self.socket is None:
+        if self._stream is None:
             if reconnect:
                 yield self.connect()
                 reconnect = False
@@ -762,25 +763,28 @@ def _read_packet(self, packet_type=MysqlPacket):
         and return a MysqlPacket type that represents the results.
         """
         buff = b''
-        while True:
-            packet_header = yield self._stream.read_bytes(4)
-            if DEBUG: dump_packet(packet_header)
-            packet_length_bin = packet_header[:3]
-
-            #TODO: check sequence id
-            #  packet_number
-            byte2int(packet_header[3])
-
-            bin_length = packet_length_bin + b'\0'  # pad little-endian number
-            bytes_to_read = struct.unpack('<I', bin_length)[0]
-            recv_data = yield self._stream.read_bytes(bytes_to_read)
-            if DEBUG: dump_packet(recv_data)
-            buff += recv_data
-            if bytes_to_read < MAX_PACKET_LEN:
-                break
+        try:
+            while True:
+                packet_header = yield self._stream.read_bytes(4)
+                if DEBUG: dump_packet(packet_header)
+                packet_length_bin = packet_header[:3]
+
+                #TODO: check sequence id
+                #  packet_number
+                byte2int(packet_header[3])
+
+                bin_length = packet_length_bin + b'\0'  # pad little-endian number
+                bytes_to_read = struct.unpack('<I', bin_length)[0]
+                recv_data = yield self._stream.read_bytes(bytes_to_read)
+                if DEBUG: dump_packet(recv_data)
+                buff += recv_data
+                if bytes_to_read < MAX_PACKET_LEN:
+                    break
+        except iostream.StreamClosedError as e:
+            raise OperationalError(2006, "MySQL server has gone away (%s)" % (e,))
         packet = packet_type(buff, self.encoding)
         packet.check_error()
-        return packet
+        raise gen.Return(packet)
 
     def _write_bytes(self, data):
         return self._stream.write(data)
@@ -1001,7 +1005,7 @@ def read(self):
             if first_packet.is_ok_packet():
                 self._read_ok_packet(first_packet)
             else:
-                self._read_result_packet(first_packet)
+                yield self._read_result_packet(first_packet)
         finally:
             self.connection = None
 

Diff for: tornado_mysql/cursors.py

@@ -134,6 +134,7 @@ def ensure_bytes(x):
 
         yield self._query(query)
         self._executed = query
+        raise gen.Return(self.rowcount)
 
     @gen.coroutine
     def executemany(self, query, args):
@@ -159,6 +160,7 @@ def executemany(self, query, args):
                 yield self.execute(query, arg)
                 rows += self.rowcount
             self.rowcount = rows
+        raise gen.Return(self.rowcount)
 
     @gen.coroutine
     def _do_execute_many(self, prefix, values, args, max_stmt_length, encoding):
@@ -179,14 +181,13 @@ def _do_execute_many(self, prefix, values, args, max_stmt_length, encoding):
                 v = v.encode(encoding)
             if len(sql) + len(v) + 1 > max_stmt_length:
                 print(sql)
-                yield self.execute(sql)
+                yield self.execute(bytes(sql))
                 rows += self.rowcount
                 sql = bytearray(prefix)
             else:
                 sql += b','
             sql += v
-        print(sql)
-        yield self.execute(sql)
+        yield self.execute(bytes(sql))
         rows += self.rowcount
         self.rowcount = rows
 
@@ -313,9 +314,8 @@ class DictCursorMixin(object):
     # You can override this to use OrderedDict or other dict-like types.
     dict_type = dict
 
-    @gen.coroutine
     def _do_get_result(self):
-        yield super(DictCursorMixin, self)._do_get_result()
+        super(DictCursorMixin, self)._do_get_result()
         fields = []
         if self.description:
             for f in self._result.fields:
@@ -378,7 +378,7 @@ def _query(self, q):
         self._last_executed = q
         yield conn.query(q, unbuffered=True)
         yield self._do_get_result()
-        return self.rowcount
+        raise gen.Return(self.rowcount)
 
     @gen.coroutine
     def read_next(self):
@@ -393,45 +393,39 @@ def fetchone(self):
         self._check_executed()
         row = yield self.read_next()
         if row is None:
-            return None
+            raise gen.Return()
         self.rownumber += 1
-        return row
+        raise gen.Return(row)
 
+    @gen.coroutine
     def fetchall(self):
         """
         Fetch all, as per MySQLdb. Pretty useless for large queries, as
-        it is buffered. See fetchall_unbuffered(), if you want an unbuffered
-        generator version of this method.
-
-        """
-        return list(self.fetchall_unbuffered())
-
-    def fetchall_unbuffered(self):
-        """
-        Fetch all, implemented as a generator, which isn't to standard,
-        however, it doesn't make sense to return everything in a list, as that
-        would use ridiculous memory for large result sets.
+        it is buffered.
         """
-        return iter(self.fetchone, None)
-
-    def __iter__(self):
-        return self.fetchall_unbuffered()
+        rows = []
+        while True:
+            row = yield self.fetchone()
+            if row is None:
+                break
+            rows.append(row)
+        raise gen.Return(rows)
 
+    @gen.coroutine
     def fetchmany(self, size=None):
-        """ Fetch many """
-
+        """Fetch many"""
         self._check_executed()
         if size is None:
             size = self.arraysize
 
         rows = []
         for i in range_type(size):
-            row = self.read_next()
+            row = yield self.read_next()
             if row is None:
                 break
             rows.append(row)
             self.rownumber += 1
-        return rows
+        raise gen.Return(rows)
 
     def scroll(self, value, mode='relative'):
         self._check_executed()

Diff for: tornado_mysql/tests/__init__.py

@@ -1,4 +1,4 @@
-#from tornado_mysql.tests.test_issues import *
+from tornado_mysql.tests.test_issues import *
 from tornado_mysql.tests.test_basic import *
 #from tornado_mysql.tests.test_nextset import *
 #from tornado_mysql.tests.test_DictCursor import *

Diff for: tornado_mysql/tests/test_basic.py

@@ -270,7 +270,6 @@ def prepare():
 PRIMARY KEY (id)
 )
 """)
-            print("created bulkinsert")
         self.io_loop.run_sync(prepare)
 
     @gen.coroutine

Diff for: tornado_mysql/tests/test_connection.py

@@ -7,26 +7,26 @@
 
 
 class TestConnection(base.PyMySQLTestCase):
-    @gen.test
+    @gen_test
     def test_utf8mb4(self):
         """This test requires MySQL >= 5.5"""
         arg = self.databases[0].copy()
         arg['charset'] = 'utf8mb4'
         conn = yield tornado_mysql.connect(**arg)
 
-    @gen.test
+    @gen_test
     def test_largedata(self):
         """Large query and response (>=16MB)"""
         cur = self.connections[0].cursor()
-        cur.execute("SELECT @@max_allowed_packet")
+        yield cur.execute("SELECT @@max_allowed_packet")
         if cur.fetchone()[0] < 16*1024*1024 + 10:
             print("Set max_allowed_packet to bigger than 17MB")
-            return
-        t = 'a' * (16*1024*1024)
-        yield cur.execute("SELECT '" + t + "'")
-        assert cur.fetchone()[0] == t
+        else:
+            t = 'a' * (16*1024*1024)
+            yield cur.execute("SELECT '" + t + "'")
+            assert cur.fetchone()[0] == t
 
-    @gen.test
+    @gen_test
     def test_escape_string(self):
         con = self.connections[0]
         cur = con.cursor()
@@ -35,7 +35,7 @@ def test_escape_string(self):
         yield cur.execute("SET sql_mode='NO_BACKSLASH_ESCAPES'")
         self.assertEqual(con.escape("foo'bar"), "'foo''bar'")
 
-    @gen.test
+    @gen_test
     def test_autocommit(self):
         con = self.connections[0]
         self.assertFalse(con.get_autocommit())
@@ -49,7 +49,7 @@ def test_autocommit(self):
         yield cur.execute("SELECT @@AUTOCOMMIT")
         self.assertEqual(cur.fetchone()[0], 0)
 
-    @gen.test
+    @gen_test
     def test_select_db(self):
         con = self.connections[0]
         current_db = self.databases[0]['db']
@@ -59,11 +59,11 @@ def test_select_db(self):
         yield cur.execute('SELECT database()')
         self.assertEqual(cur.fetchone()[0], current_db)
 
-        con.select_db(other_db)
+        yield con.select_db(other_db)
         yield cur.execute('SELECT database()')
         self.assertEqual(cur.fetchone()[0], other_db)
 
-    @gen.test
+    @gen_test
     def test_connection_gone_away(self):
         """
         http://dev.mysql.com/doc/refman/5.0/en/gone-away.html