def test_cancel_after_paid(
self,
order_email_service_mock,
order_paid_signal_send_mock,
order_canceled_signal_send_mock,
):
article_before = self.create_article(self.shop.id, quantity=8)
quantified_articles_to_order = {(article_before, 3)}
placed_order = self.place_order(quantified_articles_to_order)
order_before = get_order(placed_order.id)
assert article_before.quantity == 5
assert_payment_is_open(order_before)
url = f'/admin/shop/orders/{order_before.id}/mark_as_paid'
form_data = {'payment_method': 'bank_transfer'}
with http_client(self.app, user_id=self.admin.id) as client:
response = client.post(url, data=form_data)
url = f'/admin/shop/orders/{order_before.id}/cancel'
form_data = {
'reason': 'Dein Vorname ist albern!',
'send_email': 'n',
}
with http_client(self.app, user_id=self.admin.id) as client:
response = client.post(url, data=form_data)
order_afterwards = get_order(order_before.id)
assert response.status_code == 302
assert_payment(
order_afterwards,
PaymentMethod.bank_transfer,
PaymentState.canceled_after_paid,
self.admin.id,
)
article_afterwards = Article.query.get(article_before.id)
assert article_afterwards.quantity == 8
order_email_service_mock.send_email_for_canceled_order_to_orderer.assert_called_once_with(
placed_order.id)
event = ShopOrderCanceled(
occurred_at=order_afterwards.payment_state_updated_at,
order_id=placed_order.id,
initiator_id=self.admin.id,
)
order_canceled_signal_send_mock.assert_called_once_with(None,
event=event)
def test_mark_order_as_paid(self, order_email_service_mock,
order_paid_signal_send_mock):
placed_order = self.place_order([])
order_before = get_order(placed_order.id)
assert_payment_is_open(order_before)
url = f'/admin/shop/orders/{order_before.id}/mark_as_paid'
form_data = {'payment_method': 'direct_debit'}
with http_client(self.app, user_id=self.admin.id) as client:
response = client.post(url, data=form_data)
order_afterwards = get_order(order_before.id)
assert response.status_code == 302
assert_payment(
order_afterwards,
PaymentMethod.direct_debit,
PaymentState.paid,
self.admin.id,
)
order_email_service_mock.send_email_for_paid_order_to_orderer.assert_called_once_with(
placed_order.id)
event = ShopOrderPaid(
occurred_at=order_afterwards.payment_state_updated_at,
order_id=placed_order.id,
)
order_paid_signal_send_mock.assert_called_once_with(None, event=event)
def test_homepage(self):
with http_client(self.app) as client:
response = client.get('/')
# By default, nothing is mounted on `/`, but at least check that
# the application boots up and doesn't return a server error.
assert response.status_code == 404
def test_cancel_before_paid(self, order_email_service_mock,
order_canceled_signal_send_mock):
article_before = self.create_article(self.shop.id, quantity=8)
quantified_articles_to_order = {(article_before, 3)}
placed_order = self.place_order(quantified_articles_to_order)
order_before = get_order(placed_order.id)
assert article_before.quantity == 5
assert_payment_is_open(order_before)
url = '/admin/shop/orders/{}/cancel'.format(order_before.id)
form_data = {
'reason': 'Dein Vorname ist albern!',
'send_email': 'y',
}
with http_client(self.app, user_id=self.admin.id) as client:
response = client.post(url, data=form_data)
order_afterwards = get_order(order_before.id)
assert response.status_code == 302
assert_payment(order_afterwards, PaymentMethod.bank_transfer,
PaymentState.canceled_before_paid, self.admin.id)
article_afterwards = Article.query.get(article_before.id)
assert article_afterwards.quantity == 8
order_email_service_mock.send_email_for_canceled_order_to_orderer \
.assert_called_once_with(placed_order.id)
order_canceled_signal_send_mock \
.assert_called_once_with(None, order_id=placed_order.id)
def test_cancel_before_paid_without_sending_email(
self, order_email_service_mock, order_canceled_signal_send_mock):
article_before = self.create_article(self.shop.id, quantity=8)
quantified_articles_to_order = {(article_before, 3)}
placed_order = self.place_order(quantified_articles_to_order)
url = f'/admin/shop/orders/{placed_order.id}/cancel'
form_data = {
'reason': 'Dein Vorname ist albern!',
# Sending e-mail is not requested.
}
with http_client(self.app, user_id=self.admin.id) as client:
response = client.post(url, data=form_data)
order_afterwards = get_order(placed_order.id)
assert response.status_code == 302
# No e-mail should be send.
order_email_service_mock.send_email_for_canceled_order_to_orderer.assert_not_called(
)
event = ShopOrderCanceled(
occurred_at=order_afterwards.payment_state_updated_at,
order_id=placed_order.id,
initiator_id=self.admin.id,
)
order_canceled_signal_send_mock.assert_called_once_with(None,
event=event)
def test_order(self, order_email_service_mock, order_placed_mock):
article_before = self.get_article()
assert article_before.quantity == 5
url = '/shop/order'
article_quantity_key = f'article_{self.article_id}'
form_data = {
'first_names': 'Hiro',
'last_name': 'Protagonist',
'country': 'State of Mind',
'zip_code': '31337',
'city': 'Atrocity',
'street': 'L33t Street 101',
article_quantity_key: 3,
}
with http_client(self.app, user_id=self.orderer.id) as client:
response = client.post(url, data=form_data)
article_afterwards = self.get_article()
assert article_afterwards.quantity == 2
order = Order.query.filter_by(placed_by=self.orderer).one()
assert_order(order, 'AEC-01-B00005', 1)
first_order_item = order.items[0]
assert_order_item(
first_order_item,
self.article_id,
article_before.price,
article_before.tax_rate,
3,
)
order_email_service_mock.send_email_for_incoming_order_to_orderer.assert_called_once_with(
order.id)
event = ShopOrderPlaced(occurred_at=order.created_at,
order_id=order.id)
order_placed_mock.assert_called_once_with(None, event=event)
order_detail_page_url = f'http://example.com/shop/orders/{order.id}'
assert_response_headers(response, order_detail_page_url)
with http_client(self.app, user_id=self.orderer.id) as client:
assert_order_detail_page_works(client, order_detail_page_url,
order.order_number)
def test_view_profile(self):
url = f'/users/{self.user.id}'
with http_client(self.app) as client:
response = client.get(url)
assert response.status_code == 200
assert response.mimetype == 'text/html'
def request_view(self, current_user, order_id):
login_user(current_user.id)
url = '/shop/orders/{}'.format(str(order_id))
with http_client(self.app, user_id=current_user.id) as client:
response = client.get(url)
return response
def send_request(self, recipient_id, text, *, current_user_id=None):
url = '/user_messages/to/{}/create'.format(recipient_id)
form_data = {
'body': text,
}
if current_user_id is not None:
login_user(current_user_id)
with http_client(self.app, user_id=current_user_id) as client:
return client.post(url, data=form_data)
def test_pin_topic(self):
topic_before = create_topic(self.category_id, self.user.id, 1)
assert_topic_is_not_pinned(topic_before)
url = '/board/topics/{}/flags/pinned'.format(topic_before.id)
with http_client(self.app, user_id=self.admin.id) as client:
response = client.post(url)
assert response.status_code == 204
topic_afterwards = find_topic(topic_before.id)
assert_topic_is_pinned(topic_afterwards, self.admin.id)
def test_order_single(self, order_email_service_mock, order_placed_mock):
article_before = self.get_article()
assert article_before.quantity == 5
url = '/shop/order_single/{}'.format(str(self.article_id))
form_data = {
'first_names': 'Hiro',
'last_name': 'Protagonist',
'country': 'State of Mind',
'zip_code': '31337',
'city': 'Atrocity',
'street': 'L33t Street 101',
'quantity': 1, # TODO: Test with `3` if limitation is removed.
}
with http_client(self.app, user_id=self.orderer.id) as client:
response = client.post(url, data=form_data)
article_afterwards = self.get_article()
assert article_afterwards.quantity == 4
order = Order.query.filter_by(placed_by=self.orderer).one()
assert_order(order, 'AEC-01-B00005', 1)
first_order_item = order.items[0]
assert_order_item(first_order_item, self.article_id,
article_before.price, article_before.tax_rate, 1)
order_email_service_mock.send_email_for_incoming_order_to_orderer \
.assert_called_once_with(order.id)
order_placed_mock.assert_called_once_with(None, order_id=order.id)
order_detail_page_url = 'http://example.com/shop/orders/{}' \
.format(order.id)
assert_response_headers(response, order_detail_page_url)
with http_client(self.app, user_id=self.orderer.id) as client:
assert_order_detail_page_works(client, order_detail_page_url,
order.order_number)
def request_comment_creation(self, match_id, *, user_id=None):
url = '/api/tourney/matches/{}/comments'.format(match_id)
headers = [
assemble_authorization_header('just-say-PLEASE'),
]
form_data = {
'body': 'gg',
}
with http_client(self.app, user_id=user_id) as client:
return client.post(url, headers=headers, data=form_data)
def test_hide_topic(self):
topic_before = create_topic(self.category_id, self.user.id, 1)
self.db.session.commit()
assert_topic_is_not_hidden(topic_before)
url = '/board/topics/{}/flags/hidden'.format(topic_before.id)
with http_client(self.app, user_id=self.admin.id) as client:
response = client.post(url)
assert response.status_code == 204
topic_afterwards = find_topic(topic_before.id)
assert_topic_is_hidden(topic_afterwards, self.admin.id)
def test_unhide_topic(self):
topic_before = create_topic(self.category_id, self.user.id, 1)
board_topic_command_service.hide_topic(topic_before, self.admin.id)
assert_topic_is_hidden(topic_before, self.admin.id)
url = '/board/topics/{}/flags/hidden'.format(topic_before.id)
with http_client(self.app, user_id=self.admin.id) as client:
response = client.delete(url)
assert response.status_code == 204
topic_afterwards = find_topic(topic_before.id)
assert_topic_is_not_hidden(topic_afterwards)
def test_move_topic(self):
topic_before = create_topic(self.category_id_1, self.user.id, 1)
assert topic_before.category.id == self.category_id_1
url = '/board/topics/{}/move'.format(topic_before.id)
form_data = {'category_id': self.category_id_2}
with http_client(self.app, user_id=self.admin.id) as client:
response = client.post(url, data=form_data)
assert response.status_code == 302
topic_afterwards = find_topic(topic_before.id)
assert topic_afterwards.category.id == self.category_id_2
def test_serialize_order(self):
filename = 'testfixtures/shop/order_export.xml'
with codecs.open(filename, encoding='iso-8859-1') as f:
expected = f.read().rstrip()
url = f'/admin/shop/orders/{self.order.id}/export'
with http_client(self.app, user_id=self.admin.id) as client:
response = client.get(url)
assert response.status_code == 200
assert response.content_type == 'application/xml; charset=iso-8859-1'
body = response.get_data().decode('utf-8')
assert body == expected
def test_cancel_before_paid_without_sending_email(self,
order_email_service_mock, order_canceled_signal_send_mock):
article_before = self.create_article(self.shop.id, quantity=8)
quantified_articles_to_order = {(article_before, 3)}
placed_order = self.place_order(quantified_articles_to_order)
url = '/admin/shop/orders/{}/cancel'.format(placed_order.id)
form_data = {
'reason': 'Dein Vorname ist albern!',
# Sending e-mail is not requested.
}
with http_client(self.app, user_id=self.admin.id) as client:
response = client.post(url, data=form_data)
assert response.status_code == 302
# No e-mail should be send.
order_email_service_mock.send_email_for_canceled_order_to_orderer \
.assert_not_called()
order_canceled_signal_send_mock \
.assert_called_once_with(None, order_id=placed_order.id)
def send_request(self, form_data):
url = '/users/'
with http_client(self.app) as client:
return client.post(url, data=form_data)
def get_as_admin(self, url):
"""Make a GET request as the admin and return the response."""
with http_client(self.app, user_id=self.admin.id) as client:
return client.get(url)
def client(app, newsletter_admin):
"""Provide a test HTTP client against the API."""
with http_client(app, user_id=newsletter_admin.id) as client:
yield client
def send_request(self, *, user_id=None):
url = '/authentication/password/update'
with http_client(self.app, user_id=user_id) as client:
return client.get(url)
def _confirm(self, verification_token):
url = '/users/email_address/confirmation/{}' \
.format(verification_token.token)
with http_client(self.app) as client:
return client.get(url)
def send_request(self, form_data, *, user_id=None):
url = '/authentication/password'
with http_client(self.app, user_id=user_id) as client:
return client.post(url, data=form_data)
def send_request(self, *, user_id=None):
url = '/users/me'
with http_client(self.app, user_id=user_id) as client:
return client.get(url)
def send_request(self, user_id):
url = '/users/{}.json'.format(user_id)
with http_client(self.app) as client:
return client.get(url)
