def setUp(self):
twisted.internet.base.DelayedCall.debug = True
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
bear_hash_key='AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB=',
)
self.fernet_mock = settings.fernet = Mock(spec=Fernet)
self.metrics_mock = settings.metrics = Mock(spec=Metrics)
self.router_mock = settings.router = Mock(spec=Router)
self.storage_mock = settings.storage = Mock(spec=Storage)
self.router_mock.register_user = Mock()
self.router_mock.register_user.return_value = (True, {}, {})
settings.routers["test"] = Mock(spec=IRouter)
settings.router.get_uaid.return_value = {
"router_type": "test",
"router_data": dict()
}
self.request_mock = Mock(body=b'', arguments={}, headers={})
self.reg = RegistrationHandler(Application(),
self.request_mock,
ap_settings=settings)
self.reg.request.uri = '/v1/xxx/yyy/register'
self.status_mock = self.reg.set_status = Mock()
self.write_mock = self.reg.write = Mock()
self.auth = ("WebPush %s" %
generate_hash(self.reg.ap_settings.bear_hash_key[0],
dummy_uaid.hex))
d = self.finish_deferred = Deferred()
self.reg.finish = lambda: d.callback(True)
self.settings = settings
def setUp(self):
self.timeout = 0.5
twisted.internet.base.DelayedCall.debug = True
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.fernet_mock = settings.fernet = Mock(spec=Fernet)
self.metrics_mock = settings.metrics = Mock(spec=Metrics)
self.agent_mock = settings.agent = Mock(spec=Agent)
self.response_mock = Mock(spec=Response)
self.router_mock = settings.router = Mock(spec=Router)
self.storage_mock = settings.storage = Mock(spec=Storage)
self.senderIDs_mock = settings.senderIDs = Mock(spec=SenderIDs)
self.senderIDs_mock.get_ID.return_value = "test_senderid"
self.request_mock = Mock(body=b'', arguments={}, headers={})
self.endpoint = endpoint.EndpointHandler(Application(),
self.request_mock,
ap_settings=settings)
self.settings = settings
settings.routers["simplepush"] = Mock(spec=IRouter)
settings.routers["webpush"] = Mock(spec=IRouter)
self.sp_router_mock = settings.routers["simplepush"]
self.wp_router_mock = settings.routers["webpush"]
self.status_mock = self.endpoint.set_status = Mock()
self.write_mock = self.endpoint.write = Mock()
d = self.finish_deferred = Deferred()
self.endpoint.finish = lambda: d.callback(True)
self.endpoint.start_time = time.time()
def setUp(self):
from autopush.web.webpush import WebPushHandler
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.fernet_mock = settings.fernet = Mock(spec=Fernet)
self.ap_settings = settings
self.router_mock = settings.router = Mock(spec=Router)
self.request_mock = Mock(body=b'', arguments={},
headers={"ttl": "0"},
host='example.com:8080')
self.wp = WebPushHandler(Application(),
self.request_mock,
ap_settings=settings)
self.wp.path_kwargs = {}
self.status_mock = self.wp.set_status = Mock()
self.write_mock = self.wp.write = Mock()
self.wp.log = Mock(spec=Logger)
d = self.finish_deferred = Deferred()
self.wp.finish = lambda: d.callback(True)
settings.routers["webpush"] = Mock(spec=IRouter)
self.wp_router_mock = settings.routers["webpush"]
self.message_mock = settings.message = Mock()
self.message_mock.all_channels.return_value = (True, [dummy_chid])
def setUp(self):
from autopush.web.base import BaseWebHandler
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.request_mock = Mock(body=b'', arguments={},
headers={"ttl": "0"},
host='example.com:8080')
self.base = BaseWebHandler(Application(),
self.request_mock,
ap_settings=settings)
self.status_mock = self.base.set_status = Mock()
self.write_mock = self.base.write = Mock()
self.base.log = Mock(spec=Logger)
d = self.finish_deferred = Deferred()
self.base.finish = lambda: d.callback(True)
# Attach some common cors stuff for testing
self.base.cors_methods = "POST,PUT"
self.base.cors_request_headers = ["content-encoding", "encryption",
"crypto-key", "ttl",
"encryption-key", "content-type",
"authorization"]
self.base.cors_response_headers = ["location", "www-authenticate"]
def mock_app_builder():
return Application([
(r'/testing/', TestHandler),
(r'/deferred_testing/', DeferredTestHandler),
(r'/cookie_testing/', CookieTestHandler),
],
cookie_secret="insecure")
def main():
StatsRouter = SockJSRouter(StatsConnection, '/statsconn')
app = Application( [ (r"/", IndexHandler),
(r'/stats', StatsHandler)
] + BroadcastRouter.urls + StatsRouter.urls )
reactor.listenTCP(8888, app)
reactor.run()
def main():
app = Application([
(r"/slow", SlowHandler),
(r"/widgets", WidgetsHandler),
(r"/widgets/([0-9].*)", WidgetHandler),
])
reactor.listenTCP(8000, app)
reactor.run()
def setUp(self):
self.app = Application()
self.request = HTTPRequest("GET", "/", connection=Mock())
self.request.headers["Accept"] = "application/json; v=v1"
self.resource_class = Mock()
self.handler = RESTHandler(
self.app, self.request,
resource_set=ResourceSet("test", versions={"v1": self.resource_class}))
self.handler._transforms = []
self.handler._request_summary = lambda: None
self.app.log_request = lambda x: None
def main(reactor):
resolver = LocationResolver(reactor)
application = Application(
[
(r'/', MainHandler),
],
xheaders=True,
resolver=resolver,
)
reactor.listenTCP(31337, application)
reactor.run()
def setUp(self):
self.timeout = 0.5
twisted.internet.base.DelayedCall.debug = True
self.mock_dynamodb2 = mock_dynamodb2()
self.mock_dynamodb2.start()
self.settings = StatusHandler.ap_settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.request_mock = Mock()
self.status = StatusHandler(Application(), self.request_mock)
self.write_mock = self.status.write = Mock()
def draw_routes():
return Application([
(r'/static/(.*)', cyclone.web.StaticFileHandler, {
'path': brickconfig.get('static', 'dir')
}),
(r'/project', ProjectIndexController),
(r'/project/?(.*)', ProjectController),
(r'/group', GroupController),
(r'/build/(.*)', BuildController),
# (r'/build/current', Current),
# (r'/group/?(.*)', Group),
# (r'/branch/(.*)', Branch),
# (r'/clear/(.*)', Clear),
# (r'/log/(.*)/+(.*)', Log),
# (r'/repo/(.*)', cyclone.web.StaticFileHandler, {'path': brickconfig.get('local_repo', 'dir')}),
(r'/', MainController)
])
def setUp(self):
twisted.internet.base.DelayedCall.debug = True
from twisted.logger import Logger
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.request_mock = Mock(body=b'', arguments={},
headers={"ttl": "0"},
host='example.com:8080')
self.lch = LogCheckHandler(Application(),
self.request_mock,
ap_settings=settings)
self.finish_deferred = Deferred()
self.lch.finish = lambda: self.finish_deferred.callback(True)
self.lch.set_status = Mock()
self.lch.write = Mock()
self.lch.log = Mock(spec=Logger)
def setUp(self):
self.timeout = 0.5
twisted.internet.base.DelayedCall.debug = True
self.log_mock = patch("autopush.health.log").start()
self.mock_dynamodb2 = mock_dynamodb2()
self.mock_dynamodb2.start()
HealthHandler.ap_settings = self.settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.router_table = self.settings.router.table
self.storage_table = self.settings.storage.table
self.request_mock = Mock()
self.health = HealthHandler(Application(), self.request_mock)
self.status_mock = self.health.set_status = Mock()
self.write_mock = self.health.write = Mock()
d = self.finish_deferred = Deferred()
self.health.finish = lambda: d.callback(True)
def setUp(self):
twisted.internet.base.DelayedCall.debug = True
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
crypto_key='AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=',
)
self.fernet_mock = settings.fernet = Mock(spec=Fernet)
self.metrics_mock = settings.metrics = Mock(spec=Metrics)
self.router_mock = settings.router = Mock(spec=Router)
self.storage_mock = settings.storage = Mock(spec=Storage)
self.message_mock = settings.message = Mock(spec=Message)
self.request_mock = Mock(body=b'', arguments={}, headers={})
self.message = MessageHandler(Application(),
self.request_mock,
ap_settings=settings)
self.status_mock = self.message.set_status = Mock()
self.write_mock = self.message.write = Mock()
d = self.finish_deferred = Deferred()
self.message.finish = lambda: d.callback(True)
def setUp(self):
twisted.internet.base.DelayedCall.debug = True
settings = endpoint.RegistrationHandler.ap_settings =\
AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.fernet_mock = settings.fernet = Mock(spec=Fernet)
self.metrics_mock = settings.metrics = Mock(spec=Metrics)
self.router_mock = settings.router = Mock(spec=Router)
self.storage_mock = settings.storage = Mock(spec=Storage)
self.senderIDs_mock = settings.senderIDs = Mock(spec=SenderIDs)
self.senderIDs_mock.get_ID.return_value = "test_senderid"
self.request_mock = Mock(body=b'', arguments={}, headers={})
self.reg = endpoint.RegistrationHandler(Application(),
self.request_mock,
ap_settings=settings)
self.status_mock = self.reg.set_status = Mock()
self.write_mock = self.reg.write = Mock()
d = self.finish_deferred = Deferred()
self.reg.finish = lambda: d.callback(True)
selected by the user.
/<length>/<keyword>
XXX this is currently disabled as it is not of use to any test.
"""
isLeaf = True
def _gen_random_string(self, length):
return ''.join(random.choice(string.letters) for x in range(length))
def genRandomPage(self, length=100, keyword=None):
data = self._gen_random_string(length / 2)
if keyword:
data += keyword
data += self._gen_random_string(length - length / 2)
data += '\n'
return data
def all(self, length, keyword):
self.set_header('Content-Disposition',
'attachment; filename="%s.txt"' % randomStr(10))
length = 100
if length > 100000:
length = 100000
self.write(self.genRandomPage(length, keyword))
HTTPRandomPageHelper = Application([
# XXX add regexps here
(r"/(.*)/(.*)", HTTPRandomPage)
])
def load(self):
if "secret" not in self.data:
self.logger.warn("Generating secret. DO NOT SHARE IT WITH ANYONE!")
self.logger.warn("It's stored in data/plugins/web/data.json - "
"keep this file secure!")
with self.data:
self.data["secret"] = mkpasswd(60, 20, 20, 20)
self.template_loader = TemplateLoader(self)
if self.config.get("output_requests", True):
log_function = self.log_request
else:
log_function = self.null_log
self.application = Application(
list(self.handlers.items()), # Handler list
## General settings
xheaders=True,
log_function=log_function,
gzip=True, # Are there browsers that don't support this now?
# error_handler=ErrorHandler,
## Security settings
cookie_secret=self.data["secret"],
login_url="/login",
## Template settings
template_loader=self.template_loader,
## Static file settings
static_path="web/static"
)
if self.config.get("hosted", False):
hosted = self.config["hosted"]
if isinstance(hosted, dict):
self.interface = os.environ.get(hosted["hostname"], False)
self.port = os.environ.get(hosted["port"], False)
if not self.interface:
self.logger.error(
"Unknown env var: %s" % hosted["hostname"]
)
return False
if not self.port:
self.logger.error(
"Unknown env var: %s" % hosted["port"]
)
return False
else:
if hosted in ["openshift"]:
self.interface = os.environ.get("OPENSHIFT__IP", False)
self.port = os.environ.get("OPENSHIFT__PORT", False)
if not self.interface:
self.logger.error(
"Unknown env var: OPENSHIFT__IP - Are you on "
"OpenShift?"
)
return False
if not self.port:
self.logger.error(
"Unknown env var: OPENSHIFT__PORT - Are you on "
"OpenShift?"
)
return False
else:
self.logger.error("Unknown hosted service: %s" % hosted)
return False
else:
if self.config.get("hostname", "0.0.0.0").strip() == "0.0.0.0":
self.interface = ""
else:
self.interface = self.config.get("hostname")
self.listen_port = self.config.get("port", 8080)
return True
def request(self, jbody=None, role=None, user_id=None, headers=None, body='',
remote_ip='0.0.0.0', method='MOCK', kwargs={}):
"""
Function userful for performing mock requests.
Args:
jbody:
The body of the request as a dict (it will be automatically
converted to string)
body:
The body of the request as a string
role:
If we should perform authentication role can be either "admin",
"receiver" or "wb"
user_id:
If when performing authentication the session should be bound
to a certain user_id.
method:
HTTP method, e.g. "GET" or "POST"
uri:
URL to fetch
role:
the role
headers:
(dict or :class:`cyclone.httputil.HTTPHeaders` instance) HTTP
headers to pass on the request
remote_ip:
If a particular remote_ip should be set.
"""
if jbody and not body:
body = json.dumps(jbody)
elif body and jbody:
raise ValueError('jbody and body in conflict')
application = Application([])
tr = proto_helpers.StringTransport()
connection = GLHTTPConnection()
connection.factory = application
connection.makeConnection(tr)
request = httpserver.HTTPRequest(uri='mock',
method=method,
headers=headers,
body=body,
remote_ip=remote_ip,
connection=connection)
handler = self._handler(application, request, **kwargs)
if role:
session = authentication.GLSession(user_id, role, 'enabled')
handler.request.headers['X-Session'] = session.id
return handler
def setUp(self):
self.app = Application(some_setting="foo")
self.request = Mock()
self.rh = RequestHandler(self.app, self.request)
def request(self,
jbody=None,
user_id=None,
role=None,
headers=None,
body='',
remote_ip='0.0.0.0',
method='MOCK',
kwargs={}):
"""
Function userful for performing mock requests.
Args:
jbody:
The body of the request as a dict (it will be automatically
converted to string)
body:
The body of the request as a string
user_id:
when simulating authentication the session should be bound
to a certain user_id.
role:
when simulating authentication the session should be bound
to a certain role.
method:
HTTP method, e.g. "GET" or "POST"
headers:
(dict or :class:`cyclone.httputil.HTTPHeaders` instance) HTTP
headers to pass on the request
remote_ip:
If a particular remote_ip should be set.
"""
if jbody and not body:
body = json.dumps(jbody)
elif body and jbody:
raise ValueError('jbody and body in conflict')
application = Application([])
tr = proto_helpers.StringTransport()
connection = GLHTTPConnection()
connection.factory = application
connection.makeConnection(tr)
request = httpserver.HTTPRequest(uri='mock',
method=method,
headers=headers,
body=body,
remote_ip=remote_ip,
connection=connection)
handler = self._handler(application, request, **kwargs)
if user_id is None and role is not None:
if role == 'admin':
user_id = self.dummyAdminUser['id']
elif role == 'receiver':
user_id = self.dummyReceiverUser_1['id']
elif role == 'custodian':
user_id = self.dummyCustodianUser['id']
if role is not None:
session = GLSession(user_id, role, 'enabled')
handler.request.headers['X-Session'] = session.id
return handler
def post(self, *arg, **kw):
method_hack = self.get_arguments('_method')
if method_hack and method_hack == 'DELETE':
return self.delete()
s = json.dumps(self.handle_upload(), separators=(',',':'))
if 'application/json' in self.request.headers.get('Accept'):
self.set_header('Content-Type', 'application/json')
self.write(s)
def delete(self):
pass
static_dir = os.path.abspath(os.path.join('..', '..'))
spec = [(r'/server/php', UploadHandler),
(r'/(.*)', StaticFileHandler, {'path': static_dir}),
]
from twisted.internet import reactor
from cyclone.web import Application
application = Application(spec, debug=True)
reactor.listenTCP(listen_port, application)
reactor.run()
def request(self,
jbody=None,
user_id=None,
role=None,
headers=None,
body='',
remote_ip='0.0.0.0',
method='MOCK',
attached_file={},
kwargs={}):
"""
Function userful for performing mock requests.
Args:
jbody:
The body of the request as a dict (it will be automatically
converted to string)
body:
The body of the request as a string
user_id:
when simulating authentication the session should be bound
to a certain user_id.
role:
when simulating authentication the session should be bound
to a certain role.
method:
HTTP method, e.g. "GET" or "POST"
headers:
(dict or :class:`cyclone.httputil.HTTPHeaders` instance) HTTP
headers to pass on the request
remote_ip:
If a particular remote_ip should be set.
attached_file:
A cyclone.httputil.HTTPFiles or a dict to place in the request.files obj
"""
if jbody and not body:
body = json.dumps(jbody)
elif body and jbody:
raise ValueError('jbody and body in conflict')
if attached_file is None:
fake_files = {}
else:
fake_files = {
'file': [attached_file]
} # Yes this is ugly, but it's the format
application = Application([])
tr = proto_helpers.StringTransport()
connection = GLHTTPConnection()
connection.factory = application
connection.makeConnection(tr)
request = httpserver.HTTPRequest(uri='mock',
method=method,
headers=headers,
body=body,
remote_ip=remote_ip,
connection=connection,
files=fake_files)
def mock_write(cls, response=None):
if response:
self.responses.append(response)
self._handler.write = mock_write
def mock_finish(cls):
pass
self._handler.finish = mock_finish
handler = self._handler(application, request, **kwargs) # pylint: disable=not-callable
if user_id is None and role is not None:
if role == 'admin':
user_id = self.dummyAdminUser['id']
elif role == 'receiver':
user_id = self.dummyReceiverUser_1['id']
elif role == 'custodian':
user_id = self.dummyCustodianUser['id']
if role is not None:
session = GLSession(user_id, role, 'enabled')
handler.request.headers['X-Session'] = session.id
return handler
for k, v in request.get('http_request_headers', {}).iteritems():
http_request_headers[str(k)] = map(str, v)
self.control_measurement(
http_url=str(request['http_request']),
include_http_responses=include_http_responses,
http_request_headers=http_request_headers,
socket_list=request['tcp_connect'],
invalid_sockets=invalid_sockets
)
except HTTPError:
raise
except Exception as exc:
log.msg("Got invalid request")
log.exception(exc)
raise HTTPError(400, 'invalid request')
class WebConnectivityStatus(RequestHandler):
def get(self):
self.write({"status": "ok"})
HTTPRandomPageHelper = Application([
# XXX add regexps here
(r"/(.*)/(.*)", HTTPRandomPage)
], log_function=log_function)
WebConnectivityHelper = Application([
(r"/status", WebConnectivityStatus),
(r"/", WebConnectivity)
], log_function=log_function)
