Backport PR #6556: Use some more informative asserts in inprocess kernel tests

Prompted by gh-6552 (but doesn't fix it)

IPython/kernel/inprocess/tests/test_kernel.py

@@ -1,95 +1,95 b''
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2012  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 from __future__ import print_function
 
 # Standard library imports
 import sys
 import unittest
 
 # Local imports
 from IPython.kernel.inprocess.blocking import BlockingInProcessKernelClient
 from IPython.kernel.inprocess.manager import InProcessKernelManager
 from IPython.kernel.inprocess.ipkernel import InProcessKernel
 from IPython.testing.decorators import skipif_not_matplotlib
 from IPython.utils.io import capture_output
 from IPython.utils import py3compat
 
 if py3compat.PY3:
     from io import StringIO
 else:
     from StringIO import StringIO
 
 #-----------------------------------------------------------------------------
 # Test case
 #-----------------------------------------------------------------------------
 
 class InProcessKernelTestCase(unittest.TestCase):
 
     def setUp(self):
         self.km = InProcessKernelManager()
         self.km.start_kernel()
         self.kc = BlockingInProcessKernelClient(kernel=self.km.kernel)
         self.kc.start_channels()
 
     @skipif_not_matplotlib
     def test_pylab(self):
         """ Does pylab work in the in-process kernel?
         """
         kc = self.kc
         kc.execute('%pylab')
         msg = get_stream_message(kc)
-        self.assert_('matplotlib' in msg['content']['data'])
+        self.assertIn('matplotlib', msg['content']['data'])
 
     def test_raw_input(self):
         """ Does the in-process kernel handle raw_input correctly?
         """
         io = StringIO('foobar\n')
         sys_stdin = sys.stdin
         sys.stdin = io
         try:
             if py3compat.PY3:
                 self.kc.execute('x = input()')
             else:
                 self.kc.execute('x = raw_input()')
         finally:
             sys.stdin = sys_stdin
         self.assertEqual(self.km.kernel.shell.user_ns.get('x'), 'foobar')
 
     def test_stdout(self):
         """ Does the in-process kernel correctly capture IO?
         """
         kernel = InProcessKernel()
 
         with capture_output() as io:
             kernel.shell.run_cell('print("foo")')
         self.assertEqual(io.stdout, 'foo\n')
 
         kc = BlockingInProcessKernelClient(kernel=kernel)
         kernel.frontends.append(kc)
         kc.shell_channel.execute('print("bar")')
         msg = get_stream_message(kc)
         self.assertEqual(msg['content']['data'], 'bar\n')
 
 #-----------------------------------------------------------------------------
 # Utility functions
 #-----------------------------------------------------------------------------
 
 def get_stream_message(kernel_client, timeout=5):
     """ Gets a single stream message synchronously from the sub channel.
     """
     while True:
         msg = kernel_client.get_iopub_msg(timeout=timeout)
         if msg['header']['msg_type'] == 'stream':
             return msg
 
 
 if __name__ == '__main__':
     unittest.main()

IPython/kernel/inprocess/tests/test_kernelmanager.py

@@ -1,111 +1,111 b''
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2012  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 from __future__ import print_function
 
 # Standard library imports
 import unittest
 
 # Local imports
 from IPython.kernel.inprocess.blocking import BlockingInProcessKernelClient
 from IPython.kernel.inprocess.manager import InProcessKernelManager
 
 #-----------------------------------------------------------------------------
 # Test case
 #-----------------------------------------------------------------------------
 
 class InProcessKernelManagerTestCase(unittest.TestCase):
 
     def test_interface(self):
         """ Does the in-process kernel manager implement the basic KM interface?
         """
         km = InProcessKernelManager()
         self.assert_(not km.has_kernel)
 
         km.start_kernel()
         self.assert_(km.has_kernel)
         self.assert_(km.kernel is not None)
 
         kc = BlockingInProcessKernelClient(kernel=km.kernel)
         self.assert_(not kc.channels_running)
 
         kc.start_channels()
         self.assert_(kc.channels_running)
 
         old_kernel = km.kernel
         km.restart_kernel()
-        self.assert_(km.kernel is not None)
+        self.assertIsNotNone(km.kernel)
         self.assertNotEquals(km.kernel, old_kernel)
 
         km.shutdown_kernel()
         self.assert_(not km.has_kernel)
 
         self.assertRaises(NotImplementedError, km.interrupt_kernel)
         self.assertRaises(NotImplementedError, km.signal_kernel, 9)
 
         kc.stop_channels()
         self.assert_(not kc.channels_running)
 
     def test_execute(self):
         """ Does executing code in an in-process kernel work?
         """
         km = InProcessKernelManager()
         km.start_kernel()
         kc = BlockingInProcessKernelClient(kernel=km.kernel)
         kc.start_channels()
         kc.execute('foo = 1')
         self.assertEquals(km.kernel.shell.user_ns['foo'], 1)
 
     def test_complete(self):
         """ Does requesting completion from an in-process kernel work?
         """
         km = InProcessKernelManager()
         km.start_kernel()
         kc = BlockingInProcessKernelClient(kernel=km.kernel)
         kc.start_channels()
         km.kernel.shell.push({'my_bar': 0, 'my_baz': 1})
         kc.complete('my_ba', 'my_ba', 5)
         msg = kc.get_shell_msg()
         self.assertEqual(msg['header']['msg_type'], 'complete_reply')
         self.assertEqual(sorted(msg['content']['matches']),
                           ['my_bar', 'my_baz'])
 
     def test_object_info(self):
         """ Does requesting object information from an in-process kernel work?
         """
         km = InProcessKernelManager()
         km.start_kernel()
         kc = BlockingInProcessKernelClient(kernel=km.kernel)
         kc.start_channels()
         km.kernel.shell.user_ns['foo'] = 1
         kc.object_info('foo')
         msg = kc.get_shell_msg()
         self.assertEquals(msg['header']['msg_type'], 'object_info_reply')
         self.assertEquals(msg['content']['name'], 'foo')
         self.assertEquals(msg['content']['type_name'], 'int')
 
     def test_history(self):
         """ Does requesting history from an in-process kernel work?
         """
         km = InProcessKernelManager()
         km.start_kernel()
         kc = BlockingInProcessKernelClient(kernel=km.kernel)
         kc.start_channels()
         kc.execute('%who')
         kc.history(hist_access_type='tail', n=1)
         msg = kc.shell_channel.get_msgs()[-1]
         self.assertEquals(msg['header']['msg_type'], 'history_reply')
         history = msg['content']['history']
         self.assertEquals(len(history), 1)
         self.assertEquals(history[0][2], '%who')
 
 
 if __name__ == '__main__':
     unittest.main()