Beispiel #1
0
 def test_setattr_type_check(self):
     # setattr requires that options be the right type and doesn't
     # parse from string formats.
     options = OptionParser()
     options.define('foo', default=1, type=int)
     with self.assertRaises(Error):
         options.foo = '2'
Beispiel #2
0
 def test_setattr_type_check(self):
     # setattr requires that options be the right type and doesn't
     # parse from string formats.
     options = OptionParser()
     options.define('foo', default=1, type=int)
     with self.assertRaises(Error):
         options.foo = '2'
Beispiel #3
0
    def _parse_logger_callback(self):
        # print('parse_logger_callback: ')
        if options.disable_log:
            options.logging = None
        if options.log_file_prefix and options.log_port_prefix:
            options.log_file_prefix += ".%s" % options.port

        tornado_logger = logging.getLogger('tornado')
        enable_pretty_logging(logger=tornado_logger)
        logdir = options.logging_dir or settings.LOGGING_DIR
        for log in settings.log_cfg.logging:
            opt = OptionParser()
            define_logging_options(opt)
            self._define(opt)
            opt.log_rotate_when = log.get('when', 'midnight')
            opt.log_to_stderr = log.get(
                'log_to_stderr', False
            ) if options.log_to_stderr is None else options.log_to_stderr
            opt.logging = log.get('level', 'INFO')
            opt.log_file_prefix = os.path.join(logdir, log['filename'])
            if log.get('backups'):
                opt.log_file_num_backups = log.get('backups')
            if opt.log_port_prefix:
                opt.log_file_prefix += ".%s" % options.port
            opt.log_rotate_interval = log.get('interval', 1)
            opt.log_rotate_mode = 'time'
            logger = logging.getLogger(log['name'])
            logger.propagate = 0
            enable_pretty_logging(options=opt, logger=logger)

            map(
                lambda h: h.setFormatter(
                    LogFormatter(fmt=log.get("formatter", settings.
                                             standard_format),
                                 color=settings.DEBUG)), logger.handlers)
Beispiel #4
0
 def parse_logger_callback(self):
     if options.disable_log:
         options.logging = None
     if options.log_file_prefix and options.log_port_prefix:
         options.log_file_prefix += ".%s" % options.port
     if options.log_patch:
         logging.handlers.TimedRotatingFileHandler = ProcessLogTimedFileHandler
     tornado_logger = logging.getLogger('tornado')
     enable_pretty_logging(logger=tornado_logger)
     logdir = options.logging_dir or settings.LOGGING_DIR
     for log in settings.LOGGING:
         opt = OptionParser()
         define_logging_options(opt)
         self.define(opt)
         opt.log_rotate_when = log.get('when', 'midnight')
         opt.log_to_stderr = log.get('log_to_stderr', False)
         opt.logging = log.get('level', 'INFO')
         opt.log_file_prefix = os.path.join(logdir, log['filename'])
         if log.get('backups'):
             opt.log_file_num_backups = log.get('backups')
         if opt.log_port_prefix:
             opt.log_file_prefix += ".%s" % options.port
         opt.log_rotate_interval = log.get('interval', 1)
         opt.log_rotate_mode = 'time'
         logger = logging.getLogger(log['name'])
         if not settings.DEBUG:
             logger.propagate = 0
         else:
             if not opt.log_to_stderr:
                 logger.propagate = 0
             else:
                 logger.propagate = 1
         enable_pretty_logging(options=opt, logger=logger)
         map(lambda h: h.setFormatter(LogFormatter(fmt=log.get("formatter", LogFormatter.DEFAULT_FORMAT),
                                                   color=settings.DEBUG)), logger.handlers)
Beispiel #5
0
 def test_parse_config_file(self):
     options = OptionParser()
     options.define("port", default=80)
     options.define("username", default='foo')
     options.define("my_path")
     config_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
                                "options_test.cfg")
     options.parse_config_file(config_path)
     self.assertEqual(options.port, 443)
     self.assertEqual(options.username, "李康")
     self.assertEqual(options.my_path, config_path)
Beispiel #6
0
 def test_help(self):
     options = OptionParser()
     try:
         orig_stderr = sys.stderr
         sys.stderr = StringIO()
         with self.assertRaises(SystemExit):
             options.parse_command_line(["main.py", "--help"])
         usage = sys.stderr.getvalue()
     finally:
         sys.stderr = orig_stderr
     self.assertIn("Usage:", usage)
Beispiel #7
0
 def test_help(self):
     options = OptionParser()
     try:
         orig_stderr = sys.stderr
         sys.stderr = StringIO()
         with self.assertRaises(SystemExit):
             options.parse_command_line(["main.py", "--help"])
         usage = sys.stderr.getvalue()
     finally:
         sys.stderr = orig_stderr
     self.assertIn("Usage:", usage)
Beispiel #8
0
 def test_dash_underscore_cli(self):
     # Dashes and underscores should be interchangeable.
     for defined_name in ["foo-bar", "foo_bar"]:
         for flag in ["--foo-bar=a", "--foo_bar=a"]:
             options = OptionParser()
             options.define(defined_name)
             options.parse_command_line(["main.py", flag])
             # Attr-style access always uses underscores.
             self.assertEqual(options.foo_bar, "a")
             # Dict-style access allows both.
             self.assertEqual(options["foo-bar"], "a")
             self.assertEqual(options["foo_bar"], "a")
Beispiel #9
0
def generate_options(envfile=None, autosetup=False):
    '''
    This generates a Tornado options object for use in testing.

    '''

    generated_options = OptionParser()

    # load all of the conf vars as command-line options
    for cv in confvars.CONF:
        generated_options.define(confvars.CONF[cv]['cmdline'],
                                 default=confvars.CONF[cv]['default'],
                                 help=confvars.CONF[cv]['help'],
                                 type=confvars.CONF[cv]['type'])

    # the path to an env file containing environment variables
    generated_options.define(
        'envfile',
        default=envfile,
        help=('Path to a file containing environ variables '
              'for testing/development.'),
        type=str)

    # whether to make a new authdb if none exists
    generated_options.define(
        'autosetup',
        default=autosetup,
        help=("If this is True, will automatically generate an SQLite "
              "authentication database in the basedir if there isn't one "
              "present and the value of the authdb option is also None."),
        type=bool)

    return generated_options
Beispiel #10
0
 def setUp(self):
     super(EnablePrettyLoggingTest, self).setUp()
     self.options = OptionParser()
     define_logging_options(self.options)
     self.logger = logging.Logger(
         'tornado.test.log_test.EnablePrettyLoggingTest')
     self.logger.propagate = False
Beispiel #11
0
    def test_group_dict(self):
        options = OptionParser()
        options.define("a", default=1)
        options.define("b", group="b_group", default=2)

        frame = sys._getframe(0)
        this_file = frame.f_code.co_filename
        self.assertEqual(set(["b_group", "", this_file]), options.groups())

        b_group_dict = options.group_dict("b_group")
        self.assertEqual({"b": 2}, b_group_dict)

        self.assertEqual({}, options.group_dict("nonexistent"))
Beispiel #12
0
    def test_group_dict(self):
        options = OptionParser()
        options.define('a', default=1)
        options.define('b', group='b_group', default=2)

        frame = sys._getframe(0)
        this_file = frame.f_code.co_filename
        self.assertEqual(set(['b_group', '', this_file]), options.groups())

        b_group_dict = options.group_dict('b_group')
        self.assertEqual({'b': 2}, b_group_dict)

        self.assertEqual({}, options.group_dict('nonexistent'))
Beispiel #13
0
 def test_error_redefine_underscore(self):
     # Ensure that the dash/underscore normalization doesn't
     # interfere with the redefinition error.
     tests = [
         ('foo-bar', 'foo-bar'),
         ('foo_bar', 'foo_bar'),
         ('foo-bar', 'foo_bar'),
         ('foo_bar', 'foo-bar'),
     ]
     for a, b in tests:
         with subTest(self, a=a, b=b):
             options = OptionParser()
             options.define(a)
             with self.assertRaises(Error) as cm:
                 options.define(b)
             self.assertRegexpMatches(str(cm.exception),
                                      'Option.*foo.bar.*already defined')
Beispiel #14
0
    def test_dash_underscore_introspection(self):
        # Original names are preserved in introspection APIs.
        options = OptionParser()
        options.define("with-dash", group="g")
        options.define("with_underscore", group="g")
        all_options = ["help", "with-dash", "with_underscore"]
        self.assertEqual(sorted(options), all_options)
        self.assertEqual(sorted(k for (k, v) in options.items()), all_options)
        self.assertEqual(sorted(options.as_dict().keys()), all_options)

        self.assertEqual(
            sorted(options.group_dict("g")), ["with-dash", "with_underscore"]
        )

        # --help shows CLI-style names with dashes.
        buf = StringIO()
        options.print_help(buf)
        self.assertIn("--with-dash", buf.getvalue())
        self.assertIn("--with-underscore", buf.getvalue())
Beispiel #15
0
    def test_mock_patch(self):
        # ensure that our setattr hooks don't interfere with mock.patch
        options = OptionParser()
        options.define('foo', default=1)
        options.parse_command_line(['main.py', '--foo=2'])
        self.assertEqual(options.foo, 2)

        with mock.patch.object(options.mockable(), 'foo', 3):
            self.assertEqual(options.foo, 3)
        self.assertEqual(options.foo, 2)

        # Try nested patches mixed with explicit sets
        with mock.patch.object(options.mockable(), 'foo', 4):
            self.assertEqual(options.foo, 4)
            options.foo = 5
            self.assertEqual(options.foo, 5)
            with mock.patch.object(options.mockable(), 'foo', 6):
                self.assertEqual(options.foo, 6)
            self.assertEqual(options.foo, 5)
        self.assertEqual(options.foo, 2)
Beispiel #16
0
    def test_group_dict(self):
        options = OptionParser()
        options.define("a", default=1)
        options.define("b", group="b_group", default=2)

        frame = sys._getframe(0)
        this_file = frame.f_code.co_filename
        self.assertEqual(set(["b_group", "", this_file]), options.groups())

        b_group_dict = options.group_dict("b_group")
        self.assertEqual({"b": 2}, b_group_dict)

        self.assertEqual({}, options.group_dict("nonexistent"))
Beispiel #17
0
    def test_subcommand(self):
        base_options = OptionParser()
        base_options.define("verbose", default=False)
        sub_options = OptionParser()
        sub_options.define("foo", type=str)
        rest = base_options.parse_command_line(
            ["main.py", "--verbose", "subcommand", "--foo=bar"])
        self.assertEqual(rest, ["subcommand", "--foo=bar"])
        self.assertTrue(base_options.verbose)
        rest2 = sub_options.parse_command_line(rest)
        self.assertEqual(rest2, [])
        self.assertEqual(sub_options.foo, "bar")

        # the two option sets are distinct
        try:
            orig_stderr = sys.stderr
            sys.stderr = StringIO()
            with self.assertRaises(Error):
                sub_options.parse_command_line(["subcommand", "--verbose"])
        finally:
            sys.stderr = orig_stderr
Beispiel #18
0
    def test_parse_callbacks(self):
        options = OptionParser()
        self.called = False

        def callback():
            self.called = True
        options.add_parse_callback(callback)

        # non-final parse doesn't run callbacks
        options.parse_command_line(["main.py"], final=False)
        self.assertFalse(self.called)

        # final parse does
        options.parse_command_line(["main.py"])
        self.assertTrue(self.called)

        # callbacks can be run more than once on the same options
        # object if there are multiple final parses
        self.called = False
        options.parse_command_line(["main.py"])
        self.assertTrue(self.called)
Beispiel #19
0
 def test_error_redefine(self):
     options = OptionParser()
     options.define('foo')
     with self.assertRaises(Error) as cm:
         options.define('foo')
     self.assertRegexpMatches(str(cm.exception),
                              'Option.*foo.*already defined')
Beispiel #20
0
 def test_dash_underscore_file(self):
     # No matter how an option was defined, it can be set with underscores
     # in a config file.
     for defined_name in ['foo-bar', 'foo_bar']:
         options = OptionParser()
         options.define(defined_name)
         options.parse_config_file(os.path.join(os.path.dirname(__file__),
                                                "options_test.cfg"))
         self.assertEqual(options.foo_bar, 'a')
Beispiel #21
0
    def test_parse_callbacks(self):
        options = OptionParser()
        self.called = False
        def callback():
            self.called = True
        options.add_parse_callback(callback)

        # non-final parse doesn't run callbacks
        options.parse_command_line(["main.py"], final=False)
        self.assertFalse(self.called)

        # final parse does
        options.parse_command_line(["main.py"])
        self.assertTrue(self.called)

        # callbacks can be run more than once on the same options
        # object if there are multiple final parses
        self.called = False
        options.parse_command_line(["main.py"])
        self.assertTrue(self.called)
Beispiel #22
0
    def test_mock_patch(self):
        # ensure that our setattr hooks don't interfere with mock.patch
        options = OptionParser()
        options.define('foo', default=1)
        options.parse_command_line(['main.py', '--foo=2'])
        self.assertEqual(options.foo, 2)

        with mock.patch.object(options.mockable(), 'foo', 3):
            self.assertEqual(options.foo, 3)
        self.assertEqual(options.foo, 2)

        # Try nested patches mixed with explicit sets
        with mock.patch.object(options.mockable(), 'foo', 4):
            self.assertEqual(options.foo, 4)
            options.foo = 5
            self.assertEqual(options.foo, 5)
            with mock.patch.object(options.mockable(), 'foo', 6):
                self.assertEqual(options.foo, 6)
            self.assertEqual(options.foo, 5)
        self.assertEqual(options.foo, 2)
Beispiel #23
0
 def test_dash_underscore_cli(self):
     # Dashes and underscores should be interchangeable.
     for defined_name in ["foo-bar", "foo_bar"]:
         for flag in ["--foo-bar=a", "--foo_bar=a"]:
             options = OptionParser()
             options.define(defined_name)
             options.parse_command_line(["main.py", flag])
             # Attr-style access always uses underscores.
             self.assertEqual(options.foo_bar, "a")
             # Dict-style access allows both.
             self.assertEqual(options["foo-bar"], "a")
             self.assertEqual(options["foo_bar"], "a")
Beispiel #24
0
 def test_dash_underscore_cli(self):
     # Dashes and underscores should be interchangeable.
     for defined_name in ['foo-bar', 'foo_bar']:
         for flag in ['--foo-bar=a', '--foo_bar=a']:
             options = OptionParser()
             options.define(defined_name)
             options.parse_command_line(['main.py', flag])
             # Attr-style access always uses underscores.
             self.assertEqual(options.foo_bar, 'a')
             # Dict-style access allows both.
             self.assertEqual(options['foo-bar'], 'a')
             self.assertEqual(options['foo_bar'], 'a')
def generate_options(envfile=None, autosetup=False):
    """
    This generates a Tornado options object for use in testing.

    """

    generated_options = OptionParser()

    # load all of the conf vars as command-line options
    for cv in confvars.CONF:
        generated_options.define(
            confvars.CONF[cv]["cmdline"],
            default=confvars.CONF[cv]["default"],
            help=confvars.CONF[cv]["help"],
            type=confvars.CONF[cv]["type"],
        )

    # the path to an env file containing environment variables
    generated_options.define(
        "envfile",
        default=envfile,
        help=(
            "Path to a file containing environ variables "
            "for testing/development."
        ),
        type=str,
    )

    # whether to make a new authdb if none exists
    generated_options.define(
        "autosetup",
        default=autosetup,
        help=(
            "If this is True, will automatically generate an SQLite "
            "authentication database in the basedir if there isn't one "
            "present and the value of the authdb option is also None."
        ),
        type=bool,
    )

    return generated_options
Beispiel #26
0
 def test_error_redefine_underscore(self):
     # Ensure that the dash/underscore normalization doesn't
     # interfere with the redefinition error.
     tests = [
         ("foo-bar", "foo-bar"),
         ("foo_bar", "foo_bar"),
         ("foo-bar", "foo_bar"),
         ("foo_bar", "foo-bar"),
     ]
     for a, b in tests:
         with subTest(self, a=a, b=b):
             options = OptionParser()
             options.define(a)
             with self.assertRaises(Error) as cm:
                 options.define(b)
             self.assertRegexpMatches(str(cm.exception),
                                      "Option.*foo.bar.*already defined")
Beispiel #27
0
 def _define_options(self):
     options = OptionParser()
     options.define('str', type=str)
     options.define('basestring', type=basestring_type)
     options.define('int', type=int)
     options.define('float', type=float)
     options.define('datetime', type=datetime.datetime)
     options.define('timedelta', type=datetime.timedelta)
     options.define('email', type=Email)
     options.define('list-of-int', type=int, multiple=True)
     return options
Beispiel #28
0
 def test_parse_config_file(self):
     options = OptionParser()
     options.define("port", default=80)
     options.parse_config_file(os.path.join(os.path.dirname(__file__),
                                            "options_test.cfg"))
     self.assertEquals(options.port, 443)
Beispiel #29
0
 def test_parse_command_line(self):
     options = OptionParser()
     options.define("port", default=80)
     options.parse_command_line(["main.py", "--port=443"])
     self.assertEqual(options.port, 443)
Beispiel #30
0
    def test_dash_underscore_introspection(self):
        # Original names are preserved in introspection APIs.
        options = OptionParser()
        options.define('with-dash', group='g')
        options.define('with_underscore', group='g')
        all_options = ['help', 'with-dash', 'with_underscore']
        self.assertEqual(sorted(options), all_options)
        self.assertEqual(sorted(k for (k, v) in options.items()), all_options)
        self.assertEqual(sorted(options.as_dict().keys()), all_options)

        self.assertEqual(sorted(options.group_dict('g')),
                         ['with-dash', 'with_underscore'])

        # --help shows CLI-style names with dashes.
        buf = StringIO()
        options.print_help(buf)
        self.assertIn('--with-dash', buf.getvalue())
        self.assertIn('--with-underscore', buf.getvalue())
Beispiel #31
0
 def test_multiple_int(self):
     options = OptionParser()
     options.define("foo", type=int, multiple=True)
     options.parse_command_line(["main.py", "--foo=1,3,5:7"])
     self.assertEqual(options.foo, [1, 3, 5, 6, 7])
Beispiel #32
0
    def test_dash_underscore_introspection(self):
        # Original names are preserved in introspection APIs.
        options = OptionParser()
        options.define("with-dash", group="g")
        options.define("with_underscore", group="g")
        all_options = ["help", "with-dash", "with_underscore"]
        self.assertEqual(sorted(options), all_options)
        self.assertEqual(sorted(k for (k, v) in options.items()), all_options)
        self.assertEqual(sorted(options.as_dict().keys()), all_options)

        self.assertEqual(sorted(options.group_dict("g")),
                         ["with-dash", "with_underscore"])

        # --help shows CLI-style names with dashes.
        buf = StringIO()
        options.print_help(buf)
        self.assertIn("--with-dash", buf.getvalue())
        self.assertIn("--with-underscore", buf.getvalue())
Beispiel #33
0
 def test_multiple_int(self):
     options = OptionParser()
     options.define('foo', type=int, multiple=True)
     options.parse_command_line(['main.py', '--foo=1,3,5:7'])
     self.assertEqual(options.foo, [1, 3, 5, 6, 7])
Beispiel #34
0
 def test_setattr_with_callback(self):
     values = []
     options = OptionParser()
     options.define('foo', default=1, type=int, callback=values.append)
     options.foo = 2
     self.assertEqual(values, [2])
Beispiel #35
0
 def test_setattr(self):
     options = OptionParser()
     options.define('foo', default=1, type=int)
     options.foo = 2
     self.assertEqual(options.foo, 2)
Beispiel #36
0
 def test_parse_command_line(self):
     options = OptionParser()
     options.define("port", default=80)
     options.parse_command_line(["main.py", "--port=443"])
     self.assertEqual(options.port, 443)
Beispiel #37
0
 def test_multiple_string(self):
     options = OptionParser()
     options.define("foo", type=str, multiple=True)
     options.parse_command_line(["main.py", "--foo=a,b,c"])
     self.assertEqual(options.foo, ["a", "b", "c"])
Beispiel #38
0
 def test_setattr(self):
     options = OptionParser()
     options.define('foo', default=1, type=int)
     options.foo = 2
     self.assertEqual(options.foo, 2)
Beispiel #39
0
 def test_multiple_int(self):
     options = OptionParser()
     options.define("foo", type=int, multiple=True)
     options.parse_command_line(["main.py", "--foo=1,3,5:7"])
     self.assertEqual(options.foo, [1, 3, 5, 6, 7])
Beispiel #40
0
 def test_types(self):
     options = OptionParser()
     options.define('str', type=str)
     options.define('basestring', type=basestring_type)
     options.define('int', type=int)
     options.define('float', type=float)
     options.define('datetime', type=datetime.datetime)
     options.define('timedelta', type=datetime.timedelta)
     options.parse_command_line(['main.py',
                                 '--str=asdf',
                                 '--basestring=qwer',
                                 '--int=42',
                                 '--float=1.5',
                                 '--datetime=2013-04-28 05:16',
                                 '--timedelta=45s'])
     self.assertEqual(options.str, 'asdf')
     self.assertEqual(options.basestring, 'qwer')
     self.assertEqual(options.int, 42)
     self.assertEqual(options.float, 1.5)
     self.assertEqual(options.datetime,
                      datetime.datetime(2013, 4, 28, 5, 16))
     self.assertEqual(options.timedelta, datetime.timedelta(seconds=45))
Beispiel #41
0
 def _define_options(self):
     options = OptionParser()
     options.define("str", type=str)
     options.define("basestring", type=basestring_type)
     options.define("int", type=int)
     options.define("float", type=float)
     options.define("datetime", type=datetime.datetime)
     options.define("timedelta", type=datetime.timedelta)
     options.define("email", type=Email)
     options.define("list-of-int", type=int, multiple=True)
     return options
Beispiel #42
0
 def test_multiple_string(self):
     options = OptionParser()
     options.define('foo', type=str, multiple=True)
     options.parse_command_line(['main.py', '--foo=a,b,c'])
     self.assertEqual(options.foo, ['a', 'b', 'c'])
Beispiel #43
0
 def test_parse_config_file(self):
     options = OptionParser()
     options.define("port", default=80)
     options.parse_config_file(
         os.path.join(os.path.dirname(__file__), "options_test.cfg"))
     self.assertEquals(options.port, 443)
Beispiel #44
0
 def test_setattr_with_callback(self):
     values = []
     options = OptionParser()
     options.define('foo', default=1, type=int, callback=values.append)
     options.foo = 2
     self.assertEqual(values, [2])
Beispiel #45
0
    def test_subcommand(self):
        base_options = OptionParser()
        base_options.define("verbose", default=False)
        sub_options = OptionParser()
        sub_options.define("foo", type=str)
        rest = base_options.parse_command_line(
            ["main.py", "--verbose", "subcommand", "--foo=bar"])
        self.assertEqual(rest, ["subcommand", "--foo=bar"])
        self.assertTrue(base_options.verbose)
        rest2 = sub_options.parse_command_line(rest)
        self.assertEqual(rest2, [])
        self.assertEqual(sub_options.foo, "bar")

        # the two option sets are distinct
        try:
            orig_stderr = sys.stderr
            sys.stderr = StringIO()
            with self.assertRaises(Error):
                sub_options.parse_command_line(["subcommand", "--verbose"])
        finally:
            sys.stderr = orig_stderr
Beispiel #46
0
 def _sample_options(self):
     options = OptionParser()
     options.define('a', default=1)
     options.define('b', default=2)
     return options
Beispiel #47
0
 def test_setitem(self):
     options = OptionParser()
     options.define('foo', default=1, type=int)
     options['foo'] = 2
     self.assertEqual(options['foo'], 2)
Beispiel #48
0
 def test_setitem(self):
     options = OptionParser()
     options.define("foo", default=1, type=int)
     options["foo"] = 2
     self.assertEqual(options["foo"], 2)