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"))