def setUp(self): super().setUp() test_users = make_test_users() self.security_staff = test_users['security_staff'] load_random_prisoner_locations() generate_payments(payment_batch=200, days_of_history=3) generate_disbursements(disbursement_batch=200, days_of_history=3)
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_get_events_grouped_by_profile_and_filtered(self): generate_payments(payment_batch=200, days_of_history=5) call_command('update_security_profiles') user = self.security_staff[0] lt = timezone.now() - timedelta(days=2) gte = lt - timedelta(days=3) response = self.client.get( reverse('event-list'), {'rule': 'CSFREQ', 'group_by': 'sender_profile', '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) latest = {} for event in Event.objects.filter( rule='CSFREQ', triggered_at__gte=gte, triggered_at__lt=lt ): profile_id = event.sender_profile_event.sender_profile.id if profile_id not in latest: latest[profile_id] = event else: if latest[profile_id].triggered_at < event.triggered_at: latest[profile_id] = event latest_ids = [e.id for e in latest.values()] self.assertEqual(response.data['count'], len(latest_ids)) for event in response.data['results']: if event['id'] not in latest_ids: self.fail()
def setUp(self): super().setUp() self.users = make_test_users(clerks_per_prison=1) prisoner_locations = load_random_prisoner_locations(number_of_prisoners=1) generate_payments(payment_batch=1) prisoner_profiles = generate_prisoner_profiles_from_prisoner_locations(prisoner_locations) sender_profiles = generate_sender_profiles_from_payments(number_of_senders=1, reassign_dcsd=True) prisoner_profiles[0].monitoring_users.add(self.users['security_fiu_users'][0].id) sender_profiles[0].debit_card_details.first().monitoring_users.add(self.users['security_fiu_users'][0].id) response = self.client.post( reverse( 'security-check-auto-accept-list' ), data={ 'prisoner_profile_id': prisoner_profiles[0].id, 'debit_card_sender_details_id': sender_profiles[0].debit_card_details.first().id, 'states': [ { 'reason': 'This person has amazing hair', } ] }, format='json', HTTP_AUTHORIZATION=self.get_http_authorization_for_user(self.users['security_fiu_users'][0]), ) self.assertEqual(response.status_code, 201) self.auto_accept_rule = CheckAutoAcceptRule.objects.get(id=response.json()['id'])
def test_cannot_accept_check_with_rejection_reason(self): # Setup users = make_test_users(clerks_per_prison=1) prisoner_locations = load_random_prisoner_locations() generate_payments(payment_batch=50) generate_prisoner_profiles_from_prisoner_locations(prisoner_locations) generate_sender_profiles_from_payments(number_of_senders=1, reassign_dcsd=True) generate_checks(number_of_checks=1, create_invalid_checks=False, overrides={'status': 'pending'}) check = Check.objects.filter(status='pending').first() # Execute response = self.client.post( reverse('security-check-accept', kwargs={'pk': check.id}), { 'decision_reason': 'computer says no', 'rejection_reasons': { 'payment_source_linked_other_prisoners': True, } }, format='json', HTTP_AUTHORIZATION=self.get_http_authorization_for_user(users['security_fiu_users'][0]) ) # Assert Response self.assertEqual(response.status_code, 400) self.assertEqual( response.json(), {'non_field_errors': ['You cannot give rejection reasons when accepting a check']} ) # Assert Lack of State Change check.refresh_from_db() self.assertEqual(check.status, 'pending') self.assertEqual(check.rejection_reasons, {}) self.assertEqual(check.decision_reason, '')
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 setUp(self): super().setUp() test_users = make_test_users() self.prison_clerks = test_users['prison_clerks'] self.send_money_users = test_users['send_money_users'] load_random_prisoner_locations(50) generate_payments(50, days_of_history=1)
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 make_2days_of_random_models(self): test_users = make_test_users() load_random_prisoner_locations() generate_payments(payment_batch=20, days_of_history=2) while not Disbursement.objects.sent().exists(): generate_disbursements(disbursement_batch=20, days_of_history=2) return test_users['security_staff']
def setUp(self): super().setUp() test_users = make_test_users() self.prison_clerks = test_users['prison_clerks'] self.send_money_users = test_users['send_money_users'] load_random_prisoner_locations(50) generate_payments(50, days_of_history=1)
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 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 test_will_not_check_non_initial_credits(self): make_test_users(clerks_per_prison=1) load_random_prisoner_locations(number_of_prisoners=1) generate_payments() for credit in Credit.objects.credit_pending(): self.assertFalse(credit.should_check()) for credit in Credit.objects.credited(): self.assertFalse(credit.should_check())
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 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_will_not_check_non_pending_payments(self): make_test_users(clerks_per_prison=1) load_random_prisoner_locations(number_of_prisoners=1) generate_payments(10) credit = Credit.objects.credited().first() credit.owner = None credit.resolution = CREDIT_RESOLUTION.INITIAL credit.payment.status = PAYMENT_STATUS.FAILED credit.save() self.assertFalse(credit.should_check())
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 _make_candidate_credit(self): make_test_users(clerks_per_prison=1) load_random_prisoner_locations(number_of_prisoners=1) generate_payments(10) call_command('update_security_profiles') credit = Credit.objects.credited().first() credit.owner = None credit.resolution = CREDIT_RESOLUTION.INITIAL payment = credit.payment payment.status = PAYMENT_STATUS.PENDING credit.log_set.filter(action=CREDIT_LOG_ACTIONS.CREDITED).delete() return credit
def setUp(self): super().setUp() test_users = make_test_users() self.security_staff = test_users['security_staff'] load_random_prisoner_locations() generate_payments(payment_batch=20, days_of_history=2, overrides={ 'status': PAYMENT_STATUS.TAKEN, 'credited': True }) generate_disbursements(disbursement_batch=20, days_of_history=1)
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_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() 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_get_batch(self): user = self.bank_admins[0] batch = Batch(date=date(2016, 3, 3)) batch.save() other_batch = Batch(date=date(2016, 3, 4)) other_batch.save() for i, payment in enumerate(generate_payments(50, days_of_history=1)): if i % 2: payment.batch = batch else: payment.batch = other_batch payment.save() response = self.client.get( reverse('batch-list'), {'date': date(2016, 3, 3)}, format='json', HTTP_AUTHORIZATION=self.get_http_authorization_for_user(user) ) batches = response.data['results'] self.assertEqual(len(batches), 1) self.assertEqual(batches[0]['id'], batch.id) self.assertEqual(batches[0]['date'], batch.date.isoformat()) self.assertEqual(batches[0]['payment_amount'], batch.payment_amount)
def test_update_prisoner_profiles(self): payments = generate_payments(payment_batch=100, days_of_history=5) call_command('update_security_profiles', verbosity=0) valid_payments = filter(lambda payment: payment.status == PAYMENT_STATUS.TAKEN and payment.credit.prison, payments) prisoner_numbers = set(payment.prisoner_number for payment in valid_payments) self.assertEqual(PrisonerProfile.objects.all().count(), len(prisoner_numbers)) sender_profile = SenderProfile.objects.filter( debit_card_details__isnull=False, prisoners__isnull=False, ).first() debit_card_details = sender_profile.debit_card_details.first() prisoner_profile = PrisonerProfile.objects.first() 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'] = debit_card_details.card_number_last_digits new_payments[0]['card_expiry_date'] = debit_card_details.card_expiry_date new_payments[0]['recipient_name'] = 'Mr. John Doe' new_payments[0]['prisoner_number'] = prisoner_profile.prisoner_number new_payments[0]['prisoner_dob'] = prisoner_profile.prisoner_dob create_payments(new_payments) call_command('update_security_profiles', verbosity=0) prisoner_profile.refresh_from_db() recipient_names = list(recipient_name.name for recipient_name in prisoner_profile.provided_names.all()) self.assertEqual(recipient_names[-1], 'Mr. John Doe')
def test_payment_for_pair_with_inactive_auto_accept_caught_by_delayed_capture(self): self.client.patch( reverse( 'security-check-auto-accept-detail', args=[self.auto_accept_rule.id] ), data={ 'states': [ { 'active': False, 'reason': 'Ignore that they cut off their hair', } ] }, format='json', HTTP_AUTHORIZATION=self.get_http_authorization_for_user(self.users['security_fiu_users'][0]), ) payments = generate_payments( payment_batch=1, overrides={ 'credit': { 'prisoner_profile_id': self.auto_accept_rule.prisoner_profile_id, 'sender_profile_id': self.auto_accept_rule.debit_card_sender_details.sender.id } } ) credit = payments[0].credit # Call check = Check.objects.create_for_credit(credit) # Assert self.assertEqual(check.auto_accept_rule_state, None) self.assertEqual(check.rules, ['FIUMONP', 'FIUMONS']) self.assertEqual(check.status, CHECK_STATUS.PENDING)
def test_get_batch(self): user = self.bank_admins[0] batch = Batch(date=date(2016, 3, 3)) batch.save() other_batch = Batch(date=date(2016, 3, 4)) other_batch.save() for i, payment in enumerate(generate_payments(50, days_of_history=1)): if i % 2: payment.batch = batch else: payment.batch = other_batch payment.save() response = self.client.get( reverse('batch-list'), {'date': date(2016, 3, 3)}, format='json', HTTP_AUTHORIZATION=self.get_http_authorization_for_user(user)) batches = response.data['results'] self.assertEqual(len(batches), 1) self.assertEqual(batches[0]['id'], batch.id) self.assertEqual(batches[0]['date'], batch.date.isoformat()) self.assertEqual(batches[0]['payment_amount'], batch.payment_amount)
def test_list_credits_for_prisoner_includes_not_completed(self): payments = generate_payments( 10, days_of_history=1, overrides={'status': PAYMENT_STATUS.REJECTED}) prisoner_profile_id = list( filter(lambda p: p.credit.prisoner_profile_id, payments))[0].credit.prisoner_profile_id credits = Credit.objects_all.filter( prisoner_profile_id=prisoner_profile_id) data = self._get_list(self._get_authorised_user(), path_params=[prisoner_profile_id], only_completed=False)['results'] self.assertTrue(len(data) > 0) self.assertEqual(len(credits), len(data)) for credit in credits: self.assertTrue(credit.id in [d['id'] for d in data]) self.assertTrue( any([ d['resolution'] in (CREDIT_RESOLUTION.FAILED, CREDIT_RESOLUTION.INITIAL) for d in data ]))
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 test_update_prisoner_profiles(self): payments = generate_payments(payment_batch=100, days_of_history=5) call_command('update_security_profiles', verbosity=0) valid_payments = filter(lambda payment: payment.status == PAYMENT_STATUS.TAKEN and payment.credit.prison, payments) prisoner_numbers = set(payment.prisoner_number for payment in valid_payments) self.assertEqual(PrisonerProfile.objects.all().count(), len(prisoner_numbers)) sender_profile = SenderProfile.objects.filter( debit_card_details__isnull=False, prisoners__isnull=False, ).first() debit_card_details = sender_profile.debit_card_details.first() prisoner_profile = PrisonerProfile.objects.first() 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'] = debit_card_details.card_number_last_digits new_payments[0]['card_expiry_date'] = debit_card_details.card_expiry_date new_payments[0]['recipient_name'] = 'Mr. John Doe' new_payments[0]['prisoner_number'] = prisoner_profile.prisoner_number new_payments[0]['prisoner_dob'] = prisoner_profile.prisoner_dob create_payments(new_payments) call_command('update_security_profiles', verbosity=0) prisoner_profile.refresh_from_db() recipient_names = list(recipient_name.name for recipient_name in prisoner_profile.provided_names.all()) self.assertEqual(recipient_names[-1], 'Mr. John Doe')
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 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 test_credits_dump_for_ap(self): self.basic_setup() generate_payments(payment_batch=20, days_of_history=2) with tempfile.NamedTemporaryFile() as export_file: call_command('dump_for_ap', 'credits', export_file.name) jsonlines = open(export_file.name).read().splitlines() credit_ids = [] for record in jsonlines: parsedjson = json.loads(record) credit_ids.append(parsedjson['Internal ID']) completed_payments = Payment.objects.exclude(status__in=( PAYMENT_STATUS.PENDING, PAYMENT_STATUS.REJECTED, PAYMENT_STATUS.EXPIRED, )) expected_credit_ids = sorted(payment.credit_id for payment in completed_payments) self.assertListEqual(credit_ids, expected_credit_ids)
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 test_payment_for_pair_with_active_auto_accept_progresses_immediately(self): # Set up payments = generate_payments( payment_batch=1, overrides={ 'credit': { 'prisoner_profile_id': self.auto_accept_rule.prisoner_profile_id, 'sender_profile_id': self.auto_accept_rule.debit_card_sender_details.sender.id } } ) credit = payments[0].credit # Call check = Check.objects.create_for_credit(credit) # Assert self.assertEqual(check.auto_accept_rule_state, self.auto_accept_rule.get_latest_state()) self.assertEqual(check.rules, ['FIUMONP', 'FIUMONS']) self.assertEqual(check.status, CHECK_STATUS.ACCEPTED)
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 test_payment_where_prisoner_not_on_auto_accept_caught_by_delayed_capture(self): prisoner_profile_id = PrisonerProfile.objects.exclude( id=self.auto_accept_rule.prisoner_profile_id ).first().id payments = generate_payments( payment_batch=1, overrides={ 'credit': { 'prisoner_profile_id': prisoner_profile_id, 'sender_profile_id': self.auto_accept_rule.debit_card_sender_details.sender.id } } ) credit = payments[0].credit # Call check = Check.objects.create_for_credit(credit) # Assert self.assertEqual(check.auto_accept_rule_state, None) self.assertEqual(check.rules, ['FIUMONS']) self.assertEqual(check.status, CHECK_STATUS.PENDING)
def generate_checks(number_of_checks=1, specific_payments_to_check=tuple(), create_invalid_checks=True, number_of_prisoners_to_use=5, number_of_senders_to_use=5, overrides=None): fake_prisoner_names = { pp_id[0]: fake.name() for pp_id in PrisonerProfile.objects.values_list('id') } fake_sender_names = { sp_id[0]: fake.name() for sp_id in SenderProfile.objects.values_list('id') } fiu = Group.objects.get(name='FIU').user_set.first() billing_address_sender_profile_id_mapping = {} if create_invalid_checks: filters = [PAYMENT_FILTERS_FOR_INVALID_CHECK] else: filters = [] filters.extend([ *([PAYMENT_FILTERS_FOR_VALID_CHECK] * number_of_checks), *specific_payments_to_check ]) for j, filter_set in enumerate(filters): sender_profile, cardholder_name = _get_sender_profile( j, filter_set, number_of_senders_to_use, fake_sender_names, billing_address_sender_profile_id_mapping, fiu) filter_set = filter_set.copy() prisoner_profile, prisoner_name = _get_prisoner_profile( j, filter_set, number_of_prisoners_to_use, fake_prisoner_names, fiu) credit_filters = filter_set.pop('credit', {}) candidate_payment = Payment.objects.filter( credit=Credit.objects.filter(**credit_filters).get_or_create( **_get_credit_values( credit_filters, sender_profile.id if sender_profile else None, prisoner_profile.id if prisoner_profile else None, prisoner_name))[0], **filter_set).first() if not candidate_payment: candidate_payment = generate_payments( payment_batch=1, overrides=dict(credit=_get_credit_values( credit_filters, sender_profile.id if sender_profile else None, prisoner_profile.id if prisoner_profile else None, prisoner_name), **_get_payment_values(filter_set, cardholder_name)))[0] if sender_profile: candidate_payment.billing_address = billing_address_sender_profile_id_mapping.get( sender_profile.id) # We ensure that the sender profile includes the cardholder name # In the test data there should only be one debit_card_details per sender_profile, we use get_or_create CardholderName.objects.get_or_create( name=candidate_payment.cardholder_name, debit_card_sender_details=sender_profile. debit_card_details.first()) candidate_payment.save() candidate_payment.credit.log_set.filter( action=CREDIT_LOG_ACTIONS.CREDITED).delete() # Checks already get created in the payment saving process for applicable credits # (see payment/models.py::create_security_check_if_needed_and_attach_profiles if not hasattr(candidate_payment.credit, 'security_check'): check = Check.objects.create_for_credit(candidate_payment.credit) else: check = candidate_payment.credit.security_check if (not overrides or 'state' not in overrides) and j % 5: check.status = random.choice( [CHECK_STATUS.ACCEPTED, CHECK_STATUS.REJECTED]) check.actioned_at = datetime.now(tz=pytz.utc) check.actioned_by = random.choice( list( Group.objects.filter( name='FIU').first().user_set.all())) check.save() if overrides: for k, v in overrides.items(): setattr(check, k, v) check.save() generate_auto_accept_rules() return Check.objects.all()
def setUp(self): make_test_users(1) load_random_prisoner_locations(1) self.payments = generate_payments(self.payment_count, days_of_history=10)
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): make_test_users(1) load_random_prisoner_locations(1) self.payments = generate_payments(self.payment_count, days_of_history=10)
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 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)
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'] )