class BucketLoggingTest(unittest.TestCase): def setUp(self): self.session = mock.MagicMock() self.client = Client(session=self.session) mock_response(self.session) def test_create_bucket_logs_info_message(self): with mock.patch('kinto_http.logger') as mocked_logger: self.client.create_bucket(id="buck", data={'foo': 'bar'}) mocked_logger.info.assert_called_with("Create bucket 'buck'") def test_update_bucket_logs_info_message(self): with mock.patch('kinto_http.logger') as mocked_logger: self.client.update_bucket(id='buck', data={'foo': 'bar'}) mocked_logger.info.assert_called_with("Update bucket 'buck'") def test_get_bucket_logs_info_message(self): with mock.patch('kinto_http.logger') as mocked_logger: self.client.get_bucket(id="buck") mocked_logger.info.assert_called_with("Get bucket 'buck'") def test_delete_bucket_logs_info_message(self): with mock.patch('kinto_http.logger') as mocked_logger: self.client.delete_bucket(id="buck") mocked_logger.info.assert_called_with("Delete bucket 'buck'") def test_delete_buckets_logs_info_message(self): with mock.patch('kinto_http.logger') as mocked_logger: self.client.delete_buckets() mocked_logger.info.assert_called_with('Delete buckets')
def test_logger_outputs_replication_information(self, logger): origin_session = mock.MagicMock() origin_session.server_url = "http://origin/v1" destination_session = mock.MagicMock() destination_session.server_url = "http://destination/v1" mock_response(origin_session) mock_response(destination_session) origin = Client( session=origin_session, bucket="buck", collection="coll" ) destination = Client( session=destination_session, bucket="buck", collection="coll" ) destination._server_settings = {'batch_max_requests': 15} replicate(origin, destination) msg = ("Replication from <KintoClient http://origin/v1/buckets/buck/" "collections/coll> to <KintoClient http://destination/v1/" "buckets/buck/collections/coll>") logger.info.assert_any_call(msg) logger.info.assert_any_call("replication of 0 records")
def test_multiple_record_deletion(self): client = Client(server_url=self.server_url, auth=self.auth, bucket='mozilla', collection='payments') client.create_bucket() client.create_collection() client.create_record({'foo': 'bar'}) client.delete_records() assert len(client.get_records()) == 0
def test_bucket_sharing(self): alice_credentials = ('alice', 'p4ssw0rd') alice_userid = self.get_user_id(alice_credentials) # Create a bucket and share it with alice. self.client.create_bucket('shared-bucket', permissions={'read': [alice_userid, ]}) alice_client = Client(server_url=self.server_url, auth=alice_credentials) alice_client.get_bucket('shared-bucket')
class GroupTest(unittest.TestCase): def setUp(self): self.session = mock.MagicMock() mock_response(self.session) self.client = Client(session=self.session, bucket='mybucket') def test_create_group_can_deduce_id_from_data(self): self.client.create_group(data={'id': 'group'}) self.session.request.assert_called_with( 'put', '/buckets/mybucket/groups/group', data={'id': 'group'}, permissions=None, headers=DO_NOT_OVERWRITE) def test_update_group_can_deduce_id_from_data(self): self.client.update_group(data={'id': 'group'}) self.session.request.assert_called_with( 'put', '/buckets/mybucket/groups/group', data={'id': 'group'}, permissions=None, headers=None) def test_create_group_raises_if_group_id_is_missing(self): with pytest.raises(KeyError) as e: self.client.create_group() self.assertEqual('%s' % e.value, "'Please provide a group id'") def test_update_group_raises_if_group_id_is_missing(self): with pytest.raises(KeyError) as e: self.client.update_group() self.assertEqual('%s' % e.value, "'Please provide a group id'")
def test_collection_argument_takes_precedence(self): mock_response(self.session) # Specify a different collection name for the client and the operation. client = Client(session=self.session, bucket='mybucket', collection='wrong_collection') client.update_record(data={'id': '1234'}, collection='good_collection', permissions=mock.sentinel.permissions) self.session.request.assert_called_with( 'put', '/buckets/mybucket/collections/good_collection/records/1234', data={'id': '1234'}, headers=None, permissions=mock.sentinel.permissions)
def test_collection_sharing(self): alice_credentials = ('alice', 'p4ssw0rd') alice_userid = self.get_user_id(alice_credentials) self.client.create_bucket('bob-bucket') self.client.create_collection( 'shared', bucket='bob-bucket', permissions={'read': [alice_userid, ]}) # Try to read the collection as Alice. alice_client = Client(server_url=self.server_url, auth=alice_credentials) alice_client.get_collection('shared', bucket='bob-bucket')
def test_updating_data_on_a_group(self): client = Client(server_url=self.server_url, auth=self.auth, bucket='mozilla') client.create_bucket() client.create_group('payments', data={'members': []}) client.patch_group('payments', data={'secret': 'psssssst!'}) group = client.get_group('payments') assert group['data']['secret'] == 'psssssst!'
def test_record_creation_and_retrieval(self): client = Client(server_url=self.server_url, auth=self.auth, bucket='mozilla', collection='payments') client.create_bucket() client.create_collection() created = client.create_record(data={'foo': 'bar'}, permissions={'read': ['alexis']}) record = client.get_record(id=created['data']['id']) assert 'alexis' in record['permissions']['read']
def test_records_list_retrieval(self): client = Client(server_url=self.server_url, auth=self.auth, bucket='mozilla', collection='payments') client.create_bucket() client.create_collection() client.create_record(data={'foo': 'bar'}, permissions={'read': ['alexis']}) records = client.get_records() assert len(records) == 1
def test_one_record_deletion(self): client = Client(server_url=self.server_url, auth=self.auth, bucket='mozilla', collection='payments') client.create_bucket() client.create_collection() record = client.create_record({'foo': 'bar'}) deleted = client.delete_record(record['data']['id']) assert deleted['deleted'] is True assert len(client.get_records()) == 0
def test_single_record_creation_if_not_exists(self): client = Client(server_url=self.server_url, auth=self.auth, bucket='mozilla', collection='payments') client.create_bucket() client.create_collection() created = client.create_record(data={'foo': 'bar'}) client.create_record(data={'id': created['data']['id'], 'bar': 'baz'}, if_not_exists=True)
def test_updating_data_on_a_collection(self): client = Client(server_url=self.server_url, auth=self.auth, bucket='mozilla', collection='payments') client.create_bucket() client.create_collection() client.patch_collection(data={'secret': 'psssssst!'}) collection = client.get_collection() assert collection['data']['secret'] == 'psssssst!'
def test_record_deletion_if_exists(self): client = Client(server_url=self.server_url, auth=self.auth, bucket='mozilla', collection='payments') client.create_bucket() client.create_collection() record = client.create_record(data={'foo': 'bar'}) deleted = client.delete_record(id=record['data']['id']) deleted_if_exists = client.delete_record(id=record['data']['id'], if_exists=True) assert deleted['deleted'] is True assert deleted_if_exists is None
def test_records_paginated_list_retrieval(self): client = Client(server_url=self.server_url, auth=self.auth, bucket="mozilla", collection="payments") client.create_bucket() client.create_collection() for i in range(10): client.create_record(data={"foo": "bar"}, permissions={"read": ["account:alexis"]}) # Kinto is running with kinto.paginate_by = 5 records = client.get_records() assert len(records) == 10
def test_record_deletion_if_exists(self): client = Client(server_url=self.server_url, auth=self.auth, bucket="mozilla", collection="payments") client.create_bucket() client.create_collection() record = client.create_record(data={"foo": "bar"}) deleted = client.delete_record(id=record["data"]["id"]) deleted_if_exists = client.delete_record(id=record["data"]["id"], if_exists=True) assert deleted["deleted"] is True assert deleted_if_exists is None
def test_single_record_creation_if_not_exists(self): client = Client(server_url=self.server_url, auth=self.auth, bucket='mozilla', collection='payments') client.create_bucket() client.create_collection() created = client.create_record(data={'foo': 'bar'}) client.create_record(data={ 'id': created['data']['id'], 'bar': 'baz' }, if_not_exists=True)
def test_records_paginated_list_retrieval(self): client = Client(server_url=self.server_url, auth=self.auth, bucket='mozilla', collection='payments') client.create_bucket() client.create_collection() for i in range(10): client.create_record(data={'foo': 'bar'}, permissions={'read': ['account:alexis']}) # Kinto is running with kinto.paginate_by = 5 records = client.get_records() assert len(records) == 10
def test_single_record_creation_if_not_exists(self): client = Client(server_url=self.server_url, auth=self.auth, bucket="mozilla", collection="payments") client.create_bucket() client.create_collection() created = client.create_record(data={"foo": "bar"}) client.create_record(data={ "id": created["data"]["id"], "bar": "baz" }, if_not_exists=True)
class CollectionLoggingTest(unittest.TestCase): def setUp(self): self.session = mock.MagicMock() self.client = Client(session=self.session) mock_response(self.session) def test_create_collection_logs_info_message(self): with mock.patch('kinto_http.logger') as mocked_logger: self.client.create_collection('mozilla', bucket="buck", data={'foo': 'bar'}, permissions={'write': [ 'blah', ]}) mocked_logger.info.assert_called_with( "Create collection 'mozilla' in bucket 'buck'") def test_update_collection_logs_info_message(self): with mock.patch('kinto_http.logger') as mocked_logger: self.client.update_collection( data={'foo': 'bar'}, collection='mozilla', bucket='buck', permissions={'write': [ 'blahblah', ]}) mocked_logger.info.assert_called_with( "Update collection 'mozilla' in bucket 'buck'") def test_get_collection_logs_info_message(self): with mock.patch('kinto_http.logger') as mocked_logger: self.client.get_collection('mozilla', bucket='buck') mocked_logger.info.assert_called_with( "Get collection 'mozilla' in bucket 'buck'") def test_delete_collection_logs_info_message(self): with mock.patch('kinto_http.logger') as mocked_logger: self.client.delete_collection('mozilla', bucket="buck") mocked_logger.info.assert_called_with( "Delete collection 'mozilla' in bucket 'buck'") def test_delete_collections_logs_info_message(self): with mock.patch('kinto_http.logger') as mocked_logger: self.client.delete_collections(bucket="buck") mocked_logger.info.assert_called_with( "Delete collections in bucket 'buck'")
def test_client_is_represented_properly_with_bucket(self): client = Client( server_url="https://kinto.notmyidea.org/v1", bucket="homebrewing", ) expected_repr = ("<KintoClient https://kinto.notmyidea.org/v1/" "buckets/homebrewing>") assert str(client) == expected_repr
def test_single_record_save(self): client = Client(server_url=self.server_url, auth=self.auth, bucket='mozilla', collection='payments') client.create_bucket() client.create_collection() created = client.create_record(data={'foo': 'bar'}, permissions={'read': ['account:alexis']}) created['data']['bar'] = 'baz' # XXX enhance this in order to have to pass only one argument, created. client.update_record(id=created['data']['id'], data=created['data']) retrieved = client.get_record(id=created['data']['id']) assert 'account:alexis' in retrieved['permissions']['read'] assert retrieved['data']['foo'] == u'bar' assert retrieved['data']['bar'] == u'baz' assert created['data']['id'] == retrieved['data']['id']
def test_single_record_can_overwrite(self): client = Client(server_url=self.server_url, auth=self.auth, bucket='mozilla', collection='payments') client.create_bucket() client.create_collection() created = client.create_record(data={'foo': 'bar'}, permissions={'read': ['alexis']}) client.create_record(data={'id': created['data']['id'], 'bar': 'baz'}, safe=False)
def test_record_deletion_if_exists(self): client = Client(server_url=self.server_url, auth=self.auth, bucket='mozilla', collection='payments') client.create_bucket() client.create_collection() record = client.create_record({'foo': 'bar'}) deleted = client.delete_record(record['data']['id']) deleted_if_exists = client.delete_record(record['data']['id'], if_exists=True) assert deleted['deleted'] is True assert deleted_if_exists is None
def test_records_deletion_when_no_records_exist(self): client = Client(server_url=self.server_url, auth=self.auth, bucket='mozilla', collection='payments') client.create_bucket() client.create_collection() deleted_records = client.delete_records() assert len(deleted_records) == 0
def test_records_generator_retrieval(self): client = Client(server_url=self.server_url, auth=self.auth, bucket="mozilla", collection="payments") client.create_bucket() client.create_collection() for i in range(10): client.create_record(data={"foo": "bar"}, permissions={"read": ["account:alexis"]}) pages = list(client.get_paginated_records()) assert len(pages) == 2
def test_batch_does_not_raise_exception_if_batch_4xx_errors_are_ignored(self): error = { "errno": 121, "message": "Forbidden", "code": 403, "error": "This user cannot access this resource." } self.session.request.side_effect = [ ({"settings": {"batch_max_requests": 25}}, []), ({"responses": [ {"status": 200, "path": "/url1", "body": {}, "headers": {}}, {"status": 403, "path": "/url2", "body": error, "headers": {}} ]}, [])] client = Client(session=self.session, ignore_batch_4xx=True) with client.batch(bucket='moz', collection='test') as batch: # Do not raise batch.create_record(id=1234, data={'foo': 'bar'}) batch.create_record(id=5678, data={'tutu': 'toto'})
def test_client_is_represented_properly_with_bucket_and_collection(self): client = Client( server_url="https://kinto.notmyidea.org/v1", bucket="homebrewing", collection="recipes" ) expected_repr = ("<KintoClient https://kinto.notmyidea.org/v1/" "buckets/homebrewing/collections/recipes>") assert str(client) == expected_repr
def test_records_paginated_list_retrieval(self): client = Client(server_url=self.server_url, auth=self.auth, bucket='mozilla', collection='payments') client.create_bucket() client.create_collection() for i in range(10): client.create_record(data={'foo': 'bar'}, permissions={'read': ['alexis']}) # Kinto is running with kinto.paginate_by = 5 records = client.get_records() assert len(records) == 10
def test_records_timestamp_retrieval(self): client = Client(server_url=self.server_url, auth=self.auth, bucket='mozilla', collection='payments') client.create_bucket() client.create_collection() record = client.create_record(data={'foo': 'bar'}, permissions={'read': ['account:alexis']}) etag = client.get_records_timestamp() assert str(etag) == str(record["data"]["last_modified"])
def test_single_record_doesnt_overwrite(self): client = Client(server_url=self.server_url, auth=self.auth, bucket='mozilla', collection='payments') client.create_bucket() client.create_collection() created = client.create_record(data={'foo': 'bar'}, permissions={'read': ['alexis']}) with self.assertRaises(KintoException): # Create a second record with the ID of the first one. client.create_record(data={'id': created['data']['id'], 'bar': 'baz'})
def test_record_creation_and_retrieval(self): client = Client(server_url=self.server_url, auth=self.auth, bucket="mozilla", collection="payments") client.create_bucket() client.create_collection() created = client.create_record( data={"foo": "bar"}, permissions={"read": ["account:alexis"]}) record = client.get_record(id=created["data"]["id"]) assert "account:alexis" in record["permissions"]["read"]
class GroupLoggingTest(unittest.TestCase): def setUp(self): self.session = mock.MagicMock() self.client = Client(session=self.session) mock_response(self.session) def test_create_group_logs_info_message(self): with mock.patch('kinto_http.logger') as mocked_logger: self.client.create_group( id='mozilla', bucket="buck", data={'foo': 'bar'}, permissions={'write': ['blah', ]}) mocked_logger.info.assert_called_with( "Create group 'mozilla' in bucket 'buck'") def test_update_group_logs_info_message(self): with mock.patch('kinto_http.logger') as mocked_logger: self.client.update_group( data={'foo': 'bar'}, id='mozilla', bucket='buck', permissions={'write': ['blahblah', ]}) mocked_logger.info.assert_called_with( "Update group 'mozilla' in bucket 'buck'") def test_get_group_logs_info_message(self): with mock.patch('kinto_http.logger') as mocked_logger: self.client.get_group( id='mozilla', bucket='buck') mocked_logger.info.assert_called_with( "Get group 'mozilla' in bucket 'buck'") def test_delete_group_logs_info_message(self): with mock.patch('kinto_http.logger') as mocked_logger: self.client.delete_group( id='mozilla', bucket="buck") mocked_logger.info.assert_called_with( "Delete group 'mozilla' in bucket 'buck'") def test_delete_groups_logs_info_message(self): with mock.patch('kinto_http.logger') as mocked_logger: self.client.delete_groups( bucket="buck") mocked_logger.info.assert_called_with( "Delete groups in bucket 'buck'")
def test_records_timestamp_retrieval(self): client = Client(server_url=self.server_url, auth=self.auth, bucket="mozilla", collection="payments") client.create_bucket() client.create_collection() record = client.create_record(data={"foo": "bar"}, permissions={"read": ["account:alexis"]}) etag = client.get_records_timestamp() assert str(etag) == str(record["data"]["last_modified"])
def test_single_record_can_overwrite(self): client = Client(server_url=self.server_url, auth=self.auth, bucket="mozilla", collection="payments") client.create_bucket() client.create_collection() created = client.create_record( data={"foo": "bar"}, permissions={"read": ["account:alexis"]}) client.create_record(data={ "id": created["data"]["id"], "bar": "baz" }, safe=False)
def test_single_record_can_overwrite(self): client = Client(server_url=self.server_url, auth=self.auth, bucket='mozilla', collection='payments') client.create_bucket() client.create_collection() created = client.create_record( data={'foo': 'bar'}, permissions={'read': ['account:alexis']}) client.create_record(data={ 'id': created['data']['id'], 'bar': 'baz' }, safe=False)
def setUpClass(cls): super(BaseTestFunctional, cls).setUpClass() cls.signer = local_ecdsa.ECDSASigner(private_key=cls.private_key) cls.source = Client(server_url=cls.server_url, auth=DEFAULT_AUTH, bucket=cls.source_bucket, collection=cls.source_collection) cls.destination = Client(server_url=cls.server_url, auth=DEFAULT_AUTH, bucket=cls.destination_bucket, collection=cls.destination_collection) cls.editor_client = Client(server_url=cls.server_url, auth=("editor", ""), bucket=cls.source_bucket, collection=cls.source_collection) cls.someone_client = Client(server_url=cls.server_url, auth=("Sam", "Wan-Elss"), bucket=cls.source_bucket, collection=cls.source_collection)
def test_single_record_save(self): client = Client(server_url=self.server_url, auth=self.auth, bucket="mozilla", collection="payments") client.create_bucket() client.create_collection() created = client.create_record( data={"foo": "bar"}, permissions={"read": ["account:alexis"]}) created["data"]["bar"] = "baz" # XXX enhance this in order to have to pass only one argument, created. client.update_record(id=created["data"]["id"], data=created["data"]) retrieved = client.get_record(id=created["data"]["id"]) assert "account:alexis" in retrieved["permissions"]["read"] assert retrieved["data"]["foo"] == u"bar" assert retrieved["data"]["bar"] == u"baz" assert created["data"]["id"] == retrieved["data"]["id"]
def test_logger_outputs_replication_information(self, logger): origin_session = mock.MagicMock() origin_session.server_url = "http://origin/v1" destination_session = mock.MagicMock() destination_session.server_url = "http://destination/v1" mock_response(origin_session) mock_response(destination_session) origin = Client(session=origin_session, bucket="buck", collection="coll") destination = Client(session=destination_session, bucket="buck", collection="coll") destination._server_settings = {"batch_max_requests": 15} replicate(origin, destination) msg = ( "Replication from <KintoClient http://origin/v1/buckets/buck/" "collections/coll> to <KintoClient http://destination/v1/" "buckets/buck/collections/coll>" ) logger.info.assert_any_call(msg) logger.info.assert_any_call("replication of 0 records")
def __init__(self, *args, **kwargs): super(FunctionalTest, self).__init__(*args, **kwargs) # XXX Read the configuration from env variables. self.server_url = SERVER_URL self.auth = DEFAULT_AUTH # Read the configuration. self.config = configparser.RawConfigParser() self.config.read(os.path.join(__HERE__, 'config/kinto.ini')) self.client = Client(server_url=self.server_url, auth=self.auth)
def test_single_record_doesnt_overwrite(self): client = Client(server_url=self.server_url, auth=self.auth, bucket="mozilla", collection="payments") client.create_bucket() client.create_collection() created = client.create_record( data={"foo": "bar"}, permissions={"read": ["account:alexis"]}) with self.assertRaises(KintoException): # Create a second record with the ID of the first one. client.create_record(data={ "id": created["data"]["id"], "bar": "baz" })
def test_single_record_doesnt_overwrite(self): client = Client(server_url=self.server_url, auth=self.auth, bucket='mozilla', collection='payments') client.create_bucket() client.create_collection() created = client.create_record( data={'foo': 'bar'}, permissions={'read': ['account:alexis']}) with self.assertRaises(KintoException): # Create a second record with the ID of the first one. client.create_record(data={ 'id': created['data']['id'], 'bar': 'baz' })
def test_record_creation_and_retrieval(self): client = Client(server_url=self.server_url, auth=self.auth, bucket='mozilla', collection='payments') client.create_bucket() client.create_collection() created = client.create_record(data={'foo': 'bar'}, permissions={'read': ['alexis']}) record = client.get_record(created['data']['id']) assert 'alexis' in record['permissions']['read']
def test_records_timestamp_retrieval(self): client = Client(server_url=self.server_url, auth=self.auth, bucket='mozilla', collection='payments') client.create_bucket() client.create_collection() record = client.create_record(data={'foo': 'bar'}, permissions={'read': ['alexis']}) etag = client.get_records_timestamp() assert str(etag) == str(record["data"]["last_modified"])
def main(): # pragma: nocover args = get_arguments() cli_utils.setup_logger(logger, args) origin = Client(server_url=args.origin_server, auth=args.origin_auth or args.auth, bucket=args.origin_bucket or args.bucket, collection=args.origin_collection or args.collection) destination = cli_utils.create_client_from_args(args) replicate(origin, destination)
def test_single_record_save(self): client = Client(server_url=self.server_url, auth=self.auth, bucket='mozilla', collection='payments') client.create_bucket() client.create_collection() created = client.create_record(data={'foo': 'bar'}, permissions={'read': ['alexis']}) created['data']['bar'] = 'baz' # XXX enhance this in order to have to pass only one argument, created. client.update_record(id=created['data']['id'], data=created['data']) retrieved = client.get_record(created['data']['id']) assert 'alexis' in retrieved['permissions']['read'] assert retrieved['data']['foo'] == u'bar' assert retrieved['data']['bar'] == u'baz' assert created['data']['id'] == retrieved['data']['id']
def get_nightly_builds(from_datestr="2018-10", to_datestr="2018-11"): """Return nightly build data for all builds.""" client = KintoClient(server_url=BUILDHUB_URL) records = client.get_records( **{ "target.platform": "linux-x86_64", "target.channel": "nightly", "source.product": "firefox", "target.locale": "en-US", # Caution: use build.date because download.date is crazy for dates before # 2016. "gt_build.date": from_datestr, "lt_build.date": to_datestr, "_sort": "-download.date", "_fields": "build.id,source.revision,download.date", # "_limit": 10, }, bucket="build-hub", collection="releases", ) return records
def initKintoClient(self): self.kinto_client = None kinto_url = settings.conf.value("KintoServerUrl") if kinto_url is not None and kinto_url != "": kinto_bucket = settings.conf.value("KintoDefaultBucket") kinto_credentials = (settings.conf.value("KintoBasicUserCred"), settings.conf.value("KintoBasicPasswordCred")) logger.debug(kinto_credentials) if kinto_bucket is None or kinto_bucket == "": kinto_bucket = "joliebulle" logger.debug("using default bucket 'joliebulle'") try: tmp_client = Client(server_url=kinto_url, auth=kinto_credentials) tmp_client.create_bucket(id=kinto_bucket, if_not_exists=True) self.kinto_client = Client(server_url=kinto_url, bucket=kinto_bucket, auth=kinto_credentials) # Création des collections self.kinto_client.create_collection(id='recipes', if_not_exists=True) self.kinto_client.create_collection(id='ingredients', if_not_exists=True) logger.info("Synchronize with kinto server at :" + repr(self.kinto_client)) except Exception as e: logger.warn("Failed to initialize Kinto synchronisation: " + repr(e))
def test_blocklist_timestamp(env, conf): if env == 'prod': pytest.skip('Skipping blocklist timestamp test in production') client = Client(server_url=conf.get(env, 'reader_server'), bucket='blocklists') # Take the highest timestamp of the collections contained in the blocklist.xml. last_modified = -1 for cid in ('addons', 'plugins', 'gfx'): records = client.get_records(collection=cid, _sort='-last_modified', _limit=1, enabled='true') if len(records) > 0: last_modified = max(last_modified, records[0]['last_modified']) # Read the current XML blocklist ETag. blocklist_uri = conf.get(env, 'reader_server').strip('/') + ( '/blocklist/3/{ec8030f7-c20a-464f-9b0e-13a3a9e97384}/58.0' '/Firefox/20180123185941/Darwin_x86_64-gcc3-u-i386-x86_64' '/en-US/release/Darwin 17.4.0/default/default/invalid/invalid/0/') r = requests.get(blocklist_uri) r.raise_for_status() etag_header = int(r.headers.get('ETag', '')[1:-1]) last_modified_header = r.headers.get('Last-Modified', '') last_modified_header = datetime.datetime.strptime( last_modified_header, '%a, %d %b %Y %H:%M:%S GMT') # Check XML attribute <blocklist lastupdate="1483471392954"> dom = minidom.parseString(r.text) root = dom.getElementsByTagName('blocklist')[0] last_modified_attr = int(root.getAttribute('lastupdate')) # Make sure they all match. # See https://bugzilla.mozilla.org/show_bug.cgi?id=1436469 assert last_modified == etag_header last_modified_dt = datetime.datetime.utcfromtimestamp(last_modified / 1000.0) assert last_modified_dt.replace(microsecond=0) == last_modified_header assert last_modified == last_modified_attr
def test_round_trip_with_client_wins(self): # Load some data cmd = 'kinto-wizard {} --server={} --auth={}' load_cmd = cmd.format("load {}".format(self.file), self.server, self.auth) sys.argv = load_cmd.split(" ") main() # Change something that could make the server to fail. client = Client(server_url=self.server, auth=tuple(self.auth.split(':'))) client.update_record(bucket='build-hub', collection='archives', id='0831d549-0a69-48dd-b240-feef94688d47', data={}) record = client.get_record(bucket='build-hub', collection='archives', id='0831d549-0a69-48dd-b240-feef94688d47') assert set(record['data'].keys()) == {'id', 'last_modified'} cmd = 'kinto-wizard {} --server={} -D --auth={} --force' load_cmd = cmd.format("load {}".format(self.file), self.server, self.auth) sys.argv = load_cmd.split(" ") main() record = client.get_record(bucket='build-hub', collection='archives', id='0831d549-0a69-48dd-b240-feef94688d47') assert set(record['data'].keys()) != {'id', 'last_modified'}
def test_round_trip_with_delete_missing_records_ask_for_confirmation(self): # Load some data cmd = 'kinto-wizard {} --server={} --auth={}' load_cmd = cmd.format("load {}".format(self.file), self.server, self.auth) sys.argv = load_cmd.split(" ") main() # Change something that could make the server to fail. client = Client(server_url=self.server, auth=tuple(self.auth.split(':'))) client.create_record(bucket='build-hub', collection='archives', id='8031d549-0a69-48dd-b240-feef94688d47', data={}) cmd = 'kinto-wizard {} --server={} -D --auth={} --delete-records' load_cmd = cmd.format("load {}".format(self.file), self.server, self.auth) sys.argv = load_cmd.split(" ") with mockInput('yes'): main() with pytest.raises(exceptions.KintoException) as exc: client.get_record(bucket='build-hub', collection='archives', id='8031d549-0a69-48dd-b240-feef94688d47') assert "'Not Found'" in str(exc.value)
def initKintoClient(self): self.kinto_client = None kinto_url = settings.conf.value("KintoServerUrl") if kinto_url is not None and kinto_url != "": kinto_bucket = settings.conf.value("KintoDefaultBucket") kinto_credentials=(settings.conf.value("KintoBasicUserCred"), settings.conf.value("KintoBasicPasswordCred")) logger.debug(kinto_credentials) if kinto_bucket is None or kinto_bucket == "": kinto_bucket = "joliebulle" logger.debug("using default bucket 'joliebulle'") try: tmp_client = Client(server_url=kinto_url, auth = kinto_credentials) tmp_client.create_bucket(id=kinto_bucket, if_not_exists=True) self.kinto_client = Client(server_url=kinto_url, bucket=kinto_bucket, auth = kinto_credentials) # Création des collections self.kinto_client.create_collection(id='recipes', if_not_exists=True) self.kinto_client.create_collection(id='ingredients', if_not_exists=True) logger.info("Synchronize with kinto server at :" + repr(self.kinto_client)) except Exception as e: logger.warn("Failed to initialize Kinto synchronisation: " + repr(e))
def test_record_sharing(self): alice_credentials = ('alice', 'p4ssw0rd') alice_userid = self.get_user_id(alice_credentials) # Create a record, and share it with Alice. self.client.create_bucket('bob-bucket') self.client.create_collection('bob-personal-collection', bucket='bob-bucket') record = self.client.create_record( data={'foo': 'bar'}, permissions={'read': [alice_userid, ]}, bucket='bob-bucket', collection='bob-personal-collection') # Try to read the record as Alice alice_client = Client(server_url=self.server_url, auth=alice_credentials) record = alice_client.get_record( id=record['data']['id'], bucket='bob-bucket', collection='bob-personal-collection') assert record['data']['foo'] == 'bar'
def main(): args = _get_args() print("Get editor's user id") editor_client = Client(server_url=args.server, auth=tuple(args.editor_auth.split(':'))) editor_id = editor_client.server_info()['user']['id'] print("Get reviewer's user id") reviewer_client = Client(server_url=args.server, auth=tuple(args.reviewer_auth.split(':'))) reviewer_id = reviewer_client.server_info()['user']['id'] print("Create signoff workflow groups") admin_client = Client(server_url=args.server, auth=tuple(args.auth.split(':')), bucket=args.bucket) print("Create/update editors group") editors_group = admin_client.create_group('editors', data={'members': []}, if_not_exists=True) editors_group['data']['members'] = editors_group['data']['members'] + [editor_id] admin_client.update_group('editors', editors_group['data'], safe=True) print("Create/update reviewers group") reviewers_group = admin_client.create_group('reviewers', data={'members': []}, if_not_exists=True) reviewers_group['data']['members'] = reviewers_group['data']['members'] + [reviewer_id] admin_client.update_group('reviewers', data=reviewers_group['data'], safe=True)
def setUp(self): self.session = mock.MagicMock() self.client = Client(session=self.session) mock_response(self.session)
class RecordLoggingTest(unittest.TestCase): def setUp(self): self.session = mock.MagicMock() self.client = Client(session=self.session) mock_response(self.session) def test_create_record_logs_info_message(self): with mock.patch('kinto_http.logger') as mocked_logger: self.client.create_bucket(id='buck') self.client.create_collection(id='mozilla', bucket='buck') self.client.create_record( id='fake-record', data={'foo': 'bar'}, permissions={'write': ['blah', ]}, bucket='buck', collection='mozilla') mocked_logger.info.assert_called_with( "Create record with id 'fake-record' in collection 'mozilla' in bucket 'buck'") def test_update_record_logs_info_message(self): with mock.patch('kinto_http.logger') as mocked_logger: self.client.create_bucket(id='buck') self.client.create_collection(bucket='buck', id='mozilla') self.client.update_record( id='fake-record', data={'ss': 'aa'}, bucket='buck', collection='mozilla') mocked_logger.info.assert_called_with( "Update record with id 'fake-record' in collection 'mozilla' in bucket 'buck'") def test_get_record_logs_info_message(self): with mock.patch('kinto_http.logger') as mocked_logger: self.client.create_bucket(id='buck') self.client.create_collection(id='mozilla', bucket='buck') self.client.get_record( id='fake-record', bucket='buck', collection='mozilla') mocked_logger.info.assert_called_with( "Get record with id 'fake-record' from collection 'mozilla' in bucket 'buck'") def test_delete_record_logs_info_message(self): with mock.patch('kinto_http.logger') as mocked_logger: self.client.create_bucket(id='buck') self.client.create_collection(id='mozilla', bucket='buck') self.client.delete_record( id='fake-record', bucket='buck', collection='mozilla') mocked_logger.info.assert_called_with( "Delete record with id 'fake-record' from collection 'mozilla' in bucket 'buck'") def test_delete_records_logs_info_message(self): with mock.patch('kinto_http.logger') as mocked_logger: self.client.create_bucket(id='buck') self.client.create_collection(id='mozilla', bucket='buck') self.client.delete_records( bucket='buck', collection='mozilla') mocked_logger.info.assert_called_with( "Delete records from collection 'mozilla' in bucket 'buck'")
def setUp(self): self.session = mock.MagicMock() self.client = Client( session=self.session, bucket='mybucket', collection='mycollection')
class ClientTest(unittest.TestCase): def setUp(self): self.session = mock.MagicMock() self.client = Client(session=self.session) mock_response(self.session) def test_server_info(self): self.client.server_info() self.session.request.assert_called_with('get', '/') def test_context_manager_works_as_expected(self): settings = {"batch_max_requests": 25} self.session.request.side_effect = [({"settings": settings}, []), ({"responses": []}, [])] with self.client.batch(bucket='mozilla', collection='test') as batch: batch.create_record(id=1234, data={'foo': 'bar'}) batch.create_record(id=5678, data={'bar': 'baz'}) self.session.request.assert_called_with( method='POST', endpoint='/batch', payload={'requests': [ {'body': {'data': {'foo': 'bar'}}, 'path': '/buckets/mozilla/collections/test/records/1234', 'method': 'PUT', 'headers': {'If-None-Match': '*'}}, {'body': {'data': {'bar': 'baz'}}, 'path': '/buckets/mozilla/collections/test/records/5678', 'method': 'PUT', 'headers': {'If-None-Match': '*'}}]}) def test_batch_raises_exception(self): # Make the next call to sess.request raise a 403. exception = KintoException() exception.response = mock.MagicMock() exception.response.status_code = 403 exception.request = mock.sentinel.request self.session.request.side_effect = exception with self.assertRaises(KintoException): with self.client.batch(bucket='moz', collection='test') as batch: batch.create_record(id=1234, data={'foo': 'bar'}) def test_batch_raises_exception_if_subrequest_failed(self): error = { "errno": 121, "message": "This user cannot access this resource.", "code": 403, "error": "Forbidden" } self.session.request.side_effect = [ ({"settings": {"batch_max_requests": 25}}, []), ({"responses": [ {"status": 200, "path": "/url1", "body": {}, "headers": {}}, {"status": 404, "path": "/url2", "body": error, "headers": {}} ]}, [])] with self.assertRaises(KintoException): with self.client.batch(bucket='moz', collection='test') as batch: batch.create_record(id=1234, data={'foo': 'bar'}) batch.create_record(id=5678, data={'tutu': 'toto'}) def test_batch_options_are_transmitted(self): settings = {"batch_max_requests": 25} self.session.request.side_effect = [({"settings": settings}, [])] with mock.patch('kinto_http.create_session') as create_session: with self.client.batch(bucket='moz', collection='test', retry=12, retry_after=20): _, last_call_kwargs = create_session.call_args_list[-1] self.assertEqual(last_call_kwargs['retry'], 12) self.assertEqual(last_call_kwargs['retry_after'], 20) def test_client_is_represented_properly(self): client = Client( server_url="https://kinto.notmyidea.org/v1", bucket="homebrewing", collection="recipes" ) expected_repr = ("<KintoClient https://kinto.notmyidea.org/v1/" "buckets/homebrewing/collections/recipes>") assert str(client) == expected_repr def test_client_uses_default_bucket_if_not_specified(self): mock_response(self.session) client = Client(session=self.session) client.get_bucket() self.session.request.assert_called_with('get', '/buckets/default') def test_client_uses_passed_bucket_if_specified(self): client = Client( server_url="https://kinto.notmyidea.org/v1", bucket="buck") assert client._bucket_name == "buck" def test_client_clone_with_auth(self): client_clone = self.client.clone(auth=("reviewer", "")) assert client_clone.session.auth == ("reviewer", "") assert self.client.session != client_clone.session assert self.client.session.server_url == client_clone.session.server_url assert self.client.session.auth != client_clone.session.auth assert self.client.session.nb_retry == client_clone.session.nb_retry assert self.client.session.retry_after == client_clone.session.retry_after assert self.client._bucket_name == client_clone._bucket_name assert self.client._collection_name == client_clone._collection_name def test_client_clone_with_server_url(self): client_clone = self.client.clone(server_url="https://kinto.notmyidea.org/v1") assert client_clone.session.server_url == "https://kinto.notmyidea.org/v1" assert self.client.session != client_clone.session assert self.client.session.server_url != client_clone.session.server_url assert self.client.session.auth == client_clone.session.auth assert self.client.session.nb_retry == client_clone.session.nb_retry assert self.client.session.retry_after == client_clone.session.retry_after assert self.client._bucket_name == client_clone._bucket_name assert self.client._collection_name == client_clone._collection_name def test_client_clone_with_new_session(self): session = create_session(auth=("reviewer", ""), server_url="https://kinto.notmyidea.org/v1") client_clone = self.client.clone(session=session) assert client_clone.session == session assert self.client.session != client_clone.session assert self.client.session.server_url != client_clone.session.server_url assert self.client.session.auth != client_clone.session.auth assert self.client._bucket_name == client_clone._bucket_name assert self.client._collection_name == client_clone._collection_name def test_client_clone_with_auth_and_server_url(self): client_clone = self.client.clone(auth=("reviewer", ""), server_url="https://kinto.notmyidea.org/v1") assert client_clone.session.auth == ("reviewer", "") assert client_clone.session.server_url == "https://kinto.notmyidea.org/v1" assert self.client.session != client_clone.session assert self.client.session.server_url != client_clone.session.server_url assert self.client.session.auth != client_clone.session.auth assert self.client.session.nb_retry == client_clone.session.nb_retry assert self.client.session.retry_after == client_clone.session.retry_after assert self.client._bucket_name == client_clone._bucket_name assert self.client._collection_name == client_clone._collection_name def test_client_clone_with_existing_session(self): client_clone = self.client.clone(session=self.client.session) assert self.client.session == client_clone.session assert self.client.session.server_url == client_clone.session.server_url assert self.client.session.auth == client_clone.session.auth assert self.client._bucket_name == client_clone._bucket_name assert self.client._collection_name == client_clone._collection_name def test_client_clone_with_new_bucket_and_collection(self): client_clone = self.client.clone(bucket="bucket_blah", collection="coll_blah") assert self.client.session == client_clone.session assert self.client.session.server_url == client_clone.session.server_url assert self.client.session.auth == client_clone.session.auth assert self.client.session.nb_retry == client_clone.session.nb_retry assert self.client.session.retry_after == client_clone.session.retry_after assert self.client._bucket_name != client_clone._bucket_name assert self.client._collection_name != client_clone._collection_name assert client_clone._bucket_name == "bucket_blah" assert client_clone._collection_name == "coll_blah" def test_client_clone_with_auth_and_server_url_bucket_and_collection(self): client_clone = self.client.clone(auth=("reviewer", ""), server_url="https://kinto.notmyidea.org/v1", bucket="bucket_blah", collection="coll_blah") assert self.client.session != client_clone.session assert self.client.session.server_url != client_clone.session.server_url assert self.client.session.auth != client_clone.session.auth assert self.client._bucket_name != client_clone._bucket_name assert self.client._collection_name != client_clone._collection_name assert client_clone.session.auth == ("reviewer", "") assert client_clone.session.server_url == "https://kinto.notmyidea.org/v1" assert client_clone._bucket_name == "bucket_blah" assert client_clone._collection_name == "coll_blah"
def test_client_uses_default_bucket_if_not_specified(self): mock_response(self.session) client = Client(session=self.session) client.get_bucket() self.session.request.assert_called_with('get', '/buckets/default')