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)