def test_settings_crypto_key(self):
fake = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA='
settings = AutopushSettings(crypto_key=fake)
eq_(settings.fernet._fernets[0]._encryption_key,
'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
fake2 = 'BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB='
settings = AutopushSettings(crypto_key=[fake, fake2])
eq_(settings.fernet._fernets[0]._encryption_key,
'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
eq_(settings.fernet._fernets[1]._encryption_key,
'\x10A\x04\x10A\x04\x10A\x04\x10A\x04\x10A\x04\x10')
def setUp(self):
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.headers = headers = {
"content-encoding": "aes128",
"encryption": "awesomecrypto",
"crypto-key": "niftykey"
}
self.router = WebPushRouter(settings, {})
self.notif = Notification("EncMessageId", "data",
dummy_chid, headers, 20)
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 = settings.router = Mock(spec=Router)
self.message_mock = settings.message = Mock(spec=Message)
self.agent_mock = Mock(spec=settings.agent)
settings.agent = self.agent_mock
self.router.metrics = Mock()
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):
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.headers = headers = {
"content-encoding": "aes128",
"encryption": "awesomecrypto",
"crypto-key": "niftykey"
}
self.router = WebPushRouter(settings, {})
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 = settings.router = Mock(spec=Router)
self.message_mock = settings.message = Mock(spec=Message)
self.agent_mock = Mock(spec=settings.agent)
settings.agent = self.agent_mock
self.router.metrics = Mock()
self.settings = settings
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 test_update_rotating_tables_month_end(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)
AutopushSettings._tomorrow = Mock()
AutopushSettings._tomorrow.return_value = tomorrow
settings = AutopushSettings(hostname="example.com",
resolve_hostname=True)
# shift off tomorrow's table.
tomorrow_table = sorted(settings.message_tables.keys())[-1]
settings.message_tables.pop(tomorrow_table)
# Get the deferred back
d = settings.update_rotating_tables()
def check_tables(result):
eq_(len(settings.message_tables), 3)
eq_(sorted(settings.message_tables.keys())[-1], tomorrow_table)
d.addCallback(check_tables)
return d
def test_update_rotating_tables(self):
from autopush.db import get_month
settings = AutopushSettings(hostname="example.com",
resolve_hostname=True)
# Erase the tables it has on init, and move current month back one
last_month = get_month(-1)
settings.current_month = last_month.month
settings.message_tables = {}
# Create the next month's table, just in case today is the day before
# a new month, in which case the lack of keys will cause an error in
# update_rotating_tables
next_month = get_month(1)
settings.message_tables[next_month.month] = None
# Get the deferred back
e = Deferred()
d = settings.update_rotating_tables()
def check_tables(result):
eq_(len(settings.message_tables), 2)
eq_(settings.current_month, get_month().month)
d.addCallback(check_tables)
d.addBoth(lambda x: e.callback(True))
return e
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.db = db = test_db()
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_settings(settings, db, Mock())
routers["test"] = Mock(spec=IRouter)
app = EndpointHTTPFactory(settings, 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(settings.bear_hash_key[0], dummy_uaid.hex))
self.settings = settings
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(
EndpointHTTPFactory(settings, db=None, 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
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 test_init(self):
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
with assert_raises(IOError):
GCMRouter(settings, {"senderIDs": {}})
def setUp(self, fgcm):
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.gcm_config = {'s3_bucket': 'None',
'max_data': 32,
'ttl': 60,
'senderid_list': {'test123':
{"auth": "12345678abcdefg"}}}
self.gcm = fgcm
self.router = GCMRouter(settings, self.gcm_config)
self.headers = {"content-encoding": "aesgcm",
"encryption": "test",
"encryption-key": "test"}
# Payloads are Base64-encoded.
self.notif = Notification(10, "q60d6g", dummy_chid, self.headers,
200)
self.router_data = dict(
router_data=dict(
token="connect_data",
creds=dict(senderID="test123", auth="12345678abcdefg")))
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.mock_result = mock_result
fgcm.send.return_value = mock_result
def test_update_not_needed(self):
from autopush.db import get_month
settings = AutopushSettings(hostname="google.com",
resolve_hostname=True)
db = DatabaseManager.from_settings(settings)
db.create_initial_message_tables()
# Erase the tables it has on init, and move current month back one
db.message_tables = {}
# Create the next month's table, just in case today is the day before
# a new month, in which case the lack of keys will cause an error in
# update_rotating_tables
next_month = get_month(1)
db.message_tables[next_month.month] = None
# Get the deferred back
e = Deferred()
d = db.update_rotating_tables()
def check_tables(result):
eq_(len(db.message_tables), 1)
d.addCallback(check_tables)
d.addBoth(lambda x: e.callback(True))
return e
def test_gcmclient_fail(self, fgcm):
fgcm.side_effect = Exception
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
with assert_raises(IOError):
GCMRouter(settings, {"senderIDs": {"test123": {"auth": "abcd"}}})
def __init__(self, sysargs, use_files=True):
args = self._load_args(sysargs, use_files)
self._settings = AutopushSettings(
crypto_key=args.crypto_key,
router_tablename=args.router_tablename,
storage_tablename=args.storage_tablename,
message_tablename=args.message_tablename,
)
self._endpoint = args.endpoint
self._pp = pprint.PrettyPrinter(indent=4)
def setUp(self):
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
apns_config = {'cert_file': 'fake.cert', 'key_file': 'fake.key'}
self.mock_apns = Mock(spec=apns.APNs)
self.router = APNSRouter(settings, apns_config)
self.router.apns = self.mock_apns
self.notif = Notification(10, "data", dummy_chid, None, 200)
self.router_data = dict(router_data=dict(token="connect_data"))
def test_init(self, ffcm):
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
def throw_auth(*args, **kwargs):
raise Exception("oopsy")
ffcm.side_effect = throw_auth
with assert_raises(IOError):
FCMRouter(settings, {})
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)
AutopushSettings._tomorrow = Mock()
AutopushSettings._tomorrow.return_value = tomorrow
settings = AutopushSettings()
eq_(len(settings.message_tables), 3)
def setUp(self):
twisted.internet.base.DelayedCall.debug = True
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
crypto_key='AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=',
)
db = test_db()
self.message_mock = db.message = Mock(spec=Message)
self.fernet_mock = settings.fernet = Mock(spec=Fernet)
app = EndpointHTTPFactory.for_handler(MessageHandler, settings, db=db)
self.client = Client(app)
def __init__(self, sysargs, use_files=True):
args = self._load_args(sysargs, use_files)
self._settings = settings = AutopushSettings(
crypto_key=args.crypto_key,
router_tablename=args.router_tablename,
storage_tablename=args.storage_tablename,
message_tablename=args.message_tablename,
statsd_host=None,
)
self.db = DatabaseManager.from_settings(settings)
self.db.setup(settings.preflight_uaid)
self._endpoint = args.endpoint
self._pp = pprint.PrettyPrinter(indent=4)
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 setUp(self):
twisted.internet.base.DelayedCall.debug = True
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.logs = TestingLogObserver()
begin_or_register(self.logs, discardBuffer=True)
self.addCleanup(globalLogPublisher.removeObserver, self.logs)
app = EndpointHTTPFactory.for_handler(LogCheckHandler, settings)
self.client = Client(app)
def test_update_not_needed(self):
settings = AutopushSettings(
hostname="google.com", resolve_hostname=True)
# Erase the tables it has on init, and move current month back one
settings.message_tables = {}
# Get the deferred back
d = settings.update_rotating_tables()
def check_tables(result):
eq_(len(settings.message_tables), 0)
d.addCallback(check_tables)
return d
def _make_fut(self):
from autopush.web.webpush import WebPushRequestSchema
from autopush.settings import AutopushSettings
schema = WebPushRequestSchema()
schema.context["log"] = Mock()
schema.context["settings"] = settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
settings.router = Mock()
settings.router.get_uaid.return_value = dict(
router_type="gcm",
uaid=dummy_uaid,
)
settings.fernet = self.fernet_mock = Mock()
return schema
def test_update_rotating_tables_month_end(self):
"""Test that rotating adds next months table
This test is intended to ensure that if the next day is a new
month, then update_rotating_tables realizes this and add's
the new table to the message_tables.
A pre-requisite is that today cannot be the last day of
the current month. Therefore, we first sub in _tomorrow to
ensure it always appears as next month, and then remove
the new table create_initial_tables made so we can observe
update_rotating_tables add the new one.
Note that sorting message table keys to find the last month
does *not work* since the month digit is not zero-padded.
"""
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)
AutopushSettings._tomorrow = Mock()
AutopushSettings._tomorrow.return_value = tomorrow
settings = AutopushSettings(hostname="example.com",
resolve_hostname=True)
# We should have 3 tables, one for next/this/last month
eq_(len(settings.message_tables), 3)
# Grab next month's table name and remove it
next_month = get_rotating_message_table(settings._message_prefix,
delta=1)
settings.message_tables.pop(next_month.table_name)
# Get the deferred back
d = settings.update_rotating_tables()
def check_tables(result):
eq_(len(settings.message_tables), 3)
ok_(next_month.table_name in settings.message_tables)
d.addCallback(check_tables)
return d
def setUp(self):
from twisted.logger import Logger
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
apns_config = {'cert_file': 'fake.cert', 'key_file': 'fake.key'}
self.mock_apns = Mock(spec=apns.APNs)
self.router = APNSRouter(settings, apns_config)
self.router.apns = self.mock_apns
self.router.log = Mock(spec=Logger)
self.headers = {"content-encoding": "aesgcm",
"encryption": "test",
"encryption-key": "test"}
self.notif = Notification(10, "q60d6g", dummy_chid, self.headers,
200)
self.router_data = dict(router_data=dict(token="connect_data"))
def setUp(self):
self.timeout = 0.5
twisted.internet.base.DelayedCall.debug = True
self.mock_dynamodb2 = mock_dynamodb2()
self.mock_dynamodb2.start()
self.addCleanup(self.mock_dynamodb2.stop)
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.request_mock = Mock()
self.status = StatusHandler(
EndpointHTTPFactory(settings, db=None, routers=None),
self.request_mock)
self.write_mock = self.status.write = Mock()
def setUp(self):
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
self.router = SimpleRouter(settings, {})
self.notif = Notification(10, "data", dummy_chid, None, 200)
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 = settings.router = Mock(spec=Router)
self.storage_mock = settings.storage = Mock(spec=Storage)
self.agent_mock = Mock(spec=settings.agent)
settings.agent = self.agent_mock
self.router.metrics = Mock()
def test_update_rotating_tables(self):
from autopush.db import get_month
settings = AutopushSettings(
hostname="example.com", resolve_hostname=True)
# Erase the tables it has on init, and move current month back one
last_month = get_month(-1)
settings.current_month = last_month.month
settings.message_tables = {}
# Get the deferred back
d = settings.update_rotating_tables()
def check_tables(result):
eq_(len(settings.message_tables), 1)
d.addCallback(check_tables)
return d
def setUp(self, mt, mc):
from twisted.logger import Logger
settings = AutopushSettings(
hostname="localhost",
statsd_host=None,
)
apns_config = {
'firefox': {
'cert': 'fake.cert',
'key': 'fake.key',
'topic': 'com.example.SomeApp',
'max_connections': 2,
}
}
self.mock_connection = mc
mc.return_value = mc
self.router = APNSRouter(settings, apns_config)
self.mock_response = Mock()
self.mock_response.status = 200
mc.get_response.return_value = self.mock_response
# toss the existing connection
try:
self.router.apns['firefox'].connections.pop()
except IndexError: # pragma nocover
pass
self.router.apns['firefox'].connections.append(self.mock_connection)
self.router.apns['firefox'].log = Mock(spec=Logger)
self.headers = {
"content-encoding": "aesgcm",
"encryption": "test",
"encryption-key": "test"
}
self.notif = WebPushNotification(
uaid=uuid.UUID(dummy_uaid),
channel_id=uuid.UUID(dummy_chid),
data="q60d6g",
headers=self.headers,
ttl=200,
message_id=10,
)
self.notif.cleanup_headers()
self.router_data = dict(
router_data=dict(token="connect_data", rel_channel="firefox"))
