Add failing test for listing nonexistant directory

IPython/html/services/notebooks/tests/test_notebooks_api.py

@@ -1,215 +1,213
 # coding: utf-8
 """Test the notebooks webservice API."""
 
 import io
 import os
 import shutil
 from unicodedata import normalize
 
 from zmq.utils import jsonapi
 
 pjoin = os.path.join
 
 import requests
 
 from IPython.html.utils import url_path_join
-from IPython.html.tests.launchnotebook import NotebookTestBase
+from IPython.html.tests.launchnotebook import NotebookTestBase, assert_http_error
 from IPython.nbformat.current import (new_notebook, write, read, new_worksheet,
                                       new_heading_cell, to_notebook_json)
 from IPython.utils.data import uniq_stable
 
 class NBAPI(object):
     """Wrapper for notebook API calls."""
     def __init__(self, base_url):
         self.base_url = base_url
 
     @property
     def nb_url(self):
         return url_path_join(self.base_url, 'api/notebooks')
 
     def _req(self, verb, path, body=None):
         response = requests.request(verb,
                 url_path_join(self.base_url, 'api/notebooks', path), data=body)
         response.raise_for_status()
         return response
 
     def list(self, path='/'):
         return self._req('GET', path)
 
     def read(self, name, path='/'):
         return self._req('GET', url_path_join(path, name))
 
     def create_untitled(self, path='/'):
         return self._req('POST', path)
 
     def upload(self, name, body, path='/'):
         return self._req('POST', url_path_join(path, name), body)
 
     def copy(self, name, path='/'):
         return self._req('POST', url_path_join(path, name, 'copy'))
 
     def save(self, name, body, path='/'):
         return self._req('PUT', url_path_join(path, name), body)
 
     def delete(self, name, path='/'):
         return self._req('DELETE', url_path_join(path, name))
 
     def rename(self, name, path, new_name):
         body = jsonapi.dumps({'name': new_name})
         return self._req('PATCH', url_path_join(path, name), body)
 
 class APITest(NotebookTestBase):
     """Test the kernels web service API"""
     dirs_nbs = [('', 'inroot'),
                 ('Directory with spaces in', 'inspace'),
                 (u'unicodé', 'innonascii'),
                 ('foo', 'a'),
                 ('foo', 'b'),
                 ('foo', 'name with spaces'),
                 ('foo', u'unicodé'),
                 ('foo/bar', 'baz'),
                ]
 
     dirs = uniq_stable([d for (d,n) in dirs_nbs])
     del dirs[0]  # remove ''
 
     def setUp(self):
         nbdir = self.notebook_dir.name
 
         for d in self.dirs:
             os.mkdir(pjoin(nbdir, d))
 
         for d, name in self.dirs_nbs:
             with io.open(pjoin(nbdir, d, '%s.ipynb' % name), 'w') as f:
                 nb = new_notebook(name=name)
                 write(nb, f, format='ipynb')
 
         self.nb_api = NBAPI(self.base_url())
 
     def tearDown(self):
         nbdir = self.notebook_dir.name
 
         for dname in ['foo', 'Directory with spaces in', u'unicodé']:
             shutil.rmtree(pjoin(nbdir, dname), ignore_errors=True)
 
         if os.path.isfile(pjoin(nbdir, 'inroot.ipynb')):
             os.unlink(pjoin(nbdir, 'inroot.ipynb'))
 
     def test_list_notebooks(self):
         nbs = self.nb_api.list().json()
         self.assertEqual(len(nbs), 1)
         self.assertEqual(nbs[0]['name'], 'inroot.ipynb')
 
         nbs = self.nb_api.list('/Directory with spaces in/').json()
         self.assertEqual(len(nbs), 1)
         self.assertEqual(nbs[0]['name'], 'inspace.ipynb')
 
         nbs = self.nb_api.list(u'/unicodé/').json()
         self.assertEqual(len(nbs), 1)
         self.assertEqual(nbs[0]['name'], 'innonascii.ipynb')
 
         nbs = self.nb_api.list('/foo/bar/').json()
         self.assertEqual(len(nbs), 1)
         self.assertEqual(nbs[0]['name'], 'baz.ipynb')
 
         nbs = self.nb_api.list('foo').json()
         self.assertEqual(len(nbs), 4)
         nbnames = { normalize('NFC', n['name']) for n in nbs }
         expected = [ u'a.ipynb', u'b.ipynb', u'name with spaces.ipynb', u'unicodé.ipynb']
         expected = { normalize('NFC', name) for name in expected }
         self.assertEqual(nbnames, expected)
 
-    def assert_404(self, name, path):
-        try:
-            self.nb_api.read(name, path)
-        except requests.HTTPError as e:
-            self.assertEqual(e.response.status_code, 404)
-        else:
-            assert False, "Reading a non-existent notebook should fail"
+    def test_list_nonexistant_dir(self):
+        with assert_http_error(404):
+            self.nb_api.list('nonexistant')
 
     def test_get_contents(self):
         for d, name in self.dirs_nbs:
             nb = self.nb_api.read('%s.ipynb' % name, d+'/').json()
             self.assertEqual(nb['name'], '%s.ipynb' % name)
             self.assertIn('content', nb)
             self.assertIn('metadata', nb['content'])
             self.assertIsInstance(nb['content']['metadata'], dict)
 
         # Name that doesn't exist - should be a 404
-        self.assert_404('q.ipynb', 'foo')
+        with assert_http_error(404):
+            self.nb_api.read('q.ipynb', 'foo')
 
     def _check_nb_created(self, resp, name, path):
         self.assertEqual(resp.status_code, 201)
         self.assertEqual(resp.headers['Location'].split('/')[-1], name)
         self.assertEqual(resp.json()['name'], name)
         assert os.path.isfile(pjoin(self.notebook_dir.name, path, name))
 
     def test_create_untitled(self):
         resp = self.nb_api.create_untitled(path='foo')
         self._check_nb_created(resp, 'Untitled0.ipynb', 'foo')
 
         # Second time
         resp = self.nb_api.create_untitled(path='foo')
         self._check_nb_created(resp, 'Untitled1.ipynb', 'foo')
 
         # And two directories down
         resp = self.nb_api.create_untitled(path='foo/bar')
         self._check_nb_created(resp, 'Untitled0.ipynb', pjoin('foo', 'bar'))
 
     def test_upload(self):
         nb = new_notebook(name='Upload test')
         nbmodel = {'content': nb}
         resp = self.nb_api.upload('Upload test.ipynb', path='foo',
                                               body=jsonapi.dumps(nbmodel))
         self._check_nb_created(resp, 'Upload test.ipynb', 'foo')
 
     def test_copy(self):
         resp = self.nb_api.copy('a.ipynb', path='foo')
         self._check_nb_created(resp, 'a-Copy0.ipynb', 'foo')
 
     def test_delete(self):
         for d, name in self.dirs_nbs:
             resp = self.nb_api.delete('%s.ipynb' % name, d)
             self.assertEqual(resp.status_code, 204)
 
         for d in self.dirs + ['/']:
             nbs = self.nb_api.list(d).json()
             self.assertEqual(len(nbs), 0)
 
     def test_rename(self):
         resp = self.nb_api.rename('a.ipynb', 'foo', 'z.ipynb')
         self.assertEqual(resp.headers['Location'].split('/')[-1], 'z.ipynb')
         self.assertEqual(resp.json()['name'], 'z.ipynb')
         assert os.path.isfile(pjoin(self.notebook_dir.name, 'foo', 'z.ipynb'))
 
         nbs = self.nb_api.list('foo').json()
         nbnames = set(n['name'] for n in nbs)
         self.assertIn('z.ipynb', nbnames)
         self.assertNotIn('a.ipynb', nbnames)
 
     def test_save(self):
         resp = self.nb_api.read('a.ipynb', 'foo')
         nbcontent = jsonapi.loads(resp.text)['content']
         nb = to_notebook_json(nbcontent)
         ws = new_worksheet()
         nb.worksheets = [ws]
         ws.cells.append(new_heading_cell('Created by test'))
 
         nbmodel= {'name': 'a.ipynb', 'path':'foo', 'content': nb}
         resp = self.nb_api.save('a.ipynb', path='foo', body=jsonapi.dumps(nbmodel))
 
         nbfile = pjoin(self.notebook_dir.name, 'foo', 'a.ipynb')
         with open(nbfile, 'r') as f:
             newnb = read(f, format='ipynb')
         self.assertEqual(newnb.worksheets[0].cells[0].source,
                          'Created by test')
 
         # Save and rename
         nbmodel= {'name': 'a2.ipynb', 'path':'foo/bar', 'content': nb}
         resp = self.nb_api.save('a.ipynb', path='foo', body=jsonapi.dumps(nbmodel))
         saved = resp.json()
         self.assertEqual(saved['name'], 'a2.ipynb')
         self.assertEqual(saved['path'], 'foo/bar')
         assert os.path.isfile(pjoin(self.notebook_dir.name,'foo','bar','a2.ipynb'))
         assert not os.path.isfile(pjoin(self.notebook_dir.name, 'foo', 'a.ipynb'))
-        self.assert_404('a.ipynb', 'foo')
  No newline at end of file
+        with assert_http_error(404):
+            self.nb_api.read('a.ipynb', 'foo')
  No newline at end of file

IPython/html/services/sessions/tests/test_sessions_api.py

@@ -1,113 +1,106
 """Test the sessions web service API."""
 
 import io
 import os
 import json
 import requests
 import shutil
 
 pjoin = os.path.join
 
 from IPython.html.utils import url_path_join
-from IPython.html.tests.launchnotebook import NotebookTestBase
+from IPython.html.tests.launchnotebook import NotebookTestBase, assert_http_error
 from IPython.nbformat.current import new_notebook, write
 
 class SessionAPI(object):
     """Wrapper for notebook API calls."""
     def __init__(self, base_url):
         self.base_url = base_url
 
     def _req(self, verb, path, body=None):
         response = requests.request(verb,
                 url_path_join(self.base_url, 'api/sessions', path), data=body)
 
         if 400 <= response.status_code < 600:
             try:
                 response.reason = response.json()['message']
             except:
                 pass
         response.raise_for_status()
 
         return response
 
     def list(self):
         return self._req('GET', '')
 
     def get(self, id):
         return self._req('GET', id)
 
     def create(self, name, path):
         body = json.dumps({'notebook': {'name':name, 'path':path}})
         return self._req('POST', '', body)
 
     def modify(self, id, name, path):
         body = json.dumps({'notebook': {'name':name, 'path':path}})
         return self._req('PATCH', id, body)
 
     def delete(self, id):
         return self._req('DELETE', id)
 
 class SessionAPITest(NotebookTestBase):
     """Test the sessions web service API"""
     def setUp(self):
         nbdir = self.notebook_dir.name
         os.mkdir(pjoin(nbdir, 'foo'))
 
         with io.open(pjoin(nbdir, 'foo', 'nb1.ipynb'), 'w') as f:
             nb = new_notebook(name='nb1')
             write(nb, f, format='ipynb')
 
         self.sess_api = SessionAPI(self.base_url())
 
     def tearDown(self):
         for session in self.sess_api.list().json():
             self.sess_api.delete(session['id'])
         shutil.rmtree(pjoin(self.notebook_dir.name, 'foo'))
 
-    def assert_404(self, id):
-        try:
-            self.sess_api.get(id)
-        except requests.HTTPError as e:
-            self.assertEqual(e.response.status_code, 404)
-        else:
-            assert False, "Getting nonexistent session didn't give HTTP error"
-
     def test_create(self):
         sessions = self.sess_api.list().json()
         self.assertEqual(len(sessions), 0)
 
         resp = self.sess_api.create('nb1.ipynb', 'foo')
         self.assertEqual(resp.status_code, 201)
         newsession = resp.json()
         self.assertIn('id', newsession)
         self.assertEqual(newsession['notebook']['name'], 'nb1.ipynb')
         self.assertEqual(newsession['notebook']['path'], 'foo')
 
         sessions = self.sess_api.list().json()
         self.assertEqual(sessions, [newsession])
 
         # Retrieve it
         sid = newsession['id']
         got = self.sess_api.get(sid).json()
         self.assertEqual(got, newsession)
 
     def test_delete(self):
         newsession = self.sess_api.create('nb1.ipynb', 'foo').json()
         sid = newsession['id']
 
         resp = self.sess_api.delete(sid)
         self.assertEqual(resp.status_code, 204)
 
         sessions = self.sess_api.list().json()
         self.assertEqual(sessions, [])
 
-        self.assert_404(sid)
+        with assert_http_error(404):
+            self.sess_api.get(sid)
 
     def test_modify(self):
         newsession = self.sess_api.create('nb1.ipynb', 'foo').json()
         sid = newsession['id']
 
         changed = self.sess_api.modify(sid, 'nb2.ipynb', '').json()
         self.assertEqual(changed['id'], sid)
         self.assertEqual(changed['notebook']['name'], 'nb2.ipynb')
         self.assertEqual(changed['notebook']['path'], '')

IPython/html/tests/launchnotebook.py

@@ -1,69 +1,81
 """Base class for notebook tests."""
 
 import sys
 import time
 import requests
+from contextlib import contextmanager
 from subprocess import Popen, PIPE
 from unittest import TestCase
 
 from IPython.utils.tempdir import TemporaryDirectory
 
-
 class NotebookTestBase(TestCase):
     """A base class for tests that need a running notebook.
     
     This creates an empty profile in a temp ipython_dir
     and then starts the notebook server with a separate temp notebook_dir.
     """
 
     port = 12341
 
     @classmethod
     def wait_until_alive(cls):
         """Wait for the server to be alive"""
         url = 'http://localhost:%i/api/notebooks' % cls.port
         while True:
             try:
                 requests.get(url)
             except requests.exceptions.ConnectionError:
                 time.sleep(.1)
             else:
                 break
     
     @classmethod
     def wait_until_dead(cls):
         """Wait for the server to stop getting requests after shutdown"""
         url = 'http://localhost:%i/api/notebooks' % cls.port
         while True:
             try:
                 requests.get(url)
             except requests.exceptions.ConnectionError:
                 break
             else:
                 time.sleep(.1)
     
     @classmethod
     def setup_class(cls):
         cls.ipython_dir = TemporaryDirectory()
         cls.notebook_dir = TemporaryDirectory()
         notebook_args = [
             sys.executable, '-c',
             'from IPython.html.notebookapp import launch_new_instance; launch_new_instance()',
             '--port=%d' % cls.port,
             '--no-browser',
             '--ipython-dir=%s' % cls.ipython_dir.name,
             '--notebook-dir=%s' % cls.notebook_dir.name
         ]        
         cls.notebook = Popen(notebook_args, stdout=PIPE, stderr=PIPE)
         cls.wait_until_alive()
 
     @classmethod
     def teardown_class(cls):
         cls.notebook.terminate()
         cls.ipython_dir.cleanup()
         cls.notebook_dir.cleanup()
         cls.wait_until_dead()
 
     @classmethod
     def base_url(cls):
         return 'http://localhost:%i/' % cls.port
+
+
+@contextmanager
+def assert_http_error(status):
+    try:
+        yield
+    except requests.HTTPError as e:
+        real_status = e.response.status_code
+        assert real_status == status, \
+                    "Expected status %d, got %d" % (real_status, status)
+    else:
+        assert False, "Expected HTTP error status"
  No newline at end of file