def test_get_events_filtered_by_date(self):
generate_transactions(transaction_batch=100, days_of_history=5)
generate_payments(payment_batch=100, days_of_history=5)
generate_disbursements(disbursement_batch=100, days_of_history=5)
user = self.security_staff[0]
for credit in Credit.objects.all():
if RULES['HA'].triggered(credit):
RULES['HA'].create_event(credit)
for disbursement in Disbursement.objects.filter(resolution=DISBURSEMENT_RESOLUTION.SENT):
if RULES['HA'].triggered(disbursement):
RULES['HA'].create_event(disbursement)
lt = timezone.now()
gte = lt - timedelta(days=2)
response = self.client.get(
reverse('event-list'),
{'triggered_at__lt': lt, 'triggered_at__gte': gte},
format='json',
HTTP_AUTHORIZATION=self.get_http_authorization_for_user(user)
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertGreater(response.data['count'], 0)
self.assertEqual(
response.data['count'],
Event.objects.filter(triggered_at__gte=gte, triggered_at__lt=lt).count()
)
def test_filter_by_last_week_credit_count(self):
generate_transactions(transaction_batch=300, days_of_history=30)
generate_payments(payment_batch=300, days_of_history=30)
call_command('update_security_profiles')
minimum_credit_count = 3
data = self._get_list(
self._get_authorised_user(),
totals__time_period=TIME_PERIOD.LAST_7_DAYS,
credit_count__gte=minimum_credit_count,
)
self.assertEqual(
SenderProfile.objects.filter(
totals__time_period=TIME_PERIOD.LAST_7_DAYS,
totals__credit_count__gte=minimum_credit_count
).count(),
data['count']
)
pks = [item['id'] for item in data['results']]
for profile in SenderProfile.objects.filter(pk__in=pks):
for totals in profile.totals.all():
if totals.time_period == TIME_PERIOD.LAST_7_DAYS:
self.assertGreaterEqual(totals.credit_count, minimum_credit_count)
for profile in SenderProfile.objects.exclude(pk__in=pks):
for totals in profile.totals.all():
if totals.time_period == TIME_PERIOD.LAST_7_DAYS:
self.assertLess(totals.credit_count, minimum_credit_count)
def test_get_events(self):
generate_transactions(transaction_batch=100, days_of_history=5)
generate_payments(payment_batch=100, days_of_history=5)
generate_disbursements(disbursement_batch=100, days_of_history=5)
user = self.security_staff[0]
for credit in Credit.objects.all():
if RULES['HA'].triggered(credit):
RULES['HA'].create_event(credit)
for disbursement in Disbursement.objects.filter(resolution=DISBURSEMENT_RESOLUTION.SENT):
if RULES['HA'].triggered(disbursement):
RULES['HA'].create_event(disbursement)
response = self.client.get(
reverse('event-list'), format='json',
HTTP_AUTHORIZATION=self.get_http_authorization_for_user(user)
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertGreater(response.data['count'], 0)
triggering_credits = Credit.objects.filter(
amount__gte=12000,
)
triggering_disbursements = Disbursement.objects.filter(
amount__gte=12000, resolution=DISBURSEMENT_RESOLUTION.SENT
)
self.assertEqual(
response.data['count'],
triggering_credits.count() + triggering_disbursements.count()
)
def test_update_security_profiles_subsequent_bank_transfer(self):
generate_transactions(transaction_batch=100, days_of_history=5)
generate_payments(payment_batch=100, days_of_history=5)
call_command('update_security_profiles', verbosity=0)
sender_to_update = SenderProfile.objects.filter(
bank_transfer_details__isnull=False,
prisoners__isnull=False
).first()
bank_details = sender_to_update.bank_transfer_details.first()
prisoner_to_update = sender_to_update.prisoners.first()
initial_sender_credit_count = sender_to_update.totals.get(
time_period=TIME_PERIOD.ALL_TIME).credit_count
initial_sender_credit_total = sender_to_update.totals.get(
time_period=TIME_PERIOD.ALL_TIME).credit_total
initial_prisoner_credit_count = prisoner_to_update.totals.get(
time_period=TIME_PERIOD.ALL_TIME).credit_count
initial_prisoner_credit_total = prisoner_to_update.totals.get(
time_period=TIME_PERIOD.ALL_TIME).credit_total
new_transactions = generate_initial_transactions_data(
tot=1, include_debits=False,
include_administrative_credits=False,
include_unidentified_credits=False, days_of_history=0
)
new_transactions[0]['received_at'] = timezone.now()
new_transactions[0]['sender_name'] = bank_details.sender_name
new_transactions[0]['sender_sort_code'] = bank_details.sender_bank_account.sort_code
new_transactions[0]['sender_account_number'] = bank_details.sender_bank_account.account_number
new_transactions[0]['sender_roll_number'] = bank_details.sender_bank_account.roll_number
new_transactions[0]['prisoner_number'] = prisoner_to_update.prisoner_number
new_transactions[0]['prisoner_dob'] = prisoner_to_update.prisoner_dob
create_transactions(new_transactions)
call_command('update_security_profiles', verbosity=0)
sender_to_update.refresh_from_db()
self.assertEqual(
sender_to_update.totals.get(time_period=TIME_PERIOD.ALL_TIME).credit_count,
initial_sender_credit_count + 1
)
self.assertEqual(
sender_to_update.totals.get(time_period=TIME_PERIOD.ALL_TIME).credit_total,
initial_sender_credit_total + new_transactions[0]['amount']
)
prisoner_to_update.refresh_from_db()
self.assertEqual(
prisoner_to_update.totals.get(time_period=TIME_PERIOD.ALL_TIME).credit_count,
initial_prisoner_credit_count + 1
)
self.assertEqual(
prisoner_to_update.totals.get(time_period=TIME_PERIOD.ALL_TIME).credit_total,
initial_prisoner_credit_total + new_transactions[0]['amount']
)
def setUp(self):
super().setUp()
make_test_users(clerks_per_prison=1)
load_random_prisoner_locations()
generate_transactions(transaction_batch=50)
self.superuser = User.objects.create_superuser(username='******', password='******',
email='*****@*****.**')
self.client.login(username='******', password='******')
def setUp(self):
super().setUp()
make_test_users(clerks_per_prison=1)
load_random_prisoner_locations()
generate_transactions(transaction_batch=50)
self.superuser = User.objects.create_superuser(username='******',
password='******',
email='*****@*****.**')
self.client.login(username='******', password='******')
def test_update_security_profiles_subsequent_disbursement(self):
generate_transactions(transaction_batch=100, days_of_history=5)
generate_payments(payment_batch=100, days_of_history=5)
generate_disbursements(disbursement_batch=100, days_of_history=5)
call_command('update_security_profiles', verbosity=0)
recipient_to_update = RecipientProfile.objects.filter(
bank_transfer_details__isnull=False,
prisoners__isnull=False
).first()
bank_details = recipient_to_update.bank_transfer_details.first()
prisoner_to_update = recipient_to_update.prisoners.first()
initial_recipient_disbursement_count = recipient_to_update.totals.get(
time_period=TIME_PERIOD.ALL_TIME).disbursement_count
initial_recipient_disbursement_total = recipient_to_update.totals.get(
time_period=TIME_PERIOD.ALL_TIME).disbursement_total
initial_prisoner_disbursement_count = prisoner_to_update.totals.get(
time_period=TIME_PERIOD.ALL_TIME).disbursement_count
initial_prisoner_disbursement_total = prisoner_to_update.totals.get(
time_period=TIME_PERIOD.ALL_TIME).disbursement_total
new_disbursements = generate_initial_disbursement_data(
tot=1, days_of_history=0
)
new_disbursements[0]['method'] = DISBURSEMENT_METHOD.BANK_TRANSFER
new_disbursements[0]['sort_code'] = bank_details.recipient_bank_account.sort_code
new_disbursements[0]['account_number'] = bank_details.recipient_bank_account.account_number
new_disbursements[0]['roll_number'] = bank_details.recipient_bank_account.roll_number
new_disbursements[0]['prisoner_number'] = prisoner_to_update.prisoner_number
new_disbursements[0]['prisoner_name'] = prisoner_to_update.prisoner_name
new_disbursements[0]['resolution'] = DISBURSEMENT_RESOLUTION.SENT
create_disbursements(new_disbursements)
call_command('update_security_profiles', verbosity=0)
recipient_to_update.refresh_from_db()
self.assertEqual(
recipient_to_update.totals.get(time_period=TIME_PERIOD.ALL_TIME).disbursement_count,
initial_recipient_disbursement_count + 1
)
self.assertEqual(
recipient_to_update.totals.get(time_period=TIME_PERIOD.ALL_TIME).disbursement_total,
initial_recipient_disbursement_total + new_disbursements[0]['amount']
)
prisoner_to_update.refresh_from_db()
self.assertEqual(
prisoner_to_update.totals.get(time_period=TIME_PERIOD.ALL_TIME).disbursement_count,
initial_prisoner_disbursement_count + 1
)
self.assertEqual(
prisoner_to_update.totals.get(time_period=TIME_PERIOD.ALL_TIME).disbursement_total,
initial_prisoner_disbursement_total + new_disbursements[0]['amount']
)
def test_update_security_profiles_subsequent_card_payment(self):
generate_transactions(transaction_batch=100, days_of_history=5)
generate_payments(payment_batch=100, days_of_history=5)
call_command('update_security_profiles', verbosity=0)
sender_to_update = SenderProfile.objects.filter(
debit_card_details__isnull=False, prisoners__isnull=False).first()
card_details = sender_to_update.debit_card_details.first()
prisoner_to_update = sender_to_update.prisoners.first()
initial_sender_credit_count = sender_to_update.credit_count
initial_sender_credit_total = sender_to_update.credit_total
initial_sender_cardholder_names = list(
card_details.cardholder_names.values_list('name', flat=True))
initial_sender_emails = list(
card_details.sender_emails.values_list('email', flat=True))
initial_prisoner_credit_count = prisoner_to_update.credit_count
initial_prisoner_credit_total = prisoner_to_update.credit_total
new_payments = generate_initial_payment_data(tot=1, days_of_history=0)
new_payments[0]['created'] = timezone.now()
new_payments[0]['email'] = '*****@*****.**'
new_payments[0]['cardholder_name'] = 'other name'
new_payments[0][
'card_number_last_digits'] = card_details.card_number_last_digits
new_payments[0]['card_expiry_date'] = card_details.card_expiry_date
new_payments[0]['billing_address']['postcode'] = card_details.postcode
new_payments[0]['prisoner_number'] = prisoner_to_update.prisoner_number
new_payments[0]['prisoner_dob'] = prisoner_to_update.prisoner_dob
create_payments(new_payments, overrides={'credited': True})
call_command('update_security_profiles', verbosity=0)
sender_to_update.refresh_from_db()
self.assertEqual(sender_to_update.credit_count,
initial_sender_credit_count + 1)
self.assertEqual(
sender_to_update.credit_total,
initial_sender_credit_total + new_payments[0]['amount'])
card_details.refresh_from_db()
self.assertEqual(
sorted(card_details.cardholder_names.values_list('name',
flat=True)),
sorted(initial_sender_cardholder_names + ['other name']))
self.assertEqual(
sorted(card_details.sender_emails.values_list('email', flat=True)),
sorted(initial_sender_emails + ['*****@*****.**']))
prisoner_to_update.refresh_from_db()
self.assertEqual(prisoner_to_update.credit_count,
initial_prisoner_credit_count + 1)
self.assertEqual(
prisoner_to_update.credit_total,
initial_prisoner_credit_total + new_payments[0]['amount'])
def setUp(self):
super().setUp()
test_users = make_test_users()
self.prison_clerks = test_users['prison_clerks']
self.security_staff = test_users['security_staff']
load_random_prisoner_locations()
generate_transactions(transaction_batch=100, days_of_history=5)
generate_payments(payment_batch=100, days_of_history=5)
call_command('update_security_profiles')
def setUp(self):
super().setUp()
test_users = make_test_users()
self.prison_clerks = test_users['prison_clerks']
self.security_staff = test_users['security_staff']
load_random_prisoner_locations()
generate_transactions(transaction_batch=100, days_of_history=5)
generate_payments(payment_batch=100, days_of_history=5)
generate_disbursements(disbursement_batch=150, days_of_history=5)
call_command('update_security_profiles')
def test_debit_card_and_bank_transfer_data_included_in_export(self):
self.basic_setup()
generate_transactions(transaction_batch=1)
generate_payments(payment_batch=1)
with tempfile.NamedTemporaryFile() as export_file:
call_command('dump_for_ap', 'credits', export_file.name)
jsonlines = open(export_file.name).read()
self.assertIn('"Payment method": "Bank transfer"', jsonlines)
self.assertIn('"Payment method": "Debit card"', jsonlines)
def test_update_security_profiles_subsequent_bank_transfer(self):
generate_transactions(transaction_batch=100, days_of_history=5)
generate_payments(payment_batch=100, days_of_history=5)
call_command('update_security_profiles', verbosity=0)
sender_to_update = SenderProfile.objects.filter(
bank_transfer_details__isnull=False,
prisoners__isnull=False
).first()
bank_details = sender_to_update.bank_transfer_details.first()
prisoner_to_update = sender_to_update.prisoners.first()
initial_sender_credit_count = sender_to_update.credit_count
initial_sender_credit_total = sender_to_update.credit_total
initial_prisoner_credit_count = prisoner_to_update.credit_count
initial_prisoner_credit_total = prisoner_to_update.credit_total
new_transactions = generate_initial_transactions_data(
tot=1, include_debits=False,
include_administrative_credits=False,
include_unidentified_credits=False, days_of_history=0
)
new_transactions[0]['received_at'] = timezone.now()
new_transactions[0]['sender_name'] = bank_details.sender_name
new_transactions[0]['sender_sort_code'] = bank_details.sender_bank_account.sort_code
new_transactions[0]['sender_account_number'] = bank_details.sender_bank_account.account_number
new_transactions[0]['sender_roll_number'] = bank_details.sender_bank_account.roll_number
new_transactions[0]['prisoner_number'] = prisoner_to_update.prisoner_number
new_transactions[0]['prisoner_dob'] = prisoner_to_update.prisoner_dob
create_transactions(new_transactions)
call_command('update_security_profiles', verbosity=0)
sender_to_update.refresh_from_db()
self.assertEqual(
sender_to_update.credit_count, initial_sender_credit_count + 1
)
self.assertEqual(
sender_to_update.credit_total,
initial_sender_credit_total + new_transactions[0]['amount']
)
prisoner_to_update.refresh_from_db()
self.assertEqual(
prisoner_to_update.credit_count, initial_prisoner_credit_count + 1
)
self.assertEqual(
prisoner_to_update.credit_total,
initial_prisoner_credit_total + new_transactions[0]['amount']
)
def test_update_security_profiles_subsequent_disbursement(self):
generate_transactions(transaction_batch=100, days_of_history=5)
generate_payments(payment_batch=100, days_of_history=5)
generate_disbursements(disbursement_batch=100, days_of_history=5)
call_command('update_security_profiles', verbosity=0)
recipient_to_update = RecipientProfile.objects.filter(
bank_transfer_details__isnull=False,
prisoners__isnull=False
).first()
bank_details = recipient_to_update.bank_transfer_details.first()
prisoner_to_update = recipient_to_update.prisoners.first()
initial_recipient_disbursement_count = recipient_to_update.disbursement_count
initial_recipient_disbursement_total = recipient_to_update.disbursement_total
initial_prisoner_disbursement_count = prisoner_to_update.disbursement_count
initial_prisoner_disbursement_total = prisoner_to_update.disbursement_total
new_disbursements = generate_initial_disbursement_data(
tot=1, days_of_history=0
)
new_disbursements[0]['method'] = DISBURSEMENT_METHOD.BANK_TRANSFER
new_disbursements[0]['sort_code'] = bank_details.recipient_bank_account.sort_code
new_disbursements[0]['account_number'] = bank_details.recipient_bank_account.account_number
new_disbursements[0]['roll_number'] = bank_details.recipient_bank_account.roll_number
new_disbursements[0]['prisoner_number'] = prisoner_to_update.prisoner_number
new_disbursements[0]['prisoner_name'] = prisoner_to_update.prisoner_name
create_disbursements(new_disbursements)
call_command('update_security_profiles', verbosity=0)
recipient_to_update.refresh_from_db()
self.assertEqual(
recipient_to_update.disbursement_count,
initial_recipient_disbursement_count + 1
)
self.assertEqual(
recipient_to_update.disbursement_total,
initial_recipient_disbursement_total + new_disbursements[0]['amount']
)
prisoner_to_update.refresh_from_db()
self.assertEqual(
prisoner_to_update.disbursement_count,
initial_prisoner_disbursement_count + 1
)
self.assertEqual(
prisoner_to_update.disbursement_total,
initial_prisoner_disbursement_total + new_disbursements[0]['amount']
)
def test_will_not_check_transactions(self):
make_test_users(clerks_per_prison=1)
load_random_prisoner_locations(number_of_prisoners=1)
generate_transactions(consistent_history=True)
for credit in Credit.objects.credit_pending():
self.assertFalse(credit.should_check())
for credit in Credit.objects.credited():
self.assertFalse(credit.should_check())
for credit in Credit.objects.refund_pending():
self.assertFalse(credit.should_check())
for credit in Credit.objects.refunded():
self.assertFalse(credit.should_check())
def test_update_security_profiles_initial(self):
generate_transactions(transaction_batch=100, days_of_history=5)
generate_payments(payment_batch=100, days_of_history=5)
generate_disbursements(disbursement_batch=100, days_of_history=5)
call_command('update_security_profiles', verbosity=0)
for sender_profile in SenderProfile.objects.all():
SenderTotals.objects.filter(sender_profile=sender_profile).update_all_totals()
self.assertEqual(
len(sender_profile.credits.all()),
sender_profile.totals.get(time_period=TIME_PERIOD.ALL_TIME).credit_count
)
self.assertEqual(
sum([credit.amount for credit in sender_profile.credits.all()]),
sender_profile.totals.get(time_period=TIME_PERIOD.ALL_TIME).credit_total
)
for recipient_profile in RecipientProfile.objects.filter(
bank_transfer_details__isnull=False
):
self.assertEqual(
sum([disbursement.amount for disbursement in recipient_profile.disbursements.all()]),
recipient_profile.totals.get(time_period=TIME_PERIOD.ALL_TIME).disbursement_total
)
self.assertEqual(
len(recipient_profile.disbursements.all()),
recipient_profile.totals.get(time_period=TIME_PERIOD.ALL_TIME).disbursement_count
)
for prisoner_profile in PrisonerProfile.objects.all():
if prisoner_profile.credits.count():
self.assertTrue(prisoner_profile.single_offender_id)
self.assertEqual(
sum([credit.amount for credit in prisoner_profile.credits.all()]),
prisoner_profile.totals.get(time_period=TIME_PERIOD.ALL_TIME).credit_total
)
self.assertEqual(
len(prisoner_profile.credits.all()),
prisoner_profile.totals.get(time_period=TIME_PERIOD.ALL_TIME).credit_count
)
self.assertEqual(
sum([disbursement.amount for disbursement in prisoner_profile.disbursements.all()]),
prisoner_profile.totals.get(time_period=TIME_PERIOD.ALL_TIME).disbursement_total
)
self.assertEqual(
len(prisoner_profile.disbursements.all()),
prisoner_profile.totals.get(time_period=TIME_PERIOD.ALL_TIME).disbursement_count
)
def setUp(self):
super().setUp()
test_users = make_test_users()
self.user = test_users['security_staff'][0]
load_random_prisoner_locations()
# generate random data which may or may not match amount rules
generate_transactions(transaction_batch=200, days_of_history=3)
generate_payments(payment_batch=200, days_of_history=3)
generate_disbursements(disbursement_batch=200, days_of_history=3)
# £1 does not match NWN or HA rules and no monitoring exists, i.e. no non-counting rules can trigger
Payment.objects.update(amount=100)
Transaction.objects.update(amount=100)
Credit.objects.update(amount=100)
Disbursement.objects.update(amount=100)
def setUp(self):
super().setUp()
test_users = make_test_users(clerks_per_prison=2)
self.prison_clerks = test_users['prison_clerks']
self.prisoner_location_admins = test_users['prisoner_location_admins']
self.bank_admins = test_users['bank_admins']
self.refund_bank_admins = test_users['refund_bank_admins']
self.send_money_users = test_users['send_money_users']
self.security_staff = test_users['security_staff']
self.latest_transaction_date = latest_transaction_date()
self.latest_payment_date = latest_payment_date()
load_random_prisoner_locations()
transaction_credits = [
t.credit for t in generate_transactions(
transaction_batch=self.transaction_batch, days_of_history=5)
if t.credit
]
payment_credits = [
p.credit
for p in generate_payments(payment_batch=self.transaction_batch,
days_of_history=5)
if p.credit and p.credit.resolution != 'initial'
]
self.credits = transaction_credits + payment_credits
self.prisons = Prison.objects.all()
def setUp(self):
super().setUp()
self.private_prison = mommy.make(Prison, name='Private', private_estate=True)
self.private_bank_account = mommy.make(PrisonBankAccount, prison=self.private_prison)
test_users = make_test_users(clerks_per_prison=2)
self.prison_clerks = test_users['prison_clerks']
self.bank_admins = test_users['bank_admins']
load_random_prisoner_locations()
transaction_credits = [
t.credit for t in generate_transactions(transaction_batch=20, days_of_history=4)
if t.credit
]
payment_credits = [
p.credit for p in generate_payments(payment_batch=20, days_of_history=4)
if p.credit and p.credit.resolution != 'initial'
]
self.credits = transaction_credits + payment_credits
self.prisons = Prison.objects.all()
self.latest_date = timezone.now().replace(hour=0, minute=0, second=0, microsecond=0)
date = Credit.objects.earliest().received_at.replace(hour=0, minute=0, second=0, microsecond=0)
while date < self.latest_date:
end_of_date = date + datetime.timedelta(days=1)
PrivateEstateBatch.objects.create_batches(date, end_of_date)
date = end_of_date
def test_update_current_prisons(self):
generate_transactions(transaction_batch=100, days_of_history=5)
generate_payments(payment_batch=100, days_of_history=5)
call_command('update_security_profiles', verbosity=0)
def check_locations():
for prisoner_profile in PrisonerProfile.objects.all():
current_location = PrisonerLocation.objects.get(
prisoner_number=prisoner_profile.prisoner_number,
active=True
)
self.assertEqual(prisoner_profile.current_prison, current_location.prison)
check_locations()
for location in PrisonerLocation.objects.all():
location.prison = Prison.objects.all().order_by('?').first()
call_command('update_current_prisons')
check_locations()
def test_update_current_prisons(self):
generate_transactions(transaction_batch=100, days_of_history=5)
generate_payments(payment_batch=100, days_of_history=5)
call_command('update_security_profiles', verbosity=0)
def check_locations():
for prisoner_profile in PrisonerProfile.objects.all():
current_location = PrisonerLocation.objects.get(
prisoner_number=prisoner_profile.prisoner_number,
active=True
)
self.assertEqual(prisoner_profile.current_prison, current_location.prison)
check_locations()
for location in PrisonerLocation.objects.all():
location.prison = Prison.objects.all().order_by('?').first()
call_command('update_current_prisons')
check_locations()
def _get_transactions(self, tot=100):
transactions = generate_transactions(transaction_batch=tot)
data_list = []
for _, trans in enumerate(transactions):
refund = False
if trans.credit and trans.credit.refund_pending:
refund = True
data_list.append({'id': trans.id, 'refunded': refund})
return data_list
def test_update_security_profiles_initial(self):
generate_transactions(transaction_batch=100, days_of_history=5)
generate_payments(payment_batch=100, days_of_history=5)
generate_disbursements(disbursement_batch=100, days_of_history=5)
call_command('update_security_profiles', verbosity=0)
for sender_profile in SenderProfile.objects.all():
credits = Credit.objects.filter(sender_profile.credit_filters)
self.assertEqual(
sum([credit.amount for credit in credits]),
sender_profile.credit_total
)
self.assertEqual(len(credits), sender_profile.credit_count)
for recipient_profile in RecipientProfile.objects.filter(
bank_transfer_details__isnull=False
):
disbursements = Disbursement.objects.filter(recipient_profile.disbursement_filters)
self.assertEqual(
sum([disbursement.amount for disbursement in disbursements]),
recipient_profile.disbursement_total
)
self.assertEqual(len(disbursements), recipient_profile.disbursement_count)
for prisoner_profile in PrisonerProfile.objects.all():
if prisoner_profile.credits.count():
self.assertTrue(prisoner_profile.single_offender_id)
credits = Credit.objects.filter(prisoner_profile.credit_filters)
self.assertEqual(
sum([credit.amount for credit in credits]),
prisoner_profile.credit_total
)
self.assertEqual(len(credits), prisoner_profile.credit_count)
disbursements = Disbursement.objects.filter(prisoner_profile.disbursement_filters)
self.assertEqual(
sum([disbursement.amount for disbursement in disbursements]),
prisoner_profile.disbursement_total
)
self.assertEqual(len(disbursements), prisoner_profile.disbursement_count)
def setUp(self):
super().setUp()
self.private_prison = mommy.make(Prison,
name='Private',
private_estate=True)
self.private_bank_account = mommy.make(PrisonBankAccount,
prison=self.private_prison)
test_users = make_test_users(clerks_per_prison=2)
self.prison_clerks = test_users['prison_clerks']
self.bank_admins = test_users['bank_admins']
load_random_prisoner_locations()
transaction_credits = [
t.credit for t in generate_transactions(transaction_batch=20,
days_of_history=4)
if t.credit
]
payment_credits = [
p.credit
for p in generate_payments(payment_batch=20, days_of_history=4)
if p.credit and p.credit.resolution != 'initial'
]
self.credits = transaction_credits + payment_credits
self.prisons = Prison.objects.all()
creditable = Credit.STATUS_LOOKUP[
CREDIT_STATUS.CREDITED] | Credit.STATUS_LOOKUP[
CREDIT_STATUS.CREDIT_PENDING]
private_estate_credit_set = Credit.objects.filter(
prison__private_estate=True).filter(creditable)
if not private_estate_credit_set.exists():
public_estate_credits = Credit.objects.filter(
prison__private_estate=False).filter(creditable)
public_estate_credits[public_estate_credits.count() //
2:].update(prison=self.private_prison)
self.latest_date = timezone.now().replace(hour=0,
minute=0,
second=0,
microsecond=0)
date = Credit.objects.earliest().received_at.replace(hour=0,
minute=0,
second=0,
microsecond=0)
while date < self.latest_date:
end_of_date = date + datetime.timedelta(days=1)
PrivateEstateBatch.objects.create_batches(date, end_of_date)
date = end_of_date
def test_profile_update_minimum_viable_data(self):
generate_transactions(transaction_batch=100, days_of_history=5)
generate_payments(payment_batch=100, days_of_history=5)
generate_disbursements(disbursement_batch=100, days_of_history=5)
delete_non_related_nullable_fields(Payment.objects.all(),
null_fields_to_leave_populated=set([
'email',
'cardholder_name',
'card_number_first_digits',
'card_number_last_digits',
'card_expiry_date',
'billing_address',
]))
delete_non_related_nullable_fields(Transaction.objects.all(),
null_fields_to_leave_populated=set([
'sender_name',
'sender_sort_code',
'sender_account_number'
]))
delete_non_related_nullable_fields(
Credit.objects.all(),
null_fields_to_leave_populated=set([
'prison',
'prisoner_name',
'prisoner_number', # Needed to populate PrisonerProfile
]))
delete_non_related_nullable_fields(
Disbursement.objects.all(),
null_fields_to_leave_populated=set([
'sort_code', # Needed to populate BankAccount
'account_number' # Needed to populate BankAccount
]))
call_command('update_security_profiles', verbosity=0)
self._assert_counts()
def setUp(self):
super().setUp()
test_users = make_test_users(clerks_per_prison=2)
self.prison_clerks = test_users['prison_clerks']
self.prisoner_location_admins = test_users['prisoner_location_admins']
self.bank_admins = test_users['bank_admins']
self.refund_bank_admins = test_users['refund_bank_admins']
self.send_money_users = test_users['send_money_users']
self.security_staff = test_users['security_staff']
self.latest_transaction_date = latest_transaction_date()
self.latest_payment_date = latest_payment_date()
load_random_prisoner_locations()
transaction_credits = [t.credit for t in generate_transactions(
transaction_batch=self.transaction_batch, days_of_history=5
) if t.credit]
payment_credits = [p.credit for p in generate_payments(
payment_batch=self.transaction_batch, days_of_history=5
) if p.credit and p.credit.resolution != 'initial']
self.credits = transaction_credits + payment_credits
self.prisons = Prison.objects.all()
def handle(self, *args, **options):
if settings.ENVIRONMENT == 'prod':
return self.handle_prod(**options)
verbosity = options.get('verbosity', 1)
protect_superusers = options['protect_superusers']
protect_usernames = options['protect_usernames']
protect_credits = options['protect_credits']
prisons = options['prisons']
prisoners = options['prisoners']
number_of_prisoners = options['number_of_prisoners']
clerks_per_prison = options['clerks_per_prison']
credits = options['credits']
print_message = self.stdout.write if verbosity else lambda m: m
if not protect_credits:
print_message('Deleting all credits')
Balance.objects.all().delete()
Transaction.objects.all().delete()
Payment.objects.all().delete()
Credit.objects_all.all().delete()
Batch.objects.all().delete()
SenderProfile.objects.all().delete()
PrisonerProfile.objects.all().delete()
SavedSearch.objects.all().delete()
Disbursement.objects.all().delete()
user_set = get_user_model().objects.exclude(username__in=protect_usernames or [])
if protect_superusers:
user_set = user_set.exclude(is_superuser=True)
print_message('Deleting %d users' % user_set.count())
user_set.delete()
print_message('Deleting all prisons')
Prison.objects.all().delete()
fixtures = ['initial_groups.json', 'initial_types.json']
if 'sample' in prisons:
fixtures.append('test_prisons.json')
if 'nomis' in prisons:
fixtures.append('test_nomis_prisons.json')
if 'mtp' in prisons:
fixtures.append('test_nomis_mtp_prisons.json')
if 'nomis-api-dev' in prisons:
fixtures.append('dev_nomis_api_prisons.json')
print_message('Loading default user group and selected prison fixtures')
call_command('loaddata', *fixtures, verbosity=verbosity)
print_message('Giving super users full API access')
give_superusers_full_access()
print_message('Making test users')
make_test_users(clerks_per_prison=clerks_per_prison)
print_message('Making test user admins')
make_test_user_admins()
print_message('Making token retrieval user')
make_token_retrieval_user()
if 'nomis' in prisoners:
load_prisoner_locations_from_file('test_nomis_prisoner_locations.csv')
if 'nomis-api-dev' in prisoners:
load_prisoner_locations_from_file('dev_nomis_api_prisoner_locations.csv')
if 'sample' in prisoners:
load_random_prisoner_locations(number_of_prisoners=number_of_prisoners)
number_of_transactions = options['number_of_transactions']
number_of_payments = options['number_of_payments']
number_of_disbursements = options['number_of_disbursements']
days_of_history = options['days_of_history']
if credits == 'random':
print_message('Generating random credits')
generate_transactions(transaction_batch=number_of_transactions)
generate_payments(payment_batch=number_of_payments)
elif credits == 'nomis':
print_message('Generating test NOMIS credits')
generate_transactions(
transaction_batch=number_of_transactions,
predetermined_transactions=True,
consistent_history=True,
include_debits=False,
include_administrative_credits=False,
include_unidentified_credits=True,
days_of_history=days_of_history
)
generate_payments(
payment_batch=number_of_payments,
consistent_history=True,
days_of_history=days_of_history
)
generate_disbursements(
disbursement_batch=number_of_disbursements,
days_of_history=days_of_history
)
call_command('update_security_profiles')
digital_takeup = options['digital_takeup']
if digital_takeup:
print_message('Generating digital take-up')
generate_digital_takeup(days_of_history=days_of_history)
def setUp(self):
super().setUp()
make_test_users()
load_random_prisoner_locations()
generate_transactions(transaction_batch=100, days_of_history=21)
def handle(self, *args, **options): # noqa: C901
if settings.ENVIRONMENT == 'prod':
return self.handle_prod(**options)
verbosity = options.get('verbosity', 1)
no_protect_superusers = options['no_protect_superusers']
protect_usernames = options['protect_usernames']
protect_credits = options['protect_credits']
prisons = options['prisons']
prisoners = options['prisoners']
number_of_prisoners = options['number_of_prisoners']
number_of_senders = options['number_of_senders']
clerks_per_prison = options['clerks_per_prison']
credits = options['credits']
number_of_transactions = options['number_of_transactions']
number_of_payments = options['number_of_payments']
number_of_disbursements = options['number_of_disbursements']
number_of_checks = options['number_of_checks']
days_of_history = options['days_of_history']
extra_generate_checks_args = {}
print_message = self.stdout.write if verbosity else lambda m: m
if not protect_credits and credits != 'production-scale':
print_message('Deleting all credits')
Balance.objects.all().delete()
Transaction.objects.all().delete()
Payment.objects.all().delete()
Credit.objects_all.all().delete()
Batch.objects.all().delete()
SenderProfile.objects.all().delete()
PrisonerProfile.objects.all().delete()
SavedSearch.objects.all().delete()
Disbursement.objects.all().delete()
RecipientProfile.objects.all().delete()
Check.objects.all().delete()
if credits == 'production-scale':
# N.B. This scenario will eat your RAM like there's no tomorrow. ~13GB usage is
# about as far as I've got before it's keeled over and i've had to rerun
# If running it outside your development environment, be sure that it's not using the same
# resource pool as a production service
# If running it on your development environment you may need to tweak oom-killer so it
# doesn't kill this process as soon as you near the memory limit of your system
number_of_existing_transactions = Transaction.objects.count()
number_of_existing_payments = Payment.objects.count()
number_of_existing_prisoner_locations = PrisonerLocation.objects.count()
number_of_existing_prisoners_profiles = PrisonerProfile.objects.count()
number_of_existing_disbursements = Disbursement.objects.count()
number_of_existing_checks = Check.objects.count()
number_of_existing_senders = SenderProfile.objects.count()
number_of_existing_prisoners = min(
[number_of_existing_prisoner_locations, number_of_existing_prisoners_profiles]
)
number_of_desired_transactions = 300000
number_of_desired_payments = 3000000
number_of_desired_prisoners = 80000
number_of_desired_senders = 700000
number_of_desired_disbursements = 20000
number_of_desired_checks = 900000
number_of_prisoners = max(
0, number_of_desired_prisoners - number_of_existing_prisoners
)
print_message(
f'Number of prisoners to be created is {number_of_desired_prisoners} - {number_of_existing_prisoners}'
f' <= {number_of_prisoners}'
)
number_of_transactions = max(
0, number_of_desired_transactions - number_of_existing_transactions
)
print_message(
f'Number of transactions to be created is {number_of_desired_transactions} - '
f'{number_of_existing_transactions} <= {number_of_transactions}'
)
number_of_payments = max(
0, number_of_desired_payments - number_of_existing_payments
)
print_message(
f'Number of payments to be created is {number_of_desired_payments} - {number_of_existing_payments}'
f' <= {number_of_payments}'
)
number_of_disbursements = max(
0, number_of_desired_disbursements - number_of_existing_disbursements
)
print_message(
f'Number of disbursements to be created is {number_of_desired_disbursements} - '
f'{number_of_existing_disbursements} <= {number_of_disbursements}'
)
number_of_senders = max(
0, number_of_desired_senders - number_of_existing_senders
)
print_message(
f'Number of senders to be created is {number_of_desired_senders} - {number_of_existing_senders}'
f' <= {number_of_senders}'
)
number_of_checks = max(
0, number_of_desired_checks - number_of_existing_checks
)
print_message(
f'Number of checks to be created is {number_of_desired_checks} - {number_of_existing_checks}'
f' <= {number_of_checks}'
)
assert number_of_desired_checks <= 3 * number_of_desired_payments, (
'Due to constraints on the number of payments with a billing address '
'in mtp_api/payments/tests/utils.py::setup_payment you must have checks <= 3*payments'
)
days_of_history = 1300
prisons.append('nomis-api-dev')
prisoners.append('sample')
else:
user_set = get_user_model().objects.exclude(username__in=protect_usernames or [])
if not no_protect_superusers:
user_set = user_set.exclude(is_superuser=True)
print_message('Deleting %d users' % user_set.count())
user_set.delete()
print_message('Deleting all prisons')
Prison.objects.all().delete()
fixtures = ['initial_groups.json', 'initial_types.json']
if 'sample' in prisons:
fixtures.append('test_prisons.json')
if 'nomis' in prisons:
fixtures.append('test_nomis_prisons.json')
if 'mtp' in prisons:
fixtures.append('test_nomis_mtp_prisons.json')
if 'nomis-api-dev' in prisons:
fixtures.append('dev_nomis_api_prisons.json')
if 'dev-prison-api' in prisons:
fixtures.append('dev_prison_api_prisons.json')
print_message('Loading default user group and selected prison fixtures')
call_command('loaddata', *fixtures, verbosity=verbosity)
print_message('Giving super users full API access')
create_super_admin(self.stdout, self.style.SUCCESS)
give_superusers_full_access()
if credits != 'production-scale' or User.objects.count() < 2:
print_message('Making test users')
make_test_users(clerks_per_prison=clerks_per_prison)
print_message('Making test user admins')
make_test_user_admins()
print_message('Making token retrieval user')
prisoner_locations = None
if 'nomis' in prisoners:
prisoner_locations = load_prisoner_locations_from_file('test_nomis_prisoner_locations.csv')
if 'nomis-api-dev' in prisoners:
prisoner_locations = load_prisoner_locations_from_file('dev_nomis_api_prisoner_locations.csv')
if 'dev-prison-api' in prisoners:
prisoner_locations = load_prisoner_locations_from_dev_prison_api(number_of_prisoners=number_of_prisoners)
if 'sample' in prisoners:
prisoner_locations = load_random_prisoner_locations(number_of_prisoners=number_of_prisoners)
if not prisoner_locations:
prisoner_locations = PrisonerLocation.objects.all()
if credits == 'random':
print_message('Generating random credits')
generate_transactions(transaction_batch=number_of_transactions)
generate_payments(payment_batch=number_of_payments)
elif credits == 'nomis':
print_message('Generating test NOMIS credits')
generate_transactions(
transaction_batch=number_of_transactions,
predetermined_transactions=True,
consistent_history=True,
include_debits=False,
include_administrative_credits=False,
include_unidentified_credits=True,
days_of_history=days_of_history
)
generate_payments(
payment_batch=number_of_payments,
consistent_history=True,
days_of_history=days_of_history
)
elif credits == 'production-scale':
print_message('Generating production-like transactions')
generate_transactions(
transaction_batch=number_of_transactions,
predetermined_transactions=True,
consistent_history=True,
include_debits=True,
include_administrative_credits=True,
include_unidentified_credits=True,
days_of_history=days_of_history
)
print_message('Generating production-like payments/credits')
generate_payments(
payment_batch=number_of_payments,
consistent_history=True,
days_of_history=days_of_history,
attach_profiles_to_individual_credits=False,
number_of_senders=number_of_senders
)
print_message(f'Generating (at least) {number_of_prisoners} prisoner profiles')
prisoner_profiles = generate_prisoner_profiles_from_prisoner_locations(prisoner_locations)
print_message(f'Generated {len(prisoner_profiles)} prisoner profiles')
print_message(f'Generating {number_of_senders} sender profiles')
sender_profiles = generate_sender_profiles_from_payments(number_of_senders)
print_message(f'Generated {len(sender_profiles)} sender profiles')
prisoner_profiles_count = PrisonerProfile.objects.count()
sender_profiles_count = SenderProfile.objects.count()
extra_generate_checks_args.update({
'create_invalid_checks': False,
'number_of_senders_to_use': int((number_of_checks * 5) / sender_profiles_count),
'number_of_prisoners_to_use': int((number_of_checks * 5) / prisoner_profiles_count)
})
print_message('Generating disbursements')
generate_disbursements(
disbursement_batch=number_of_disbursements,
days_of_history=days_of_history
)
print_message('Generating checks')
generate_checks(
number_of_checks=number_of_checks,
**extra_generate_checks_args
)
print_message('Associating credits with profiles')
with silence_logger(level=logging.WARNING):
call_command('update_security_profiles')
digital_takeup = options['digital_takeup']
if digital_takeup:
print_message('Generating digital take-up')
generate_digital_takeup(days_of_history=days_of_history)
def setUp(self):
super().setUp()
make_test_users()
load_random_prisoner_locations()
generate_transactions(transaction_batch=100, days_of_history=21)
def _populate_transactions(self, tot=100):
return generate_transactions(transaction_batch=tot)
def test_update_security_profiles_initial(self):
generate_transactions(transaction_batch=100, days_of_history=5)
generate_payments(payment_batch=100, days_of_history=5)
generate_disbursements(disbursement_batch=100, days_of_history=5)
call_command('update_security_profiles', verbosity=0)
self._assert_counts()
def setUp(self):
super().setUp()
make_test_users(clerks_per_prison=1)
load_random_prisoner_locations(number_of_prisoners=1)
generate_transactions(transaction_batch=1)
generate_payments(payment_batch=1)
def test_update_security_profiles_subsequent_card_payment(self):
generate_transactions(transaction_batch=100, days_of_history=5)
generate_payments(payment_batch=100, days_of_history=5)
call_command('update_security_profiles', verbosity=0)
sender_to_update = SenderProfile.objects.filter(
debit_card_details__isnull=False,
prisoners__isnull=False
).first()
card_details = sender_to_update.debit_card_details.first()
prisoner_to_update = sender_to_update.prisoners.first()
initial_sender_credit_count = sender_to_update.totals.get(
time_period=TIME_PERIOD.ALL_TIME).credit_count
initial_sender_credit_total = sender_to_update.totals.get(
time_period=TIME_PERIOD.ALL_TIME).credit_total
initial_sender_cardholder_names = list(card_details.cardholder_names.values_list('name', flat=True))
initial_sender_emails = list(card_details.sender_emails.values_list('email', flat=True))
initial_prisoner_credit_count = prisoner_to_update.totals.get(
time_period=TIME_PERIOD.ALL_TIME).credit_count
initial_prisoner_credit_total = prisoner_to_update.totals.get(
time_period=TIME_PERIOD.ALL_TIME).credit_total
new_payments = generate_initial_payment_data(tot=1, days_of_history=0)
new_payments[0]['created'] = timezone.now()
new_payments[0]['email'] = '*****@*****.**'
new_payments[0]['cardholder_name'] = 'other name'
new_payments[0]['card_number_last_digits'] = card_details.card_number_last_digits
new_payments[0]['card_expiry_date'] = card_details.card_expiry_date
new_payments[0]['billing_address']['postcode'] = card_details.postcode
new_payments[0]['prisoner_number'] = prisoner_to_update.prisoner_number
new_payments[0]['prisoner_dob'] = prisoner_to_update.prisoner_dob
create_payments(new_payments)
call_command('update_security_profiles', verbosity=0)
sender_to_update.refresh_from_db()
self.assertEqual(
sender_to_update.totals.get(time_period=TIME_PERIOD.ALL_TIME).credit_count,
initial_sender_credit_count + 1
)
self.assertEqual(
sender_to_update.totals.get(time_period=TIME_PERIOD.ALL_TIME).credit_total,
initial_sender_credit_total + new_payments[0]['amount']
)
card_details.refresh_from_db()
self.assertEqual(
sorted(card_details.cardholder_names.values_list('name', flat=True)),
sorted(initial_sender_cardholder_names + ['other name'])
)
self.assertEqual(
sorted(card_details.sender_emails.values_list('email', flat=True)),
sorted(initial_sender_emails + ['*****@*****.**'])
)
prisoner_to_update.refresh_from_db()
self.assertEqual(
prisoner_to_update.totals.get(time_period=TIME_PERIOD.ALL_TIME).credit_count,
initial_prisoner_credit_count + 1
)
self.assertEqual(
prisoner_to_update.totals.get(time_period=TIME_PERIOD.ALL_TIME).credit_total,
initial_prisoner_credit_total + new_payments[0]['amount']
)
def handle(self, *args, **options):
if settings.ENVIRONMENT == 'prod':
return self.handle_prod(**options)
verbosity = options.get('verbosity', 1)
protect_superusers = options['protect_superusers']
protect_usernames = options['protect_usernames']
protect_credits = options['protect_credits']
prisons = options['prisons']
prisoners = options['prisoners']
number_of_prisoners = options['number_of_prisoners']
clerks_per_prison = options['clerks_per_prison']
credits = options['credits']
print_message = self.stdout.write if verbosity else lambda m: m
if not protect_credits:
print_message('Deleting all credits')
Balance.objects.all().delete()
Transaction.objects.all().delete()
Payment.objects.all().delete()
Credit.objects_all.all().delete()
Batch.objects.all().delete()
SenderProfile.objects.all().delete()
PrisonerProfile.objects.all().delete()
SavedSearch.objects.all().delete()
Disbursement.objects.all().delete()
RecipientProfile.objects.all().delete()
user_set = get_user_model().objects.exclude(username__in=protect_usernames or [])
if protect_superusers:
user_set = user_set.exclude(is_superuser=True)
print_message('Deleting %d users' % user_set.count())
user_set.delete()
print_message('Deleting all prisons')
Prison.objects.all().delete()
fixtures = ['initial_groups.json', 'initial_types.json']
if 'sample' in prisons:
fixtures.append('test_prisons.json')
if 'nomis' in prisons:
fixtures.append('test_nomis_prisons.json')
if 'mtp' in prisons:
fixtures.append('test_nomis_mtp_prisons.json')
if 'nomis-api-dev' in prisons:
fixtures.append('dev_nomis_api_prisons.json')
print_message('Loading default user group and selected prison fixtures')
call_command('loaddata', *fixtures, verbosity=verbosity)
print_message('Giving super users full API access')
give_superusers_full_access()
print_message('Making test users')
make_test_users(clerks_per_prison=clerks_per_prison)
print_message('Making test user admins')
make_test_user_admins()
print_message('Making token retrieval user')
make_token_retrieval_user()
if 'nomis' in prisoners:
load_prisoner_locations_from_file('test_nomis_prisoner_locations.csv')
if 'nomis-api-dev' in prisoners:
load_prisoner_locations_from_file('dev_nomis_api_prisoner_locations.csv')
if 'sample' in prisoners:
load_random_prisoner_locations(number_of_prisoners=number_of_prisoners)
number_of_transactions = options['number_of_transactions']
number_of_payments = options['number_of_payments']
number_of_disbursements = options['number_of_disbursements']
days_of_history = options['days_of_history']
if credits == 'random':
print_message('Generating random credits')
generate_transactions(transaction_batch=number_of_transactions)
generate_payments(payment_batch=number_of_payments)
elif credits == 'nomis':
print_message('Generating test NOMIS credits')
generate_transactions(
transaction_batch=number_of_transactions,
predetermined_transactions=True,
consistent_history=True,
include_debits=False,
include_administrative_credits=False,
include_unidentified_credits=True,
days_of_history=days_of_history
)
generate_payments(
payment_batch=number_of_payments,
consistent_history=True,
days_of_history=days_of_history
)
generate_disbursements(
disbursement_batch=number_of_disbursements,
days_of_history=days_of_history
)
call_command('update_security_profiles')
digital_takeup = options['digital_takeup']
if digital_takeup:
print_message('Generating digital take-up')
generate_digital_takeup(days_of_history=days_of_history)
