def test_delete_pipeline_dne(authorization_header):
pipeline = schemas.pipeline.PipelineCreate(name='test-delete-dne')
pipeline_id = test_create_pipeline(authorization_header, pipeline)['id']
assert pipeline_id
response = client.delete(f'/pipeline/{pipeline_id}', headers=authorization_header)
assert response.status_code == 200
response = client.delete(f'/pipeline/{pipeline_id}', headers=authorization_header)
assert response.status_code == 404
def testTrashCategoriesDeleteInvalidId(self, client):
"""Test soft delete a record in trash categories table
trash with id 123 is not in the table, hence will get a 404(Not Found) error"""
token = createTokenAdmin()
res = client.delete('/v1/trash_category/123',
headers={'Authorization': "Bearer " + token},
content_type='application/json')
assert res.status_code == 404
def test_reset_setting_unknown_setting_key():
with database_mock() as db:
db: StandardDatabase
insert_mocks(db, "users")
insert_mocks(db, "settings")
with authed_request(client, "alice", ALICE_PASSWORD) as params:
result = client.delete("/settings/lorem_ipsum", **params)
assert result.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY
def test_dates_get_invalid_no_token(self, client):
"""test invalid post without token"""
res = client.delete('/api/date', content_type='application/json')
res_json = json.loads(res.data)
if res.status_code != 401:
raise ValueError(
'The res.status_code must be 401, please check your code')
def testTrashCategoriesDelete(self, client):
"""Test soft delete a record in trash category table with valid token and id"""
token = createTokenAdmin()
res = client.delete('/v1/trash_category/{}'.format(
TestTrashManagement.temp_category_id),
headers={'Authorization': "Bearer " + token},
content_type='application/json')
assert res.status_code == 200
def test_dates_delete_invalid(self, client):
token = create_token()
data = {"date": "22-01-2020"}
res = client.delete('/api/date',
data=json.dumps(data),
headers={'Authorization': 'Bearer ' + token},
content_type='application/json')
res_json = json.loads(res.data)
if res.status_code != 404:
raise ValueError(
'The res.status_code must be 200, please check your code')
def test_invitations_user_decline_event(self, client):
"""
test invalid reject without token
"""
token = create_token()
res = client.delete('/api/invitations/decline/1',
headers={'Authorization':'Bearer ' + token},
content_type='application/json')
if res.status_code != 200:
raise ValueError('The res.status_code must be 200, please check your code')
def test_reset_all_settings():
with database_mock() as db:
db: StandardDatabase
insert_mocks(db, "users")
insert_mocks(db, "settings")
with authed_request(client, "alice", ALICE_PASSWORD) as params:
result = client.delete("/settings", **params)
assert result.status_code == 200
for key, value in json.loads(
get_default_settings().json(by_alias=True)
).items():
assert result.json()[key] == value
def test_reset_setting():
with database_mock() as db:
db: StandardDatabase
insert_mocks(db, "users")
insert_mocks(db, "settings")
with authed_request(client, "alice", ALICE_PASSWORD) as params:
result = client.delete("/settings/offdays", **params)
expected = {
**json.loads(mocks.settings.alice.json(by_alias=True)),
"offdays": json.loads(get_default_settings().json())["offdays"],
}
assert result.status_code == 200
assert result.json() == expected
def test_delete_subject():
with database_mock() as db:
db: StandardDatabase
insert_mocks(db, "users")
db.collection("subjects").insert(mocks.subjects.mathematiques.json())
with authed_request(client, "alice", ALICE_PASSWORD) as params:
response = client.delete(
f"/subjects/{mocks.subjects.mathematiques.object_key}",
**params)
assert response.status_code == status.HTTP_204_NO_CONTENT
assert not response.text
assert db.collection("subjects").all().count() == 0
def test_if_returns_404_if_the_address_doesnt_exist(create_user):
response = client.delete(
url_for('users_address_bp.users_address_delete',
user_id=1,
address_id=10))
expected_return = {
"status": "Error",
"status_code": 404,
"message": "Address not found",
}
assert response.status_code == 404
assert json.loads(response.data) == expected_return
def test_if_returns_401_if_address_doesnt_belong_to_user(
create_user, create_address):
response = client.delete(
url_for('users_address_bp.users_address_delete',
user_id=2,
address_id=1))
expected_return = {
"status": "Error",
"status_code": 401,
"message": "Could not verify",
}
assert response.status_code == 401
assert json.loads(response.data) == expected_return
def test_delete_grades():
with database_mock() as db:
db: StandardDatabase
insert_mocks(db, "users")
insert_mocks(db, "grades")
with authed_request(client, "alice", ALICE_PASSWORD) as params:
response = client.delete(
f"/grades/{mocks.grades.alice_trigo.object_key}",
**params,
)
assert response.status_code == status.HTTP_204_NO_CONTENT
assert not response.text
assert db.collection("grades").all().count() == 3
assert db.collection("grades").get(
mocks.grades.alice_trigo._key) is None
def test_if_delete_users_address_with_success(create_user, valid_address):
# Creating address for testing
client.post(url_for('users_address_bp.users_address_create', user_id=1),
json=valid_address)
response = client.delete(
url_for('users_address_bp.users_address_delete',
user_id=1,
address_id=1))
expected_return = {
"status": "Success",
"status_code": 200,
"message": "Address deleted successfully",
}
assert response.status_code == 200
assert json.loads(response.data) == expected_return
def test_author_ok(self):
author = {
"first_name": "First Name",
"last_name": "Last Name",
}
createResponse = client.post('/authors',
data=json.dumps(dict(author=author)))
createResult = json.loads(createResponse.data)
assert createResponse.status_code == 200
assert createResult['first_name'] == "First Name"
assert createResult['last_name'] == "Last Name"
getResponse = client.get('/authors/{}'.format(createResult['id']))
getResult = json.loads(createResponse.data)
assert getResponse.status_code == 200
assert getResult['first_name'] == "First Name"
assert getResult['last_name'] == "Last Name"
newAuthor = {
"first_name": "John",
"last_name": "Doe",
}
updateResponse = client.put('/authors/{}'.format(createResult['id']),
data=json.dumps(dict(author=newAuthor)))
updateResult = json.loads(updateResponse.data)
assert updateResponse.status_code == 200
assert updateResult['first_name'] == "John"
assert updateResult['last_name'] == "Doe"
deleteResponse = client.delete('/authors/{}'.format(getResult['id']))
assert deleteResponse.status_code == 200
getResponse = client.get('/authors/{}'.format(getResult['id']))
assert getResponse.status_code == 404
def test_genre_ok(self):
genre = {
"name": "Name",
}
createResponse = client.post('/genres',
data=json.dumps(dict(genre=genre)))
createResult = json.loads(createResponse.data)
assert createResponse.status_code == 200
assert createResult['name'] == "Name"
getResponse = client.get('/genres/{}'.format(createResult['id']))
getResult = json.loads(createResponse.data)
assert getResponse.status_code == 200
assert getResult['name'] == "Name"
newGenre = {
"name": "Comedy",
}
updateResponse = client.put('/genres/{}'.format(createResult['id']),
data=json.dumps(dict(genre=newGenre)))
updateResult = json.loads(updateResponse.data)
assert updateResponse.status_code == 200
assert updateResult['name'] == "Comedy"
deleteResponse = client.delete('/genres/{}'.format(getResult['id']))
assert deleteResponse.status_code == 200
getResponse = client.get('/genres/{}'.format(getResult['id']))
assert getResponse.status_code == 404
def test_user_deleteme2(self,client):
token=user_required()
res = client.delete('/user/me',headers={'Authorization':'Bearer '+token})
res_json = json.loads(res.data)
assert res.status_code == 200
def test_user_deletme_failed(self,client):
token=shop_required()
res = client.delete('/user/me',headers={'Authorization':'Bearer '+'abc'})
res_json = json.loads(res.data)
assert res.status_code == 422
def test_transaction_shop_delete(self,client):
token=shop_required()
res = client.delete('/transaction/shop/'+str(TestCartEndpoint.transactionid),headers={'Authorization':'Bearer '+token})
res_json = json.loads(res.data)
assert res.status_code == 200
def test_item_deactivate_failed(self,client):
token=shop_required()
res = client.delete('/item/me/activate/'+str(TestItemEndpoint.itemid), headers={'Authorization':'Bearer '+token})
res_json = json.loads(res.data)
assert res.status_code == 404
def test_shop_deactivate_failed(self,client):
token=user_required()
res = client.delete('shop/me/activate',headers={'Authorization':'Bearer '+token})
res_json = json.loads(res.data)
assert res.status_code == 403
def test_response(self, setup_db):
response = client.delete(f"/projects/{1}")
assert response.status_code == 200
assert response.json() == {}
def test_db_data(self, setup_db):
client.delete(f"/projects/{1}")
project = setup_db.query(Project).filter(Project.id == 1).first()
assert project is None
def test_book_ok(self):
author = {
"first_name": "First Name",
"last_name": "Last Name",
}
createAuthorResponse = client.post(
'/authors', data=json.dumps(dict(author=author)))
createAuthorResult = json.loads(createAuthorResponse.data)
assert createAuthorResponse.status_code == 200
book = {
"name": "Name",
"description": "Description",
"pages": "123",
"image": "",
"author_id": createAuthorResult['id'],
"genres": []
}
createResponse = client.post(
'/books', data=json.dumps(dict(book=book)))
createResult = json.loads(createResponse.data)
assert createResponse.status_code == 200
assert createResult['name'] == "Name"
assert createResult['description'] == "Description"
assert createResult['pages'] == 123
getResponse = client.get('/books/{}'.format(createResult['id']))
getResult = json.loads(createResponse.data)
assert getResponse.status_code == 200
assert getResult['name'] == "Name"
assert getResult['description'] == "Description"
assert int(getResult['pages']) == 123
newBook = {
"name": "Harry Potter",
"description": "Description",
"pages": "124",
"image": "",
"author_id": "1",
"genres": []
}
updateResponse = client.put(
'/books/{}'.format(createResult['id']), data=json.dumps(dict(book=newBook)))
updateResult = json.loads(updateResponse.data)
assert updateResponse.status_code == 200
assert updateResult['name'] == "Harry Potter"
assert updateResult['description'] == "Description"
assert int(updateResult['pages']) == 124
deleteResponse = client.delete('/books/{}'.format(getResult['id']))
assert deleteResponse.status_code == 200
getResponse = client.get('/books/{}'.format(getResult['id']))
assert getResponse.status_code == 404
deleteAuthorResponse = client.delete('/authors/{}'.format(createAuthorResult['id']))
assert deleteAuthorResponse.status_code == 200
def test_response(self, setup_db):
response = client.delete(f"/projects/{2}")
assert response.status_code == 404
def test_cart_delete1(self,client):
token=shop_required()
res = client.delete('/cart/'+str(TestItemEndpoint.cartid),headers={'Authorization':'Bearer '+token})
res_json = json.loads(res.data)
assert res.status_code == 200
def test_admin(self, client):
#test register admin
data = {
"username": "******",
"password": "******",
"phonenumber": "0987635343",
"address": "Bimasakti",
"role": "admin"
}
res = client.post('/user/register',
data=json.dumps(data),
content_type='application/json')
res_json = json.loads(res.data)
assert res.status_code == 200
assert res_json['data']['username'] == 'admin'
################
#test login admin
################
# 1 success
data = {"username": "******", "password": "******"}
res = client.post('/user/login',
data=json.dumps(data),
content_type='application/json')
res_json = json.loads(res.data)
assert res.status_code == 200
assert res_json['token'] is not None
token_admin = res.json['token']
# 2 failed wrong password
data = {"username": "******", "password": "******"}
res = client.post('/user/login',
data=json.dumps(data),
content_type='application/json')
assert res.status_code == 422
# test create user by admin
data = {
"username": "******",
"password": "******",
"phonenumber": "987645343",
"address": "Jember"
}
res = client.post('/user/',
data=json.dumps(data),
headers={'Authorization': 'Bearer ' + token_admin},
content_type='application/json')
res_json = json.loads(res.data)
assert res.status_code == 200
id_user_test = res_json['data']['id']
# test create user failed (user already exist)
data = {
"username": "******",
"password": "******",
"phonenumber": "987645343",
"address": "Jember"
}
res = client.post('/user/',
data=json.dumps(data),
headers={'Authorization': 'Bearer ' + token_admin},
content_type='application/json')
res_json = json.loads(res.data)
assert res.status_code == 422
# test update user by admin
data = {
"username": "******",
"password": "******",
"phonenumber": "987645343",
"address": "Malang"
}
res = client.put('/user/' + str(id_user_test),
data=json.dumps(data),
headers={'Authorization': 'Bearer ' + token_admin},
content_type='application/json')
assert res.status_code == 200
################
# test get user
################
# 1 failed, id is empty
res = client.get('/user/',
data=json.dumps(data),
headers={'Authorization': 'Bearer ' + token_admin},
content_type='application/json')
assert res.status_code == 400
# 2 success
res = client.get('/user/' + str(id_user_test),
data=json.dumps(data),
headers={'Authorization': 'Bearer ' + token_admin},
content_type='application/json')
assert res.status_code == 200
#test delete user
res = client.delete('/user/' + str(id_user_test),
data=json.dumps(data),
headers={'Authorization': 'Bearer ' + token_admin},
content_type='application/json')
assert res.status_code == 200
def test_toc_delete(client):
test_toc_import(client)
r = client.delete('/v1/toc')
assert int(r.get_json()['deleted']) == 100
test_toc_empty(client)
