예제 #1
0
 def test_add_header_parsing(self):
     """
     When --add-header is specific, the value is parsed.
     """
     options = Options()
     options.parseOptions(
         ["--add-header", "K1: V1", "--add-header", "K2: V2"])
     self.assertEqual(options["extraHeaders"], [("K1", "V1"), ("K2", "V2")])
예제 #2
0
 def test_twoPorts(self):
     """
     If the I{--http} option is given twice, there are two listeners
     """
     options = Options()
     options.parseOptions(['--listen', 'tcp:8001', '--listen', 'tcp:8002'])
     self.assertIn('8001', options['ports'][0])
     self.assertIn('8002', options['ports'][1])
예제 #3
0
 def test_twoPorts(self):
     """
     If the I{--http} option is given twice, there are two listeners
     """
     options = Options()
     options.parseOptions(["--listen", "tcp:8001", "--listen", "tcp:8002"])
     self.assertIn("8001", options["ports"][0])
     self.assertIn("8002", options["ports"][1])
예제 #4
0
 def test_add_header_parsing(self):
     """
     When --add-header is specific, the value is parsed.
     """
     options = Options()
     options.parseOptions(
         ['--add-header', 'K1: V1', '--add-header', 'K2: V2'])
     self.assertEqual(options['extraHeaders'], [('K1', 'V1'), ('K2', 'V2')])
예제 #5
0
 def test_displayTracebacks(self):
     """
     Passing --display-tracebacks will enable traceback rendering on the
     generated Site.
     """
     options = Options()
     options.parseOptions(["--display-tracebacks"])
     service = makeService(options)
     self.assertTrue(service.services[0].factory.displayTracebacks)
예제 #6
0
 def test_displayTracebacksNotGiven(self):
     """
     Not passing --display-tracebacks will leave traceback rendering on the
     generated Site off.
     """
     options = Options()
     options.parseOptions([])
     service = makeService(options)
     self.assertFalse(service.services[0].factory.displayTracebacks)
예제 #7
0
    def test_HTTPSAcceptedOnAvailableSSL(self):
        """
        When SSL support is present, it accepts the --https option.
        """
        options = Options()

        options.parseOptions(['--https=443'])

        self.assertEqual('443', options['https'])
예제 #8
0
 def test_defaultPort(self):
     """
     If the I{--port} option is not specified, L{Options} defaults the port
     to C{8080}.
     """
     options = Options()
     options.parseOptions([])
     self.assertEqual(
         strports.parse(options['port'], None)[:2], ('TCP', (8080, None)))
예제 #9
0
    def test_HTTPSAcceptedOnAvailableSSL(self):
        """
        When SSL support is present, it accepts the --https option.
        """
        options = Options()

        options.parseOptions(["--https=443"])

        self.assertIn("ssl", options["ports"][0])
        self.assertIn("443", options["ports"][0])
예제 #10
0
 def test_invalidApplication(self):
     """
     If I{--wsgi} is given an invalid name, L{Options.parseOptions}
     raises L{UsageError}.
     """
     options = Options()
     for name in [__name__ + ".nosuchthing", "foo."]:
         exc = self.assertRaises(UsageError, options.parseOptions,
                                 ["--wsgi", name])
         self.assertEqual(str(exc), f"No such WSGI application: {name!r}")
예제 #11
0
 def test_defaultPort(self):
     """
     If the I{--port} option is not specified, L{Options} defaults the port
     to C{8080}.
     """
     options = Options()
     options.parseOptions([])
     self.assertEqual(
         endpoints._parseServer(options["ports"][0], None)[:2],
         ("TCP", (8080, None)))
 def test_invalidApplication(self):
     """
     If I{--wsgi} is given an invalid name, L{Options.parseOptions}
     raises L{UsageError}.
     """
     options = Options()
     for name in [__name__ + '.nosuchthing', 'foo.']:
         exc = self.assertRaises(
             UsageError, options.parseOptions, ['--wsgi', name])
         self.assertEqual(str(exc), "No such WSGI application: %r" % (name,))
예제 #13
0
    def test_HTTPSFailureOnMissingSSL(self):
        """
        An L{UsageError} is raised when C{https} is requested but there is no
        support for SSL.
        """
        options = Options()

        exception = self.assertRaises(UsageError, options.parseOptions,
                                      ['--https=443'])

        self.assertEqual('SSL support not installed', exception.args[0])
예제 #14
0
 def test_defaultPersonalPath(self):
     """
     If the I{--port} option not specified but the I{--personal} option is,
     L{Options} defaults the port to C{UserDirectory.userSocketName} in the
     user's home directory.
     """
     options = Options()
     options.parseOptions(["--personal"])
     path = os.path.expanduser(
         os.path.join("~", UserDirectory.userSocketName))
     self.assertEqual(options["ports"][0], f"unix:{path}")
예제 #15
0
 def test_defaultPersonalPath(self):
     """
     If the I{--port} option not specified but the I{--personal} option is,
     L{Options} defaults the port to C{UserDirectory.userSocketName} in the
     user's home directory.
     """
     options = Options()
     options.parseOptions(['--personal'])
     path = os.path.expanduser(
         os.path.join('~', UserDirectory.userSocketName))
     self.assertEqual(options['ports'][0], 'unix:{}'.format(path))
예제 #16
0
 def test_defaultPersonalPath(self):
     """
     If the I{--port} option not specified but the I{--personal} option is,
     L{Options} defaults the port to C{UserDirectory.userSocketName} in the
     user's home directory.
     """
     options = Options()
     options.parseOptions(['--personal'])
     path = os.path.expanduser(
         os.path.join('~', UserDirectory.userSocketName))
     self.assertEqual(
         strports.parse(options['port'], None)[:2], ('UNIX', (path, None)))
예제 #17
0
 def test_add_header_resource(self):
     """
     When --add-header is specified, the resource is a composition that adds
     headers.
     """
     options = Options()
     options.parseOptions(
         ["--add-header", "K1: V1", "--add-header", "K2: V2"])
     service = makeService(options)
     resource = service.services[0].factory.resource
     self.assertIsInstance(resource, _AddHeadersResource)
     self.assertEqual(resource._headers, [("K1", "V1"), ("K2", "V2")])
     self.assertIsInstance(resource._originalResource, demo.Test)
예제 #18
0
    def test_noTracebacksDeprecation(self):
        """
        Passing --notracebacks is deprecated.
        """
        options = Options()
        options.parseOptions(["--notracebacks"])
        makeService(options)

        warnings = self.flushWarnings([self.test_noTracebacksDeprecation])
        self.assertEqual(warnings[0]['category'], DeprecationWarning)
        self.assertEqual(warnings[0]['message'],
                         "--notracebacks was deprecated in Twisted NEXT")
        self.assertEqual(len(warnings), 1)
예제 #19
0
 def test_add_header_resource(self):
     """
     When --add-header is specified, the resource is a composition that adds
     headers.
     """
     options = Options()
     options.parseOptions(
         ['--add-header', 'K1: V1', '--add-header', 'K2: V2'])
     service = makeService(options)
     resource = service.services[0].factory.resource
     self.assertIsInstance(resource, _AddHeadersResource)
     self.assertEqual(resource._headers, [('K1', 'V1'), ('K2', 'V2')])
     self.assertIsInstance(resource._originalResource, demo.Test)
예제 #20
0
 def test_personalServer(self):
     """
     The I{--personal} option to L{makeService} causes it to return a
     service which will listen on the server address given by the I{--port}
     option.
     """
     port = self.mktemp()
     options = Options()
     options.parseOptions(['--port', 'unix:' + port, '--personal'])
     service = makeService(options)
     service.startService()
     self.addCleanup(service.stopService)
     self.assertTrue(os.path.exists(port))
     self.assertTrue(stat.S_ISSOCK(os.stat(port).st_mode))
예제 #21
0
    def _pathOption(self):
        """
        Helper for the I{--path} tests which creates a directory and creates
        an L{Options} object which uses that directory as its static
        filesystem root.

        @return: A two-tuple of a L{FilePath} referring to the directory and
            the value associated with the C{'root'} key in the L{Options}
            instance after parsing a I{--path} option.
        """
        path = FilePath(self.mktemp())
        path.makedirs()
        options = Options()
        options.parseOptions(['--path', path.path])
        root = options['root']
        return path, root
예제 #22
0
 def test_pathServer(self):
     """
     The I{--path} option to L{makeService} causes it to return a service
     which will listen on the server address given by the I{--port} option.
     """
     path = FilePath(self.mktemp())
     path.makedirs()
     port = self.mktemp()
     options = Options()
     options.parseOptions(['--port', 'unix:' + port, '--path', path.path])
     service = makeService(options)
     service.startService()
     self.addCleanup(service.stopService)
     self.assertIsInstance(service.services[0].factory.resource, File)
     self.assertEqual(service.services[0].factory.resource.path, path.path)
     self.assertTrue(os.path.exists(port))
     self.assertTrue(stat.S_ISSOCK(os.stat(port).st_mode))
예제 #23
0
    def test_wsgi(self):
        """
        The I{--wsgi} option takes the fully-qualifed Python name of a WSGI
        application object and creates a L{WSGIResource} at the root which
        serves that application.
        """
        options = Options()
        options.parseOptions(['--wsgi', __name__ + '.application'])
        root = options['root']
        self.assertTrue(root, WSGIResource)
        self.assertIdentical(root._reactor, reactor)
        self.assertTrue(isinstance(root._threadpool, ThreadPool))
        self.assertIdentical(root._application, application)

        # The threadpool should start and stop with the reactor.
        self.assertFalse(root._threadpool.started)
        reactor.fireSystemEvent('startup')
        self.assertTrue(root._threadpool.started)
        self.assertFalse(root._threadpool.joined)
        reactor.fireSystemEvent('shutdown')
        self.assertTrue(root._threadpool.joined)