def setUp(self):
from autopush.web.base import BaseWebHandler
conf = AutopushConfig(
hostname="localhost",
statsd_host=None,
)
self.request_mock = Mock(body=b'',
arguments={},
headers={"ttl": "0"},
host='example.com:8080')
self.base = BaseWebHandler(
EndpointHTTPFactory(conf, db=test_db(SinkMetrics()), routers=None),
self.request_mock)
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 setUp(self):
twisted.internet.base.DelayedCall.debug = True
conf = AutopushConfig(
hostname="localhost",
statsd_host=None,
bear_hash_key='AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB=',
)
self.fernet_mock = conf.fernet = Mock(spec=Fernet)
self.db = db = test_db()
db.router = Mock(spec=Router)
db.router.register_user.return_value = (True, {}, {})
db.router.get_uaid.return_value = {
"router_type": "test",
"router_data": dict()
}
db.create_initial_message_tables()
self.routers = routers = routers_from_config(conf, db, Mock())
routers["test"] = Mock(spec=IRouter)
app = EndpointHTTPFactory(conf, db=db, routers=routers)
self.client = Client(app)
self.request_mock = Mock(body=b'', arguments={}, headers={})
self.reg = NewRegistrationHandler(app, self.request_mock)
self.auth = ("WebPush %s" %
generate_hash(conf.bear_hash_key[0], dummy_uaid.hex))
self.conf = conf
def setUp(self):
conf = AutopushConfig(
hostname="localhost",
statsd_host=None,
)
self.metrics = metrics = Mock(spec=SinkMetrics)
self.db = db = test_db(metrics=metrics)
self.headers = headers = {
"content-encoding": "aes128",
"encryption": "awesomecrypto",
"crypto-key": "niftykey"
}
self.agent_mock = agent = Mock(spec=Agent)
self.router = WebPushRouter(conf, {}, db, agent)
self.notif = WebPushNotification(
uaid=uuid.UUID(dummy_uaid),
channel_id=uuid.UUID(dummy_chid),
data="data",
headers=headers,
ttl=20,
message_id=uuid.uuid4().hex,
)
self.notif.cleanup_headers()
mock_result = Mock(spec=gcmclient.Result)
mock_result.canonical = dict()
mock_result.failed = dict()
mock_result.not_registered = dict()
mock_result.retry_after = 1000
self.router_mock = db.router
self.message_mock = db._message = Mock(spec=Message)
self.conf = conf
def setUp(self):
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.metrics = metrics = Mock(spec=SinkMetrics)
self.db = db = test_db(metrics=metrics)
self.headers = headers = {
"content-encoding": "aes128",
"encryption": "awesomecrypto",
"crypto-key": "niftykey"
}
self.router = WebPushRouter(settings, {}, db)
self.notif = WebPushNotification(
uaid=uuid.UUID(dummy_uaid),
channel_id=uuid.UUID(dummy_chid),
data="data",
headers=headers,
ttl=20,
message_id=uuid.uuid4().hex,
)
self.notif.cleanup_headers()
mock_result = Mock(spec=gcmclient.gcm.Result)
mock_result.canonical = dict()
mock_result.failed = dict()
mock_result.not_registered = dict()
mock_result.needs_retry.return_value = False
self.router_mock = db.router
self.message_mock = db.message = Mock(spec=Message)
self.agent_mock = Mock(spec=settings.agent)
settings.agent = self.agent_mock
self.settings = settings
def _make_fut(self):
from autopush.web.webpush import WebPushRequestSchema
schema = WebPushRequestSchema()
schema.context.update(conf=Mock(),
metrics=SinkMetrics(),
db=test_db(),
routers=Mock(),
log=Mock())
return schema
def _make_fut(self):
from autopush.web.simplepush import SimplePushRequestSchema
schema = SimplePushRequestSchema()
schema.context.update(settings=Mock(),
metrics=SinkMetrics(),
db=test_db(),
routers=Mock(),
log=Mock())
return schema
def test_new_month(self):
today = datetime.date.today()
next_month = today.month + 1
next_year = today.year
if next_month > 12: # pragma: nocover
next_month = 1
next_year += 1
tomorrow = datetime.datetime(year=next_year, month=next_month, day=1)
db = test_db()
db._tomorrow = Mock()
db._tomorrow.return_value = tomorrow
db.create_initial_message_tables()
assert len(db.message_tables) == 3
def setUp(self):
twisted.internet.base.DelayedCall.debug = True
conf = AutopushConfig(
hostname="localhost",
statsd_host=None,
crypto_key='AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=',
)
db = test_db()
self.message_mock = db._message = Mock(spec=Message)
self.fernet_mock = conf.fernet = Mock(spec=Fernet)
app = EndpointHTTPFactory.for_handler(MessageHandler, conf, db=db)
self.client = Client(app)
def setUp(self):
from autopush.web.webpush import WebPushHandler
self.conf = conf = AutopushConfig(
hostname="localhost",
statsd_host=None,
use_cryptography=True,
)
self.fernet_mock = conf.fernet = Mock(spec=Fernet)
self.db = db = test_db()
self.message_mock = db.message = Mock(spec=Message)
self.message_mock.all_channels.return_value = (True, [dummy_chid])
app = EndpointHTTPFactory.for_handler(WebPushHandler, conf, db=db)
self.wp_router_mock = app.routers["webpush"] = Mock(spec=IRouter)
self.client = Client(app)
def setUp(self):
from twisted.logger import Logger
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.metrics = metrics = Mock(spec=SinkMetrics)
db = test_db(metrics=metrics)
self.agent_mock = agent = Mock(spec=Agent)
self.router = SimpleRouter(settings, {}, db, agent)
self.router.log = Mock(spec=Logger)
self.notif = Notification(10, "data", dummy_chid)
mock_result = Mock(spec=gcmclient.gcm.Result)
mock_result.canonical = dict()
mock_result.failed = dict()
mock_result.not_registered = dict()
mock_result.needs_retry.return_value = False
self.router_mock = db.router
self.storage_mock = db.storage
def _make_fut(self):
from autopush.config import AutopushConfig
from autopush.web.webpush import WebPushRequestSchema
conf = AutopushConfig(
hostname="localhost",
statsd_host=None,
)
db = test_db()
schema = WebPushRequestSchema()
schema.context.update(conf=conf,
metrics=SinkMetrics(),
db=db,
routers=Mock(),
log=Mock())
db.router.get_uaid.return_value = dict(
router_type="gcm",
uaid=dummy_uaid,
router_data=dict(creds=dict(senderID="bogus")),
)
conf.fernet = self.fernet_mock = Mock()
return schema
def test_decorator(self):
from autopush.http import EndpointHTTPFactory
from autopush.web.base import BaseWebHandler, threaded_validate
from autopush.tests.client import Client
schema = self._make_basic_schema()
class AHandler(BaseWebHandler):
def authenticate_peer_cert(self):
pass
@threaded_validate(schema)
def get(self):
self.write("done")
self.finish()
app = EndpointHTTPFactory(Mock(),
db=test_db(),
routers=None,
handlers=[('/test', AHandler)])
client = Client(app)
resp = yield client.get('/test')
assert resp.content == "done"
