%PDF-
%PDF-
Mini Shell
Mini Shell
# coding: utf-8
"""
Tests for traitlets.config.application.Application
"""
# Copyright (c) IPython Development Team.
# Distributed under the terms of the Modified BSD License.
import contextlib
import io
import json
import logging
import os
import sys
from io import StringIO
from tempfile import TemporaryDirectory
from unittest import TestCase
import pytest
from pytest import mark
from traitlets import (
Bool,
Bytes,
Dict,
HasTraits,
Integer,
List,
Set,
Tuple,
Unicode,
)
from traitlets.config.application import Application
from traitlets.config.configurable import Configurable
from traitlets.config.loader import Config
from traitlets.tests.utils import (
check_help_all_output,
check_help_output,
get_output_error_code,
)
try:
from unittest import mock
except ImportError:
import mock
pjoin = os.path.join
class Foo(Configurable):
i = Integer(0, help="""
The integer i.
Details about i.
""").tag(config=True)
j = Integer(1, help="The integer j.").tag(config=True)
name = Unicode('Brian', help="First name.").tag(config=True)
la = List([]).tag(config=True)
li = List(Integer()).tag(config=True)
fdict = Dict().tag(config=True, multiplicity='+')
class Bar(Configurable):
b = Integer(0, help="The integer b.").tag(config=True)
enabled = Bool(True, help="Enable bar.").tag(config=True)
tb = Tuple(()).tag(config=True, multiplicity='*')
aset = Set().tag(config=True, multiplicity='+')
bdict = Dict().tag(config=True)
idict = Dict(value_trait=Integer()).tag(config=True)
key_dict = Dict(per_key_traits={'i': Integer(), 'b': Bytes()}).tag(config=True)
class MyApp(Application):
name = Unicode('myapp')
running = Bool(False, help="Is the app running?").tag(config=True)
classes = List([Bar, Foo])
config_file = Unicode('', help="Load this config file").tag(config=True)
warn_tpyo = Unicode("yes the name is wrong on purpose", config=True,
help="Should print a warning if `MyApp.warn-typo=...` command is passed")
aliases = {}
aliases.update(Application.aliases)
aliases.update({
('fooi', 'i') : 'Foo.i',
('j', 'fooj') : ('Foo.j', "`j` terse help msg"),
'name' : 'Foo.name',
'la': 'Foo.la',
'li': 'Foo.li',
'tb': 'Bar.tb',
'D': 'Bar.bdict',
'enabled' : 'Bar.enabled',
'enable' : 'Bar.enabled',
'log-level' : 'Application.log_level',
})
flags = {}
flags.update(Application.flags)
flags.update({('enable', 'e'):
({'Bar': {'enabled' : True}},
"Set Bar.enabled to True"),
('d', 'disable'):
({'Bar': {'enabled' : False}},
"Set Bar.enabled to False"),
'crit':
({'Application' : {'log_level' : logging.CRITICAL}},
"set level=CRITICAL"),
})
def init_foo(self):
self.foo = Foo(parent=self)
def init_bar(self):
self.bar = Bar(parent=self)
def class_to_names(classes):
return [klass.__name__ for klass in classes]
class TestApplication(TestCase):
def test_log(self):
stream = StringIO()
app = MyApp(log_level=logging.INFO)
handler = logging.StreamHandler(stream)
# trigger reconstruction of the log formatter
app.log.handlers = [handler]
app.log_format = "%(message)s"
app.log_datefmt = "%Y-%m-%d %H:%M"
app.log.info("hello")
assert "hello" in stream.getvalue()
def test_no_eval_cli_text(self):
app = MyApp()
app.initialize(['--Foo.name=1'])
app.init_foo()
assert app.foo.name == '1'
def test_basic(self):
app = MyApp()
self.assertEqual(app.name, 'myapp')
self.assertEqual(app.running, False)
self.assertEqual(app.classes, [MyApp, Bar, Foo])
self.assertEqual(app.config_file, '')
def test_mro_discovery(self):
app = MyApp()
self.assertSequenceEqual(class_to_names(app._classes_with_config_traits()),
['Application', 'MyApp', 'Bar', 'Foo'])
self.assertSequenceEqual(class_to_names(app._classes_inc_parents()),
['Configurable', 'LoggingConfigurable', 'SingletonConfigurable',
'Application', 'MyApp', 'Bar', 'Foo'])
self.assertSequenceEqual(class_to_names(app._classes_with_config_traits([Application])),
['Application'])
self.assertSequenceEqual(class_to_names(app._classes_inc_parents([Application])),
['Configurable', 'LoggingConfigurable', 'SingletonConfigurable',
'Application'])
self.assertSequenceEqual(class_to_names(app._classes_with_config_traits([Foo])),
['Foo'])
self.assertSequenceEqual(class_to_names(app._classes_inc_parents([Bar])),
['Configurable', 'Bar'])
class MyApp2(Application): # no defined `classes` attr
pass
self.assertSequenceEqual(class_to_names(app._classes_with_config_traits([Foo])),
['Foo'])
self.assertSequenceEqual(class_to_names(app._classes_inc_parents([Bar])),
['Configurable', 'Bar'])
def test_config(self):
app = MyApp()
app.parse_command_line([
"--i=10",
"--Foo.j=10",
"--enable=False",
"--log-level=50",
])
config = app.config
print(config)
self.assertEqual(config.Foo.i, 10)
self.assertEqual(config.Foo.j, 10)
self.assertEqual(config.Bar.enabled, False)
self.assertEqual(config.MyApp.log_level, 50)
def test_config_seq_args(self):
app = MyApp()
app.parse_command_line("--li 1 --li 3 --la 1 --tb AB 2 --Foo.la=ab --Bar.aset S1 --Bar.aset S2 --Bar.aset S1".split())
assert app.extra_args == ["2"]
config = app.config
assert config.Foo.li == [1, 3]
assert config.Foo.la == ["1", "ab"]
assert config.Bar.tb == ("AB",)
self.assertEqual(config.Bar.aset, {"S1", "S2"})
app.init_foo()
assert app.foo.li == [1, 3]
assert app.foo.la == ['1', 'ab']
app.init_bar()
self.assertEqual(app.bar.aset, {'S1', 'S2'})
assert app.bar.tb == ('AB',)
def test_config_dict_args(self):
app = MyApp()
app.parse_command_line(
"--Foo.fdict a=1 --Foo.fdict b=b --Foo.fdict c=3 "
"--Bar.bdict k=1 -D=a=b -D 22=33 "
"--Bar.idict k=1 --Bar.idict b=2 --Bar.idict c=3 "
.split())
fdict = {'a': '1', 'b': 'b', 'c': '3'}
bdict = {'k': '1', 'a': 'b', '22': '33'}
idict = {'k': 1, 'b': 2, 'c': 3}
config = app.config
assert config.Bar.idict == idict
self.assertDictEqual(config.Foo.fdict, fdict)
self.assertDictEqual(config.Bar.bdict, bdict)
app.init_foo()
self.assertEqual(app.foo.fdict, fdict)
app.init_bar()
assert app.bar.idict == idict
self.assertEqual(app.bar.bdict, bdict)
def test_config_propagation(self):
app = MyApp()
app.parse_command_line(["--i=10","--Foo.j=10","--enable=False","--log-level=50"])
app.init_foo()
app.init_bar()
self.assertEqual(app.foo.i, 10)
self.assertEqual(app.foo.j, 10)
self.assertEqual(app.bar.enabled, False)
def test_cli_priority(self):
"""Test that loading config files does not override CLI options"""
name = 'config.py'
class TestApp(Application):
value = Unicode().tag(config=True)
config_file_loaded = Bool().tag(config=True)
aliases = {'v': 'TestApp.value'}
app = TestApp()
with TemporaryDirectory() as td:
config_file = pjoin(td, name)
with open(config_file, 'w') as f:
f.writelines([
"c.TestApp.value = 'config file'\n",
"c.TestApp.config_file_loaded = True\n"
])
app.parse_command_line(['--v=cli'])
assert 'value' in app.config.TestApp
assert app.config.TestApp.value == 'cli'
assert app.value == 'cli'
app.load_config_file(name, path=[td])
assert app.config_file_loaded
assert app.config.TestApp.value == 'cli'
assert app.value == 'cli'
def test_ipython_cli_priority(self):
# this test is almost entirely redundant with above,
# but we can keep it around in case of subtle issues creeping into
# the exact sequence IPython follows.
name = 'config.py'
class TestApp(Application):
value = Unicode().tag(config=True)
config_file_loaded = Bool().tag(config=True)
aliases = {'v': ('TestApp.value', 'some help')}
app = TestApp()
with TemporaryDirectory() as td:
config_file = pjoin(td, name)
with open(config_file, 'w') as f:
f.writelines([
"c.TestApp.value = 'config file'\n",
"c.TestApp.config_file_loaded = True\n"
])
# follow IPython's config-loading sequence to ensure CLI priority is preserved
app.parse_command_line(['--v=cli'])
# this is where IPython makes a mistake:
# it assumes app.config will not be modified,
# and storing a reference is storing a copy
cli_config = app.config
assert 'value' in app.config.TestApp
assert app.config.TestApp.value == 'cli'
assert app.value == 'cli'
app.load_config_file(name, path=[td])
assert app.config_file_loaded
# enforce cl-opts override config file opts:
# this is where IPython makes a mistake: it assumes
# that cl_config is a different object, but it isn't.
app.update_config(cli_config)
assert app.config.TestApp.value == 'cli'
assert app.value == 'cli'
def test_cli_allow_none(self):
class App(Application):
aliases = {"opt": "App.opt"}
opt = Unicode(allow_none=True, config=True)
app = App()
app.parse_command_line(["--opt=None"])
assert app.opt is None
def test_flags(self):
app = MyApp()
app.parse_command_line(["--disable"])
app.init_bar()
self.assertEqual(app.bar.enabled, False)
app = MyApp()
app.parse_command_line(["-d"])
app.init_bar()
self.assertEqual(app.bar.enabled, False)
app = MyApp()
app.parse_command_line(["--enable"])
app.init_bar()
self.assertEqual(app.bar.enabled, True)
app = MyApp()
app.parse_command_line(["-e"])
app.init_bar()
self.assertEqual(app.bar.enabled, True)
def test_flags_help_msg(self):
app = MyApp()
stdout = io.StringIO()
with contextlib.redirect_stdout(stdout):
app.print_flag_help()
hmsg = stdout.getvalue()
self.assertRegex(hmsg, "(?<!-)-e, --enable\\b")
self.assertRegex(hmsg, "(?<!-)-d, --disable\\b")
self.assertIn("Equivalent to: [--Bar.enabled=True]", hmsg)
self.assertIn("Equivalent to: [--Bar.enabled=False]", hmsg)
def test_aliases(self):
app = MyApp()
app.parse_command_line(["--i=5", "--j=10"])
app.init_foo()
self.assertEqual(app.foo.i, 5)
app.init_foo()
self.assertEqual(app.foo.j, 10)
app = MyApp()
app.parse_command_line(["-i=5", "-j=10"])
app.init_foo()
self.assertEqual(app.foo.i, 5)
app.init_foo()
self.assertEqual(app.foo.j, 10)
app = MyApp()
app.parse_command_line(["--fooi=5", "--fooj=10"])
app.init_foo()
self.assertEqual(app.foo.i, 5)
app.init_foo()
self.assertEqual(app.foo.j, 10)
def test_aliases_help_msg(self):
app = MyApp()
stdout = io.StringIO()
with contextlib.redirect_stdout(stdout):
app.print_alias_help()
hmsg = stdout.getvalue()
self.assertRegex(hmsg, "(?<!-)-i, --fooi\\b")
self.assertRegex(hmsg, "(?<!-)-j, --fooj\\b")
self.assertIn("Equivalent to: [--Foo.i]", hmsg)
self.assertIn("Equivalent to: [--Foo.j]", hmsg)
self.assertIn("Equivalent to: [--Foo.name]", hmsg)
def test_flag_clobber(self):
"""test that setting flags doesn't clobber existing settings"""
app = MyApp()
app.parse_command_line(["--Bar.b=5", "--disable"])
app.init_bar()
self.assertEqual(app.bar.enabled, False)
self.assertEqual(app.bar.b, 5)
app.parse_command_line(["--enable", "--Bar.b=10"])
app.init_bar()
self.assertEqual(app.bar.enabled, True)
self.assertEqual(app.bar.b, 10)
def test_warn_autocorrect(self):
stream = StringIO()
app = MyApp(log_level=logging.INFO)
app.log.handlers = [logging.StreamHandler(stream)]
cfg = Config()
cfg.MyApp.warn_typo = "WOOOO"
app.config = cfg
self.assertIn("warn_typo", stream.getvalue())
self.assertIn("warn_tpyo", stream.getvalue())
def test_flatten_flags(self):
cfg = Config()
cfg.MyApp.log_level = logging.WARN
app = MyApp()
app.update_config(cfg)
self.assertEqual(app.log_level, logging.WARN)
self.assertEqual(app.config.MyApp.log_level, logging.WARN)
app.initialize(["--crit"])
self.assertEqual(app.log_level, logging.CRITICAL)
# this would be app.config.Application.log_level if it failed:
self.assertEqual(app.config.MyApp.log_level, logging.CRITICAL)
def test_flatten_aliases(self):
cfg = Config()
cfg.MyApp.log_level = logging.WARN
app = MyApp()
app.update_config(cfg)
self.assertEqual(app.log_level, logging.WARN)
self.assertEqual(app.config.MyApp.log_level, logging.WARN)
app.initialize(["--log-level", "CRITICAL"])
self.assertEqual(app.log_level, logging.CRITICAL)
# this would be app.config.Application.log_level if it failed:
self.assertEqual(app.config.MyApp.log_level, "CRITICAL")
def test_extra_args(self):
app = MyApp()
app.parse_command_line(["--Bar.b=5", 'extra', 'args', "--disable"])
app.init_bar()
self.assertEqual(app.bar.enabled, False)
self.assertEqual(app.bar.b, 5)
self.assertEqual(app.extra_args, ['extra', 'args'])
app = MyApp()
app.parse_command_line(["--Bar.b=5", '--', 'extra', "--disable", 'args'])
app.init_bar()
self.assertEqual(app.bar.enabled, True)
self.assertEqual(app.bar.b, 5)
self.assertEqual(app.extra_args, ['extra', '--disable', 'args'])
app = MyApp()
app.parse_command_line(
["--disable", "--la", "-", "-", "--Bar.b=1", "--", "-", "extra"]
)
self.assertEqual(app.extra_args, ["-", "-", "extra"])
def test_unicode_argv(self):
app = MyApp()
app.parse_command_line(['ünîcødé'])
def test_document_config_option(self):
app = MyApp()
app.document_config_options()
def test_generate_config_file(self):
app = MyApp()
assert 'The integer b.' in app.generate_config_file()
def test_generate_config_file_classes_to_include(self):
class NotInConfig(HasTraits):
from_hidden = Unicode('x', help="""From hidden class
Details about from_hidden.
""").tag(config=True)
class NoTraits(Foo, Bar, NotInConfig):
pass
app = MyApp()
app.classes.append(NoTraits)
conf_txt = app.generate_config_file()
print(conf_txt)
self.assertIn('The integer b.', conf_txt)
self.assertIn('# Foo(Configurable)', conf_txt)
self.assertNotIn('# Configurable', conf_txt)
self.assertIn('# NoTraits(Foo, Bar)', conf_txt)
# inherited traits, parent in class list:
self.assertIn('# c.NoTraits.i', conf_txt)
self.assertIn('# c.NoTraits.j', conf_txt)
self.assertIn('# c.NoTraits.n', conf_txt)
self.assertIn('# See also: Foo.j', conf_txt)
self.assertIn('# See also: Bar.b', conf_txt)
self.assertEqual(conf_txt.count('Details about i.'), 1)
# inherited traits, parent not in class list:
self.assertIn("# c.NoTraits.from_hidden", conf_txt)
self.assertNotIn('# See also: NotInConfig.', conf_txt)
self.assertEqual(conf_txt.count('Details about from_hidden.'), 1)
self.assertNotIn("NotInConfig", conf_txt)
def test_multi_file(self):
app = MyApp()
app.log = logging.getLogger()
name = 'config.py'
with TemporaryDirectory('_1') as td1:
with open(pjoin(td1, name), 'w') as f1:
f1.write("get_config().MyApp.Bar.b = 1")
with TemporaryDirectory('_2') as td2:
with open(pjoin(td2, name), 'w') as f2:
f2.write("get_config().MyApp.Bar.b = 2")
app.load_config_file(name, path=[td2, td1])
app.init_bar()
self.assertEqual(app.bar.b, 2)
app.load_config_file(name, path=[td1, td2])
app.init_bar()
self.assertEqual(app.bar.b, 1)
@mark.skipif(not hasattr(TestCase, 'assertLogs'), reason='requires TestCase.assertLogs')
def test_log_collisions(self):
app = MyApp()
app.log = logging.getLogger()
app.log.setLevel(logging.INFO)
name = 'config'
with TemporaryDirectory('_1') as td:
with open(pjoin(td, name + '.py'), 'w') as f:
f.write("get_config().Bar.b = 1")
with open(pjoin(td, name + '.json'), 'w') as f:
json.dump({
'Bar': {
'b': 2
}
}, f)
with self.assertLogs(app.log, logging.WARNING) as captured:
app.load_config_file(name, path=[td])
app.init_bar()
assert app.bar.b == 2
output = '\n'.join(captured.output)
assert 'Collision' in output
assert '1 ignored, using 2' in output
assert pjoin(td, name + '.py') in output
assert pjoin(td, name + '.json') in output
@mark.skipif(not hasattr(TestCase, 'assertLogs'), reason='requires TestCase.assertLogs')
def test_log_bad_config(self):
app = MyApp()
app.log = logging.getLogger()
name = 'config.py'
with TemporaryDirectory() as td:
with open(pjoin(td, name), 'w') as f:
f.write("syntax error()")
with self.assertLogs(app.log, logging.ERROR) as captured:
app.load_config_file(name, path=[td])
output = '\n'.join(captured.output)
self.assertIn('SyntaxError', output)
def test_raise_on_bad_config(self):
app = MyApp()
app.raise_config_file_errors = True
app.log = logging.getLogger()
name = 'config.py'
with TemporaryDirectory() as td:
with open(pjoin(td, name), 'w') as f:
f.write("syntax error()")
with self.assertRaises(SyntaxError):
app.load_config_file(name, path=[td])
def test_subcommands_instanciation(self):
"""Try all ways to specify how to create sub-apps."""
app = Root.instance()
app.parse_command_line(['sub1'])
self.assertIsInstance(app.subapp, Sub1)
## Check parent hierarchy.
self.assertIs(app.subapp.parent, app)
Root.clear_instance()
Sub1.clear_instance() # Otherwise, replaced spuriously and hierarchy check fails.
app = Root.instance()
app.parse_command_line(['sub1', 'sub2'])
self.assertIsInstance(app.subapp, Sub1)
self.assertIsInstance(app.subapp.subapp, Sub2)
## Check parent hierarchy.
self.assertIs(app.subapp.parent, app)
self.assertIs(app.subapp.subapp.parent, app.subapp)
Root.clear_instance()
Sub1.clear_instance() # Otherwise, replaced spuriously and hierarchy check fails.
app = Root.instance()
app.parse_command_line(['sub1', 'sub3'])
self.assertIsInstance(app.subapp, Sub1)
self.assertIsInstance(app.subapp.subapp, Sub3)
self.assertTrue(app.subapp.subapp.flag) # Set by factory.
## Check parent hierarchy.
self.assertIs(app.subapp.parent, app)
self.assertIs(app.subapp.subapp.parent, app.subapp) # Set by factory.
def test_loaded_config_files(self):
app = MyApp()
app.log = logging.getLogger()
name = 'config.py'
with TemporaryDirectory('_1') as td1:
config_file = pjoin(td1, name)
with open(config_file, 'w') as f:
f.writelines([
"c.MyApp.running = True\n"
])
app.load_config_file(name, path=[td1])
self.assertEqual(len(app.loaded_config_files), 1)
self.assertEqual(app.loaded_config_files[0], config_file)
app.start()
self.assertEqual(app.running, True)
# emulate an app that allows dynamic updates and update config file
with open(config_file, 'w') as f:
f.writelines([
"c.MyApp.running = False\n"
])
# reload and verify update, and that loaded_configs was not increased
app.load_config_file(name, path=[td1])
self.assertEqual(len(app.loaded_config_files), 1)
self.assertEqual(app.running, False)
# Attempt to update, ensure error...
with self.assertRaises(AttributeError):
app.loaded_config_files = "/foo"
# ensure it can't be udpated via append
app.loaded_config_files.append("/bar")
self.assertEqual(len(app.loaded_config_files), 1)
# repeat to ensure no unexpected changes occurred
app.load_config_file(name, path=[td1])
self.assertEqual(len(app.loaded_config_files), 1)
self.assertEqual(app.running, False)
def test_cli_multi_scalar(caplog):
class App(Application):
aliases = {"opt": "App.opt"}
opt = Unicode(config=True)
app = App(log=logging.getLogger())
with pytest.raises(SystemExit):
app.parse_command_line(["--opt", "1", "--opt", "2"])
record = caplog.get_records("call")[-1]
message = record.message
assert "Error loading argument" in message
assert "App.opt=['1', '2']" in message
assert "opt only accepts one value" in message
assert record.levelno == logging.CRITICAL
class Root(Application):
subcommands = {
'sub1': ('traitlets.config.tests.test_application.Sub1', 'import string'),
}
class Sub3(Application):
flag = Bool(False)
class Sub2(Application):
pass
class Sub1(Application):
subcommands = {
'sub2': (Sub2, 'Application class'),
'sub3': (lambda root: Sub3(parent=root, flag=True), 'factory'),
}
class DeprecatedApp(Application):
override_called = False
parent_called = False
def _config_changed(self, name, old, new):
self.override_called = True
def _capture(*args):
self.parent_called = True
with mock.patch.object(self.log, 'debug', _capture):
super(DeprecatedApp, self)._config_changed(name, old, new)
def test_deprecated_notifier():
app = DeprecatedApp()
assert not app.override_called
assert not app.parent_called
app.config = Config({'A': {'b': 'c'}})
assert app.override_called
assert app.parent_called
def test_help_output():
check_help_output(__name__)
def test_help_all_output():
check_help_all_output(__name__)
def test_show_config_cli():
out, err, ec = get_output_error_code([sys.executable, '-m', __name__, '--show-config'])
assert ec == 0
assert 'show_config' not in out
def test_show_config_json_cli():
out, err, ec = get_output_error_code([sys.executable, '-m', __name__, '--show-config-json'])
assert ec == 0
assert 'show_config' not in out
def test_show_config(capsys):
cfg = Config()
cfg.MyApp.i = 5
# don't show empty
cfg.OtherApp
app = MyApp(config=cfg, show_config=True)
app.start()
out, err = capsys.readouterr()
assert 'MyApp' in out
assert 'i = 5' in out
assert 'OtherApp' not in out
def test_show_config_json(capsys):
cfg = Config()
cfg.MyApp.i = 5
cfg.OtherApp
app = MyApp(config=cfg, show_config_json=True)
app.start()
out, err = capsys.readouterr()
displayed = json.loads(out)
assert Config(displayed) == cfg
def test_deep_alias():
from traitlets.config import Application, Configurable
from traitlets import Int
class Foo(Configurable):
val = Int(default_value=5).tag(config=True)
class Bar(Configurable):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.foo = Foo(parent=self)
class TestApp(Application):
name = 'test'
aliases = {'val': 'Bar.Foo.val'}
classes = [Foo, Bar]
def initialize(self, *args, **kwargs):
super().initialize(*args, **kwargs)
self.bar = Bar(parent=self)
app = TestApp()
app.initialize(['--val=10'])
assert app.bar.foo.val == 10
assert len(list(app.emit_alias_help())) > 0
if __name__ == '__main__':
# for test_help_output:
MyApp.launch_instance()
Zerion Mini Shell 1.0