Python OptionParser.define方法代码示例

# 需要导入模块: from tornado.options import OptionParser [as 别名]
# 或者: from tornado.options.OptionParser import define [as 别名]
 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'

# 需要导入模块: from tornado.options import OptionParser [as 别名]
# 或者: from tornado.options.OptionParser import define [as 别名]
 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')

# 需要导入模块: from tornado.options import OptionParser [as 别名]
# 或者: from tornado.options.OptionParser import define [as 别名]
 def test_parse_config_file(self):
     options = OptionParser()
     options.define("port", default=80)
     options.define("username", default='foo')
     options.parse_config_file(os.path.join(os.path.dirname(__file__),
                                            "options_test.cfg"))
     self.assertEquals(options.port, 443)
     self.assertEqual(options.username, "李康")

# 需要导入模块: from tornado.options import OptionParser [as 别名]
# 或者: from tornado.options.OptionParser import define [as 别名]
 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')

# 需要导入模块: from tornado.options import OptionParser [as 别名]
# 或者: from tornado.options.OptionParser import define [as 别名]
 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")

# 需要导入模块: from tornado.options import OptionParser [as 别名]
# 或者: from tornado.options.OptionParser import define [as 别名]
    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'))

# 需要导入模块: from tornado.options import OptionParser [as 别名]
# 或者: from tornado.options.OptionParser import define [as 别名]
    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"))

# 需要导入模块: from tornado.options import OptionParser [as 别名]
# 或者: from tornado.options.OptionParser import define [as 别名]
 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')

# 需要导入模块: from tornado.options import OptionParser [as 别名]
# 或者: from tornado.options.OptionParser import define [as 别名]
    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())

# 需要导入模块: from tornado.options import OptionParser [as 别名]
# 或者: from tornado.options.OptionParser import define [as 别名]
    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())

# 需要导入模块: from tornado.options import OptionParser [as 别名]
# 或者: from tornado.options.OptionParser import define [as 别名]
    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)

# 需要导入模块: from tornado.options import OptionParser [as 别名]
# 或者: from tornado.options.OptionParser import define [as 别名]
    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

# 需要导入模块: from tornado.options import OptionParser [as 别名]
# 或者: from tornado.options.OptionParser import define [as 别名]
 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)

# 需要导入模块: from tornado.options import OptionParser [as 别名]
# 或者: from tornado.options.OptionParser import define [as 别名]
        
    ListenerRouter = SockJSRouter(ListenerConnection, '/listener')
    handlers.extend(ListenerRouter.urls)

    BodyRouter = SockJSRouter(BodyConnection, '/body')
    handlers.extend(BodyRouter.urls)

    # Create multiplexer
    router = MultiplexConnection.get(objClass=HijackConnection)

    # Register multiplexer
    HijackRouter = SockJSRouter(router, '/hijack')
    handlers.extend(HijackRouter.urls)

    options = OptionParser()
    options.define("port", default=8002, help="run on the given port", type=int)
    options.define("proxyport", default=8989, help="port the proxy is running on", type=int)
    options.define("proxyhost", default=None, help="host the proxy is running on", type=str)
    options.define("mongourl", default="localhost:27017", help="mongodb url", type=str)

    options.parse_command_line()

    db = motor.MotorClient('mongodb://'+options.mongourl, tz_aware=True)
    
    db.proxyservice['origins'].create_index("origin", background=True)

    ui_methods={'nice_headers': BaseRequestHandler.nice_headers}
    settings = dict(
        handlers=handlers,
        static_path=os.path.join(os.path.dirname(__file__), 'static'),
        db=db,

# 需要导入模块: from tornado.options import OptionParser [as 别名]
# 或者: from tornado.options.OptionParser import define [as 别名]
 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)