async def test_write_large_blob_data(db, guillotina_main):
root = get_utility(IApplication, name='root')
db = root['db']
request = get_mocked_request(db)
login(request)
async with managed_transaction(request=request):
container = await db.async_get('container')
if container is None:
container = await create_content_in_container(
db, 'Container', 'container', request=request,
title='Container')
blob = Blob(container)
container.blob = blob
multiplier = 999999
blobfi = blob.open('w')
await blobfi.async_write(b'foobar' * multiplier)
async with managed_transaction(request=request):
container = await db.async_get('container')
assert await container.blob.open().async_read() == (b'foobar' * multiplier)
assert container.blob.size == len(b'foobar' * multiplier)
assert container.blob.chunks == 6
await db.async_del('container')
async def test_navigator_preload(container_requester):
async with container_requester as requester:
response, status = await requester(
'POST',
'/db/guillotina/',
data=json.dumps({
"@type": "Item",
"title": "Item1",
"id": "item1"
}))
assert status == 201
request = get_mocked_request(requester.db)
root = await get_root(request)
txn = await request._tm.begin(request)
container = await root.async_get('guillotina')
item1 = await container.async_get('item1')
item1.title = "Item1bis"
txn.register(item1)
nav = Navigator(txn, container)
item1_bis = await nav.get('/item1')
assert item1_bis.title == 'Item1bis'
assert item1_bis is item1
await request._tm.abort(txn=txn)
def transaction(self, request=None):
if request is None:
request = get_mocked_request(self.db)
login(request)
return wrap_request(
request, managed_transaction(
request=request, write=True, adopt_parent_txn=True))
async def test_create_annotation(db, guillotina_main):
root = get_utility(IApplication, name='root')
db = root['db']
request = get_mocked_request(db)
login(request)
async with managed_transaction(request=request, write=True):
container = await create_content_in_container(
db, 'Container', 'container', request=request,
title='Container')
ob = await create_content_in_container(
container, 'Item', 'foobar', request=request)
annotations = IAnnotations(ob)
data = AnnotationData()
data['foo'] = 'bar'
await annotations.async_set('foobar', data)
async with managed_transaction(request=request, write=True):
container = await db.async_get('container')
ob = await container.async_get('foobar')
annotations = IAnnotations(ob)
assert 'foobar' in (await annotations.async_keys())
await annotations.async_del('foobar')
async with managed_transaction(request=request, write=True):
container = await db.async_get('container')
ob = await container.async_get('foobar')
annotations = IAnnotations(ob)
assert 'foobar' not in (await annotations.async_keys())
await container.async_del('foobar')
await db.async_del('container')
async def test_object_utils(container_requester):
async with container_requester as requester:
response, status = await requester(
'POST',
'/db/guillotina/',
data=json.dumps({
"@type": "Item",
"title": "Item1",
"id": "item1"
}))
assert status == 201
request = get_mocked_request(requester.db)
root = await get_root(request)
txn = await request._tm.begin(request)
container = await root.async_get('guillotina')
ob = await utils.get_object_by_oid(response['@uid'], txn)
assert ob is not None
assert ob._p_oid == response['@uid']
ob2 = await utils.navigate_to(container, 'item1')
assert ob2._p_oid == ob._p_oid
url = utils.get_object_url(ob, request)
assert url.endswith('item1')
await request._tm.abort(txn=txn)
def __init__(self, db, user=RootUser('root')):
self.db = db
self.tm = db.get_transaction_manager()
self.request = get_mocked_request()
self.user = user
self.request._tm = self.tm
self.request._db_id = db.id
self._active_txn = None
def dummy_request(dummy_guillotina, monkeypatch):
from guillotina.interfaces import IApplication
from guillotina.component import get_utility
root = get_utility(IApplication, name='root')
db = root['db']
request = get_mocked_request(db)
return request
async def run2():
ob = test_utils.create_content()
req = test_utils.get_mocked_request()
start = time.time()
print('Test multi adapter')
for _ in range(ITERATIONS):
get_multi_adapter((ob, req), IResourceDeserializeFromJson)
end = time.time()
print(f'Done with {ITERATIONS} in {end - start} seconds')
async def test_multi_upload(container_requester):
async with container_requester as requester:
response, status = await requester(
'POST',
'/db/guillotina/',
data=json.dumps({
'@type': 'Item',
'@behaviors': [IMultiAttachment.__identifier__],
'id': 'foobar'
})
)
assert status == 201
response, status = await requester(
'PATCH',
'/db/guillotina/foobar/@upload/files/key1',
data=b'X' * 1024 * 1024 * 10,
headers={
'x-upload-size': str(1024 * 1024 * 10)
}
)
assert status == 200
response, status = await requester(
'PATCH',
'/db/guillotina/foobar/@upload/files/key2',
data=b'Y' * 1024 * 1024 * 10,
headers={
'x-upload-size': str(1024 * 1024 * 10)
}
)
assert status == 200
response, status = await requester(
'GET',
'/db/guillotina/foobar/@download/files/key1'
)
assert status == 200
assert response == b'X' * 1024 * 1024 * 10
response, status = await requester(
'GET',
'/db/guillotina/foobar/@download/files/key2'
)
assert status == 200
assert response == b'Y' * 1024 * 1024 * 10
request = utils.get_mocked_request(requester.db)
root = await utils.get_root(request)
async with managed_transaction(request=request, abort_when_done=True):
container = await root.async_get('guillotina')
obj = await container.async_get('foobar')
behavior = IMultiAttachment(obj)
await behavior.load()
assert behavior.files['key1']._blob.chunks == 2
assert behavior.files['key2']._blob.chunks == 2
async def get_content(self, path):
server = get_server()
app = server['app']
root = app.root
request = get_mocked_request()
path = path.split('?')[0]
path = tuple(p for p in path.split('/') if p)
ob, tail = await traverse(request, root, path)
await abort(request)
return ob, tail
def convert_interfaces_to_schema(interfaces):
properties = {}
try:
request = get_current_request()
except RequestNotFound:
from guillotina.tests.utils import get_mocked_request
request = get_mocked_request()
for iface in interfaces:
serializer = get_multi_adapter(
(iface, request), ISchemaSerializeToJson)
properties[iface.__identifier__] = serializer.serialize()
return properties
def convert_interfaces_to_schema(interfaces):
properties = {}
try:
request = get_current_request()
except RequestNotFound:
from guillotina.tests.utils import get_mocked_request
request = get_mocked_request()
for iface in interfaces:
serializer = get_multi_adapter((iface, request),
ISchemaSerializeToJson)
properties[iface.__identifier__] = serializer.serialize()
return properties
async def test_put_content(container_requester):
async with container_requester as requester:
data = 'WFhY' * 1024 + 'WA=='
_, status = await requester('POST',
'/db/guillotina/',
data=json.dumps({
"@type":
"Item",
"title":
"Item1",
"id":
"item1",
"@behaviors":
[IAttachment.__identifier__],
IDublinCore.__identifier__: {
"title": "foo",
"description": "bar",
"tags": ["one", "two"]
},
IAttachment.__identifier__: {
'file': {
'filename': 'foobar.jpg',
'content-type': 'image/jpeg',
'encoding': 'base64',
'data': data
}
}
}))
assert status == 201
_, status = await requester('PUT',
'/db/guillotina/item1',
data=json.dumps({
"@behaviors":
[IAttachment.__identifier__],
IDublinCore.__identifier__: {
"title": "foobar"
}
}))
resp, status = await requester('GET', '/db/guillotina/item1')
assert resp[IDublinCore.__identifier__]['tags'] is None
assert resp[IAttachment.__identifier__]['file'] is None
request = utils.get_mocked_request(requester.db)
root = await utils.get_root(request)
async with managed_transaction(request=request, abort_when_done=True):
container = await root.async_get('guillotina')
obj = await container.async_get('item1')
assert obj.title == 'foobar'
with pytest.raises(AttributeError):
obj.description
async def test_tus(container_requester):
async with await container_requester as requester:
response, status = await requester(
'POST',
'/db/guillotina/',
data=json.dumps({
'@type':
'Item',
'@behaviors': ['guillotina.behaviors.attachment.IAttachment'],
'id':
'foobar'
}))
assert status == 201
response, status = await requester(
'POST',
'/db/guillotina/foobar/@tusupload/file',
headers={
'UPLOAD-LENGTH': str(1024 * 1024 * 10),
'TUS-RESUMABLE': '1.0.0'
})
assert status == 201
for idx in range(10):
# 10, 1mb chunks
response, status = await requester(
'PATCH',
'/db/guillotina/foobar/@tusupload/file',
headers={
'CONTENT-LENGTH': str(1024 * 1024 * 1),
'TUS-RESUMABLE': '1.0.0',
'upload-offset': str(1024 * 1024 * idx)
},
data=b'X' * 1024 * 1024 * 1)
assert status == 200
response, status = await requester(
'GET', '/db/guillotina/foobar/@download/file')
assert status == 200
assert len(response) == (1024 * 1024 * 10)
request = utils.get_mocked_request(requester.db)
root = await utils.get_root(request)
async with managed_transaction(request=request, abort_when_done=True):
container = await root.async_get('guillotina')
obj = await container.async_get('foobar')
behavior = IAttachment(obj)
await behavior.load()
assert behavior.file._blob.chunks == 10
async def test_create_contenttype(site_requester):
async with await site_requester as requester:
response, status = await requester('POST',
'/db/guillotina/',
data=json.dumps({
"@type": "Item",
"title": "Item1",
"id": "item1"
}))
assert status == 201
request = utils.get_mocked_request(requester.db)
root = await utils.get_root(request)
site = await root.async_get('guillotina')
obj = await site.async_get('item1')
assert obj.title == 'Item1'
async def test_copy_file_ob(manager_type, redis_container,
container_requester):
async with container_requester as requester:
_, status = await requester(
"POST",
"/db/guillotina/",
data=json.dumps({
"@type": "Item",
"@behaviors": [IAttachment.__identifier__],
"id": "foobar"
}),
)
assert status == 201
data = chunked_stream_gen(b"X",
chunk_size=1024 * 1024 * 4,
total_size=1024 * 1024 * 4)
response, status = await requester(
"PATCH",
"/db/guillotina/foobar/@upload/file",
data=data,
headers={"x-upload-size": str(1024 * 1024 * 4)},
)
assert status == 200
async with transaction(db=requester.db, abort_when_done=True) as txn:
root = await txn.manager.get_root(txn)
container = await root.async_get("guillotina")
task_vars.container.set(container)
request = utils.get_mocked_request(db=requester.db)
with request:
obj = await container.async_get("foobar")
attachment = IAttachment(obj)
await attachment.load()
if manager_type == "db":
existing_id = attachment.file._blob.bid
else:
existing_id = attachment.file.uri
cfm = get_multi_adapter(
(obj, request, IAttachment["file"].bind(attachment)),
IFileManager)
from_cfm = get_multi_adapter(
(obj, request, IAttachment["file"].bind(attachment)),
IFileManager)
await cfm.copy(from_cfm)
if manager_type == "db":
assert existing_id != attachment.file._blob.bid
else:
assert existing_id != attachment.file.uri
async def test_create_content(container_requester):
async with container_requester as requester:
_, status = await requester('POST',
'/db/guillotina/',
data=json.dumps({
"@type": "Item",
"title": "Item1",
"id": "item1"
}))
assert status == 201
request = utils.get_mocked_request(requester.db)
root = await utils.get_root(request)
async with managed_transaction(request=request, abort_when_done=True):
container = await root.async_get('guillotina')
obj = await container.async_get('item1')
assert obj.title == 'Item1'
async def test_sharing_prinrole(container_requester):
async with container_requester as requester:
response, status = await requester(
"POST",
"/db/guillotina/@sharing",
data=json.dumps(
{"prinrole": [{"principal": "user1", "role": "guillotina.Reader", "setting": "AllowSingle"}]}
),
)
assert status == 200
request = utils.get_mocked_request(db=requester.db) # noqa
root = await utils.get_root(db=requester.db)
async with transaction(abort_when_done=True):
container = await root.async_get("guillotina")
assert "user1" in container.__acl__["prinrole"]._bycol
async def runit(type_name):
print(f"Test content serialization with {type_name}")
request = get_mocked_request()
txn = mocks.MockTransaction()
ob = await create_content(type_name, id="foobar")
ob.__txn__ = txn
deserializer = get_multi_adapter((ob, request),
IResourceDeserializeFromJson)
tags = []
for l1 in string.ascii_letters:
tags.append(l1)
for l2 in string.ascii_letters:
tags.append(l1 + l2)
# for l3 in string.ascii_letters:
# tags.append(l1 + l2 + l3)
print(f"{len(tags)} tags")
data = {
"title": "Foobar",
"guillotina.behaviors.dublincore.IDublinCore": {
"tags":
tags,
"creation_date":
"2020-01-02T19:07:48.748922Z",
"effective_date":
"2020-01-02T19:07:48.748922Z",
"expiration_date":
"2020-01-02T19:07:48.748922Z",
"creators": [
"".join(i)
for i in zip(string.ascii_letters, string.ascii_letters)
],
},
"measures.configuration.ITestBehavior1": {
"foobar": "123"
},
"measures.configuration.ITestBehavior2": {
"foobar": "123"
},
"measures.configuration.ITestBehavior3": {
"foobar": "123"
},
}
start = time.time()
for _ in range(ITERATIONS):
await deserializer(data, validate_all=True)
end = time.time()
print(f"Done with {ITERATIONS} in {end - start} seconds")
async def test_retry_on_txn_not_finished(guillotina):
util = get_utility(IQueueUtility)
var = []
async def printHi(msg):
await asyncio.sleep(0.01)
var.append(msg)
request = utils.get_mocked_request(db=guillotina.db)
root = await utils.get_root(db=guillotina.db)
async with transaction(db=guillotina.db):
await util.add(AsyncMockView(root, request, printHi, "hola1"))
await asyncio.sleep(0.05)
await util._queue.join()
assert "hola1" in var
assert len(var) == 1
async def test_gcr_memory(self):
self.request = get_mocked_request()
count = 0
current = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024.0 / 1024.0
while True:
count += 1
utils.get_current_request()
if count % 1000000 == 0:
break
if count % 100000 == 0:
gc.collect()
new = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024.0 / 1024.0
if new - current > 10: # memory leak, this shouldn't happen
assert new == current
async def test_multi_upload(manager_type, redis_container,
container_requester):
async with container_requester as requester:
response, status = await requester(
'POST',
'/db/guillotina/',
data=json.dumps({
'@type': 'Item',
'@behaviors': [IMultiAttachment.__identifier__],
'id': 'foobar'
}))
assert status == 201
response, status = await requester(
'PATCH',
'/db/guillotina/foobar/@upload/files/key1',
data=b'X' * 1024 * 1024 * 10,
headers={'x-upload-size': str(1024 * 1024 * 10)})
assert status == 200
response, status = await requester(
'PATCH',
'/db/guillotina/foobar/@upload/files/key2',
data=b'Y' * 1024 * 1024 * 10,
headers={'x-upload-size': str(1024 * 1024 * 10)})
assert status == 200
response, status = await requester(
'GET', '/db/guillotina/foobar/@download/files/key1')
assert status == 200
assert response == b'X' * 1024 * 1024 * 10
response, status = await requester(
'GET', '/db/guillotina/foobar/@download/files/key2')
assert status == 200
assert response == b'Y' * 1024 * 1024 * 10
request = utils.get_mocked_request(db=requester.db)
root = await utils.get_root(request)
async with transaction(db=requester.db, abort_when_done=True):
container = await root.async_get('guillotina')
obj = await container.async_get('foobar')
behavior = IMultiAttachment(obj)
await behavior.load()
assert behavior.files['key1'].chunks == 2
assert behavior.files['key2'].chunks == 2
async def test_copy_file_ob(manager_type, redis_container,
container_requester):
async with container_requester as requester:
_, status = await requester('POST',
'/db/guillotina/',
data=json.dumps({
'@type':
'Item',
'@behaviors':
[IAttachment.__identifier__],
'id':
'foobar'
}))
assert status == 201
response, status = await requester(
'PATCH',
'/db/guillotina/foobar/@upload/file',
data=b'X' * 1024 * 1024 * 4,
headers={'x-upload-size': str(1024 * 1024 * 4)})
assert status == 200
async with transaction(db=requester.db, abort_when_done=True) as txn:
root = await txn.manager.get_root(txn)
container = await root.async_get('guillotina')
task_vars.container.set(container)
request = utils.get_mocked_request(db=requester.db)
with request:
obj = await container.async_get('foobar')
attachment = IAttachment(obj)
await attachment.load()
if manager_type == 'db':
existing_id = attachment.file._blob.bid
else:
existing_id = attachment.file.uri
cfm = get_multi_adapter(
(obj, request, IAttachment['file'].bind(attachment)),
IFileManager)
from_cfm = get_multi_adapter(
(obj, request, IAttachment['file'].bind(attachment)),
IFileManager)
await cfm.copy(from_cfm)
if manager_type == 'db':
assert existing_id != attachment.file._blob.bid
else:
assert existing_id != attachment.file.uri
async def test_get_content_depth(container_requester):
async with container_requester as requester:
response, status = await requester('POST',
'/db/guillotina/',
data=json.dumps({
"@type": "Item",
"title": "Item1",
"id": "item1"
}))
assert status == 201
request = get_mocked_request(requester.db)
root = await get_root(request)
txn = await request._tm.begin(request)
container = await root.async_get('guillotina')
obj = await container.async_get('item1')
assert utils.get_content_depth(container) == 1
assert utils.get_content_depth(obj) == 2
await request._tm.abort(txn=txn)
async def test_apply_cors(guillotina_main):
request = get_mocked_request()
resp = Response(
headers={
"Access-Control-Allow-Origin": "http://localhost:8080",
"Access-Control-Allow-Methods": "GET, PUT, PATCH",
"Access-Control-Expose-Headers": "Location",
"Location": "/test",
}
)
resp = await _apply_cors(request, resp)
assert resp.headers["Access-Control-Allow-Origin"] == "http://localhost:8080"
assert resp.headers["Access-Control-Allow-Methods"] == "GET, POST, PUT, PATCH"
assert resp.headers["Access-Control-Allow-Headers"] == "*"
assert resp.headers["Access-Control-Expose-Headers"] == "*"
assert resp.headers["Access-Control-Allow-Credentials"] == "true"
assert resp.headers["Access-Control-Max-Age"] == "3660"
assert resp.headers["Location"] == "/test"
async def test_get_content_depth(container_requester):
async with container_requester as requester:
response, status = await requester(
'POST',
'/db/guillotina/',
data=json.dumps({
"@type": "Item",
"title": "Item1",
"id": "item1"
}))
assert status == 201
request = get_mocked_request(requester.db)
root = await get_root(request)
txn = await request._tm.begin(request)
container = await root.async_get('guillotina')
obj = await container.async_get('item1')
assert utils.get_content_depth(container) == 1
assert utils.get_content_depth(obj) == 2
await request._tm.abort(txn=txn)
async def test_create_blob(db, guillotina_main):
root = get_utility(IApplication, name='root')
db = root['db']
request = get_mocked_request(db)
login(request)
async with managed_transaction(request=request):
container = await create_content_in_container(
db, 'Container', 'container', request=request,
title='Container')
blob = Blob(container)
container.blob = blob
async with managed_transaction(request=request):
container = await db.async_get('container')
assert blob.bid == container.blob.bid
assert blob.resource_zoid == container._p_oid
await db.async_del('container')
async def test_get_behavior(container_requester):
async with container_requester as requester:
response, status = await requester('POST',
'/db/guillotina/',
data=json.dumps({
"@type": "Item",
"title": "Item1",
"id": "item1"
}))
assert status == 201
request = get_mocked_request(requester.db)
root = await get_root(request)
txn = await request._tm.begin(request)
container = await root.async_get('guillotina')
item1 = await container.async_get('item1')
behavior = await get_behavior(item1, IDublinCore)
assert behavior is not None
await request._tm.abort(txn=txn)
async def test_create_blob(postgres, guillotina_main):
root = get_utility(IApplication, name='root')
db = root['db']
request = get_mocked_request(db)
login(request)
async with managed_transaction(request=request):
container = await create_content_in_container(
db, 'Container', 'container', request=request,
title='Container')
blob = Blob(container)
container.blob = blob
async with managed_transaction(request=request):
container = await db.async_get('container')
assert blob.bid == container.blob.bid
assert blob.resource_zoid == container._p_oid
await db.async_del('container')
def get_service_definition(self, resource, tail):
if tail and len(tail) > 0:
# convert match lookups
view_name = routes.path_to_view_name(tail)
elif not tail:
view_name = ''
else:
return None
request = get_mocked_request()
method = (self.options.get('method') or 'get').upper()
method = app_settings['http_methods'][method]
# container registry lookup
try:
view = query_multi_adapter(
(resource, request), method, name=view_name)
return view.__route__.service_configuration
except AttributeError:
pass
def get_service_definition(self, resource, tail):
if tail and len(tail) > 0:
# convert match lookups
view_name = routes.path_to_view_name(tail)
elif not tail:
view_name = ''
else:
return None
request = get_mocked_request()
method = (self.options.get('method') or 'get').upper()
method = app_settings['http_methods'][method]
# container registry lookup
try:
view = query_multi_adapter(
(resource, request), method, name=view_name)
return view.__route__.service_configuration
except AttributeError:
pass
async def test_get_behavior(container_requester):
async with container_requester as requester:
response, status = await requester(
'POST',
'/db/guillotina/',
data=json.dumps({
"@type": "Item",
"title": "Item1",
"id": "item1"
}))
assert status == 201
request = get_mocked_request(requester.db)
root = await get_root(request)
txn = await request._tm.begin(request)
container = await root.async_get('guillotina')
item1 = await container.async_get('item1')
behavior = await get_behavior(item1, IDublinCore)
assert behavior is not None
await request._tm.abort(txn=txn)
async def run_consumer(self, worker, consumer, worker_conf):
"""
Run the consumer in a way that makes sure we exit
if the consumer throws an error
"""
request = get_mocked_request()
login()
task_vars.request.set(request)
try:
await worker(consumer, request, worker_conf, app_settings)
except Exception:
logger.error("Error running consumer", exc_info=True)
finally:
util = get_utility(IKafkaProducerUtility)
try:
await util.stop_active_consumers()
except Exception:
pass
os._exit(1)
async def _run_worker(self, arguments, settings, app, loop=None):
self.request = get_mocked_request()
task_vars.request.set(self.request)
loop = loop or self.get_loop()
# Run the actual worker in the same loop
worker = Worker(self.request, loop, arguments.max_running_tasks)
await worker.start()
timeout = arguments.auto_kill_timeout
if timeout > 0:
loop.create_task(loop_probe(loop))
# We need to run this outside the main loop and the current thread
threading.Timer(timeout / 4, loop_check, args=[loop,
timeout]).start()
while True:
# make this run forever...
await asyncio.sleep(999999)
async def test_apply_recursive(command_arguments, hive_requester):
async with hive_requester as requester:
_, status = await requester(
'POST',
'/db/guillotina/',
data=json.dumps({
'@type': 'Folder',
'title': 'Folder',
'id': 'folder'
})
)
assert status == 201
_, status = await requester(
'POST',
'/db/guillotina/folder',
data=json.dumps({
'@type': 'Item',
'title': 'Item',
'id': 'item'
})
)
assert status == 201
request = get_mocked_request(requester.db)
root = await get_root(request)
await request._tm.begin(request)
container = await root.async_get('guillotina')
request.container = container
# now do it with tasks...
apply_function.__class__.__name__ = 'apply_function' # to dump func
task = create_apply_task(
'apply-recursive', container, apply_function, request)
command_arguments.payload = task.serialize()
command_arguments.task_id = None
command_arguments.tags = []
wc = WorkerCommand(command_arguments)
await wc.run(command_arguments, app_settings, None)
assert len(apply_function.calls) == 4
assert apply_function.calls[0]['args'][0]._p_oid == container._p_oid
async def test_add_sync_utility(guillotina, loop):
util = get_utility(IQueueUtility)
var = []
async def printHi(msg):
await asyncio.sleep(0.01)
var.append(msg)
request = utils.get_mocked_request(db=guillotina.db)
root = await utils.get_root(db=guillotina.db)
await util.add(AsyncMockView(root, request, printHi, "hola1"))
await util.add(AsyncMockView(root, request, printHi, "hola2"))
await util.add(AsyncMockView(root, request, printHi, "hola3"))
await util.add(AsyncMockView(root, request, printHi, "hola4"))
await util._queue.join()
assert "hola1" in var
assert "hola2" in var
assert "hola3" in var
assert "hola4" in var
assert len(var) == 4
async def test_add_sync_utility(guillotina, loop):
util = get_utility(IQueueUtility)
var = []
async def printHi(msg):
asyncio.sleep(0.01)
var.append(msg)
request = utils.get_mocked_request(guillotina.db)
root = await utils.get_root(request)
await util.add(AsyncMockView(root, request, printHi, 'hola1'))
await util.add(AsyncMockView(root, request, printHi, 'hola2'))
await util.add(AsyncMockView(root, request, printHi, 'hola3'))
await util.add(AsyncMockView(root, request, printHi, 'hola4'))
await util._queue.join()
assert 'hola1' in var
assert 'hola2' in var
assert 'hola3' in var
assert 'hola4' in var
assert len(var) == 4
async def test_add_sync_utility(guillotina, loop):
util = get_utility(IQueueUtility)
var = []
async def printHi(msg):
await asyncio.sleep(0.01)
var.append(msg)
request = utils.get_mocked_request(guillotina.db)
root = await utils.get_root(request)
await util.add(AsyncMockView(root, request, printHi, 'hola1'))
await util.add(AsyncMockView(root, request, printHi, 'hola2'))
await util.add(AsyncMockView(root, request, printHi, 'hola3'))
await util.add(AsyncMockView(root, request, printHi, 'hola4'))
await util._queue.join()
assert 'hola1' in var
assert 'hola2' in var
assert 'hola3' in var
assert 'hola4' in var
assert len(var) == 4
async def test_sharing_prinrole(container_requester):
async with container_requester as requester:
response, status = await requester('POST',
'/db/guillotina/@sharing',
data=json.dumps({
'prinrole': [{
'principal':
'user1',
'role':
'guillotina.Reader',
'setting':
'AllowSingle'
}]
}))
assert status == 200
request = utils.get_mocked_request(db=requester.db)
root = await utils.get_root(request)
async with transaction(abort_when_done=True):
container = await root.async_get('guillotina')
assert 'user1' in container.__acl__['prinrole']._bycol
async def test_sharing_roleperm(container_requester):
async with container_requester as requester:
response, status = await requester('POST',
'/db/guillotina/@sharing',
data=json.dumps({
'roleperm': [{
'permission':
'guillotina.ViewContent',
'role':
'guillotina.Reader',
'setting':
'AllowSingle'
}]
}))
assert status == 200
request = utils.get_mocked_request(requester.db)
root = await utils.get_root(request)
async with managed_transaction(request=request, abort_when_done=True):
container = await root.async_get('guillotina')
assert 'guillotina.Reader' in container.__acl__['roleperm']._bycol
async def test_copy_file_ob(container_requester):
async with container_requester as requester:
_, status = await requester(
'POST',
'/db/guillotina/',
data=json.dumps({
'@type': 'Item',
'@behaviors': [IAttachment.__identifier__],
'id': 'foobar'
})
)
assert status == 201
response, status = await requester(
'PATCH',
'/db/guillotina/foobar/@upload/file',
data=b'X' * 1024 * 1024 * 4,
headers={
'x-upload-size': str(1024 * 1024 * 4)
}
)
assert status == 200
request = utils.get_mocked_request(requester.db)
root = await utils.get_root(request)
async with managed_transaction(request=request, abort_when_done=True):
container = await root.async_get('guillotina')
obj = await container.async_get('foobar')
attachment = IAttachment(obj)
await attachment.load()
existing_bid = attachment.file._blob.bid
cfm = get_multi_adapter(
(obj, request, IAttachment['file'].bind(attachment)), IFileManager
)
from_cfm = get_multi_adapter(
(obj, request, IAttachment['file'].bind(attachment)), IFileManager
)
await cfm.copy(from_cfm)
assert existing_bid != attachment.file._blob.bid
async def test_large_upload_chunks(container_requester):
async with container_requester as requester:
response, status = await requester(
'POST',
'/db/guillotina/',
data=json.dumps({
'@type': 'Item',
'@behaviors': [IAttachment.__identifier__],
'id': 'foobar'
})
)
assert status == 201
response, status = await requester(
'PATCH',
'/db/guillotina/foobar/@upload/file',
data=b'X' * 1024 * 1024 * 10,
headers={
'x-upload-size': str(1024 * 1024 * 10)
}
)
assert status == 200
response, status = await requester(
'GET',
'/db/guillotina/foobar/@download/file'
)
assert status == 200
assert len(response) == (1024 * 1024 * 10)
request = utils.get_mocked_request(requester.db)
root = await utils.get_root(request)
async with managed_transaction(request=request, abort_when_done=True):
container = await root.async_get('guillotina')
obj = await container.async_get('foobar')
behavior = IAttachment(obj)
await behavior.load()
assert behavior.file._blob.chunks == 2
async def test_copy_file_ob(container_requester):
async with container_requester as requester:
_, status = await requester(
'POST',
'/db/guillotina/',
data=json.dumps({
'@type': 'Item',
'@behaviors': [IAttachment.__identifier__],
'id': 'foobar'
})
)
assert status == 201
response, status = await requester(
'PATCH',
'/db/guillotina/foobar/@upload/file',
data=b'X' * 1024 * 1024 * 4,
headers={
'x-upload-size': str(1024 * 1024 * 4)
}
)
assert status == 200
request = utils.get_mocked_request(requester.db)
root = await utils.get_root(request)
async with managed_transaction(request=request, abort_when_done=True):
container = await root.async_get('guillotina')
obj = await container.async_get('foobar')
attachment = IAttachment(obj)
await attachment.load()
existing_bid = attachment.file._blob.bid
cfm = get_multi_adapter(
(obj, request, IAttachment['file'].bind(attachment)), IFileManager
)
from_cfm = get_multi_adapter(
(obj, request, IAttachment['file'].bind(attachment)), IFileManager
)
await cfm.copy(from_cfm)
assert existing_bid != attachment.file._blob.bid
async def test_object_utils(container_requester):
async with container_requester as requester:
response, status = await requester(
"POST", "/db/guillotina/", data=json.dumps({"@type": "Item", "title": "Item1", "id": "item1"})
)
assert status == 201
request = get_mocked_request(db=requester.db)
root = await get_root(db=requester.db)
tm = requester.db.get_transaction_manager()
txn = await tm.begin()
container = await root.async_get("guillotina")
ob = await utils.get_object_by_uid(response["@uid"], txn)
assert ob is not None
assert ob.__uuid__ == response["@uid"]
ob2 = await utils.navigate_to(container, "item1")
assert ob2.__uuid__ == ob.__uuid__
url = utils.get_object_url(ob, request)
assert url.endswith("item1")
await tm.abort(txn=txn)
async def test_add_sync_utility(guillotina, loop):
requester = await guillotina
app = getUtility(IApplication, name='root')
app.add_async_utility(QUEUE_UTILITY_CONFIG, loop)
util = getUtility(IQueueUtility)
var = []
async def printHi():
var.append('hola')
request = utils.get_mocked_request(requester.db)
root = await utils.get_root(request)
view = AsyncMockView(root, request, printHi)
await util.add(view)
await util.add(view)
await util._queue.join()
assert 'hola' in var
assert len(var) == 2
app.del_async_utility(QUEUE_UTILITY_CONFIG)
async def test_managed_transaction_with_adoption(container_requester):
async with container_requester as requester:
request = utils.get_mocked_request(requester.db)
root = await utils.get_root(request)
async with managed_transaction(request=request, abort_when_done=True):
container = await root.async_get('guillotina')
container.title = 'changed title'
container._p_register()
assert container._p_oid in container._p_jar.modified
# nest it with adoption
async with managed_transaction(request=request,
adopt_parent_txn=True):
# this should commit, take on parent txn for container
pass
# no longer modified, adopted in previous txn
assert container._p_oid not in container._p_jar.modified
# finally, retrieve it again and make sure it's updated
async with managed_transaction(request=request, abort_when_done=True):
container = await root.async_get('guillotina')
assert container.title == 'changed title'
async def test_create_content(container_requester):
async with container_requester as requester:
_, status = await requester(
'POST',
'/db/guillotina/',
data=json.dumps({
"@type": "Item",
"title": "Item1",
"id": "item1"
})
)
assert status == 201
_, status = await requester(
'GET',
'/db/guillotina/item1'
)
assert _['@static_behaviors'][0] == 'guillotina.behaviors.dublincore.IDublinCore'
request = utils.get_mocked_request(db=requester.db)
root = await utils.get_root(request)
async with transaction(db=requester.db, abort_when_done=True):
container = await root.async_get('guillotina')
obj = await container.async_get('item1')
assert obj.title == 'Item1'
async def test_get_containers(container_requester):
async with container_requester as requester:
request = get_mocked_request(requester.db)
containers = [c async for c in utils.get_containers(request)]
assert len(containers) > 0
async def test_navigator_get(container_requester):
async with container_requester as requester:
response, status = await requester(
'POST',
'/db/guillotina/',
data=json.dumps({
"@type": "Folder",
"title": "Folder1",
"id": "folder1"
}))
response, status = await requester(
'POST',
'/db/guillotina/folder1',
data=json.dumps({
"@type": "Folder",
"title": "Folder2",
"id": "folder2"
}))
response, status = await requester(
'POST',
'/db/guillotina',
data=json.dumps({
"@type": "Item",
"title": "Item0",
"id": "item0"
}))
response, status = await requester(
'POST',
'/db/guillotina/folder1',
data=json.dumps({
"@type": "Item",
"title": "Item1",
"id": "item1"
}))
response, status = await requester(
'POST',
'/db/guillotina/folder1/folder2',
data=json.dumps({
"@type": "Item",
"title": "Item2",
"id": "item2"
}))
assert status == 201
request = get_mocked_request(requester.db)
root = await get_root(request)
txn = await request._tm.begin(request)
container = await root.async_get('guillotina')
item0 = await container.async_get('item0')
txn.delete(item0)
nav = Navigator(txn, container)
item1 = await nav.get('/folder1/item1')
assert item1.__name__ == 'item1'
item1_bis = await nav.get('/folder1/item1')
item2 = await nav.get('/folder1/folder2/item2')
folder2 = await nav.get('/folder1/folder2')
assert item2.__parent__ is folder2
assert item1_bis is item1
nav.delete(item2)
assert await nav.get('/folder1/folder2/item2') is None
assert await nav.get('/folder1/item0') is None
await request._tm.abort(txn=txn)
def test_get_authenticated_user_without_request(dummy_guillotina):
db = get_db(dummy_guillotina, 'db')
request = get_mocked_request(db)
login(request)
assert utils.get_authenticated_user() is not None
async def test_tus_unknown_size(container_requester):
async with container_requester as requester:
response, status = await requester(
'POST',
'/db/guillotina/',
data=json.dumps({
'@type': 'Item',
'@behaviors': [IAttachment.__identifier__],
'id': 'foobar'
})
)
assert status == 201
response, status = await requester(
'OPTIONS',
'/db/guillotina/foobar/@tusupload/file',
headers={
'Origin': 'http://foobar.com',
'Access-Control-Request-Method': 'POST'
})
assert status == 200
response, status = await requester(
'POST',
'/db/guillotina/foobar/@tusupload/file',
headers={
'Upload-Defer-Length': '1',
'TUS-RESUMABLE': '1.0.0'
}
)
assert status == 201
response, status = await requester(
'HEAD',
'/db/guillotina/foobar/@tusupload/file')
assert status == 200
offset = 0
for idx in range(10):
# random sizes
size = 1024 * random.choice([1024, 1243, 5555, 7777])
response, status = await requester(
'PATCH',
'/db/guillotina/foobar/@tusupload/file',
headers={
'TUS-RESUMABLE': '1.0.0',
'upload-offset': str(offset)
},
data=b'X' * size
)
offset += size
assert status == 200
response, status = await requester(
'PATCH',
'/db/guillotina/foobar/@tusupload/file',
headers={
'TUS-RESUMABLE': '1.0.0',
'upload-offset': str(offset),
'UPLOAD-LENGTH': str(offset) # finish it
},
data=b''
)
response, status = await requester(
'GET',
'/db/guillotina/foobar/@download/file'
)
assert status == 200
assert len(response) == offset
request = utils.get_mocked_request(requester.db)
root = await utils.get_root(request)
async with managed_transaction(request=request, abort_when_done=True):
container = await root.async_get('guillotina')
obj = await container.async_get('foobar')
behavior = IAttachment(obj)
await behavior.load()
assert behavior.file._blob.size == offset
async def test_tus_with_empty_file(container_requester):
async with container_requester as requester:
response, status = await requester(
'POST',
'/db/guillotina/',
data=json.dumps({
'@type': 'Item',
'@behaviors': [IAttachment.__identifier__],
'id': 'foobar'
})
)
assert status == 201
response, status = await requester(
'OPTIONS',
'/db/guillotina/foobar/@tusupload/file',
headers={
'Origin': 'http://foobar.com',
'Access-Control-Request-Method': 'POST'
})
assert status == 200
response, status = await requester(
'POST',
'/db/guillotina/foobar/@tusupload/file',
headers={
'UPLOAD-LENGTH': '0',
'TUS-RESUMABLE': '1.0.0'
}
)
assert status == 201
response, status = await requester(
'HEAD',
'/db/guillotina/foobar/@tusupload/file')
assert status == 200
response, status = await requester(
'PATCH',
'/db/guillotina/foobar/@tusupload/file',
headers={
'CONTENT-LENGTH': '0',
'TUS-RESUMABLE': '1.0.0',
'upload-offset': '0'
},
data=b''
)
assert status == 200
response, status = await requester(
'GET',
'/db/guillotina/foobar/@download/file'
)
assert status == 200
assert len(response) == 0
request = utils.get_mocked_request(requester.db)
root = await utils.get_root(request)
async with managed_transaction(request=request, abort_when_done=True):
container = await root.async_get('guillotina')
obj = await container.async_get('foobar')
behavior = IAttachment(obj)
await behavior.load()
assert behavior.file._blob.chunks == 0
async def test_read_request_data_throws_exception_if_no_cache_data():
request = get_mocked_request()
request._retry_attempt = 1
with pytest.raises(UnRetryableRequestError):
await read_request_data(request, 5)
async def test_read_request_data_handles_retries():
request = get_mocked_request()
request._retry_attempt = 1
request._last_read_pos = 0
request._cache_data = b'aaa'
assert await read_request_data(request, 5) == b'aaa'
def setup_fake_request(self):
self.request = get_mocked_request()
login(self.request)
