def test_form_ok(self):
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
aptrental = model_creation.create_test_aptrental(
transaction, timezone.now())
form = self.form_type(model_to_dict(transaction), instance=transaction)
self.assertTrue(form.is_valid())
def test_deposit_returned(self):
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
aptrental = model_creation.create_test_aptrental(
transaction, timezone.now())
aptrentaldeposit = model_creation.create_test_aptrentaldeposit(
transaction, aptrental, timezone.now())
aptrentaldepositbase = BaseConcept.objects.get(
code=aptrentaldeposit.code)
transaction.close(self.admin)
self.assertFalse(aptrentaldeposit.deposit_return)
self.assertTrue(aptrentaldeposit.can_return_deposit)
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
depositreturn = model_creation.create_test_depositreturn(
transaction, aptrentaldeposit, timezone.now())
depositreturnbase = BaseConcept.objects.get(code=depositreturn.code)
self.assertFalse(aptrentaldeposit.deposit_return)
self.assertFalse(aptrentaldepositbase.deposit_return)
self.assertTrue(aptrentaldeposit.can_return_deposit)
self.assertTrue(aptrentaldepositbase.can_return_deposit)
transaction.close(self.admin)
self.assertTrue(aptrentaldeposit.deposit_return)
self.assertTrue(aptrentaldepositbase.deposit_return)
self.assertTrue(depositreturn.returned_deposit)
self.assertTrue(depositreturnbase.returned_deposit)
self.assertFalse(aptrentaldeposit.can_return_deposit)
self.assertFalse(aptrentaldepositbase.can_return_deposit)
def test_create_one_of_each(self):
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
aptrental = model_creation.create_test_aptrental(
transaction, timezone.now())
aptrentaldeposit = model_creation.create_test_aptrentaldeposit(
transaction, aptrental, timezone.now())
transaction.close(self.admin)
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
cashfloatdeposit = model_creation.create_test_cashfloatdeposit(
transaction, timezone.now())
cashfloatwithdrawal = model_creation.create_test_cashfloatwithdrawal(
transaction, timezone.now())
transaction.close(self.admin)
cashclose = model_creation.create_test_cashclose(
timezone.now(), self.admin)
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
depositreturn = model_creation.create_test_depositreturn(
transaction, aptrentaldeposit, timezone.now())
refund = model_creation.create_test_refund(transaction, aptrental,
timezone.now())
parkingrental = model_creation.create_test_parkingrental(
transaction, timezone.now())
parkingrentaldeposit = model_creation.create_test_parkingrentaldeposit(
transaction, aptrental, timezone.now())
model_creation.create_parkingrentalsettings()
model_creation.create_parkingrentalsettings()
model_creation.create_parkingrentaldepositsettings()
model_creation.create_parkingrentaldepositsettings()
def test_refunded(self):
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
aptrental = model_creation.create_test_aptrental(
transaction, timezone.now())
aptrentalbase = BaseConcept.objects.get(code=aptrental.code)
transaction.close(self.admin)
self.assertFalse(aptrental.refund_concept)
self.assertFalse(aptrentalbase.refund_concept)
self.assertTrue(aptrental.can_refund)
self.assertTrue(aptrentalbase.can_refund)
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
refund = model_creation.create_test_refund(transaction, aptrental,
timezone.now())
refundbase = BaseConcept.objects.get(code=refund.code)
self.assertFalse(aptrental.refund_concept)
self.assertFalse(aptrentalbase.refund_concept)
self.assertTrue(aptrentalbase.can_refund)
transaction.close(self.admin)
self.assertTrue(aptrental.refund_concept)
self.assertTrue(aptrentalbase.refund_concept)
self.assertTrue(refund.refunded_concept)
self.assertTrue(refundbase.refunded_concept)
self.assertFalse(aptrental.can_refund)
self.assertFalse(aptrentalbase.can_refund)
def test_save_with_deposit(self):
transaction = model_creation.create_test_client_transaction(
self.admin, timezone.now())
adults = 2
children = 1
start_date = timezone.now()
end_date = timezone.now() + timezone.timedelta(days=7)
aptrental = model_creation.create_test_aptrental(
transaction,
timezone.now(),
adults=adults,
children=children,
start_date=start_date,
end_date=end_date,
)
form_data = {
'adults': adults,
'children': children,
'start_date': start_date,
'end_date': end_date,
'add_deposit': True,
}
form = AptRentalForm(data=form_data, instance=aptrental)
self.assertTrue(form.is_valid())
self.assertTrue(form.save())
def test_with_nonreturnable_concept(self):
# Create a deposit
transaction = model_creation.create_test_transaction(self.admin, timezone.now())
aptrental = model_creation.create_test_aptrental(transaction, timezone.now())
self.kwargs = {'concept_code': aptrental.code}
self.get_url = 'pass'
self.get_template = 'core/message.html'
self.repeat_get()
def test_with_concept(self):
# Create a deposit
transaction = model_creation.create_test_transaction(self.admin, timezone.now())
aptrental = model_creation.create_test_aptrental(transaction, timezone.now())
transaction.close(self.admin)
self.kwargs = {'concept_code': aptrental.code}
self.get_url = 'pass'
self.get_template = 'transactions/transaction_edit.html'
self.repeat_get()
def test_returned_deposit(self):
transaction = model_creation.create_test_transaction(self.admin, timezone.now())
aptrental = model_creation.create_test_aptrental(transaction, timezone.now())
aptrentaldeposit = model_creation.create_test_aptrentaldeposit(transaction, aptrental, timezone.now())
transaction.close(self.admin)
transaction = model_creation.create_test_transaction(self.admin, timezone.now())
deposit_return = model_creation.create_test_depositreturn(
transaction, aptrentaldeposit, timezone.now())
basereturn = BaseConcept.objects.get(code=deposit_return.code)
self.assertTrue(basereturn.returned_deposit)
def test_deposit_status_filter(self):
# Initial returned
filter_data = {
'deposit_status': True,
}
concept_filter = ConceptFilter(data=filter_data)
initial_returned = concept_filter.qs.count()
# One more returned
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
aptrental = model_creation.create_test_aptrental(
transaction, timezone.now())
aptrentaldeposit = model_creation.create_test_aptrentaldeposit(
transaction, aptrental, timezone.now())
transaction.close(self.admin)
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
depositreturn = model_creation.create_test_depositreturn(
transaction, aptrentaldeposit, timezone.now())
transaction.close(self.admin)
concept_filter = ConceptFilter(data=filter_data)
self.assertEqual(concept_filter.qs.count(), initial_returned + 1)
# Initial pending
filter_data = {
'deposit_status': False,
}
concept_filter = ConceptFilter(data=filter_data)
initial_pending = concept_filter.qs.count()
# One more pending
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
aptrental = model_creation.create_test_aptrental(
transaction, timezone.now())
aptrentaldeposit = model_creation.create_test_aptrentaldeposit(
transaction, aptrental, timezone.now())
transaction.close(self.admin)
concept_filter = ConceptFilter(data=filter_data)
self.assertEqual(concept_filter.qs.count(), initial_pending + 1)
def test_closed(self):
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
aptrental = model_creation.create_test_aptrental(
transaction, timezone.now())
aptrentaldeposit = model_creation.create_test_aptrentaldeposit(
transaction, aptrental, timezone.now())
transaction.close(self.admin)
timestamp = transaction.closed_date
transaction.close(self.admin)
self.assertEqual(timestamp, transaction.closed_date)
def test_refunded_concept(self):
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
aptrental = model_creation.create_test_aptrental(
transaction, timezone.now())
transaction.close(self.admin)
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
refund = model_creation.create_test_refund(transaction, aptrental,
timezone.now())
transaction.close(self.admin)
baserefund = BaseConcept.objects.get(code=refund.code)
self.assertTrue(baserefund.refunded_concept)
def test_min_value(self):
transaction1 = model_creation.create_test_transaction(self.admin, timezone.now())
start_date = timezone.now()
aptrental = model_creation.create_test_aptrental(
transaction1, timezone.now(),
adults=1,
children=0,
end_date=start_date + timezone.timedelta(days=1),
start_date=start_date,
)
aptrentaldeposit = AptRentalDeposit()
aptrentaldeposit.save(aptrental=aptrental)
self.assertEqual(aptrentaldeposit.value.amount, aptrentaldeposit.settings.min)
def test_with_return(self):
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
aptrental = model_creation.create_test_aptrental(
transaction, timezone.now())
aptrentaldeposit = model_creation.create_test_aptrentaldeposit(
transaction, aptrental, timezone.now())
transaction.close(self.admin)
transaction2 = model_creation.create_test_transaction(
self.admin, timezone.now())
depositreturn = model_creation.create_test_depositreturn(
transaction2, aptrentaldeposit, timezone.now())
transaction2.close(self.admin)
self.model_object = transaction2
self.test_attrs()
def test_closed(self):
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
aptrental = model_creation.create_test_aptrental(
transaction, timezone.now())
aptrentaldeposit = model_creation.create_test_aptrentaldeposit(
transaction, aptrental, timezone.now())
transaction.close(self.admin)
self.kwargs = {'transaction_code': transaction.code}
self.log_admin_in()
response = self.client.get(
reverse(self.url, kwargs=self.kwargs),
follow=True,
)
self.assertTemplateUsed(response, 'core/message.html')
self.assertEqual(response.status_code, 200)
def test_with_concept_and_transaction(self):
# Create a deposit
transaction = model_creation.create_test_transaction(self.admin, timezone.now())
aptrental = model_creation.create_test_aptrental(transaction, timezone.now())
transaction.close(self.admin)
self.kwargs = {
'concept_code': aptrental.code,
}
if self.client.session: # pragma: no cover
session = self.client.session
else: # pragma: no cover
engine = import_module(settings.SESSION_ENGINE)
session = engine.SessionStore()
session['refund_transaction_code'] = create_test_transaction(self.admin, timezone.now()).code
session.save()
self.get_url = 'pass'
self.get_template = 'transactions/transaction_edit.html'
self.repeat_get()
def test_save(self):
transaction = model_creation.create_test_transaction(self.admin, timezone.now())
aptrental = model_creation.create_test_aptrental(transaction, timezone.now())
aptrentaldeposit = model_creation.create_test_aptrentaldeposit(transaction, aptrental, timezone.now())
transaction.close(self.admin)
self.assertFalse(aptrentaldeposit.deposit_return)
self.assertTrue(aptrentaldeposit.can_return_deposit)
transaction = model_creation.create_test_transaction(self.admin, timezone.now())
deposit_return = model_creation.create_test_depositreturn(
transaction, aptrentaldeposit, timezone.now())
self.assertFalse(aptrentaldeposit.deposit_return)
self.assertTrue(aptrentaldeposit.can_return_deposit)
transaction.close(self.admin)
self.assertTrue(aptrentaldeposit.deposit_return)
self.assertFalse(aptrentaldeposit.can_return_deposit)
transaction = model_creation.create_test_transaction(self.admin, timezone.now())
with self.assertRaises(FieldError):
model_creation.create_test_depositreturn(transaction, aptrentaldeposit, timezone.now())
def test_client_signature_required(self):
# Not required
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
self.assertFalse(transaction.client_signature_required)
# Required
aptrental = model_creation.create_test_aptrental(
transaction, timezone.now())
aptrentaldeposit = model_creation.create_test_aptrentaldeposit(
transaction, aptrental, timezone.now())
transaction.close(self.admin)
transaction2 = model_creation.create_test_transaction(
self.admin, timezone.now())
depositreturn = model_creation.create_test_depositreturn(
transaction2, aptrentaldeposit, timezone.now())
transaction2.close(self.admin)
self.assertTrue(transaction2.client_signature_required)
def test_form_ok(self):
transaction1 = model_creation.create_test_transaction(self.admin, timezone.now())
aptrental = model_creation.create_test_aptrental(transaction1, timezone.now())
aptrentaldeposit = model_creation.create_test_aptrentaldeposit(transaction1, aptrental, timezone.now())
transaction1.close(self.admin)
transaction2 = model_creation.create_test_transaction(self.admin, timezone.now())
value = apps.get_model('concepts.conceptvalue')(
amount=aptrentaldeposit.value.amount,
currency=aptrentaldeposit.value.currency,
credit=False,
)
value.save()
form_data = {
'transaction': transaction2.id,
'value': value.id,
'vat_percent': 0,
'returned_deposit': aptrentaldeposit.id,
}
form = self.form_class(data=form_data)
self.assertTrue(form.is_valid())
def test_save(self):
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
aptrental = model_creation.create_test_aptrental(
transaction, timezone.now())
transaction.close(self.admin)
self.assertFalse(aptrental.refund_concept)
self.assertTrue(aptrental.can_refund)
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
refund = model_creation.create_test_refund(transaction, aptrental,
timezone.now())
self.assertFalse(aptrental.refund_concept)
self.assertTrue(aptrental.can_refund)
transaction.close(self.admin)
self.assertTrue(aptrental.refund_concept)
self.assertFalse(aptrental.can_refund)
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
with self.assertRaises(FieldError):
model_creation.create_test_refund(transaction, aptrental,
timezone.now())
def test_transaction_with_rental(self):
date = timezone.now()
employee = model_creation.get_sales_employee()
transaction = model_creation.create_test_client_transaction(
employee, date)
aptrental = model_creation.create_test_aptrental(transaction, date)
transaction.closed = True
transaction.closed_date = date
transaction.save()
cn = get_available_concepts(self.admin, transaction)
self.assertGreater(len(cn), 0)
# Cash operations should be disabled
for c in cn:
if c['name'] in ['Cash Float Deposit', 'Cash Float Withdrawal']:
self.assertEqual(c['disabled'],
True,
msg='{} is not disabled'.format(c['name']))
else:
self.assertEqual(c['disabled'],
False,
msg='{} is not enabled'.format(c['name']))
def test_bad(self):
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
aptrental = model_creation.create_test_aptrental(
transaction, timezone.now())
transaction.apt_number = None
transaction.client_first_name = None
transaction.client_last_name = None
transaction.client_id = None
transaction.save()
self.kwargs = {'transaction_code': transaction.code}
post_data = {
'confirm_button': True,
'cancel_button': False,
}
self.log_admin_in()
response = self.client.post(
reverse(self.url, kwargs=self.kwargs),
post_data,
follow=True,
)
self.assertTemplateUsed(response, self.get_template)
self.assertEqual(response.status_code, 200)
def setUpTestData(cls):
model_creation.create_default_models()
sgroup = model_creation.create_permission_group(
settings.PERMISSION_GROUPS['sales_employee'], [])
cgroup = model_creation.create_permission_group(
settings.PERMISSION_GROUPS['cash_desk_employee'], [])
# Create admin user
cls.admin = model_creation.create_superuser('administrator', 'admin',
'admin', '*****@*****.**')
# Create normal user
cls.normaluser = model_creation.create_user('sebas', 'Sebastian',
'Panti',
'*****@*****.**',
[sgroup])
# Create transaction
cls.transaction = Transaction.objects.create(employee=cls.normaluser, )
# Create a default currency
cls.currency = model_creation.create_currency_euros()
model_creation.create_currency_pounds()
model_creation.create_currency_dollars()
# Create aptrentalsettings
model_creation.create_aptrentalsettings()
cls.nightraterange = model_creation.create_nightraterange()
# Create an apartment rental
cls.aptrental = AptRental(
transaction=cls.transaction,
start_date=timezone.datetime.today(),
end_date=timezone.datetime.today() + timezone.timedelta(days=7),
)
cls.aptrental.save()
cls.aptrentaldeposit = AptRentalDeposit(
aptrental=cls.aptrental,
transaction=Transaction.objects.create(employee=cls.normaluser),
)
cls.aptrentaldeposit.save()
conceptvalue = apps.get_model('concepts.conceptvalue')(
amount=200, currency=cls.currency)
conceptvalue.save()
cls.cashfloatdeposit = apps.get_model('cash_desk.cashfloatdeposit')(
transaction=Transaction.objects.create(employee=cls.normaluser),
value=conceptvalue,
)
cls.cashfloatdeposit.save()
conceptvalue = apps.get_model('concepts.conceptvalue')(
amount=200, currency=cls.currency)
conceptvalue.save()
cls.cashfloatwithdrawal = apps.get_model(
'cash_desk.cashfloatwithdrawal')(
transaction=Transaction.objects.create(
employee=cls.normaluser),
value=conceptvalue,
)
cls.cashfloatwithdrawal.save()
# Create a depositreturn
transaction = model_creation.create_test_transaction(
cls.admin, timezone.now())
aptrental = model_creation.create_test_aptrental(
transaction, timezone.now())
aptrentaldeposit = model_creation.create_test_aptrentaldeposit(
transaction, aptrental, timezone.now())
transaction.close(cls.admin)
transaction = model_creation.create_test_transaction(
cls.admin, timezone.now())
cls.depositreturn = model_creation.create_test_depositreturn(
transaction, aptrentaldeposit, timezone.now())
# Create a parking rental
cls.parkingrental = ParkingRental(
transaction=cls.transaction,
start_date=timezone.datetime.today(),
end_date=timezone.datetime.today() + timezone.timedelta(days=7),
)
cls.parkingrental.save()
cls.parkingrentaldeposit = ParkingRentalDeposit(
parkingrental=cls.parkingrental,
transaction=Transaction.objects.create(employee=cls.normaluser),
)
cls.parkingrentaldeposit.save()
# Create a refund
transaction = model_creation.create_test_transaction(
cls.admin, timezone.now())
aptrental = model_creation.create_test_aptrental(
transaction, timezone.now())
transaction.close(cls.admin)
transaction = model_creation.create_test_transaction(
cls.admin, timezone.now())
cls.refund = model_creation.create_test_refund(transaction, aptrental,
timezone.now())
# Create a safe rental
cls.saferental = SafeRental(
transaction=cls.transaction,
start_date=timezone.datetime.today(),
end_date=timezone.datetime.today() + timezone.timedelta(days=7),
)
cls.saferental.save()
cls.saferentaldeposit = SafeRentalDeposit(
saferental=cls.saferental,
transaction=Transaction.objects.create(employee=cls.normaluser),
)
cls.saferentaldeposit.save()
# Create a servicetype, service and servicesale
cls.servicetype = model_creation.create_servicetype('Room')
cls.service = model_creation.create_service(cls.servicetype, 'Fan')
transaction = model_creation.create_test_transaction(
cls.admin, timezone.now())
cls.servicesale = model_creation.create_test_servicesale(
transaction, timezone.now())
# Create a company, show and ticket sale
cls.showcompany = model_creation.create_showcompany(
'Aqualandia & Mundomar')
cls.show = model_creation.create_show(cls.showcompany,
'Aqualandia One Day Ticket')
transaction = model_creation.create_test_transaction(
cls.admin, timezone.now())
cls.ticketsale = model_creation.create_test_ticketsale(
transaction, timezone.now())
print("\n\n============ %s ===============\n\n" % cls.__name__)
def test_save_with_aptrental(self):
transaction1 = model_creation.create_test_transaction(self.admin, timezone.now())
aptrental = model_creation.create_test_aptrental(transaction1, timezone.now())
self.assertIsNone(AptRentalDeposit().save(aptrental=aptrental))
