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_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_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_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_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_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_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_open_transaction(self):
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
self.kwargs = {'transaction_code': transaction.code}
self.get_url = 'pass'
self.get_template = 'transactions/transaction_edit.html'
self.repeat_get()
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 setUpTestData(cls):
super().setUpTestData()
if cls.app is not '':
cls.test_get = True
cls.required_permission = '{}.add_{}'.format(cls.app, cls.concept)
cls.url = '{}_new'.format(cls.concept)
cls.kwargs = {'transaction_code': create_test_transaction(cls.admin, timezone.now())}
cls.referer = '/'
cls.get_template = 'concepts/concept_edit.html'
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_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_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_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_with_cash(self):
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
cashfloatdeposit = model_creation.create_test_cashfloatdeposit(
transaction, timezone.now())
transaction.apt_number = 1008
transaction.client_first_name = 'Donna'
transaction.client_last_name = 'Kavanagh'
transaction.close(self.admin)
self.model_object = transaction
self.test_attrs()
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_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_employee_signature_required(self):
# Not required
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
self.assertFalse(transaction.employee_signature_required)
# Required
cashfloatdeposit = model_creation.create_test_cashfloatdeposit(
transaction, timezone.now())
settings = cashfloatdeposit.settings
settings.employee_signature_required = True
settings.save()
self.assertTrue(transaction.employee_signature_required)
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_all_sale_descriptions(self):
service = model_creation.create_service(
model_creation.create_servicetype('Test Inc.'),
'Test Service 1',
date_required=True,
per_adult=True,
per_child=True,
per_night=True,
per_senior=True,
per_unit=True,
variable_price=True,
)
service = model_creation.create_service(
model_creation.create_servicetype('Test Inc.'),
'Test Service 2',
date_required=True,
per_adult=False,
per_child=False,
per_night=True,
per_senior=False,
per_unit=False,
variable_price=True,
)
for service in Service.objects.all():
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
servicesale = model_creation.create_test_servicesale(
transaction,
timezone.now(),
service=service,
adults=1,
children=1,
seniors=1,
units=1)
servicesale2 = model_creation.create_test_servicesale(
transaction,
timezone.now(),
service=service,
adults=2,
children=2,
seniors=2,
units=2)
message = 'Testing description for ServiceSale {}: {}'.format(
servicesale.id, servicesale)
self.assertTrue(servicesale.description_short, msg=message)
self.assertTrue(servicesale2.description_short, msg=message)
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 test_form_no_concepts(self):
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
form = self.form_type(model_to_dict(transaction), instance=transaction)
self.assertFalse(form.is_valid())
self.assertIn('No concepts.', form.non_field_errors())
def setUpTestData(cls):
super().setUpTestData()
model = model_creation.create_test_cashfloatwithdrawal(
model_creation.create_test_transaction(cls.admin, timezone.now()), timezone.now())
cls.model_object = model
def test_save_with_saferental(self):
transaction1 = model_creation.create_test_transaction(self.admin, timezone.now())
saferental = model_creation.create_test_saferental(transaction1, timezone.now())
self.assertIsNone(SafeRentalDeposit().save(saferental=saferental))
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))
def test_save_with_parkingrental(self):
transaction1 = model_creation.create_test_transaction(self.admin, timezone.now())
parkingrental = model_creation.create_test_parkingrental(transaction1, timezone.now())
self.assertIsNone(ParkingRentalDeposit().save(parkingrental=parkingrental))
def test_empty(self):
transaction = model_creation.create_test_transaction(
self.admin, timezone.now())
self.model_object = transaction
self.test_attrs()
