def test_master_exists(self):
# old schedule
Schedule.objects.create(master=self.master_object,
date=utils.get_date(-2))
# new schedule
Schedule.objects.create(master=self.master_object,
date=utils.get_date(2))
# new schedule
Schedule.objects.create(master=self.master_object,
date=utils.get_date(1))
# today's schedule
Schedule.objects.create(master=self.master_object,
date=utils.get_date(0))
resp = self.client.get(
reverse(MasterDetailUpdateView.view_name,
args=[self.master_object.id]))
self.assertEqual(resp.status_code, status.HTTP_200_OK)
# only new schedules are returned
self.assertEqual(len(resp.data['schedule']), 3)
# ASC sorted
self.assertLess(resp.data['schedule'][0]['date'],
resp.data['schedule'][1]['date'])
self.assertLess(resp.data['schedule'][1]['date'],
resp.data['schedule'][2]['date'])
def test_list_master_orders(self):
master = Master.objects.get(first_name='VASYA')
# logging in as a master
token, _ = Token.objects.get_or_create(master=master)
self.client = APIClient()
self.client.credentials(HTTP_AUTHORIZATION=f'Token {token.key}')
service = master.services.all()[0]
# manually creating an order
order_1, _ = make_order(client=self.client_object, master=master,
service=service,
order_date=utils.get_date(1),
order_time=datetime.time(hour=11, minute=00))
# manually creating an order
order_2, _ = make_order(client=self.client_object, master=master,
service=service,
order_date=utils.get_date(1),
order_time=datetime.time(hour=12, minute=00))
resp = self.client.get(reverse(OrderListCreateView.view_name))
self.assertEqual(resp.status_code, status.HTTP_200_OK)
# two orders
# TODO test serializers
active = resp.data['active']
history = resp.data['history']
self.assertEqual(len(active), 2)
def test_create_order__one_master_many_services(self):
master = Master.objects.get(first_name='VASYA')
schedule = master.get_schedule(utils.get_date(1))
TimeSlot.objects.create(time=Time.objects.create(hour=12, minute=30),
taken=False,
schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=13, minute=00),
taken=False,
schedule=schedule)
services = master.services.all()
# two services, 5 slots, no+1
target_date = utils.get_date(1)
resp = self.client.post(
reverse(OrderListCreateView.view_name),
data={
'date':
target_date,
'payment_type':
'CARD',
'time':
'11:00',
'order_items': [
{
'locked': False,
'master_id': master.id,
'service_ids': [service.id for service in services]
},
]
},
format='json')
self.assertEqual(resp.status_code, status.HTTP_201_CREATED)
master = Master.objects.get(first_name='VASYA')
schedule = master.schedule.get(date=target_date)
# assert timeslots are correctly set
slots = schedule.time_slots.filter(
time__value__in=['11:00', '11:30', '12:00', '12:30', '13:00'],
taken=True)
self.assertEqual(len(slots), 5)
# assert order is created
orders = Order.objects.all()
self.assertTrue(len(orders), 1)
order = orders[0]
self.assertEqual(order.client, self.client_object)
self.assertEqual(order.date.strftime('%Y-%m-%d'), target_date)
self.assertEqual(order.time, datetime.time(hour=11, minute=0))
self.assertEqual(len(order.order_items.all()), 2)
# assert future balance is correct
self.assertEqual(
master.balance.future,
sum(
map(
lambda s: int(
s.masters_share(self.client_object.tip_multiplier())),
services)))
def test_list_client_orders(self):
master = Master.objects.get(first_name='VASYA')
schedule = master.get_schedule(timezone.now() + delta(days=2))
schedule.delete()
schedule = Schedule.objects.create(master=master,
date=timezone.now() + delta(days=2))
schedule.save()
TimeSlot.objects.create(time=Time.objects.create(hour=12, minute=30),
taken=False, schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=13, minute=00),
taken=False, schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=13, minute=30),
taken=False, schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=14, minute=00),
taken=False, schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=14, minute=30),
taken=False, schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=15, minute=00),
taken=False, schedule=schedule)
service = master.services.all()[0]
# manually creating an order
order_1, _ = make_order(client=self.client_object, master=master,
service=service,
order_date=utils.get_date(1),
order_time=datetime.time(hour=11, minute=00))
# manually creating an order
order_2, _ = make_order(client=self.client_object, master=master,
service=service,
order_date=utils.get_date(2),
order_time=datetime.time(hour=12, minute=30))
order_2, _ = make_order(client=self.client_object, master=master,
service=service,
order_date=utils.get_date(2),
order_time=datetime.time(hour=14, minute=30))
order_3, _ = make_order(client=self.client_object, master=master,
service=service,
order_date=utils.get_date(1),
order_time=datetime.time(hour=11, minute=30),
status=OrderStatus.DONE)
resp = self.client.get(reverse(OrderListCreateView.view_name))
self.assertEqual(resp.status_code, status.HTTP_200_OK)
# two orders
# TODO test serializers
active = resp.data['active']
history = resp.data['history']
self.assertEqual(len(active), 3)
self.assertEqual(len(history), 1)
def test_master_best_match(self, _calculate_eta):
master = Master.objects.get(first_name='VASYA')
schedule = master.get_schedule(utils.get_date(1))
schedule.delete()
schedule = Schedule.objects.create(master=master,
date=timezone.now() + delta(days=1))
schedule.save()
TimeSlot.objects.create(time=Time.objects.create(hour=10, minute=30),
taken=False, schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=11, minute=00),
taken=False, schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=11, minute=30),
taken=False, schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=12, minute=00),
taken=False, schedule=schedule)
service = master.services.all()[0]
# assume all slots are reachable
_calculate_eta.return_value = 10
url = reverse(MasterBestMatchView.view_name)
resp = self.client.get(f"{url}?service={service.id}"
f"&date={utils.get_date(1)}&time=11:00"
f"&coordinates=10,20")
self.assertEqual(resp.status_code, status.HTTP_200_OK)
# no favorites in this test
master_data = resp.data
self.assertEqual(master_data['first_name'], master.first_name)
def test_complete_order_cash(self):
master = Master.objects.get(first_name='VASYA')
service = master.services.all()[0]
# manually creating an order
order_1, _ = make_order(client=self.client_object,
master=master,
service=service,
order_date=utils.get_date(1),
order_time=datetime.time(hour=11, minute=00),
payment_type=PaymentType.CASH)
order_1.time_started = timezone.now()
order_1.status = OrderStatus.STARTED
order_1.save()
resp = self.client.patch(
reverse(CompleteOrderView.view_name, args=[order_1.id]))
self.assertEqual(resp.status_code, status.HTTP_200_OK)
self.assertEqual(resp.data['transaction_id'], None)
# TODO test serializers
order = Order.objects.get(pk=order_1.id)
self.assertIsNotNone(order.time_taken)
self.assertEqual(order.status, OrderStatus.DONE)
master = Master.objects.get(first_name='VASYA')
self.assertEqual(
master.balance.on_hold,
service.masters_share(self.client_object.tip_multiplier()))
self.assertEqual(master.balance.debt, service.service_share())
def test_create_client_existing_master(self):
make_master('mas', 10, user=self.user)
client = make_client(user=self.user, activated=False)
token, _ = Token.objects.get_or_create(client=client)
self.client = APIClient()
self.client.credentials(HTTP_AUTHORIZATION=f'Token {token.key}')
resp = self.client.post(reverse(ClientCreateView.view_name),
data={
'first_name': 'VASYA',
'gender': Gender.MALE,
'date_of_birth': utils.get_date(-100),
'tip': 10,
'address': {
'location': {
'lat': 100,
'lon': 100,
},
'city': 'kazan',
'street_name': 'latstr',
'building': '4',
'floor': 2,
'apt_number': 79,
'entrance': 6,
'has_intercom': True
}
},
format='json')
self.assertEqual(resp.status_code, status.HTTP_201_CREATED)
# dat user
self.user = PhoneAuthUser.objects.get(phone='777')
self.assertIsNotNone(self.user.client)
self.assertEqual(self.user.client.first_name, 'VASYA')
self.assertIsNotNone(self.user.master)
self.assertEqual(self.user.master.first_name, 'mas')
def test_recommendation(self):
master = Master.objects.get(first_name='VASYA')
schedule = master.get_schedule(timezone.now() + delta(days=1))
TimeSlot.objects.create(time=Time.objects.create(hour=12, minute=30),
taken=False,
schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=13, minute=00),
taken=False,
schedule=schedule)
services = list(master.services.all())
order_service = services[0]
# assume the order is almost created for 11:00 and 11:30
resp = self.client.post(reverse(UpsaleRecommendationsView.view_name),
data={
'date':
utils.get_date(1),
'time':
'11:00',
'order_items': [{
'locked':
False,
'master_id':
master.id,
'service_ids': [order_service.id]
}]
},
format='json')
self.assertEqual(resp.status_code, status.HTTP_200_OK)
self.assertEqual(resp.data, [{
'master_id': master.id,
'service_id': services[1].id
}])
def test_cancel_order_cash(self):
master = Master.objects.get(first_name='VASYA')
service = master.services.all()[0]
# manually creating an order
order_1, _ = make_order(client=self.client_object,
master=master,
service=service,
order_date=utils.get_date(2),
order_time=datetime.time(hour=12, minute=30),
payment_type=PaymentType.CASH)
self.assertNotEqual(master.balance.future, 0)
self.assertNotEqual(master.balance.debt, 0)
resp = self.client.delete(
reverse(OrderCancelView.view_name, args=[order_1.id]))
self.assertEqual(resp.status_code, status.HTTP_204_NO_CONTENT)
# two orders
with self.assertRaises(Order.DoesNotExist):
Order.objects.get(pk=order_1.id)
master = Master.objects.get(pk=master.id)
self.assertEqual(master.balance.future, 0)
self.assertEqual(master.balance.debt, 0)
def test_create_client(self):
token, _ = Token.objects.get_or_create(client=make_client(
activated=False))
self.client = APIClient()
self.client.credentials(HTTP_AUTHORIZATION=f'Token {token.key}')
resp = self.client.post(reverse(ClientCreateView.view_name),
data={
'first_name': 'VASYA',
'gender': Gender.MALE,
'date_of_birth': utils.get_date(-100),
'tip': 10,
'address': {
'location': {
'lat': 100,
'lon': 100,
},
'city': 'kazan',
'street_name': 'latstr',
'building': '4',
'floor': 2,
'apt_number': 79,
'entrance': 6,
'has_intercom': True
}
},
format='json')
self.assertEqual(resp.status_code, status.HTTP_201_CREATED)
new_client_object = Client.objects.get(first_name='VASYA')
self.assertEqual(new_client_object.first_name, 'VASYA')
self.assertEqual(new_client_object.gender, Gender.MALE)
self.assertEqual(new_client_object.tip, 10)
self.assertEqual(len(new_client_object.addresses.all()), 1)
self.assertEqual(new_client_object.home_address.city, 'kazan')
def test_create_order__one_master_many_services_does_not_fit(self):
master = Master.objects.get(first_name='VASYA')
schedule = master.get_schedule(utils.get_date(1))
TimeSlot.objects.create(time=Time.objects.create(hour=12, minute=30),
taken=True,
schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=13, minute=00),
taken=False,
schedule=schedule)
services = master.services.all()
# two services, 5 slots, no+1
resp = self.client.post(
reverse(OrderListCreateView.view_name),
data={
'date':
timezone.now().strftime('%Y-%m-%d'),
'payment_type':
'CARD',
'time':
'11:00',
'order_items': [
{
'locked': False,
'master_id': master.id,
'service_ids': [service.id for service in services]
},
]
},
format='json')
self.assertEqual(resp.status_code,
status.HTTP_500_INTERNAL_SERVER_ERROR)
# assert no order is created
self.assertEqual(Order.objects.count(), 0)
def test_update_comment(self):
master = Master.objects.get(first_name='VASYA')
service = master.services.all()[0]
# manually creating an order
# manually creating an order
order_1, _ = make_order(client=self.client_object,
master=master,
service=service,
order_date=utils.get_date(1),
order_time=datetime.time(hour=11, minute=00),
payment_type=PaymentType.CASH,
comment='LOL')
order_1.time_started = timezone.now()
order_1.status = OrderStatus.DONE
order_1.save()
self.assertEqual(order_1.comment, 'LOL')
resp = self.client.patch(reverse(OrderUpdateCommentView.view_name,
args=[order_1.id]),
data={'comment': 'A new comment'},
format='json')
self.assertEqual(resp.status_code, status.HTTP_200_OK)
order = Order.objects.get(pk=order_1.id)
self.assertEqual(order.comment, 'A new comment')
def test_create_client_existing_client(self):
token, _ = Token.objects.get_or_create(client=make_client(self.user))
self.client = APIClient()
self.client.credentials(HTTP_AUTHORIZATION=f'Token {token.key}')
resp = self.client.post(reverse(ClientCreateView.view_name),
data={
'first_name': 'VASYA',
'gender': Gender.MALE,
'date_of_birth': utils.get_date(-100),
'tip': 10,
'address': {
'location': {
'lat': 100,
'lon': 100,
},
'city': 'kazan',
'street_name': 'latstr',
'building': '4',
'floor': 2,
'apt_number': 79,
'entrance': 6,
'has_intercom': True
}
},
format='json')
self.assertEqual(resp.status_code, status.HTTP_403_FORBIDDEN)
def test_add_feedback_fail_no_orders(self):
self.order.delete()
resp = self.client.post(
reverse(AddFeedbackView.view_name, args=[self.master_object.id]),
data={
'rating': 4.0,
'text': 'superb',
'date': utils.get_date(1),
}, format='json')
self.assertEqual(resp.status_code, status.HTTP_403_FORBIDDEN)
def test_add_second_feedback(self):
feedback = Feedback.objects.create(client=self.client_object,
master=self.master_object,
rating=5, text='kek',
date=utils.get_date(0))
self.master_object.add_rating(feedback.rating)
self.master_object.save()
resp = self.client.post(
reverse(AddFeedbackView.view_name, args=[self.master_object.id]),
data={
'rating': 4.0,
'text': 'superb',
'date': utils.get_date(1),
}, format='json')
self.assertEqual(resp.status_code, status.HTTP_201_CREATED)
self.master_object = Master.objects.get(first_name='VASYA')
feedback_items = list(self.master_object.feedbacks.all())
self.assertEqual(len(feedback_items), 2)
self.assertEqual(self.master_object.rating, 4.5)
def test_add_first_feedback(self):
resp = self.client.post(
reverse(AddFeedbackView.view_name, args=[self.master_object.id]),
data={
'rating': 4.0,
'text': 'superb',
'date': utils.get_date(1),
'order_id': self.order.id
}, format='json')
self.assertEqual(resp.status_code, status.HTTP_201_CREATED)
self.master_object = Master.objects.get(first_name='VASYA')
feedback_items = list(self.master_object.feedbacks.all())
self.assertEqual(len(feedback_items), 1)
self.assertEqual(self.master_object.rating, 4.0)
self.assertEqual(feedback_items[0].text, 'superb')
self.assertEqual(feedback_items[0].rating, 4.0)
self.assertEqual(feedback_items[0].client, self.client_object)
self.assertEqual(feedback_items[0].master, self.master_object)
self.assertEqual(feedback_items[0].date.strftime('%Y-%m-%d'),
utils.get_date(1))
def test_create_order__one_master_one_service_cash(self):
master = Master.objects.get(first_name='VASYA')
service = master.services.first()
# one service 2+1 slots
target_date = utils.get_date(1)
resp = self.client.post(reverse(OrderListCreateView.view_name),
data={
'date':
target_date,
'payment_type':
'CASH',
'time':
'11:00',
'order_items': [
{
'locked': False,
'master_id': master.id,
'service_ids': [service.id]
},
]
},
format='json')
self.assertEqual(resp.status_code, status.HTTP_201_CREATED)
master = Master.objects.get(first_name='VASYA')
schedule = master.schedule.get(date=target_date)
# assert timeslots are correctly set
slots = schedule.time_slots.filter(
time__value__in=['11:00', '11:30', '12:00'], taken=True)
self.assertEqual(len(slots), 3)
# assert order is created
orders = Order.objects.all()
self.assertTrue(len(orders), 1)
order = orders[0]
self.assertEqual(order.client, self.client_object)
self.assertEqual(order.date.strftime('%Y-%m-%d'), target_date)
self.assertEqual(order.time, datetime.time(hour=11, minute=0))
self.assertEqual(len(order.order_items.all()), 1)
order_item = order.order_items.all()[0]
# assert order_items are created
self.assertEqual(order_item.master, master)
self.assertEqual(order_item.service, service)
# assert future balance is correct
self.assertEqual(
master.balance.future,
service.masters_share(self.client_object.tip_multiplier()))
# assert debt is correct
self.assertEqual(master.balance.debt, service.service_share())
def test_create_master_existing_account(self):
old_client = make_client()
token, _ = Token.objects.get_or_create(client=old_client)
self.client = APIClient()
self.client.credentials(HTTP_AUTHORIZATION=f'Token {token.key}')
resp = self.client.post(reverse(MasterListCreateView.view_name), data={
'first_name': 'SUPER_MASTER',
'gender': Gender.MALE,
'date_of_birth': utils.get_date(-100),
'email': '*****@*****.**',
'services': [service.id for service in Service.objects.all()]
}, format='json')
self.assertEqual(resp.status_code, status.HTTP_403_FORBIDDEN)
def test_create_master(self):
resp = self.client.post(reverse(MasterListCreateView.view_name), data={
'first_name': 'SUPER_MASTER',
'gender': Gender.MALE,
'date_of_birth': utils.get_date(-100),
'email': '*****@*****.**',
'services': ','.join(
[str(service.id) for service in Service.objects.all()]),
'avatar': utils.make_in_memory_image('azz')
}, format='multipart')
self.assertEqual(resp.status_code, status.HTTP_201_CREATED)
new_master = Master.objects.get(first_name='SUPER_MASTER')
self.assertEqual(new_master.status, MasterStatus.ON_REVIEW)
self.assertEqual(new_master.gender, Gender.MALE)
self.assertEqual(new_master.email, '*****@*****.**')
self.assertIsNotNone(new_master.balance)
self.assertEqual(len(new_master.services.all()),
len(Service.objects.all()))
def test_cancel_someone_elses_order(self):
master = Master.objects.get(first_name='VASYA')
service = master.services.all()[0]
# manually creating an order
order_1, _ = make_order(client=self.client_object,
master=master,
service=service,
order_date=utils.get_date(1),
order_time=datetime.time(hour=11, minute=00))
token, _ = Token.objects.get_or_create(client=make_client())
self.client = APIClient()
self.client.credentials(HTTP_AUTHORIZATION=f'Token {token.key}')
resp = self.client.delete(
reverse(OrderCancelView.view_name, args=[order_1.id]))
self.assertEqual(resp.status_code, status.HTTP_403_FORBIDDEN)
def test_create_client_partial(self):
token, _ = Token.objects.get_or_create(client=make_client(
activated=False))
self.client = APIClient()
self.client.credentials(HTTP_AUTHORIZATION=f'Token {token.key}')
resp = self.client.post(reverse(ClientCreateView.view_name),
data={
'first_name': 'VASYA',
'gender': Gender.MALE,
'date_of_birth': utils.get_date(-100),
},
format='json')
self.assertEqual(resp.status_code, status.HTTP_201_CREATED)
new_client_object = Client.objects.get(first_name='VASYA')
self.assertEqual(new_client_object.first_name, 'VASYA')
self.assertEqual(new_client_object.gender, Gender.MALE)
self.assertEqual(len(new_client_object.addresses.all()), 0)
def test_master_search_two_services(self, _calculate_eta):
master = Master.objects.get(first_name='VASYA')
schedule = master.get_schedule(utils.get_date(1))
schedule.delete()
schedule = Schedule.objects.create(master=master, date=timezone.now()
+ delta(days=1))
schedule.save()
TimeSlot.objects.create(time=Time.objects.create(hour=10, minute=30),
taken=False, schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=11, minute=00),
taken=False, schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=11, minute=30),
taken=False, schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=12, minute=00),
taken=False, schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=12, minute=30),
taken=False, schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=13, minute=00),
taken=False, schedule=schedule)
# assume all slots are reachable
_calculate_eta.return_value = 10
url = reverse(MasterSearchView.view_name)
service_ids = ','.join(
[str(service.id) for service in master.services.all()[0:2]])
resp = self.client.get(
f"{url}?services={service_ids}&coordinates=10,20")
self.assertEqual(resp.status_code, status.HTTP_200_OK)
# no favorites in this test
favorites = resp.data['favorites']
self.assertEqual(len(favorites), 0)
others = resp.data['others']
# both do at least one service in the following week
self.assertEqual(len(others), 1)
# one day with 5 slots
day_one_slots = others[0]['available_slots']
self.assertEqual(len(day_one_slots), 1)
def test_start_order(self):
master = Master.objects.get(first_name='VASYA')
service = master.services.all()[0]
# manually creating an order
order_date = utils.get_date(1, format_string=False)
order_1, _ = make_order(client=self.client_object, master=master,
service=service,
order_date=order_date,
order_time=datetime.time(hour=11, minute=00))
# we can only start it on the right day
frozen = freeze_time(order_date.replace(hour=10, minute=30))
frozen.start()
resp = self.client.patch(
reverse(StartOrderView.view_name, args=[order_1.id]))
frozen.stop()
self.assertEqual(resp.status_code, status.HTTP_204_NO_CONTENT)
# two orders
# TODO test serializers
order = Order.objects.get(pk=order_1.id)
self.assertEqual(order.status, OrderStatus.STARTED)
self.assertIsNotNone(order.time_started)
def test_complete_order_4hands(self):
# creating a new master
sanya = make_master('SANYA', 100)
feet = make_category("Педикюр")
for service in feet.services.all():
sanya.services.add(service)
sanya.save()
# VASYA works on +1,+2 does manicure, got three slots
date = utils.get_date(1)
schedule = Schedule.objects.create(master=sanya, date=date)
schedule.save()
TimeSlot.objects.create(time=Time.objects.create(hour=10, minute=30),
taken=True,
schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=11, minute=00),
taken=False,
schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=11, minute=30),
taken=False,
schedule=schedule)
vasya = Master.objects.get(first_name='VASYA')
# manually creating an order with two masters and two services
order_1, _ = make_order(client=self.client_object,
order_date=date,
master=vasya,
service=vasya.services.all()[0],
order_time=datetime.time(hour=11, minute=00))
schedule = sanya.get_schedule(date)
slot = schedule.get_slot(datetime.time(hour=11, minute=00))
order_item = OrderItem.objects.create(service=sanya.services.all()[0],
master=sanya,
order=order_1,
locked=False)
slot.order_item = order_item
slot.taken = True
slot.save()
order_1.time_started = timezone.now()
order_1.status = OrderStatus.STARTED
order_1.transaction = CloudPaymentsTransaction.objects.create(
transaction_id=1, transaction_info={'info': 'yeah'})
order_1.save()
resp = self.client.patch(
reverse(CompleteOrderView.view_name, args=[order_1.id]))
self.assertEqual(resp.status_code, status.HTTP_200_OK)
self.assertEqual(resp.data['transaction_id'], 1)
order = Order.objects.get(pk=order_1.id)
self.assertIsNotNone(order.time_taken)
self.assertEqual(order.status, OrderStatus.DONE)
vasya = Master.objects.get(first_name='VASYA')
sanya = Master.objects.get(first_name='SANYA')
self.assertEqual(
vasya.balance.on_hold,
int(vasya.services.all()[0].masters_share(
self.client_object.tip_multiplier())))
self.assertEqual(
sanya.balance.on_hold,
int(sanya.services.all()[0].masters_share(
self.client_object.tip_multiplier())))
def _make_everything():
# making an auth token
vasya = make_master("VASYA", 11.0, about='a terrible master')
petya = make_master("PETYA", 12.0)
hands = make_category("Маникюр")
feet = make_category("Педикюр")
make_display_item(hands)
make_display_item(feet)
make_display_item(hands, feet, name='4hands', special=True)
for service in hands.services.all():
vasya.services.add(service)
vasya.save()
token, _ = AppToken.objects.get_or_create(master=vasya,
key='master_token')
for service in feet.services.all():
petya.services.add(service)
petya.save()
# VASYA works on +1,+2,+3 does manicure, got three slots
schedule = Schedule.objects.create(master=vasya, date=utils.get_date(1))
schedule.save()
TimeSlot.objects.create(time=Time.objects.create(hour=11, minute=00),
taken=False, schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=11, minute=30),
taken=False, schedule=schedule)
schedule = Schedule.objects.create(master=vasya, date=utils.get_date(2))
schedule.save()
TimeSlot.objects.create(time=Time.objects.create(hour=10, minute=30),
taken=False, schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=11, minute=00),
taken=False, schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=11, minute=30),
taken=False, schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=12, minute=00),
taken=False, schedule=schedule)
schedule = Schedule.objects.create(master=vasya,
date=utils.get_date(3))
schedule.save()
TimeSlot.objects.create(time=Time.objects.create(hour=12, minute=30),
taken=False, schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=13, minute=00),
taken=False, schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=13, minute=30),
taken=False, schedule=schedule)
# PETYA works on +2th, +3th does pedicure, got all slots on +2, none on +3
schedule = Schedule.objects.create(master=petya,
date=utils.get_date(2))
schedule.save()
TimeSlot.objects.create(time=Time.objects.create(hour=10, minute=30),
taken=False, schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=11, minute=00),
taken=False, schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=11, minute=30),
taken=False, schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=12, minute=30),
taken=False, schedule=schedule)
schedule = Schedule.objects.create(master=petya,
date=utils.get_date(3))
schedule.save()
client = make_client(first_name='client')
client2 = make_client(first_name='client2')
client3 = make_client(first_name='john doe')
token, _ = AppToken.objects.get_or_create(client=client,
key='client_token')
order, _ = make_order(client=client, service=hands.services.all()[0],
order_date=utils.get_date(2),
master=vasya, order_time='10:30')
order, _ = make_order(client=client2, service=hands.services.all()[1],
order_date=utils.get_date(2),
master=vasya, order_time='11:30')
# still got 2 slots on the first day
order, _ = make_order(client=client3, service=hands.services.all()[0],
master=vasya, order_time='11:00',
order_date=utils.get_date(1),
status=OrderStatus.DONE)
order.start()
order.complete()
order.save()
def test_create_order__composite_4hands(self):
vasya = Master.objects.get(first_name='VASYA')
sanya = make_master("SANYA", 12.0)
feet = ServiceCategory.objects.get(name="Педикюр")
for service in feet.services.all():
sanya.services.add(service)
sanya.save()
target_date = utils.get_date(1)
schedule = Schedule.objects.create(master=sanya, date=target_date)
schedule.save()
TimeSlot.objects.create(time=Time.objects.create(hour=10, minute=30),
taken=True,
schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=11, minute=00),
taken=False,
schedule=schedule)
TimeSlot.objects.create(time=Time.objects.create(hour=11, minute=30),
taken=False,
schedule=schedule)
# two services, 2+1 for vasya, 2 for sanya
resp = self.client.post(reverse(OrderListCreateView.view_name),
data={
'date':
target_date,
'payment_type':
'CARD',
'time':
'11:00',
'order_items': [{
'locked':
False,
'master_id':
vasya.id,
'service_ids':
[vasya.services.first().id]
}, {
'locked':
False,
'master_id':
sanya.id,
'service_ids':
[sanya.services.first().id]
}],
'special': {
'type': 'composite'
}
},
format='json')
self.assertEqual(resp.status_code, status.HTTP_201_CREATED)
vasya = Master.objects.get(first_name='VASYA')
schedule = vasya.schedule.get(date=target_date)
# assert timeslots are correctly set
slots = schedule.time_slots.filter(
time__value__in=['11:00', '11:30', '12:00'], taken=True)
self.assertEqual(len(slots), 3)
sanya = Master.objects.get(first_name='SANYA')
schedule = sanya.schedule.get(date=target_date)
# assert timeslots are correctly set
slots = schedule.time_slots.filter(time__value__in=['11:00', '11:30'],
taken=True)
self.assertEqual(len(slots), 2)
# assert order is created
orders = Order.objects.all()
self.assertTrue(len(orders), 1)
order = orders[0]
self.assertEqual(order.client, self.client_object)
self.assertEqual(order.date.strftime('%Y-%m-%d'), target_date)
self.assertEqual(order.time, datetime.time(hour=11, minute=0))
self.assertEqual(len(order.order_items.all()), 2)
order_item = order.order_items.all()[0]
order_item_1 = order.order_items.all()[1]
# assert order_items are created
self.assertEqual(order_item.master, vasya)
self.assertEqual(order_item.service, vasya.services.first())
self.assertEqual(order_item_1.master, sanya)
self.assertEqual(order_item_1.service, sanya.services.first())
# assert future balance is correct
self.assertEqual(
vasya.balance.future,
vasya.services.first().masters_share(
self.client_object.tip_multiplier()))
self.assertEqual(
sanya.balance.future,
sanya.services.first().masters_share(
self.client_object.tip_multiplier()))
