class CollectionTest(unittest.TestCase):
def setUp(self):
self.session = mock.MagicMock()
mock_response(self.session)
self.client = Client(session=self.session, bucket="mybucket")
def test_collection_names_are_slugified(self):
self.client.get_collection("my collection")
url = "/buckets/mybucket/collections/my-collection"
self.session.request.assert_called_with("get", url)
def test_collection_creation_issues_an_http_put(self):
self.client.create_collection("mycollection", permissions=mock.sentinel.permissions)
url = "/buckets/mybucket/collections/mycollection"
self.session.request.assert_called_with(
"put", url, data=None, permissions=mock.sentinel.permissions, headers=DO_NOT_OVERWRITE
)
def test_data_can_be_sent_on_creation(self):
self.client.create_collection("mycollection", "testbucket", data={"foo": "bar"})
self.session.request.assert_called_with(
"put",
"/buckets/testbucket/collections/mycollection",
data={"foo": "bar"},
permissions=None,
headers=DO_NOT_OVERWRITE,
)
def test_collection_update_issues_an_http_put(self):
self.client.update_collection({"foo": "bar"}, collection="mycollection", permissions=mock.sentinel.permissions)
url = "/buckets/mybucket/collections/mycollection"
self.session.request.assert_called_with(
"put", url, data={"foo": "bar"}, permissions=mock.sentinel.permissions, headers=None
)
def test_update_handles_last_modified(self):
self.client.update_collection({"foo": "bar"}, collection="mycollection", last_modified=1234)
url = "/buckets/mybucket/collections/mycollection"
headers = {"If-Match": '"1234"'}
self.session.request.assert_called_with("put", url, data={"foo": "bar"}, headers=headers, permissions=None)
def test_collection_update_use_an_if_match_header(self):
data = {"foo": "bar", "last_modified": "1234"}
self.client.update_collection(data, collection="mycollection", permissions=mock.sentinel.permissions)
url = "/buckets/mybucket/collections/mycollection"
self.session.request.assert_called_with(
"put",
url,
data={"foo": "bar", "last_modified": "1234"},
permissions=mock.sentinel.permissions,
headers={"If-Match": '"1234"'},
)
def test_patch_collection_issues_an_http_patch(self):
self.client.patch_collection(collection="mycollection", data={"key": "secret"})
url = "/buckets/mybucket/collections/mycollection"
self.session.request.assert_called_with("patch", url, data={"key": "secret"}, headers=None, permissions=None)
def test_patch_collection_handles_last_modified(self):
self.client.patch_collection(collection="mycollection", data={"key": "secret"}, last_modified=1234)
url = "/buckets/mybucket/collections/mycollection"
headers = {"If-Match": '"1234"'}
self.session.request.assert_called_with("patch", url, data={"key": "secret"}, headers=headers, permissions=None)
def test_get_collections_returns_the_list_of_collections(self):
mock_response(
self.session, data=[{"id": "foo", "last_modified": "12345"}, {"id": "bar", "last_modified": "59874"}]
)
collections = self.client.get_collections(bucket="default")
assert list(collections) == [{"id": "foo", "last_modified": "12345"}, {"id": "bar", "last_modified": "59874"}]
def test_collection_can_delete_a_list_of_records(self):
self.client.delete_records(["1234", "5678"])
# url = '/buckets/mybucket/collections/mycollection/records/9'
# XXX check that the delete is done in a BATCH.
def test_collection_can_be_deleted(self):
data = {}
mock_response(self.session, data=data)
deleted = self.client.delete_collection("mycollection")
assert deleted == data
url = "/buckets/mybucket/collections/mycollection"
self.session.request.assert_called_with("delete", url, headers=None)
def test_collection_delete_if_match(self):
data = {}
mock_response(self.session, data=data)
deleted = self.client.delete_collection("mycollection", last_modified=1234)
assert deleted == data
url = "/buckets/mybucket/collections/mycollection"
self.session.request.assert_called_with("delete", url, headers={"If-Match": '"1234"'})
def test_collection_delete_if_match_not_included_if_not_safe(self):
data = {}
mock_response(self.session, data=data)
deleted = self.client.delete_collection("mycollection", last_modified=1324, safe=False)
assert deleted == data
url = "/buckets/mybucket/collections/mycollection"
self.session.request.assert_called_with("delete", url, headers=None)
def test_get_or_create_doesnt_raise_in_case_of_conflict(self):
data = {"permissions": mock.sentinel.permissions, "data": {"foo": "bar"}}
self.session.request.side_effect = [get_http_error(status=412), (data, None)]
returned_data = self.client.create_collection(
bucket="buck", collection="coll", if_not_exists=True
) # Should not raise.
assert returned_data == data
def test_get_or_create_raise_in_other_cases(self):
self.session.request.side_effect = get_http_error(status=500)
with self.assertRaises(KintoException):
self.client.create_collection(bucket="buck", collection="coll", if_not_exists=True)
class CollectionTest(unittest.TestCase):
def setUp(self):
self.session = mock.MagicMock()
mock_response(self.session)
self.client = Client(session=self.session, bucket='mybucket')
def test_collection_names_are_slugified(self):
self.client.get_collection('my collection')
url = '/buckets/mybucket/collections/my-collection'
self.session.request.assert_called_with('get', url)
def test_collection_creation_issues_an_http_put(self):
self.client.create_collection(
'mycollection',
permissions=mock.sentinel.permissions)
url = '/buckets/mybucket/collections/mycollection'
self.session.request.assert_called_with(
'put', url, data=None, permissions=mock.sentinel.permissions,
headers=DO_NOT_OVERWRITE)
def test_data_can_be_sent_on_creation(self):
self.client.create_collection(
'mycollection',
'testbucket',
data={'foo': 'bar'})
self.session.request.assert_called_with(
'put',
'/buckets/testbucket/collections/mycollection',
data={'foo': 'bar'},
permissions=None,
headers=DO_NOT_OVERWRITE)
def test_collection_update_issues_an_http_put(self):
self.client.update_collection(
{'foo': 'bar'},
collection='mycollection',
permissions=mock.sentinel.permissions)
url = '/buckets/mybucket/collections/mycollection'
self.session.request.assert_called_with(
'put', url, data={'foo': 'bar'},
permissions=mock.sentinel.permissions, headers=None)
def test_update_handles_last_modified(self):
self.client.update_collection(
{'foo': 'bar'},
collection='mycollection',
last_modified=1234)
url = '/buckets/mybucket/collections/mycollection'
headers = {'If-Match': '"1234"'}
self.session.request.assert_called_with(
'put', url, data={'foo': 'bar'},
headers=headers, permissions=None)
def test_collection_update_use_an_if_match_header(self):
data = {'foo': 'bar', 'last_modified': '1234'}
self.client.update_collection(
data,
collection='mycollection',
permissions=mock.sentinel.permissions)
url = '/buckets/mybucket/collections/mycollection'
self.session.request.assert_called_with(
'put', url, data={'foo': 'bar', 'last_modified': '1234'},
permissions=mock.sentinel.permissions,
headers={'If-Match': '"1234"'})
def test_patch_collection_issues_an_http_patch(self):
self.client.patch_collection(
collection='mycollection',
data={'key': 'secret'})
url = '/buckets/mybucket/collections/mycollection'
self.session.request.assert_called_with(
'patch', url, data={'key': 'secret'}, headers=None,
permissions=None)
def test_patch_collection_handles_last_modified(self):
self.client.patch_collection(
collection='mycollection',
data={'key': 'secret'},
last_modified=1234)
url = '/buckets/mybucket/collections/mycollection'
headers = {'If-Match': '"1234"'}
self.session.request.assert_called_with(
'patch', url, data={'key': 'secret'}, headers=headers,
permissions=None)
def test_get_collections_returns_the_list_of_collections(self):
mock_response(
self.session,
data=[
{'id': 'foo', 'last_modified': '12345'},
{'id': 'bar', 'last_modified': '59874'},
])
collections = self.client.get_collections(bucket='default')
assert list(collections) == [
{'id': 'foo', 'last_modified': '12345'},
{'id': 'bar', 'last_modified': '59874'},
]
def test_collection_can_delete_all_its_records(self):
self.client.delete_records(bucket='abucket', collection='acollection')
url = '/buckets/abucket/collections/acollection/records'
self.session.request.assert_called_with('delete', url, headers=None)
def test_delete_is_issued_on_list_deletion(self):
self.client.delete_collections(bucket='mybucket')
url = '/buckets/mybucket/collections'
self.session.request.assert_called_with('delete', url, headers=None)
def test_collection_can_be_deleted(self):
data = {}
mock_response(self.session, data=data)
deleted = self.client.delete_collection('mycollection')
assert deleted == data
url = '/buckets/mybucket/collections/mycollection'
self.session.request.assert_called_with('delete', url, headers=None)
def test_collection_delete_if_match(self):
data = {}
mock_response(self.session, data=data)
deleted = self.client.delete_collection(
'mycollection',
last_modified=1234)
assert deleted == data
url = '/buckets/mybucket/collections/mycollection'
self.session.request.assert_called_with(
'delete', url, headers={'If-Match': '"1234"'})
def test_collection_delete_if_match_not_included_if_not_safe(self):
data = {}
mock_response(self.session, data=data)
deleted = self.client.delete_collection(
'mycollection',
last_modified=1324,
safe=False)
assert deleted == data
url = '/buckets/mybucket/collections/mycollection'
self.session.request.assert_called_with('delete', url, headers=None)
def test_get_or_create_doesnt_raise_in_case_of_conflict(self):
data = {
'permissions': mock.sentinel.permissions,
'data': {'foo': 'bar'}
}
self.session.request.side_effect = [
get_http_error(status=412),
(data, None)
]
returned_data = self.client.create_collection(
bucket="buck",
collection="coll",
if_not_exists=True) # Should not raise.
assert returned_data == data
def test_get_or_create_raise_in_other_cases(self):
self.session.request.side_effect = get_http_error(status=500)
with self.assertRaises(KintoException):
self.client.create_collection(
bucket="buck",
collection="coll",
if_not_exists=True)
class FunctionalTest(unittest2.TestCase):
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 tearDown(self):
# Delete all the created objects
flush_url = urljoin(self.server_url, '/__flush__')
resp = requests.post(flush_url)
resp.raise_for_status()
def get_user_id(self, credentials):
hmac_secret = self.config.get('app:main', 'cliquet.userid_hmac_secret')
credentials = '%s:%s' % credentials
digest = cliquet_utils.hmac_digest(hmac_secret, credentials)
return 'basicauth:%s' % digest
def test_bucket_creation(self):
bucket = self.client.create_bucket('mozilla')
user_id = self.get_user_id(self.auth)
assert user_id in bucket['permissions']['write']
def test_bucket_creation_if_not_exists(self):
self.client.create_bucket('mozilla')
# Should not raise.
self.client.create_bucket('mozilla', if_not_exists=True)
def test_bucket_retrieval(self):
self.client.create_bucket('mozilla')
self.client.get_bucket('mozilla')
# XXX Add permissions handling during creation and check they are
# present during retrieval.
def test_bucket_retrieval_fails_when_not_created(self):
self.assertRaises(BucketNotFound, self.client.get_bucket,
'non-existent')
def test_bucket_deletion(self):
self.client.create_bucket('mozilla')
self.client.delete_bucket('mozilla')
self.assertRaises(BucketNotFound, self.client.get_bucket, 'mozilla')
def test_bucket_save(self):
self.client.create_bucket('mozilla', permissions={'write': ['alexis']})
bucket = self.client.get_bucket('mozilla')
assert 'alexis' in bucket['permissions']['write']
def test_collection_creation(self):
self.client.create_bucket('mozilla')
self.client.create_collection(
'payments', bucket='mozilla',
permissions={'write': ['alexis', ]}
)
# Test retrieval of a collection gets the permissions as well.
collection = self.client.get_collection('payments', bucket='mozilla')
assert 'alexis' in collection['permissions']['write']
def test_collection_creation_if_not_exists(self):
self.client.create_bucket('mozilla')
self.client.create_collection('payments', bucket='mozilla')
# Should not raise.
self.client.create_collection('payments', bucket='mozilla',
if_not_exists=True)
def test_collection_list(self):
self.client.create_bucket('mozilla')
self.client.create_collection('receipts', bucket='mozilla')
self.client.create_collection('assets', bucket='mozilla')
# The returned collections should be strings.
collections = self.client.get_collections('mozilla')
self.assertEquals(2, len(collections))
self.assertEquals(set([coll['id'] for coll in collections]),
set(['receipts', 'assets']))
def test_collection_deletion(self):
self.client.create_bucket('mozilla')
self.client.create_collection('payments', bucket='mozilla')
self.client.delete_collection('payments', bucket='mozilla')
assert len(self.client.get_collections(bucket='mozilla')) == 0
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_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_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_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 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_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_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_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_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')
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_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_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 test_request_batching(self):
with self.client.batch(bucket='mozilla', collection='fonts') as batch:
batch.create_bucket()
batch.create_collection()
batch.create_record(data={'foo': 'bar'},
permissions={'read': ['natim']})
batch.create_record(data={'bar': 'baz'},
permissions={'read': ['alexis']})
records = self.client.get_records(bucket='mozilla', collection='fonts')
assert len(records) == 2
def test_replication(self):
# First, create a few records on the first kinto collection.
with self.client.batch(bucket='origin', collection='coll') as batch:
batch.create_bucket()
batch.create_collection()
for n in range(10):
batch.create_record(data={'foo': 'bar', 'n': n})
origin = Client(
server_url=self.server_url,
auth=self.auth,
bucket='origin',
collection='coll'
)
destination = Client(
server_url=self.server_url,
auth=self.auth,
bucket='destination',
collection='coll')
replication.replicate(origin, destination)
records = self.client.get_records(bucket='destination',
collection='coll')
assert len(records) == 10
class CollectionTest(unittest.TestCase):
def setUp(self):
self.session = mock.MagicMock()
mock_response(self.session)
self.client = Client(session=self.session, bucket='mybucket')
def test_collection_names_are_slugified(self):
self.client.get_collection('my collection')
url = '/buckets/mybucket/collections/my-collection'
self.session.request.assert_called_with('get', url)
def test_collection_creation_issues_an_http_put(self):
self.client.create_collection('mycollection',
permissions=mock.sentinel.permissions)
url = '/buckets/mybucket/collections/mycollection'
self.session.request.assert_called_with(
'put',
url,
data=None,
permissions=mock.sentinel.permissions,
headers=DO_NOT_OVERWRITE)
def test_data_can_be_sent_on_creation(self):
self.client.create_collection('mycollection',
'testbucket',
data={'foo': 'bar'})
self.session.request.assert_called_with(
'put',
'/buckets/testbucket/collections/mycollection',
data={'foo': 'bar'},
permissions=None,
headers=DO_NOT_OVERWRITE)
def test_collection_update_issues_an_http_put(self):
self.client.update_collection({'foo': 'bar'},
collection='mycollection',
permissions=mock.sentinel.permissions)
url = '/buckets/mybucket/collections/mycollection'
self.session.request.assert_called_with(
'put',
url,
data={'foo': 'bar'},
permissions=mock.sentinel.permissions,
headers=None)
def test_update_handles_last_modified(self):
self.client.update_collection({'foo': 'bar'},
collection='mycollection',
last_modified=1234)
url = '/buckets/mybucket/collections/mycollection'
headers = {'If-Match': '"1234"'}
self.session.request.assert_called_with('put',
url,
data={'foo': 'bar'},
headers=headers,
permissions=None)
def test_collection_update_use_an_if_match_header(self):
data = {'foo': 'bar', 'last_modified': '1234'}
self.client.update_collection(data,
collection='mycollection',
permissions=mock.sentinel.permissions)
url = '/buckets/mybucket/collections/mycollection'
self.session.request.assert_called_with(
'put',
url,
data={
'foo': 'bar',
'last_modified': '1234'
},
permissions=mock.sentinel.permissions,
headers={'If-Match': '"1234"'})
def test_patch_collection_issues_an_http_patch(self):
self.client.patch_collection(collection='mycollection',
data={'key': 'secret'})
url = '/buckets/mybucket/collections/mycollection'
self.session.request.assert_called_with('patch',
url,
data={'key': 'secret'},
headers=None,
permissions=None)
def test_patch_collection_handles_last_modified(self):
self.client.patch_collection(collection='mycollection',
data={'key': 'secret'},
last_modified=1234)
url = '/buckets/mybucket/collections/mycollection'
headers = {'If-Match': '"1234"'}
self.session.request.assert_called_with('patch',
url,
data={'key': 'secret'},
headers=headers,
permissions=None)
def test_get_collections_returns_the_list_of_collections(self):
mock_response(self.session,
data=[
{
'id': 'foo',
'last_modified': '12345'
},
{
'id': 'bar',
'last_modified': '59874'
},
])
collections = self.client.get_collections(bucket='default')
assert list(collections) == [
{
'id': 'foo',
'last_modified': '12345'
},
{
'id': 'bar',
'last_modified': '59874'
},
]
def test_collection_can_delete_all_its_records(self):
self.client.delete_records(bucket='abucket', collection='acollection')
url = '/buckets/abucket/collections/acollection/records'
self.session.request.assert_called_with('delete', url, headers=None)
def test_delete_is_issued_on_list_deletion(self):
self.client.delete_collections(bucket='mybucket')
url = '/buckets/mybucket/collections'
self.session.request.assert_called_with('delete', url, headers=None)
def test_collection_can_be_deleted(self):
data = {}
mock_response(self.session, data=data)
deleted = self.client.delete_collection('mycollection')
assert deleted == data
url = '/buckets/mybucket/collections/mycollection'
self.session.request.assert_called_with('delete', url, headers=None)
def test_collection_delete_if_match(self):
data = {}
mock_response(self.session, data=data)
deleted = self.client.delete_collection('mycollection',
last_modified=1234)
assert deleted == data
url = '/buckets/mybucket/collections/mycollection'
self.session.request.assert_called_with('delete',
url,
headers={'If-Match': '"1234"'})
def test_collection_delete_if_match_not_included_if_not_safe(self):
data = {}
mock_response(self.session, data=data)
deleted = self.client.delete_collection('mycollection',
last_modified=1324,
safe=False)
assert deleted == data
url = '/buckets/mybucket/collections/mycollection'
self.session.request.assert_called_with('delete', url, headers=None)
def test_get_or_create_doesnt_raise_in_case_of_conflict(self):
data = {
'permissions': mock.sentinel.permissions,
'data': {
'foo': 'bar'
}
}
self.session.request.side_effect = [
get_http_error(status=412), (data, None)
]
returned_data = self.client.create_collection(
bucket="buck", collection="coll",
if_not_exists=True) # Should not raise.
assert returned_data == data
def test_get_or_create_raise_in_other_cases(self):
self.session.request.side_effect = get_http_error(status=500)
with self.assertRaises(KintoException):
self.client.create_collection(bucket="buck",
collection="coll",
if_not_exists=True)
class Kinto_Sync(unittest.TestCase):
"""
Tests that given two Kinto servers you can successfully sync data
from one to the other
"""
def setUp(self):
# Figure out what the IP address where the containers are running
f = os.popen('which docker-machine')
docker_machine = str(f.read()).strip()
if string.find(docker_machine, "/docker-machine") == -1:
print("Could not find docker-machine in our path")
exit()
f = os.popen('%s ip default' % docker_machine)
ip = str(f.read()).strip()
# Set our master and read-only end points and create our test bucket
self.master_url = "http://%s:8888/v1/" % ip
self.read_only_url = "http://%s:8889/v1/" % ip
self.credentials = ('testuser', 'abc123')
self.master = Client(server_url=self.master_url, auth=self.credentials)
self.read_only = Client(server_url=self.read_only_url,
auth=self.credentials)
self.bucket = self.get_timestamp()
self.master.create_bucket(self.bucket)
self.read_only.create_bucket(self.bucket)
def test_sync(self):
# Generate some random records
collection = self.get_timestamp()
self.master.create_collection(collection, bucket=self.bucket)
self.read_only.create_collection(collection, bucket=self.bucket)
for x in range(10):
self.read_only.create_record(data=self.generate_record(),
bucket=self.bucket,
collection=collection)
# Pause and generate some more random records on the master end-point
time.sleep(3)
for x in range(5):
self.master.create_record(data=self.generate_record(),
bucket=self.bucket,
collection=collection)
# Get the timestamp of our last record by doing an HTTP query of the
# read-only collection and grabbing the Etag value from the header
response = self.read_only.get_records(bucket=self.bucket,
collection=collection)
last_record = response[-1]
since = last_record['last_modified']
# Query the master using that value for all the records since that one
new_records = self.master.get_records(bucket=self.bucket,
collection=collection,
_since=since)
# Add those records to our read-only end-point
for data in new_records:
new_data = {
'internal_id': data['internal_id'],
'title': data['title']
}
self.read_only.create_record(data=new_data,
bucket=self.bucket,
collection=collection)
master_records = self.master.get_records(bucket=self.bucket,
collection=collection)
read_only_records = self.read_only.get_records(bucket=self.bucket,
collection=collection)
# We should have 5 records in master and 15 in read-only
self.assertEquals(5, len(master_records))
self.assertEquals(15, len(read_only_records))
# Clean up our collections
self.master.delete_collection(collection, bucket=self.bucket)
self.read_only.delete_collection(collection, bucket=self.bucket)
def test_update(self):
# Create ten records
collection = self.get_timestamp()
self.master.create_collection(collection, bucket=self.bucket)
self.read_only.create_collection(collection, bucket=self.bucket)
# Insert them into master
for x in range(10):
record = self.master.create_record(data=self.generate_record(),
collection=collection,
bucket=self.bucket)
# Replicate them over to the read-only instance
origin = dict(server_url=self.master_url,
auth=self.credentials,
bucket=self.bucket,
collection=collection)
destination = dict(server_url=self.read_only_url,
auth=self.credentials,
bucket=self.bucket,
collection=collection)
replication.replicate(origin, destination)
records = self.read_only.get_records(bucket=self.bucket,
collection=collection)
self.assertEquals(10, len(records))
# Change one record and update master
records = self.master.get_records(bucket=self.bucket,
collection=collection)
record = records[1]
record['title'] = 'Updated record'
updated_id = record['id']
self.master.update_record(record,
bucket=self.bucket,
collection=collection)
replication.replicate(origin, destination)
# Verify that the matched record was changed
record = self.read_only.get_record(updated_id,
bucket=self.bucket,
collection=collection)
self.assertEquals(updated_id, record['data']['id'])
# Verify that we have ten records in each system
self.assertEquals(
len(
self.master.get_records(bucket=self.bucket,
collection=collection)),
len(
self.read_only.get_records(bucket=self.bucket,
collection=collection)))
self.master.delete_collection(collection, bucket=self.bucket)
self.read_only.delete_collection(collection, bucket=self.bucket)
def get_timestamp(self):
n = time.time()
d = datetime.datetime.fromtimestamp(n)
return int(time.mktime(d.timetuple()))
def generate_record(self):
data = {'internal_id': self.get_timestamp(), 'title': 'Test Record'}
return data
class FunctionalTest(unittest2.TestCase):
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 tearDown(self):
# Delete all the created objects
flush_url = urljoin(self.server_url, '/__flush__')
resp = requests.post(flush_url)
resp.raise_for_status()
def get_user_id(self, credentials):
hmac_secret = self.config.get('app:main', 'kinto.userid_hmac_secret')
credentials = '%s:%s' % credentials
digest = cliquet_utils.hmac_digest(hmac_secret, credentials)
return 'basicauth:%s' % digest
def test_bucket_creation(self):
bucket = self.client.create_bucket('mozilla')
user_id = self.get_user_id(self.auth)
assert user_id in bucket['permissions']['write']
def test_bucket_creation_if_not_exists(self):
self.client.create_bucket('mozilla')
# Should not raise.
self.client.create_bucket('mozilla', if_not_exists=True)
def test_buckets_retrieval(self):
self.client.create_bucket('mozilla')
buckets = self.client.get_buckets()
assert len(buckets) == 1
def test_bucket_retrieval(self):
self.client.create_bucket('mozilla')
self.client.get_bucket('mozilla')
# XXX Add permissions handling during creation and check they are
# present during retrieval.
def test_bucket_modification(self):
bucket = self.client.create_bucket('mozilla', data={'version': 1})
assert bucket['data']['version'] == 1
bucket = self.client.patch_bucket('mozilla', data={'author': 'you'})
assert bucket['data']['version'] == 1
assert bucket['data']['author'] == 'you'
bucket = self.client.update_bucket('mozilla', data={'date': 'today'})
assert bucket['data']['date'] == 'today'
assert 'version' not in bucket['data']
def test_bucket_retrieval_fails_when_not_created(self):
self.assertRaises(BucketNotFound, self.client.get_bucket,
'non-existent')
def test_bucket_deletion(self):
self.client.create_bucket('mozilla')
self.client.delete_bucket('mozilla')
self.assertRaises(BucketNotFound, self.client.get_bucket, 'mozilla')
def test_buckets_deletion(self):
self.client.create_bucket('mozilla')
buckets = self.client.delete_buckets()
assert buckets[0]['id'] == 'mozilla'
self.assertRaises(BucketNotFound, self.client.get_bucket, 'mozilla')
def test_bucket_save(self):
self.client.create_bucket('mozilla', permissions={'write': ['alexis']})
bucket = self.client.get_bucket('mozilla')
assert 'alexis' in bucket['permissions']['write']
def test_collection_creation(self):
self.client.create_bucket('mozilla')
self.client.create_collection('payments',
bucket='mozilla',
permissions={'write': [
'alexis',
]})
# Test retrieval of a collection gets the permissions as well.
collection = self.client.get_collection('payments', bucket='mozilla')
assert 'alexis' in collection['permissions']['write']
def test_collection_creation_if_not_exists(self):
self.client.create_bucket('mozilla')
self.client.create_collection('payments', bucket='mozilla')
# Should not raise.
self.client.create_collection('payments',
bucket='mozilla',
if_not_exists=True)
def test_collection_list(self):
self.client.create_bucket('mozilla')
self.client.create_collection('receipts', bucket='mozilla')
self.client.create_collection('assets', bucket='mozilla')
# The returned collections should be strings.
collections = self.client.get_collections('mozilla')
self.assertEquals(2, len(collections))
self.assertEquals(set([coll['id'] for coll in collections]),
set(['receipts', 'assets']))
def test_collection_deletion(self):
self.client.create_bucket('mozilla')
self.client.create_collection('payments', bucket='mozilla')
self.client.delete_collection('payments', bucket='mozilla')
assert len(self.client.get_collections(bucket='mozilla')) == 0
def test_collections_deletion(self):
self.client.create_bucket('mozilla')
self.client.create_collection('amo', bucket='mozilla')
self.client.create_collection('blocklist', bucket='mozilla')
self.client.delete_collections(bucket='mozilla')
assert len(self.client.get_collections(bucket='mozilla')) == 0
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_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_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_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 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_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_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_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_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')
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_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_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 test_request_batching(self):
with self.client.batch(bucket='mozilla', collection='fonts') as batch:
batch.create_bucket()
batch.create_collection()
batch.create_record(data={'foo': 'bar'},
permissions={'read': ['natim']})
batch.create_record(data={'bar': 'baz'},
permissions={'read': ['alexis']})
records = self.client.get_records(bucket='mozilla', collection='fonts')
assert len(records) == 2
def test_replication(self):
# First, create a few records on the first kinto collection.
with self.client.batch(bucket='origin', collection='coll') as batch:
batch.create_bucket()
batch.create_collection()
for n in range(10):
batch.create_record(data={'foo': 'bar', 'n': n})
origin = Client(server_url=self.server_url,
auth=self.auth,
bucket='origin',
collection='coll')
destination = Client(server_url=self.server_url,
auth=self.auth,
bucket='destination',
collection='coll')
replication.replicate(origin, destination)
records = self.client.get_records(bucket='destination',
collection='coll')
assert len(records) == 10
class FunctionalTest(unittest2.TestCase):
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 tearDown(self):
# Delete all the created objects
flush_url = urljoin(self.server_url, "/__flush__")
resp = requests.post(flush_url)
resp.raise_for_status()
def get_user_id(self, credentials):
hmac_secret = self.config.get("app:main", "kinto.userid_hmac_secret")
credentials = "%s:%s" % credentials
digest = cliquet_utils.hmac_digest(hmac_secret, credentials)
return "basicauth:%s" % digest
def test_bucket_creation(self):
bucket = self.client.create_bucket("mozilla")
user_id = self.get_user_id(self.auth)
assert user_id in bucket["permissions"]["write"]
def test_bucket_creation_if_not_exists(self):
self.client.create_bucket("mozilla")
# Should not raise.
self.client.create_bucket("mozilla", if_not_exists=True)
def test_buckets_retrieval(self):
self.client.create_bucket("mozilla")
buckets = self.client.get_buckets()
assert len(buckets) == 1
def test_bucket_retrieval(self):
self.client.create_bucket("mozilla")
self.client.get_bucket("mozilla")
# XXX Add permissions handling during creation and check they are
# present during retrieval.
def test_bucket_modification(self):
bucket = self.client.create_bucket("mozilla", data={"version": 1})
assert bucket["data"]["version"] == 1
bucket = self.client.patch_bucket("mozilla", data={"author": "you"})
assert bucket["data"]["version"] == 1
assert bucket["data"]["author"] == "you"
bucket = self.client.update_bucket("mozilla", data={"date": "today"})
assert bucket["data"]["date"] == "today"
assert "version" not in bucket["data"]
def test_bucket_retrieval_fails_when_not_created(self):
self.assertRaises(BucketNotFound, self.client.get_bucket, "non-existent")
def test_bucket_deletion(self):
self.client.create_bucket("mozilla")
self.client.delete_bucket("mozilla")
self.assertRaises(BucketNotFound, self.client.get_bucket, "mozilla")
def test_buckets_deletion(self):
self.client.create_bucket("mozilla")
buckets = self.client.delete_buckets()
assert buckets[0]["id"] == "mozilla"
self.assertRaises(BucketNotFound, self.client.get_bucket, "mozilla")
def test_bucket_save(self):
self.client.create_bucket("mozilla", permissions={"write": ["alexis"]})
bucket = self.client.get_bucket("mozilla")
assert "alexis" in bucket["permissions"]["write"]
def test_collection_creation(self):
self.client.create_bucket("mozilla")
self.client.create_collection("payments", bucket="mozilla", permissions={"write": ["alexis"]})
# Test retrieval of a collection gets the permissions as well.
collection = self.client.get_collection("payments", bucket="mozilla")
assert "alexis" in collection["permissions"]["write"]
def test_collection_creation_if_not_exists(self):
self.client.create_bucket("mozilla")
self.client.create_collection("payments", bucket="mozilla")
# Should not raise.
self.client.create_collection("payments", bucket="mozilla", if_not_exists=True)
def test_collection_list(self):
self.client.create_bucket("mozilla")
self.client.create_collection("receipts", bucket="mozilla")
self.client.create_collection("assets", bucket="mozilla")
# The returned collections should be strings.
collections = self.client.get_collections("mozilla")
self.assertEquals(2, len(collections))
self.assertEquals(set([coll["id"] for coll in collections]), set(["receipts", "assets"]))
def test_collection_deletion(self):
self.client.create_bucket("mozilla")
self.client.create_collection("payments", bucket="mozilla")
self.client.delete_collection("payments", bucket="mozilla")
assert len(self.client.get_collections(bucket="mozilla")) == 0
def test_collections_deletion(self):
self.client.create_bucket("mozilla")
self.client.create_collection("amo", bucket="mozilla")
self.client.create_collection("blocklist", bucket="mozilla")
self.client.delete_collections(bucket="mozilla")
assert len(self.client.get_collections(bucket="mozilla")) == 0
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_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_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_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 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_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_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_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_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")
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_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_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 test_request_batching(self):
with self.client.batch(bucket="mozilla", collection="fonts") as batch:
batch.create_bucket()
batch.create_collection()
batch.create_record(data={"foo": "bar"}, permissions={"read": ["natim"]})
batch.create_record(data={"bar": "baz"}, permissions={"read": ["alexis"]})
records = self.client.get_records(bucket="mozilla", collection="fonts")
assert len(records) == 2
def test_replication(self):
# First, create a few records on the first kinto collection.
with self.client.batch(bucket="origin", collection="coll") as batch:
batch.create_bucket()
batch.create_collection()
for n in range(10):
batch.create_record(data={"foo": "bar", "n": n})
origin = Client(server_url=self.server_url, auth=self.auth, bucket="origin", collection="coll")
destination = Client(server_url=self.server_url, auth=self.auth, bucket="destination", collection="coll")
replication.replicate(origin, destination)
records = self.client.get_records(bucket="destination", collection="coll")
assert len(records) == 10
