/
test_notebookapp.py
231 lines (190 loc) · 7.08 KB
/
test_notebookapp.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
"""Test NotebookApp"""
import getpass
import logging
import os
import re
import sys
from tempfile import NamedTemporaryFile
from unittest.mock import patch
import pytest
from traitlets.tests.utils import check_help_all_output
from jupyter_core.application import NoStart
from ipython_genutils.tempdir import TemporaryDirectory
from traitlets import TraitError
from notebook import notebookapp, __version__
from notebook.auth.security import passwd_check
NotebookApp = notebookapp.NotebookApp
from .launchnotebook import NotebookTestBase, UNIXSocketNotebookTestBase
def test_help_output():
"""ipython notebook --help-all works"""
check_help_all_output('notebook')
def test_server_info_file():
td = TemporaryDirectory()
nbapp = NotebookApp(runtime_dir=td.name, log=logging.getLogger())
def get_servers():
return list(notebookapp.list_running_servers(nbapp.runtime_dir))
nbapp.initialize(argv=[])
nbapp.write_server_info_file()
servers = get_servers()
assert len(servers) == 1
assert servers[0]['port'] == nbapp.port
assert servers[0]['url'] == nbapp.connection_url
nbapp.remove_server_info_file()
assert get_servers() == []
# The ENOENT error should be silenced.
nbapp.remove_server_info_file()
def test_nb_dir():
with TemporaryDirectory() as td:
app = NotebookApp(notebook_dir=td)
assert app.notebook_dir == td
def test_no_create_nb_dir():
with TemporaryDirectory() as td:
nbdir = os.path.join(td, 'notebooks')
app = NotebookApp()
with pytest.raises(TraitError):
app.notebook_dir = nbdir
def test_missing_nb_dir():
with TemporaryDirectory() as td:
nbdir = os.path.join(td, 'notebook', 'dir', 'is', 'missing')
app = NotebookApp()
with pytest.raises(TraitError):
app.notebook_dir = nbdir
def test_invalid_nb_dir():
with NamedTemporaryFile() as tf:
app = NotebookApp()
with pytest.raises(TraitError):
app.notebook_dir = tf
def test_nb_dir_with_slash():
with TemporaryDirectory(suffix="_slash" + os.sep) as td:
app = NotebookApp(notebook_dir=td)
assert not app.notebook_dir.endswith(os.sep)
def test_nb_dir_root():
root = os.path.abspath(os.sep) # gets the right value on Windows, Posix
app = NotebookApp(notebook_dir=root)
assert app.notebook_dir == root
def test_generate_config():
with TemporaryDirectory() as td:
app = NotebookApp(config_dir=td)
app.initialize(['--generate-config', '--allow-root'])
with pytest.raises(NoStart):
app.start()
assert os.path.exists(os.path.join(td, 'jupyter_notebook_config.py'))
#test if the version testin function works
@pytest.mark.parametrize(
'version', [
'4.1.0.b1',
'4.1.b1',
'4.2',
'X.y.z',
'1.2.3.dev1.post2',
]
)
def test_pep440_bad_version(version):
with pytest.raises(ValueError):
raise_on_bad_version(version)
@pytest.mark.parametrize(
'version', [
'4.1.1',
'4.2.1b3',
]
)
def test_pep440_good_version(version):
raise_on_bad_version(version)
pep440re = re.compile(r'^(\d+)\.(\d+)\.(\d+((a|b|rc)\d+)?)(\.post\d+)?(\.dev\d*)?$')
def raise_on_bad_version(version):
if not pep440re.match(version):
raise ValueError("Versions String does apparently not match Pep 440 specification, "
"which might lead to sdist and wheel being seen as 2 different release. "
"E.g: do not use dots for beta/alpha/rc markers.")
def test_current_version():
raise_on_bad_version(__version__)
def test_notebook_password():
password = 'secret'
with TemporaryDirectory() as td:
with patch.dict('os.environ', {
'JUPYTER_CONFIG_DIR': td,
}), patch.object(getpass, 'getpass', return_value=password):
app = notebookapp.NotebookPasswordApp(log_level=logging.ERROR)
app.initialize([])
app.start()
nb = NotebookApp()
nb.load_config_file()
assert nb.password != ''
passwd_check(nb.password, password)
class StopAppTest(notebookapp.NbserverStopApp):
"""For testing the logic of NbserverStopApp."""
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.servers_shut_down = []
def shutdown_server(self, server):
self.servers_shut_down.append(server)
return True
def test_notebook_stop():
def list_running_servers(runtime_dir):
for port in range(100, 110):
yield {
'pid': 1000 + port,
'port': port,
'base_url': '/',
'hostname': 'localhost',
'notebook_dir': '/',
'secure': False,
'token': '',
'password': False,
'url': f'http://localhost:{port}',
}
mock_servers = patch('notebook.notebookapp.list_running_servers', list_running_servers)
# test stop with a match
with mock_servers:
app = StopAppTest()
app.initialize(['105'])
app.start()
assert len(app.servers_shut_down) == 1
assert app.servers_shut_down[0]['port'] == 105
# test no match
with mock_servers, patch('os.kill') as os_kill:
app = StopAppTest()
app.initialize(['999'])
with pytest.raises(SystemExit) as exc:
app.start()
assert exc.value.code == 1
assert len(app.servers_shut_down) == 0
class NotebookAppTests(NotebookTestBase):
def test_list_running_servers(self):
servers = list(notebookapp.list_running_servers())
assert len(servers) >= 1
assert self.port in {info['port'] for info in servers}
def test_log_json_default(self):
self.assertFalse(self.notebook.log_json)
def test_validate_log_json(self):
self.assertFalse(self.notebook._validate_log_json(dict(value=False)))
# UNIX sockets aren't available on Windows.
if not sys.platform.startswith('win'):
class NotebookUnixSocketTests(UNIXSocketNotebookTestBase):
def test_run(self):
self.fetch_url(self.base_url() + 'api/contents')
def test_list_running_sock_servers(self):
servers = list(notebookapp.list_running_servers())
assert len(servers) >= 1
assert self.sock in {info['sock'] for info in servers}
class NotebookAppJSONLoggingTests(NotebookTestBase):
"""Tests for when json logging is enabled."""
@classmethod
def setup_class(cls):
super().setup_class()
try:
import json_logging
cls.json_logging_available = True
except ImportError:
cls.json_logging_available = False
@classmethod
def get_patch_env(cls):
test_env = super().get_patch_env()
test_env.update({'JUPYTER_ENABLE_JSON_LOGGING': 'true'})
return test_env
def test_log_json_enabled(self):
self.assertTrue(self.notebook._default_log_json())
def test_validate_log_json(self):
self.assertEqual(
self.notebook._validate_log_json(dict(value=True)),
self.json_logging_available)