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_logger_after_exception(self): """Test logger closing correctly after exception """ # Monkey patch log closing close_old = Logger.Logger.close called = [False] def close(self): """Close the logger and record it""" close_old(self) called[0] = True Logger.Logger.close = close def foo_fun(): """Foo function """ raise RuntimeError # Monkey patch arg parser argparse._sys.argv = [ # pylint: disable=W0212 "test", "foo_fun" ] try: experiment.main(commands=[foo_fun]) except RuntimeError: pass else: raise AssertionError("RuntimeError not raised") # Make sure logger is closed self.assertTrue(called[0]) Logger.Logger.close = close_old
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_logger_after_exception(self): """Test logger closing correctly after exception """ # Monkey patch log closing close_old = Logger.Logger.close called = [False] def close(self): """Close the logger and record it""" close_old(self) called[0] = True Logger.Logger.close = close def foo_fun(): """Foo function """ raise RuntimeError # Monkey patch arg parser argparse._sys.argv = [ # pylint: disable=W0212 "test", "foo_fun"] try: experiment.main(commands=[foo_fun]) except RuntimeError: pass else: raise AssertionError("RuntimeError not raised") # Make sure logger is closed self.assertTrue(called[0]) Logger.Logger.close = close_old
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_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_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_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_runs_interactive(self, mock_interactive): """Test running main runs interactive session """ argparse._sys.argv = [ # pylint: disable=W0212 "test", "--interactive"] experiment.main(commands=[], tests=[]) self.assertTrue(mock_interactive.call_count == 1)
def test_main_runs_interactive(self, mock_interactive): """Test running main runs interactive session """ argparse._sys.argv = [ # pylint: disable=W0212 "test", "--interactive" ] experiment.main(commands=[], tests=[]) self.assertTrue(mock_interactive.call_count == 1)
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_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_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_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_logs_console(self): """Test running main logs as expected """ argparse._sys.argv = [ # pylint: disable=W0212 "test"] def hello(): """Logs a message """ log.fatal("Hello") experiment.main(default=hello) self.assertNotEqual(len(self.log_stream.getvalue()), 0) self.assertRegexpMatches(self.log_stream.getvalue(), r'Hello')
def test_main_runs_test(self): """Test running main calls tests when needed """ class ExampleTest(unittest.TestCase): """Test case for the test """ pass # Monkey patch arg parser argparse._sys.argv = [ # pylint: disable=W0212 "test", "test"] with mock.patch.object(unittest, 'TextTestRunner') as mock_method: experiment.main(commands=[], tests=[ExampleTest]) self.assertEqual(mock_method.call_count, 1)
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_runs_test(self): """Test running main calls tests when needed """ class ExampleTest(unittest.TestCase): """Test case for the test """ pass # Monkey patch arg parser argparse._sys.argv = [ # pylint: disable=W0212 "test", "test" ] with mock.patch.object(unittest, 'TextTestRunner') as mock_method: experiment.main(commands=[], tests=[ExampleTest]) self.assertEqual(mock_method.call_count, 1)
def test_main_logs_console(self): """Test running main logs as expected """ argparse._sys.argv = [ # pylint: disable=W0212 "test" ] def hello(): """Logs a message """ log.fatal("Hello") experiment.main(default=hello) self.assertNotEqual(len(self.log_stream.getvalue()), 0) self.assertRegexpMatches(self.log_stream.getvalue(), r'Hello')
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_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_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_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_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_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_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_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_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_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_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_verbosity_debug(self): """Test running main called with -v works as expected """ called = [False] def foo_fun(): """Foo function """ called[0] = True # Monkey patch arg parser argparse._sys.argv = [ # pylint: disable=W0212 "test", "-v", "foo_fun"] self.assertFalse(called[0]) experiment.main(commands=[foo_fun]) self.assertTrue(called[0]) self.assertEqual(conf['pyexperiment.verbosity'], 'DEBUG')
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_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_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_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_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_verbosity_debug(self): """Test running main called with -v works as expected """ called = [False] def foo_fun(): """Foo function """ called[0] = True # Monkey patch arg parser argparse._sys.argv = [ # pylint: disable=W0212 "test", "-v", "foo_fun" ] self.assertFalse(called[0]) experiment.main(commands=[foo_fun]) self.assertTrue(called[0]) self.assertEqual(conf['pyexperiment.verbosity'], 'DEBUG')
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_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_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_logs_file(self): """Test running main logs as expected """ conf['pyexperiment.rotate_n_logs'] = 0 argparse._sys.argv = [ # pylint: disable=W0212 "test"] def hello(): """Logs a message """ log.debug("Hello") with tempfile.NamedTemporaryFile() as temp: conf['pyexperiment.log_filename'] = temp.name conf['pyexperiment.log_to_file'] = True experiment.main(default=hello) lines = open(temp.name).readlines() self.assertNotEqual(len(lines), 0) self.assertRegexpMatches("".join(lines), r'Hello') self.assertEqual(len(self.log_stream.getvalue()), 0)
def test_main_logs_file(self): """Test running main logs as expected """ conf['pyexperiment.rotate_n_logs'] = 0 argparse._sys.argv = [ # pylint: disable=W0212 "test" ] def hello(): """Logs a message """ log.debug("Hello") with tempfile.NamedTemporaryFile() as temp: conf['pyexperiment.log_filename'] = temp.name conf['pyexperiment.log_to_file'] = True experiment.main(default=hello) lines = open(temp.name).readlines() self.assertNotEqual(len(lines), 0) self.assertRegexpMatches("".join(lines), r'Hello') self.assertEqual(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')