Improve Session REST API tests

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

@@ -1,96 +1,114 @@
 """Test the sessions web service API."""
 
-
+import io
 import os
-import sys
 import json
 import requests
+import shutil
+
+pjoin = os.path.join
 
 from IPython.utils.jsonutil import date_default
 from IPython.html.utils import url_path_join
 from IPython.html.tests.launchnotebook import NotebookTestBase
+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({'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):
-    def notebook_url(self):
+        nbdir = self.notebook_dir.name
-        return url_path_join(super(SessionAPITest,self).base_url(), 'api/notebooks')
+        os.mkdir(pjoin(nbdir, 'foo'))
 
-    def session_url(self):
+        with io.open(pjoin(nbdir, 'foo', 'nb1.ipynb'), 'w') as f:
-        return super(SessionAPITest,self).base_url() + 'api/sessions'
+            nb = new_notebook(name='nb1')
+            write(nb, f, format='ipynb')
 
-    def mknb(self, name='', path='/'):
+        self.sess_api = SessionAPI(self.base_url())
-        url = self.notebook_url() + path
-        return url, requests.post(url)
 
-    def delnb(self, name, path='/'):
+    def tearDown(self):
-        url = self.notebook_url() + path + name
+        for session in self.sess_api.list().json():
-        r = requests.delete(url)
+            self.sess_api.delete(session['id'])
-        return r.status_code
+        shutil.rmtree(pjoin(self.notebook_dir.name, 'foo'))
 
-    def test_no_sessions(self):
+    def assert_404(self, id):
-        """Make sure there are no sessions running at the start"""
+        try:
-        url = self.session_url()
+            self.sess_api.get(id)
-        r = requests.get(url)
+        except requests.HTTPError as e:
-        self.assertEqual(r.json(), [])
+            self.assertEqual(e.response.status_code, 404)
+        else:
+            assert False, "Getting nonexistent session didn't give HTTP error"
 
-    def test_session_root_handler(self):
+    def test_create(self):
-        # POST a session
+        sessions = self.sess_api.list().json()
-        url, nb = self.mknb()
+        self.assertEqual(len(sessions), 0)
-        notebook = nb.json()
-        model = {'notebook': {'name':notebook['name'], 'path': notebook['path']}}
-        r = requests.post(self.session_url(), data=json.dumps(model, default=date_default))
-        data = r.json()
-        assert isinstance(data, dict)
-        self.assertIn('name', data['notebook'])
-        self.assertEqual(data['notebook']['name'], notebook['name'])
 
-        # GET sessions
+        resp = self.sess_api.create('nb1.ipynb', 'foo')
-        r = requests.get(self.session_url())
+        self.assertEqual(resp.status_code, 201)
-        assert isinstance(r.json(), list)
+        newsession = resp.json()
-        assert isinstance(r.json()[0], dict)
+        self.assertIn('id', newsession)
-        self.assertEqual(r.json()[0]['id'], data['id'])
+        self.assertEqual(newsession['notebook']['name'], 'nb1.ipynb')
+        self.assertEqual(newsession['notebook']['path'], 'foo')
 
-        # Clean up
+        sessions = self.sess_api.list().json()
-        self.delnb('Untitled0.ipynb')
+        self.assertEqual(sessions, [newsession])
-        sess_url = self.session_url() +'/'+data['id']
-        r = requests.delete(sess_url)
-        self.assertEqual(r.status_code, 204)
 
-    def test_session_handler(self):
+        # Retrieve it
-        # Create a session
+        sid = newsession['id']
-        url, nb = self.mknb()
+        got = self.sess_api.get(sid)
-        notebook = nb.json()
+        self.assertEqual(got, newsession)
-        model = {'notebook': {'name':notebook['name'], 'path': notebook['path']}}
-        r = requests.post(self.session_url(), data=json.dumps(model, default=date_default))
-        session = r.json()
 
-        # GET a session
+    def test_delete(self):
-        sess_url = self.session_url() + '/' + session['id']
+        newsession = self.sess_api.create('nb1.ipynb', 'foo').json()
-        r = requests.get(sess_url)
+        sid = newsession['id']
-        assert isinstance(r.json(), dict)
-        self.assertEqual(r.json(), session)
 
-        # PATCH a session
+        resp = self.sess_api.delete(sid)
-        model = {'notebook': {'name':'test.ipynb', 'path': '/'}}
+        self.assertEqual(resp.status_code, 204)
-        r = requests.patch(sess_url, data=json.dumps(model, default=date_default))
-        
-        # Patching the notebook webservice too (just for consistency)
-        requests.patch(self.notebook_url() + '/Untitled0.ipynb', 
-            data=json.dumps({'name':'test.ipynb'}))
-        print r.json()
-        assert isinstance(r.json(), dict)
-        self.assertIn('name', r.json()['notebook'])
-        self.assertIn('id', r.json())
-        self.assertEqual(r.json()['notebook']['name'], 'test.ipynb')
-        self.assertEqual(r.json()['id'], session['id'])
 
-        # DELETE a session
+        sessions = self.sess_api.list().json()
-        r = requests.delete(sess_url)
+        self.assertEqual(sessions, [])
-        self.assertEqual(r.status_code, 204)
+
-        r = requests.get(self.session_url())
+        self.assert_404(sid)
-        self.assertEqual(r.json(), [])
+
-        
+    def test_modify(self):
-        # Clean up
+        newsession = self.sess_api.create('nb1.ipynb', 'foo').json()
-        r = self.delnb('test.ipynb')
+        sid = newsession['id']
-        self.assertEqual(r, 204)
+
+        changed = self.sess_api.modify(sid, 'nb2.ipynb', '').json()
+        self.assertEqual(changed['id'], sid)
+        self.assertEqual(newsession['notebook']['name'], 'nb2.ipynb')
+        self.assertEqual(newsession['notebook']['path'], '')