def test_write_endpoints(db, setup_account, api_client, default_account): # Write operations (create, update, delete) succeed. r = api_client.post_data( '/drafts', data={ 'body': '<html><body><h2>Sea, birds and sand.</h2></body></html>' }) assert r.status_code == 200 draft_id = json.loads(r.data)['id'] endpoint = '/messages/{}'.format(setup_account['message']) r = api_client.put_data(endpoint, data={"starred": True}) assert r.status_code == 200 endpoint = '/events/{}'.format(setup_account['event']) r = api_client.delete(endpoint) assert r.status_code == 200 default_account.sync_state = 'invalid' db.session.commit() # Write operations fail with an HTTP 403. r = api_client.post_data('/labels', data={"display_name": "Neu!"}) assert r.status_code == 403 endpoint = '/threads/{}'.format(setup_account['thread']) r = api_client.put_data(endpoint, data={"starred": True}) assert r.status_code == 403 endpoint = '/drafts/{}'.format(draft_id) r = api_client.delete(endpoint) assert r.status_code == 403
def test_write_endpoints(db, setup_account, api_client, default_account): # Write operations (create, update, delete) succeed. r = api_client.post_data( "/drafts", data={"body": "<html><body><h2>Sea, birds and sand.</h2></body></html>"}, ) assert r.status_code == 200 draft_id = json.loads(r.data)["id"] endpoint = "/messages/{}".format(setup_account["message"]) r = api_client.put_data(endpoint, data={"starred": True}) assert r.status_code == 200 endpoint = "/events/{}".format(setup_account["event"]) r = api_client.delete(endpoint) assert r.status_code == 200 default_account.sync_state = "invalid" db.session.commit() # Write operations fail with an HTTP 403. r = api_client.post_data("/labels", data={"display_name": "Neu!"}) assert r.status_code == 403 endpoint = "/threads/{}".format(setup_account["thread"]) r = api_client.put_data(endpoint, data={"starred": True}) assert r.status_code == 403 endpoint = "/drafts/{}".format(draft_id) r = api_client.delete(endpoint) assert r.status_code == 403
def test_api_delete_invalid(db, api_client, calendar): e_id = 'asdf' resp = api_client.delete('/events/' + e_id) assert resp.status_code != 200 e_id = generate_public_id() resp = api_client.delete('/events/' + e_id) assert resp.status_code != 200
def test_create_draft_with_attachments(api_client, attachments, example_draft): attachment_ids = [] upload_path = '/files' for filename, path in attachments: data = {'file': (open(path, 'rb'), filename)} r = api_client.post_raw(upload_path, data=data) assert r.status_code == 200 attachment_id = json.loads(r.data)[0]['id'] attachment_ids.append(attachment_id) first_attachment = attachment_ids.pop() example_draft['file_ids'] = [first_attachment] r = api_client.post_data('/drafts', example_draft) assert r.status_code == 200 returned_draft = json.loads(r.data) draft_public_id = returned_draft['id'] assert returned_draft['version'] == 0 example_draft['version'] = returned_draft['version'] assert len(returned_draft['files']) == 1 attachment_ids.append(first_attachment) example_draft['file_ids'] = attachment_ids r = api_client.put_data('/drafts/{}'.format(draft_public_id), example_draft) assert r.status_code == 200 returned_draft = json.loads(r.data) assert len(returned_draft['files']) == 3 assert returned_draft['version'] == 1 example_draft['version'] = returned_draft['version'] # Make sure we can't delete the files now for file_id in attachment_ids: r = api_client.delete('/files/{}'.format(file_id)) assert r.status_code == 400 # Now remove the attachment example_draft['file_ids'] = [first_attachment] r = api_client.put_data('/drafts/{}'.format(draft_public_id), example_draft) draft_data = api_client.get_data('/drafts/{}'.format(draft_public_id)) assert len(draft_data['files']) == 1 assert draft_data['version'] == 2 example_draft['version'] = draft_data['version'] example_draft['file_ids'] = [] r = api_client.put_data('/drafts/{}'.format(draft_public_id), example_draft) draft_data = api_client.get_data('/drafts/{}'.format(draft_public_id)) assert r.status_code == 200 assert len(draft_data['files']) == 0 assert draft_data['version'] == 3 # now that they're not attached, we should be able to delete them for file_id in attachment_ids: r = api_client.delete('/files/{}'.format(file_id)) assert r.status_code == 200
def test_delete_draft(api_client, thread, message): original_draft = { 'subject': 'parent draft', 'body': 'parent draft' } r = api_client.post_data('/drafts', original_draft) draft_public_id = json.loads(r.data)['id'] version = json.loads(r.data)['version'] updated_draft = { 'subject': 'updated draft', 'body': 'updated draft', 'version': version } r = api_client.put_data('/drafts/{}'.format(draft_public_id), updated_draft) updated_public_id = json.loads(r.data)['id'] updated_version = json.loads(r.data)['version'] r = api_client.delete('/drafts/{}'.format(updated_public_id), {'version': updated_version}) # Check that drafts were deleted drafts = api_client.get_data('/drafts') assert not drafts # Check that no orphaned threads are around threads = api_client.get_data('/threads?subject=parent%20draft') assert not threads threads = api_client.get_data('/threads?subject=updated%20draft') assert not threads # And check that threads aren't deleted if they still have messages. thread_public_id = api_client.get_data('/threads')[0]['id'] reply_draft = { 'subject': 'test reply', 'body': 'test reply', 'thread_id': thread_public_id } r = api_client.post_data('/drafts', reply_draft) public_id = json.loads(r.data)['id'] version = json.loads(r.data)['version'] thread = api_client.get_data('/threads/{}'.format(thread_public_id)) assert len(thread['draft_ids']) > 0 api_client.delete('/drafts/{}'.format(public_id), {'version': version}) thread = api_client.get_data('/threads/{}'.format(thread_public_id)) assert thread assert len(thread['draft_ids']) == 0
def test_get_invalid(api_client, uploaded_file_ids): data = api_client.get_data('/files/0000000000000000000000000') assert data['message'].startswith("Couldn't find file") data = api_client.get_data('/files/!') assert data['message'].startswith("Invalid id") data = api_client.get_data('/files/0000000000000000000000000/download') assert data['message'].startswith("Couldn't find file") data = api_client.get_data('/files/!/download') assert data['message'].startswith("Invalid id") r = api_client.delete('/files/0000000000000000000000000') assert r.status_code == 404 r = api_client.delete('/files/!') assert r.status_code == 400
def test_multisend_session( api_client, multisend, multisend2, patch_smtp, patch_crispin_del_sent, patch_sentry_to_raise, ): r = api_client.post_data("/send-multiple/" + multisend["id"], multisend["send_req"]) assert r.status_code == 200 assert json.loads(r.data)["body"] == multisend["send_req"]["body"] r = api_client.post_data("/send-multiple/" + multisend2["id"], multisend2["send_req"]) assert r.status_code == 200 assert json.loads(r.data)["body"] == multisend2["send_req"]["body"] # Make sure we can't send to people not in the message recipients req_body = { "send_req": { "body": "you're not even a recipient!", "send_to": { "name": "not in message", "email": "*****@*****.**" }, } } r = api_client.post_data("/send-multiple/" + multisend["id"], req_body) assert r.status_code == 400 r = api_client.delete("/send-multiple/" + multisend["id"]) assert r.status_code == 200 assert json.loads(r.data)["body"] == multisend["draft"]["body"]
def test_api_pessimistic_delete(db, api_client, calendar, default_account): e_data = { "title": "", "calendar_id": calendar.public_id, "when": { "time": 1407542195 }, } e_resp = api_client.post_data("/events", e_data, headers={"Api-Version": API_VERSIONS[1]}) e_resp_data = json.loads(e_resp.data) assert e_resp_data["object"] == "event" assert e_resp_data["title"] == e_data["title"] assert e_resp_data["when"]["time"] == e_data["when"]["time"] assert "id" in e_resp_data e_id = e_resp_data["id"] e_delete_resp = api_client.delete("/events/" + e_id, headers={"Api-Version": API_VERSIONS[1]}) assert e_delete_resp.status_code == 200 e_resp = api_client.get_data("/events/" + e_id) assert e_resp["status"] == "confirmed"
def test_delete_from_readonly_calendar(db, default_namespace, api_client): add_fake_event(db.session, default_namespace.id, calendar=db.session.query(Calendar).filter( Calendar.namespace_id == default_namespace.id, Calendar.read_only == True).first(), # noqa read_only=True) calendar_list = api_client.get_data('/calendars') read_only_calendar = None for c in calendar_list: if c['read_only']: read_only_calendar = c break events = api_client.get_data('/events?calendar_id={}'.format( read_only_calendar['id'])) for event in events: if event['read_only']: read_only_event = event break assert read_only_calendar assert read_only_event e_id = read_only_event['id'] resp = api_client.delete('/events/{}'.format(e_id)) assert resp.status_code == 400
def test_delete_from_readonly_calendar(db, default_namespace, api_client): add_fake_event( db.session, default_namespace.id, calendar=db.session.query(Calendar).filter( Calendar.namespace_id == default_namespace.id, Calendar.read_only == True).first(), # noqa read_only=True) calendar_list = api_client.get_data('/calendars') read_only_calendar = None for c in calendar_list: if c['read_only']: read_only_calendar = c break events = api_client.get_data('/events?calendar_id={}'.format( read_only_calendar['id'])) for event in events: if event['read_only']: read_only_event = event break assert read_only_calendar assert read_only_event e_id = read_only_event['id'] resp = api_client.delete('/events/{}'.format(e_id)) assert resp.status_code == 400
def test_multisend_session(api_client, multisend, multisend2, patch_smtp, patch_crispin_del_sent): r = api_client.post_data('/send-multiple/' + multisend['id'], multisend['send_req']) assert r.status_code == 200 assert json.loads(r.data)['body'] == multisend['send_req']['body'] r = api_client.post_data('/send-multiple/' + multisend2['id'], multisend2['send_req']) assert r.status_code == 200 assert json.loads(r.data)['body'] == multisend2['send_req']['body'] # Make sure we can't send to people not in the message recipients req_body = { 'send_req': { 'body': "you're not even a recipient!", 'send_to': { 'name': 'not in message', 'email': '*****@*****.**' } } } r = api_client.post_data('/send-multiple/' + multisend['id'], req_body) assert r.status_code == 400 r = api_client.delete('/send-multiple/' + multisend['id']) assert r.status_code == 200 assert json.loads(r.data)['body'] == multisend['draft']['body']
def test_delete_remote_draft(db, api_client, message): message.is_draft = True db.session.commit() drafts = api_client.get_data('/drafts') assert len(drafts) == 1 public_id = drafts[0]['id'] version = drafts[0]['version'] assert public_id == message.public_id and version == message.version api_client.delete('/drafts/{}'.format(public_id), {'version': version}) # Check that drafts were deleted drafts = api_client.get_data('/drafts') assert not drafts
def test_delete_draft(api_client, thread, message): original_draft = {"subject": "parent draft", "body": "parent draft"} r = api_client.post_data("/drafts", original_draft) draft_public_id = json.loads(r.data)["id"] version = json.loads(r.data)["version"] updated_draft = { "subject": "updated draft", "body": "updated draft", "version": version, } r = api_client.put_data("/drafts/{}".format(draft_public_id), updated_draft) updated_public_id = json.loads(r.data)["id"] updated_version = json.loads(r.data)["version"] r = api_client.delete("/drafts/{}".format(updated_public_id), {"version": updated_version}) # Check that drafts were deleted drafts = api_client.get_data("/drafts") assert not drafts # Check that no orphaned threads are around threads = api_client.get_data("/threads?subject=parent%20draft") assert not threads threads = api_client.get_data("/threads?subject=updated%20draft") assert not threads # And check that threads aren't deleted if they still have messages. thread_public_id = api_client.get_data("/threads")[0]["id"] reply_draft = { "subject": "test reply", "body": "test reply", "thread_id": thread_public_id, } r = api_client.post_data("/drafts", reply_draft) public_id = json.loads(r.data)["id"] version = json.loads(r.data)["version"] thread = api_client.get_data("/threads/{}".format(thread_public_id)) assert len(thread["draft_ids"]) > 0 api_client.delete("/drafts/{}".format(public_id), {"version": version}) thread = api_client.get_data("/threads/{}".format(thread_public_id)) assert thread assert len(thread["draft_ids"]) == 0
def test_delete_remote_draft(db, api_client, message): message.is_draft = True db.session.commit() drafts = api_client.get_data("/drafts") assert len(drafts) == 1 public_id = drafts[0]["id"] version = drafts[0]["version"] assert public_id == message.public_id and version == message.version api_client.delete("/drafts/{}".format(public_id), {"version": version}) # Check that drafts were deleted drafts = api_client.get_data("/drafts") assert not drafts
def test_delete_draft(api_client, thread, message): original_draft = {'subject': 'parent draft', 'body': 'parent draft'} r = api_client.post_data('/drafts', original_draft) draft_public_id = json.loads(r.data)['id'] version = json.loads(r.data)['version'] updated_draft = { 'subject': 'updated draft', 'body': 'updated draft', 'version': version } r = api_client.put_data('/drafts/{}'.format(draft_public_id), updated_draft) updated_public_id = json.loads(r.data)['id'] updated_version = json.loads(r.data)['version'] r = api_client.delete('/drafts/{}'.format(updated_public_id), {'version': updated_version}) # Check that drafts were deleted drafts = api_client.get_data('/drafts') assert not drafts # Check that no orphaned threads are around threads = api_client.get_data('/threads?subject=parent%20draft') assert not threads threads = api_client.get_data('/threads?subject=updated%20draft') assert not threads # And check that threads aren't deleted if they still have messages. thread_public_id = api_client.get_data('/threads')[0]['id'] reply_draft = { 'subject': 'test reply', 'body': 'test reply', 'thread_id': thread_public_id } r = api_client.post_data('/drafts', reply_draft) public_id = json.loads(r.data)['id'] version = json.loads(r.data)['version'] thread = api_client.get_data('/threads/{}'.format(thread_public_id)) assert len(thread['draft_ids']) > 0 api_client.delete('/drafts/{}'.format(public_id), {'version': version}) thread = api_client.get_data('/threads/{}'.format(thread_public_id)) assert thread assert len(thread['draft_ids']) == 0
def test_folders_labels_delete(db, api_client, generic_account, gmail_account): api_client = new_api_client(db, generic_account.namespace) # Generic IMAP threads, messages have a 'folders' field generic_thread = add_fake_thread(db.session, generic_account.namespace.id) generic_message = add_fake_message(db.session, generic_account.namespace.id, generic_thread) resp = api_client.post_data('/folders/', {"display_name": "Test_Folder"}) assert resp.status_code == 200 generic_folder = json.loads(resp.data) data = {"folder_id": generic_folder['id']} # Add message to folder api_client.put_data('/messages/{}'.format(generic_message.public_id), data) # try deleting folder that contains a message delete_data = api_client.delete('/folders/{}'.format(generic_folder['id'])) assert delete_data.status_code == 403 resp = api_client.post_data('/folders/', {"display_name": "Test_Folder2"}) empty_folder = json.loads(resp.data) # try deleting folder that contains a message delete_data = api_client.delete('/folders/{}'.format(empty_folder['id'])) assert delete_data.status_code == 200 # Because we're using the generic_account namespace api_client = new_api_client(db, gmail_account.namespace) # Gmail threads, messages have a 'labels' field gmail_thread = add_fake_thread(db.session, gmail_account.namespace.id) gmail_message = add_fake_message(db.session, gmail_account.namespace.id, gmail_thread) resp = api_client.post_data('/labels/', {"display_name": "Test_Labels"}) assert resp.status_code == 200 gmail_label = json.loads(resp.data) data = {"folder_id": gmail_label['id']} # Add label to message api_client.put_data('/messages/{}'.format(gmail_message.public_id), data) # try deleting label delete_data = api_client.delete('/labels/{}'.format(gmail_label['id'])) assert delete_data.status_code == 200
def test_delete(api_client, uploaded_file_ids, draft): non_attachment_id = uploaded_file_ids.pop() attachment_id = uploaded_file_ids.pop() draft['file_ids'] = [attachment_id] r = api_client.post_data('/drafts', draft) assert r.status_code == 200 # Test that we can delete a non-attachment r = api_client.delete('/files/{}'.format(non_attachment_id)) assert r.status_code == 200 data = api_client.get_data('/files/{}'.format(non_attachment_id)) assert data['message'].startswith("Couldn't find file") # Make sure that we cannot delete attachments r = api_client.delete('/files/{}'.format(attachment_id)) assert r.status_code == 400 data = api_client.get_data('/files/{}'.format(attachment_id)) assert data['id'] == attachment_id
def test_delete_draft(api_client, thread, message): original_draft = {"subject": "parent draft", "body": "parent draft"} r = api_client.post_data("/drafts", original_draft) draft_public_id = json.loads(r.data)["id"] version = json.loads(r.data)["version"] updated_draft = {"subject": "updated draft", "body": "updated draft", "version": version} r = api_client.put_data("/drafts/{}".format(draft_public_id), updated_draft) updated_public_id = json.loads(r.data)["id"] updated_version = json.loads(r.data)["version"] r = api_client.delete("/drafts/{}".format(updated_public_id), {"version": updated_version}) # Check that drafts were deleted drafts = api_client.get_data("/drafts") assert not drafts # Check that no orphaned threads are around threads = api_client.get_data("/threads?subject=parent%20draft") assert not threads threads = api_client.get_data("/threads?subject=updated%20draft") assert not threads # And check that threads aren't deleted if they still have messages. thread_public_id = api_client.get_data("/threads")[0]["id"] reply_draft = {"subject": "test reply", "body": "test reply", "thread_id": thread_public_id} r = api_client.post_data("/drafts", reply_draft) public_id = json.loads(r.data)["id"] version = json.loads(r.data)["version"] thread = api_client.get_data("/threads/{}".format(thread_public_id)) assert len(thread["draft_ids"]) > 0 api_client.delete("/drafts/{}".format(public_id), {"version": version}) thread = api_client.get_data("/threads/{}".format(thread_public_id)) assert thread assert len(thread["draft_ids"]) == 0
def test_api_delete(db, api_client, calendar, default_account): e_data = { 'title': '', 'calendar_id': calendar.public_id, 'when': {'time': 1407542195}, } e_resp = api_client.post_data('/events', e_data) e_resp_data = json.loads(e_resp.data) assert e_resp_data['object'] == 'event' assert e_resp_data['title'] == e_data['title'] assert e_resp_data['when']['time'] == e_data['when']['time'] assert 'id' in e_resp_data e_id = e_resp_data['id'] e_delete_resp = api_client.delete('/events/' + e_id) assert e_delete_resp.status_code == 200 e_resp = api_client.get_data('/events/' + e_id) assert e_resp['status'] == 'cancelled'
def test_api_pessimistic_delete(db, api_client, calendar, default_account): e_data = { 'title': '', 'calendar_id': calendar.public_id, 'when': {'time': 1407542195}, } e_resp = api_client.post_data('/events', e_data, headers={ "Api-Version": API_VERSIONS[1] }) e_resp_data = json.loads(e_resp.data) assert e_resp_data['object'] == 'event' assert e_resp_data['title'] == e_data['title'] assert e_resp_data['when']['time'] == e_data['when']['time'] assert 'id' in e_resp_data e_id = e_resp_data['id'] e_delete_resp = api_client.delete('/events/' + e_id, headers={ "Api-Version": API_VERSIONS[1] }) assert e_delete_resp.status_code == 200 e_resp = api_client.get_data('/events/' + e_id) assert e_resp['status'] == 'confirmed'
def test_api_delete(db, api_client, calendar, default_account): e_data = { "title": "", "calendar_id": calendar.public_id, "when": { "time": 1407542195 }, } e_resp = api_client.post_data("/events", e_data) e_resp_data = json.loads(e_resp.data) assert e_resp_data["object"] == "event" assert e_resp_data["title"] == e_data["title"] assert e_resp_data["when"]["time"] == e_data["when"]["time"] assert "id" in e_resp_data e_id = e_resp_data["id"] e_delete_resp = api_client.delete("/events/" + e_id) assert e_delete_resp.status_code == 200 e_resp = api_client.get_data("/events/" + e_id) assert e_resp["status"] == "cancelled"
def test_multisend_session(api_client, multisend, multisend2, patch_smtp, patch_crispin_del_sent): r = api_client.post_data('/send-multiple/' + multisend['id'], multisend['send_req']) assert r.status_code == 200 assert json.loads(r.data)['body'] == multisend['send_req']['body'] r = api_client.post_data('/send-multiple/' + multisend2['id'], multisend2['send_req']) assert r.status_code == 200 assert json.loads(r.data)['body'] == multisend2['send_req']['body'] # Make sure we can't send to people not in the message recipients req_body = {'send_req': {'body': "you're not even a recipient!", 'send_to': {'name': 'not in message', 'email': '*****@*****.**'}}} r = api_client.post_data('/send-multiple/' + multisend['id'], req_body) assert r.status_code == 400 r = api_client.delete('/send-multiple/' + multisend['id']) assert r.status_code == 200 assert json.loads(r.data)['body'] == multisend['draft']['body']