def test_main_overrides_verbosity(self):
"""Test running main called with --verbosity works as expected
"""
called = [False]
def foo_fun():
"""Foo function
"""
called[0] = True
# Monkey patch arg parser
argparse._sys.argv = [ # pylint: disable=W0212
"test", "--verbosity", "DEBUG", "foo_fun"]
self.assertFalse(called[0])
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main(commands=[foo_fun])
self.assertTrue(called[0])
self.assertEqual(conf['pyexperiment.verbosity'], 'DEBUG')
called[0] = False
# Monkey patch arg parser
argparse._sys.argv = [ # pylint: disable=W0212
"test", "--verbosity", "WARNING", "foo_fun"]
self.assertFalse(called[0])
experiment.main(commands=[foo_fun])
self.assertTrue(called[0])
self.assertEqual(conf['pyexperiment.verbosity'], 'WARNING')
def test_main_runs_other_function(self):
"""Test running main with default command and other function
"""
# Monkey patch arg parser here
argparse._sys.argv = [ # pylint: disable=W0212
"test",
"custom_function2"]
run = [False, False]
def custom_function():
"""User function
"""
run[0] = True
def custom_function2():
"""User function2
"""
run[1] = True
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main(default=custom_function,
commands=[custom_function2])
self.assertEqual(len(buf.getvalue()), 0)
self.assertFalse(run[0])
self.assertTrue(run[1])
def test_main_shows_commands(self):
"""Test running main shows commands
"""
def default_function():
"""Default function
"""
pass
def custom_function1():
"""User function
"""
pass
def custom_function2():
"""User function
"""
pass
# Monkey patch arg parser here
argparse._sys.argv = [ # pylint: disable=W0212
"test", "show_commands"]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main(default=default_function,
commands=[custom_function1, custom_function2])
self.assertNotEqual(len(buf.getvalue()), 0)
self.assertRegexpMatches(buf.getvalue(), r"default_function")
self.assertRegexpMatches(buf.getvalue(), r"custom_function1")
self.assertRegexpMatches(buf.getvalue(), r"custom_function2")
def test_print_timings_correct(self):
"""Test timing is about right
"""
buf = io.StringIO()
# Nothing should be logged yet
self.assertEqual(len(self.log_stream.getvalue()), 0)
log.initialize()
# Still, nothing should be logged yet
self.assertEqual(len(self.log_stream.getvalue()), 0)
for _ in range(3):
with log.timed("Foo", level=logging.FATAL):
time.sleep(0.01)
with stdout_redirector(buf):
log.print_timings()
# Should print correct stats
self.assertRegexpMatches(buf.getvalue(), r'\'Foo\'')
self.assertRegexpMatches(buf.getvalue(), r'3 times')
self.assertRegexpMatches(buf.getvalue(), r'total = 0.03')
self.assertRegexpMatches(buf.getvalue(), r'median = 0.01')
log.close()
# Correct timings should be logged three times
self.assertRegexpMatches(self.log_stream.getvalue(), r'Foo')
self.assertEqual(len(re.findall(r'Foo',
self.log_stream.getvalue())), 3)
self.assertRegexpMatches(self.log_stream.getvalue(), r'took 0.01')
self.assertEqual(len(re.findall(r'took 0.01',
self.log_stream.getvalue())), 3)
def test_example_messsage_with_args(self):
"""Make sure print_examples interpolates message with arguments
"""
buf = io.StringIO()
with stdout_redirector(buf):
printers.print_examples("Foo %d", 3 + 4)
self.assertRegexpMatches(buf.getvalue(), r".*%s.*" % "Foo 7")
def test_examples_print_something(self):
"""Make sure calling print_examples prints something
"""
buf = io.StringIO()
with stdout_redirector(buf):
printers.print_examples()
self.assertTrue(len(buf.getvalue()) > 0)
def test_show_nonexisting_noraise(self):
"""Test showing a state that does not exist
"""
buf = io.StringIO()
with stdout_redirector(buf):
state.show()
self.assertEqual(len(buf.getvalue()), 0)
def test_reset_seqence_appears(self):
"""Test printing actually produces the reset sequence
"""
buf = io.StringIO()
with stdout_redirector(buf):
self.printer("foo")
# We will get the assertion later (by dependency injection)
self.assertRegexpMatches(buf.getvalue(), "%s" % re.escape(printers.RESET_SEQ)) # pylint: disable=no-member
def test_message_sequence_appears(self):
"""Test printing actually prints the message
"""
buf = io.StringIO()
with stdout_redirector(buf):
self.printer("foo")
# We will get the assertion later (by dependency injection)
self.assertRegexpMatches(buf.getvalue(), "foo") # pylint: disable=no-member
def test_captures_stdout(self):
"""Test capturing stdout from print
"""
message = "This should be captured..."
buf = io.StringIO()
with stdout_redirector(buf):
print(message)
self.assertEqual(buf.getvalue(), message + '\n')
def test_reset_seqence_appears(self):
"""Test printing actually produces the reset sequence
"""
buf = io.StringIO()
with stdout_redirector(buf):
self.printer("foo")
# We will get the assertion later (by dependency injection)
self.assertRegexpMatches( # pylint: disable=no-member
buf.getvalue(), "%s" % re.escape(printers.RESET_SEQ))
def test_message_interpolates_args(self):
"""Test printing actually interpolates the arguments correctly
"""
message = "str: %s, int: %d, float %f"
arguments = ("bla", 12, 3.14)
buf = io.StringIO()
with stdout_redirector(buf):
self.printer(message, *arguments)
# We will get the assertion later (by dependency injection)
self.assertRegexpMatches(buf.getvalue(), r".*%s.*" % (message % arguments)) # pylint: disable=no-member
def test_color_sequence_appears(self):
"""Test printing actually produces the color sequence
"""
buf = io.StringIO()
with stdout_redirector(buf):
self.printer("foo")
# We will get the assertion later (by dependency injection)
# pylint: disable=no-member
self.assertIsNotNone(self.COLOR_SEQ)
self.assertRegexpMatches(buf.getvalue(),
"%s" % re.escape(self.COLOR_SEQ))
def test_message_interpolates_args(self):
"""Test printing actually interpolates the arguments correctly
"""
message = "str: %s, int: %d, float %f"
arguments = ('bla', 12, 3.14)
buf = io.StringIO()
with stdout_redirector(buf):
self.printer(message, *arguments)
# We will get the assertion later (by dependency injection)
self.assertRegexpMatches( # pylint: disable=no-member
buf.getvalue(), r'.*%s.*' % (message % arguments))
def test_main_shows_config(self):
"""Test running main shows the configuration
"""
# Monkey patch arg parser
argparse._sys.argv = [ # pylint: disable=W0212
"test", "show_config"]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main()
self.assertRegexpMatches(buf.getvalue(), r"\[pyexperiment\]")
self.assertRegexpMatches(buf.getvalue(), r"n_processes")
def test_main_shows_no_test(self):
"""Test running main complains if there are no tests
"""
# Monkey patch arg parser
argparse._sys.argv = [ # pylint: disable=W0212
"test", "show_tests"]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main(tests=[])
self.assertRegexpMatches(buf.getvalue(), r"No tests available")
def test_main_not_enough_arguments(self):
"""Test running main without command
"""
# Monkey patch arg parser here
argparse._sys.argv = [ # pylint: disable=W0212
"test"]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main()
self.assertNotEqual(len(buf.getvalue()), 0)
self.assertRegexpMatches(buf.getvalue(), r"[Nn]ot enough arguments")
def test_main_shows_config(self):
"""Test running main shows the configuration
"""
# Monkey patch arg parser
argparse._sys.argv = [ # pylint: disable=W0212
"test", "show_config"
]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main()
self.assertRegexpMatches(buf.getvalue(), r"\[pyexperiment\]")
self.assertRegexpMatches(buf.getvalue(), r"n_processes")
def test_main_shows_no_test(self):
"""Test running main complains if there are no tests
"""
# Monkey patch arg parser
argparse._sys.argv = [ # pylint: disable=W0212
"test", "show_tests"
]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main(tests=[])
self.assertRegexpMatches(buf.getvalue(), r"No tests available")
def test_main_not_enough_arguments(self):
"""Test running main without command
"""
# Monkey patch arg parser here
argparse._sys.argv = [ # pylint: disable=W0212
"test"
]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main()
self.assertNotEqual(len(buf.getvalue()), 0)
self.assertRegexpMatches(buf.getvalue(), r"[Nn]ot enough arguments")
def test_with_block_show(self):
"""Test with-block of the StateHandler does not cause show to fail
"""
with tempfile.NamedTemporaryFile() as temp:
state.reset_instance()
state['a'] = 12
with StateHandler(temp.name, load=True):
self.assertEqual(len(state), 1)
self.assertEqual(state['a'], 12)
buf = io.StringIO()
with stdout_redirector(buf):
state.show()
self.assertNotEqual(len(buf.getvalue()), 0)
self.assertRegexpMatches(buf.getvalue(), r"a:12")
def test_with_block_show(self):
"""Test with-block of the StateHandler does not cause show to fail
"""
with tempfile.NamedTemporaryFile() as temp:
state.reset_instance()
state['a'] = 12
with StateHandler(temp.name, load=True):
self.assertEqual(len(state), 1)
self.assertEqual(state['a'], 12)
buf = io.StringIO()
with stdout_redirector(buf):
state.show()
self.assertNotEqual(len(buf.getvalue()), 0)
self.assertRegexpMatches(buf.getvalue(), r"a:12")
def test_main_shows_other_state(self):
"""Test running main shows state from file
"""
with tempfile.NamedTemporaryFile() as temp:
state['foo'] = 42
state.save(temp.name)
# Monkey patch arg parser
argparse._sys.argv = [ # pylint: disable=W0212
"test", "show_state", temp.name]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main()
self.assertRegexpMatches(buf.getvalue(), r"foo")
self.assertRegexpMatches(buf.getvalue(), r"42")
def test_main_shows_test(self):
"""Test running main shows tests when needed
"""
class ExampleTest(unittest.TestCase):
"""Test case for the test
"""
pass
# Monkey patch arg parser
argparse._sys.argv = [ # pylint: disable=W0212
"test", "show_tests"]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main(tests=[ExampleTest])
self.assertRegexpMatches(buf.getvalue(), r"ExampleTest")
def test_show(self):
"""Test showing the state
"""
state['a.b'] = 12
state['bla.bli'] = 13
buf = io.StringIO()
with stdout_redirector(buf):
state.show()
self.assertNotEqual(len(buf.getvalue()), 0)
self.assertRegexpMatches(buf.getvalue(), r"\[a\]")
self.assertRegexpMatches(buf.getvalue(), r"\[bla\]")
self.assertRegexpMatches(buf.getvalue(), r"b")
self.assertRegexpMatches(buf.getvalue(), r"bli")
self.assertRegexpMatches(buf.getvalue(), r"12")
self.assertRegexpMatches(buf.getvalue(), r"13")
def test_main_shows_other_state(self):
"""Test running main shows state from file
"""
with tempfile.NamedTemporaryFile() as temp:
state['foo'] = 42
state.save(temp.name)
# Monkey patch arg parser
argparse._sys.argv = [ # pylint: disable=W0212
"test", "show_state", temp.name
]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main()
self.assertRegexpMatches(buf.getvalue(), r"foo")
self.assertRegexpMatches(buf.getvalue(), r"42")
def test_show(self):
"""Test showing the state
"""
state['a.b'] = 12
state['bla.bli'] = 13
buf = io.StringIO()
with stdout_redirector(buf):
state.show()
self.assertNotEqual(len(buf.getvalue()), 0)
self.assertRegexpMatches(buf.getvalue(), r"\[a\]")
self.assertRegexpMatches(buf.getvalue(), r"\[bla\]")
self.assertRegexpMatches(buf.getvalue(), r"b")
self.assertRegexpMatches(buf.getvalue(), r"bli")
self.assertRegexpMatches(buf.getvalue(), r"12")
self.assertRegexpMatches(buf.getvalue(), r"13")
def test_main_prints_timings_simple(self):
"""Test running main logs timings as expected with --print_timings
"""
argparse._sys.argv = [ # pylint: disable=W0212
"test", "--print-timings"]
def hello():
"""Logs a message
"""
with log.timed("bla"):
pass
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main(default=hello)
self.assertNotEqual(len(buf.getvalue()), 0)
self.assertRegexpMatches(buf.getvalue(), r'bla')
def test_main_prints_result(self):
"""Test running main prints the result of a function
"""
def custom_function():
"""User function
"""
return "Foo"
# Monkey patch arg parser here
argparse._sys.argv = [ # pylint: disable=W0212
"test", "custom_function"]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main(commands=[custom_function])
self.assertNotEqual(len(buf.getvalue()), 0)
self.assertRegexpMatches(buf.getvalue(), r'Foo')
def test_main_saves_config(self):
"""Test running main saves the configuration
"""
with tempfile.NamedTemporaryFile() as temp:
# Monkey patch arg parser
argparse._sys.argv = [ # pylint: disable=W0212
"test", "save_config", temp.name]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main()
lines = open(temp.name).readlines()
self.assertNotEqual(len(lines), 0)
self.assertRegexpMatches("".join(lines), r"\[pyexperiment\]")
self.assertRegexpMatches("".join(lines), r"n_processes")
self.assertRegexpMatches(buf.getvalue(), r'Wrote configuration')
def test_main_shows_test(self):
"""Test running main shows tests when needed
"""
class ExampleTest(unittest.TestCase):
"""Test case for the test
"""
pass
# Monkey patch arg parser
argparse._sys.argv = [ # pylint: disable=W0212
"test", "show_tests"
]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main(tests=[ExampleTest])
self.assertRegexpMatches(buf.getvalue(), r"ExampleTest")
def test_main_shows_default_state(self):
"""Test running main shows the default state
"""
with tempfile.NamedTemporaryFile() as temp:
state['bla'] = 12
state.save(temp.name)
spec = ('[pyexperiment]\n'
'state_filename = string(default=%s)' % temp.name)
# Monkey patch arg parser
argparse._sys.argv = [ # pylint: disable=W0212
"test", "show_state"]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main(config_spec=spec)
self.assertRegexpMatches(buf.getvalue(), r"bla")
self.assertRegexpMatches(buf.getvalue(), r"12")
def test_main_shows_default_state(self):
"""Test running main shows the default state
"""
with tempfile.NamedTemporaryFile() as temp:
state['bla'] = 12
state.save(temp.name)
spec = ('[pyexperiment]\n'
'state_filename = string(default=%s)' % temp.name)
# Monkey patch arg parser
argparse._sys.argv = [ # pylint: disable=W0212
"test", "show_state"
]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main(config_spec=spec)
self.assertRegexpMatches(buf.getvalue(), r"bla")
self.assertRegexpMatches(buf.getvalue(), r"12")
def test_main_prints_timings_simple(self):
"""Test running main logs timings as expected with --print_timings
"""
argparse._sys.argv = [ # pylint: disable=W0212
"test", "--print-timings"
]
def hello():
"""Logs a message
"""
with log.timed("bla"):
pass
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main(default=hello)
self.assertNotEqual(len(buf.getvalue()), 0)
self.assertRegexpMatches(buf.getvalue(), r'bla')
def test_main_prints_result(self):
"""Test running main prints the result of a function
"""
def custom_function():
"""User function
"""
return "Foo"
# Monkey patch arg parser here
argparse._sys.argv = [ # pylint: disable=W0212
"test", "custom_function"
]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main(commands=[custom_function])
self.assertNotEqual(len(buf.getvalue()), 0)
self.assertRegexpMatches(buf.getvalue(), r'Foo')
def test_main_complains_on_help(self):
"""Test running help complains on help for wrong command
"""
def custom_function():
"""Foo function
"""
pass
# Monkey patch arg parser here
argparse._sys.argv = [ # pylint: disable=W0212
"test", "help", "foo"]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main(commands=[custom_function])
self.assertRegexpMatches(buf.getvalue(), r"[cC]ommand")
self.assertRegexpMatches(buf.getvalue(), r"not")
self.assertRegexpMatches(buf.getvalue(), r"foo")
def test_main_saves_config(self):
"""Test running main saves the configuration
"""
with tempfile.NamedTemporaryFile() as temp:
# Monkey patch arg parser
argparse._sys.argv = [ # pylint: disable=W0212
"test", "save_config", temp.name
]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main()
lines = open(temp.name).readlines()
self.assertNotEqual(len(lines), 0)
self.assertRegexpMatches("".join(lines), r"\[pyexperiment\]")
self.assertRegexpMatches("".join(lines), r"n_processes")
self.assertRegexpMatches(buf.getvalue(), r'Wrote configuration')
def test_main_no_processes_long(self):
"""Test running main called with --processes works as expected
"""
called = [False]
def foo_fun():
"""Foo function
"""
called[0] = True
# Monkey patch arg parser
argparse._sys.argv = [ # pylint: disable=W0212
"test", "--processes", "44", "foo_fun"]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main(commands=[foo_fun])
self.assertTrue(called[0])
self.assertEqual(conf['pyexperiment.n_processes'],
44)
def test_main_complains_on_help(self):
"""Test running help complains on help for wrong command
"""
def custom_function():
"""Foo function
"""
pass
# Monkey patch arg parser here
argparse._sys.argv = [ # pylint: disable=W0212
"test", "help", "foo"
]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main(commands=[custom_function])
self.assertRegexpMatches(buf.getvalue(), r"[cC]ommand")
self.assertRegexpMatches(buf.getvalue(), r"not")
self.assertRegexpMatches(buf.getvalue(), r"foo")
def test_main_does_not_run_function(self):
"""Test running main does not call unnecessary function but complains
"""
run = [False]
def custom_function():
"""User function
"""
run[0] = True
# Monkey patch arg parser here
argparse._sys.argv = [ # pylint: disable=W0212
"test", "help"]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main(commands=[custom_function])
self.assertFalse(run[0])
self.assertNotEqual(len(buf.getvalue()), 0)
def test_main_gives_help(self):
"""Test running help shows docstring
"""
run = [False]
def custom_function():
"""This should be printed!!
"""
run[0] = True
# Monkey patch arg parser here
argparse._sys.argv = [ # pylint: disable=W0212
"test", "help", "custom_function"]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main(commands=[custom_function])
self.assertFalse(run[0])
self.assertIn("This should be printed!!", buf.getvalue())
def test_main_runs_function(self):
"""Test running main calls function
"""
run = [False]
def custom_function():
"""User function
"""
run[0] = True
# Monkey patch arg parser here
argparse._sys.argv = [ # pylint: disable=W0212
"test", "custom_function"]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main(commands=[custom_function])
self.assertTrue(run[0])
self.assertEqual(len(buf.getvalue()), 0)
def test_main_doesnt_test_on_help(self):
"""Test running main does not call tests when not needed
"""
class ExampleTest(unittest.TestCase):
"""Test case for the test
"""
pass
# Monkey patch arg parser
argparse._sys.argv = [ # pylint: disable=W0212
"test", "-h"]
buf = io.StringIO()
with stdout_redirector(buf):
with mock.patch.object(unittest, 'TextTestRunner') as mock_method:
try:
experiment.main(commands=[], tests=[ExampleTest])
self.assertEqual(mock_method.call_count, 0)
except SystemExit:
pass
def test_main_does_not_run_function(self):
"""Test running main does not call unnecessary function but complains
"""
run = [False]
def custom_function():
"""User function
"""
run[0] = True
# Monkey patch arg parser here
argparse._sys.argv = [ # pylint: disable=W0212
"test", "help"
]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main(commands=[custom_function])
self.assertFalse(run[0])
self.assertNotEqual(len(buf.getvalue()), 0)
def test_main_gives_help(self):
"""Test running help shows docstring
"""
run = [False]
def custom_function():
"""This should be printed!!
"""
run[0] = True
# Monkey patch arg parser here
argparse._sys.argv = [ # pylint: disable=W0212
"test", "help", "custom_function"
]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main(commands=[custom_function])
self.assertFalse(run[0])
self.assertIn("This should be printed!!", buf.getvalue())
def test_main_runs_function(self):
"""Test running main calls function
"""
run = [False]
def custom_function():
"""User function
"""
run[0] = True
# Monkey patch arg parser here
argparse._sys.argv = [ # pylint: disable=W0212
"test", "custom_function"
]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main(commands=[custom_function])
self.assertTrue(run[0])
self.assertEqual(len(buf.getvalue()), 0)
def test_main_doesnt_test_on_help(self):
"""Test running main does not call tests when not needed
"""
class ExampleTest(unittest.TestCase):
"""Test case for the test
"""
pass
# Monkey patch arg parser
argparse._sys.argv = [ # pylint: disable=W0212
"test", "-h"
]
buf = io.StringIO()
with stdout_redirector(buf):
with mock.patch.object(unittest, 'TextTestRunner') as mock_method:
try:
experiment.main(commands=[], tests=[ExampleTest])
self.assertEqual(mock_method.call_count, 0)
except SystemExit:
pass
def test_main_no_processes_long(self):
"""Test running main called with --processes works as expected
"""
called = [False]
def foo_fun():
"""Foo function
"""
called[0] = True
# Monkey patch arg parser
argparse._sys.argv = [ # pylint: disable=W0212
"test", "--processes", "44", "foo_fun"
]
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main(commands=[foo_fun])
self.assertTrue(called[0])
self.assertEqual(conf['pyexperiment.n_processes'], 44)
def test_print_timings_complains(self):
"""Test timing code complains if there are no timings
"""
buf = io.StringIO()
# Nothing should be logged yet
self.assertEqual(len(self.log_stream.getvalue()), 0)
log.initialize()
# Still, nothing should be logged yet
self.assertEqual(len(self.log_stream.getvalue()), 0)
with stdout_redirector(buf):
log.print_timings()
# Something should be printed
self.assertNotEqual(len(buf.getvalue()), 0)
self.assertRegexpMatches(buf.getvalue(), r'No timings stored')
log.close()
# Nothing should be logged
self.assertEqual(len(self.log_stream.getvalue()), 0)
def test_print_timings_prints(self):
"""Test timing code and printing really prints a message
"""
buf = io.StringIO()
# Nothing should be logged yet
self.assertEqual(len(self.log_stream.getvalue()), 0)
log.initialize()
# Still, nothing should be logged yet
self.assertEqual(len(self.log_stream.getvalue()), 0)
with log.timed(level=logging.FATAL):
_ = 1 + 1
with stdout_redirector(buf):
log.print_timings()
# Something should be printed
self.assertNotEqual(len(buf.getvalue()), 0)
log.close()
# Something should be logged
self.assertNotEqual(len(self.log_stream.getvalue()), 0)
def test_main_overrides_option(self):
"""Test running main called with -o works as expected
"""
called = [False]
def foo_fun():
"""Foo function
"""
called[0] = True
self.assertEqual(conf['bla'], 'foo')
conf['bla'] = 'bla'
# Monkey patch arg parser
argparse._sys.argv = [ # pylint: disable=W0212
"test", "-o", "bla", "foo", "foo_fun"]
self.assertFalse(called[0])
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main(commands=[foo_fun])
self.assertTrue(called[0])
self.assertEqual(conf['bla'], 'foo')
def test_main_overrides_verbosity(self):
"""Test running main called with --verbosity works as expected
"""
called = [False]
def foo_fun():
"""Foo function
"""
called[0] = True
# Monkey patch arg parser
argparse._sys.argv = [ # pylint: disable=W0212
"test", "--verbosity", "DEBUG", "foo_fun"
]
self.assertFalse(called[0])
buf = io.StringIO()
with stdout_redirector(buf):
experiment.main(commands=[foo_fun])
self.assertTrue(called[0])
self.assertEqual(conf['pyexperiment.verbosity'], 'DEBUG')
called[0] = False
# Monkey patch arg parser
argparse._sys.argv = [ # pylint: disable=W0212
"test", "--verbosity", "WARNING", "foo_fun"
]
self.assertFalse(called[0])
experiment.main(commands=[foo_fun])
self.assertTrue(called[0])
self.assertEqual(conf['pyexperiment.verbosity'], 'WARNING')
def test_show_lazy(self):
"""Test showing the state lazily loaded
"""
state['a.b'] = 12
buf = io.StringIO()
with tempfile.NamedTemporaryFile() as temp:
state.save(temp.name)
state['a.b'] = 13
state.load(temp.name, lazy=True)
with stdout_redirector(buf):
state.show()
self.assertNotEqual(len(buf.getvalue()), 0)
self.assertRegexpMatches(buf.getvalue(), r"\[a\]")
self.assertRegexpMatches(buf.getvalue(), r"b")
self.assertRegexpMatches(buf.getvalue(), r"12")
if six.PY2:
self.assertNotRegexpMatches(buf.getvalue(), r"13")
elif six.PY3:
self.assertNotRegex( # pylint: disable=E1101
buf.getvalue(), r"13")
else:
raise RuntimeError("Python version not supported")
