def test_build_bundled_pdf_with_one_pdf(self, logger, get_parser, slack):
# set up associated data
sf_pubdef = auth_models.Organization.objects.get(
slug=constants.Organizations.SF_PUBDEF)
sub = SubmissionsService.create_for_organizations(
[sf_pubdef], answers={})
fillable = mock.fillable_pdf(organization=sf_pubdef)
data = b'content'
filled = models.FilledPDF.create_with_pdf_bytes(
pdf_bytes=data, submission=sub, original_pdf=fillable)
bundle = BundlesService.create_bundle_from_submissions(
organization=sf_pubdef, submissions=[sub], skip_pdf=True)
# set up mocks
should_have_a_pdf = Mock(return_value=True)
get_individual_filled_pdfs = Mock(
return_value=[filled])
bundle.should_have_a_pdf = should_have_a_pdf
bundle.get_individual_filled_pdfs = get_individual_filled_pdfs
# run method
BundlesService.build_bundled_pdf_if_necessary(bundle)
# check results
get_parser.assert_not_called()
logger.assert_not_called()
slack.assert_not_called()
get_individual_filled_pdfs.assert_called_once_with()
self.assertEqual(bundle.bundled_pdf.read(), data)
def test_build_bundled_pdf_with_one_pdf(self, logger, get_parser, slack):
# set up associated data
sf_pubdef = auth_models.Organization.objects.get(
slug=constants.Organizations.SF_PUBDEF)
sub = SubmissionsService.create_for_organizations([sf_pubdef],
answers={})
fillable = mock.fillable_pdf(organization=sf_pubdef)
data = b'content'
filled = models.FilledPDF.create_with_pdf_bytes(pdf_bytes=data,
submission=sub,
original_pdf=fillable)
bundle = BundlesService.create_bundle_from_submissions(
organization=sf_pubdef, submissions=[sub], skip_pdf=True)
# set up mocks
should_have_a_pdf = Mock(return_value=True)
get_individual_filled_pdfs = Mock(return_value=[filled])
bundle.should_have_a_pdf = should_have_a_pdf
bundle.get_individual_filled_pdfs = get_individual_filled_pdfs
# run method
BundlesService.build_bundled_pdf_if_necessary(bundle)
# check results
get_parser.assert_not_called()
logger.assert_not_called()
slack.assert_not_called()
get_individual_filled_pdfs.assert_called_once_with()
self.assertEqual(bundle.bundled_pdf.read(), data)
def build_seed_submissions():
from intake.services import bundles as BundlesService
subs = []
orgs = Organization.objects.filter(is_receiving_agency=True)
for org in orgs:
# make 2 submissions to each org
for i in range(2):
sub = factories.FormSubmissionWithOrgsFactory.create(
organizations=[org])
subs.append(sub)
# make 1 submission to multiple orgs
target_orgs = Organization.objects.filter(
is_receiving_agency=True).exclude(slug__contains='ebclc')
multi_org_sub = factories.FormSubmissionWithOrgsFactory.create(
organizations=target_orgs)
subs.append(multi_org_sub)
sub_ids = [sub.id for sub in subs]
# applications = models.Application.objects.filter(
# form_submission_id__in=sub_ids)
applicants = []
for sub in subs:
applicants.append(sub.applicant)
"""
Creating status updates for all applications forces a mock situation
in which there are 0 unread applications, which limits our test range.
Working around that by only doing so for the first 2 applications to
an org.
"""
for org in orgs:
updated_application = models.Application.objects.filter(
organization=org, form_submission_id__in=sub_ids).first()
factories.StatusUpdateWithNotificationFactory.create(
application=updated_application,
author=org.profiles.first().user)
updated_application.has_been_opened = True
updated_application.save()
for org in orgs:
org_subs = []
for sub in subs:
has_app = sub.applications.filter(organization=org).exists()
if has_app and sub != multi_org_sub:
org_subs.append(sub)
# make a bundle for each org
bundle = BundlesService.create_bundle_from_submissions(
organization=org,
submissions=org_subs,
skip_pdf=True)
# save bundle
filename = 'mock_1_bundle_to_' + org.slug + ".json"
dump_as_json([bundle], fixture_path(filename))
filename = 'mock_{}_submissions_to_{}.json'.format(
len(org_subs), org.slug)
serialize_subs(org_subs, fixture_path(filename))
serialize_subs(
[multi_org_sub],
fixture_path('mock_1_submission_to_multiple_orgs.json'))
make_two_mock_transfers()
def test_nonexistent_pdf_returns_404(self):
self.be_cfa_user()
bundle = BundlesService.create_bundle_from_submissions(
organization=self.sf_pubdef,
submissions=self.sf_pubdef_submissions,
skip_pdf=True)
response = self.client.get(bundle.get_pdf_bundle_url())
self.assertEqual(response.status_code, 404)
def test_should_have_a_pdf_negative(self):
cc_pubdef = auth_models.Organization.objects.get(
slug=constants.Organizations.COCO_PUBDEF)
sub = SubmissionsService.create_for_organizations(
[cc_pubdef], answers={})
bundle = BundlesService.create_bundle_from_submissions(
organization=cc_pubdef, submissions=[sub], skip_pdf=True)
self.assertFalse(bundle.should_have_a_pdf())
def setUpTestData(cls):
super().setUpTestData()
# patch slack_simple
patcher = patch('intake.notifications')
patcher.start()
cls.bundle = BundlesService.create_bundle_from_submissions(
organization=cls.sf_pubdef, submissions=cls.sf_pubdef_submissions)
patcher.stop()
def test_should_have_a_pdf_positive(self):
sf_pubdef = auth_models.Organization.objects.get(slug='sf_pubdef')
mock.fillable_pdf(organization=sf_pubdef)
sub = SubmissionsService.create_for_organizations(
[sf_pubdef], answers={})
bundle = BundlesService.create_bundle_from_submissions(
organization=sf_pubdef, submissions=[sub], skip_pdf=True)
self.assertTrue(bundle.should_have_a_pdf())
def test_nonexistent_pdf_returns_404(self):
self.be_cfa_user()
bundle = BundlesService.create_bundle_from_submissions(
organization=self.sf_pubdef,
submissions=self.sf_pubdef_submissions,
skip_pdf=True)
response = self.client.get(bundle.get_pdf_bundle_url())
self.assertEqual(response.status_code, 404)
def setUpTestData(cls):
super().setUpTestData()
# patch slack_simple
patcher = patch('intake.notifications')
patcher.start()
cls.bundle = BundlesService.create_bundle_from_submissions(
organization=cls.sf_pubdef, submissions=cls.sf_pubdef_submissions)
patcher.stop()
def test_should_have_a_pdf_negative(self):
cc_pubdef = auth_models.Organization.objects.get(
slug=constants.Organizations.COCO_PUBDEF)
sub = SubmissionsService.create_for_organizations(
[cc_pubdef], answers={})
bundle = BundlesService.create_bundle_from_submissions(
organization=cc_pubdef, submissions=[sub], skip_pdf=True)
self.assertFalse(bundle.should_have_a_pdf())
def build_seed_submissions():
from intake.services import bundles as BundlesService
subs = []
orgs = Organization.objects.filter(is_receiving_agency=True)
for org in orgs:
# make 2 submissions to each org
for i in range(2):
sub = factories.FormSubmissionWithOrgsFactory.create(
organizations=[org])
subs.append(sub)
# make 1 submission to multiple orgs
target_orgs = Organization.objects.filter(
is_receiving_agency=True).exclude(slug__contains='ebclc')
multi_org_sub = factories.FormSubmissionWithOrgsFactory.create(
organizations=target_orgs)
subs.append(multi_org_sub)
sub_ids = [sub.id for sub in subs]
applicants = []
for sub in subs:
applicants.append(sub.applicant)
"""
Creating status updates for all applications forces a mock situation
in which there are 0 unread applications, which limits our test range.
Working around that by only doing so for the first 2 applications to
an org.
"""
for org in orgs:
updated_application = models.Application.objects.filter(
organization=org, form_submission_id__in=sub_ids).first()
factories.StatusUpdateWithNotificationFactory.create(
application=updated_application,
author=org.profiles.first().user)
updated_application.has_been_opened = True
updated_application.save()
for org in orgs:
org_subs = []
for sub in subs:
has_app = sub.applications.filter(organization=org).exists()
if has_app and sub != multi_org_sub:
org_subs.append(sub)
# make a bundle for each org
bundle = BundlesService.create_bundle_from_submissions(
organization=org,
submissions=org_subs,
skip_pdf=True)
# save bundle
filename = 'mock_1_bundle_to_' + org.slug + ".json"
dump_as_json([bundle], fixture_path(filename))
filename = 'mock_{}_submissions_to_{}.json'.format(
len(org_subs), org.slug)
serialize_subs(org_subs, fixture_path(filename))
serialize_subs(
[multi_org_sub],
fixture_path('mock_1_submission_to_multiple_orgs.json'))
make_two_mock_transfers()
def build_seed_submissions():
create_seed_users()
from user_accounts.models import Organization
subs = []
orgs = Organization.objects.filter(is_receiving_agency=True)
for org in orgs:
# make 2 submissions to each org
for i in range(2):
sub = factories.FormSubmissionWithOrgsFactory.create(
organizations=[org])
subs.append(sub)
# make 1 submission to multiple orgs
target_orgs = Organization.objects.filter(
is_receiving_agency=True).exclude(slug__contains='ebclc')
multi_org_sub = factories.FormSubmissionWithOrgsFactory.create(
organizations=target_orgs)
subs.append(multi_org_sub)
sub_ids = [sub.id for sub in subs]
applications = models.Application.objects.filter(
form_submission_id__in=sub_ids)
applicants = []
for sub in subs:
applicants.append(sub.applicant)
for application in applications:
factories.StatusUpdateWithNotificationFactory.create(
application=application,
author=application.organization.profiles.first().user)
for org in orgs:
org_subs = []
for sub in subs:
has_app = sub.applications.filter(organization=org).exists()
if has_app and sub != multi_org_sub:
org_subs.append(sub)
# make a bundle for each org
bundle = BundlesService.create_bundle_from_submissions(
organization=org,
submissions=org_subs,
skip_pdf=True)
# save bundle
filename = 'mock_1_bundle_to_' + org.slug + ".json"
dump_as_json([bundle], fixture_path(filename))
filename = 'mock_{}_submissions_to_{}.json'.format(
len(org_subs), org.slug)
serialize_subs(org_subs, fixture_path(filename))
serialize_subs(
[multi_org_sub],
fixture_path('mock_1_submission_to_multiple_orgs.json'))
events = []
for applicant in applicants:
events.extend(
make_mock_submission_event_sequence(applicant))
dump_as_json(events, fixture_path('mock_application_events.json'))
make_two_mock_transfers()
def test_build_bundled_pdf_with_no_filled_pdfs(self):
cc_pubdef = auth_models.Organization.objects.get(slug='cc_pubdef')
sub = SubmissionsService.create_for_organizations([cc_pubdef],
answers={})
bundle = BundlesService.create_bundle_from_submissions(
organization=cc_pubdef, submissions=[sub], skip_pdf=True)
get_pdfs_mock = Mock()
bundle.get_individual_filled_pdfs = get_pdfs_mock
BundlesService.build_bundled_pdf_if_necessary(bundle)
get_pdfs_mock.assert_not_called()
def test_staff_user_can_see_pdf_bundle(self, slack):
self.be_cfa_user()
submissions = self.sf_pubdef_submissions
bundle = BundlesService.create_bundle_from_submissions(
submissions=submissions, organization=self.sf_pubdef)
ids = [s.id for s in submissions]
url = url_with_ids('intake-pdf_bundle', ids)
response = self.client.get(url)
self.assertRedirects(response, bundle.get_pdf_bundle_url())
pdf_response = self.client.get(response.url)
self.assertEqual(pdf_response.status_code, 200)
def build_seed_submissions():
subs = []
orgs = Organization.objects.filter(is_receiving_agency=True)
for org in orgs:
# make 2 submissions to each org
for i in range(2):
sub = factories.FormSubmissionWithOrgsFactory.create(
organizations=[org])
subs.append(sub)
# make 1 submission to multiple orgs
target_orgs = Organization.objects.filter(
is_receiving_agency=True).exclude(slug__contains='ebclc')
multi_org_sub = factories.FormSubmissionWithOrgsFactory.create(
organizations=target_orgs)
subs.append(multi_org_sub)
sub_ids = [sub.id for sub in subs]
applications = models.Application.objects.filter(
form_submission_id__in=sub_ids)
applicants = []
for sub in subs:
applicants.append(sub.applicant)
for application in applications:
factories.StatusUpdateWithNotificationFactory.create(
application=application,
author=application.organization.profiles.first().user)
for org in orgs:
org_subs = []
for sub in subs:
has_app = sub.applications.filter(organization=org).exists()
if has_app and sub != multi_org_sub:
org_subs.append(sub)
# make a bundle for each org
bundle = BundlesService.create_bundle_from_submissions(
organization=org,
submissions=org_subs,
skip_pdf=True)
# save bundle
filename = 'mock_1_bundle_to_' + org.slug + ".json"
dump_as_json([bundle], fixture_path(filename))
filename = 'mock_{}_submissions_to_{}.json'.format(
len(org_subs), org.slug)
serialize_subs(org_subs, fixture_path(filename))
serialize_subs(
[multi_org_sub],
fixture_path('mock_1_submission_to_multiple_orgs.json'))
events = []
for applicant in applicants:
events.extend(
make_mock_submission_event_sequence(applicant))
dump_as_json(events, fixture_path('mock_application_events.json'))
make_two_mock_transfers()
def test_build_bundled_pdf_with_no_filled_pdfs(self):
cc_pubdef = auth_models.Organization.objects.get(
slug=constants.Organizations.COCO_PUBDEF)
sub = SubmissionsService.create_for_organizations(
[cc_pubdef], answers={})
bundle = BundlesService.create_bundle_from_submissions(
organization=cc_pubdef, submissions=[sub], skip_pdf=True)
get_pdfs_mock = Mock()
bundle.get_individual_filled_pdfs = get_pdfs_mock
BundlesService.build_bundled_pdf_if_necessary(bundle)
get_pdfs_mock.assert_not_called()
def test_staff_user_can_see_pdf_bundle(self, slack):
self.be_cfa_user()
submissions = self.sf_pubdef_submissions
bundle = BundlesService.create_bundle_from_submissions(
submissions=submissions,
organization=self.sf_pubdef)
ids = [s.id for s in submissions]
url = url_with_ids('intake-pdf_bundle', ids)
response = self.client.get(url)
self.assertRedirects(response, bundle.get_pdf_bundle_url())
pdf_response = self.client.get(response.url)
self.assertEqual(pdf_response.status_code, 200)
def test_get_individual_filled_pdfs(self):
sf_pubdef = auth_models.Organization.objects.get(slug='sf_pubdef')
fillable = mock.fillable_pdf(organization=sf_pubdef)
subs = [
SubmissionsService.create_for_organizations(
[sf_pubdef], answers={})
for i in range(2)]
expected_pdfs = [
models.FilledPDF(original_pdf=fillable, submission=sub)
for sub in subs]
for pdf in expected_pdfs:
pdf.save()
bundle = BundlesService.create_bundle_from_submissions(
organization=sf_pubdef, submissions=subs, skip_pdf=True)
query = bundle.get_individual_filled_pdfs().order_by('pk')
pdfs = list(query)
self.assertListEqual(pdfs, expected_pdfs)
def test_has_pdf_bundle_url_if_needed(self, slack):
"""ApplicationBundleDetailView return pdf url if needed
create an `ApplicationBundle` that needs a pdf
try to access `ApplicationBundleDetailView` using `id`
assert that the url for `FilledPDFBundle` is in the template.
"""
self.be_sfpubdef_user()
mock_pdf = SimpleUploadedFile('a.pdf',
b"things",
content_type="application/pdf")
bundle = BundlesService.create_bundle_from_submissions(
organization=self.sf_pubdef,
submissions=self.sf_pubdef_submissions,
bundled_pdf=mock_pdf)
url = bundle.get_pdf_bundle_url()
result = self.client.get(
reverse('intake-app_bundle_detail',
kwargs=dict(bundle_id=bundle.id)))
self.assertContains(result, url)
def test_has_pdf_bundle_url_if_needed(self):
"""ApplicationBundleDetailView return pdf url if needed
create an `ApplicationBundle` that needs a pdf
try to access `ApplicationBundleDetailView` using `id`
assert that the url for `FilledPDFBundle` is in the template.
"""
self.be_sfpubdef_user()
mock_pdf = SimpleUploadedFile(
'a.pdf', b"things", content_type="application/pdf")
bundle = BundlesService.create_bundle_from_submissions(
organization=self.sf_pubdef,
submissions=self.sf_pubdef_submissions,
bundled_pdf=mock_pdf
)
url = bundle.get_pdf_bundle_url()
result = self.client.get(reverse(
'intake-app_bundle_detail',
kwargs=dict(bundle_id=bundle.id)))
self.assertContains(result, url)
def test_build_bundled_pdf_if_has_pdfs(self, logger, get_parser, slack):
sf_pubdef = auth_models.Organization.objects.get(slug='sf_pubdef')
subs = [
SubmissionsService.create_for_organizations([sf_pubdef],
answers={})
for i in range(2)
]
should_have_a_pdf = Mock(return_value=True)
get_individual_filled_pdfs = Mock(
return_value=[Mock(pdf=b'pdf') for sub in subs])
get_parser.return_value.join_pdfs.return_value = b'pdf'
bundle = BundlesService.create_bundle_from_submissions(
organization=sf_pubdef, submissions=subs, skip_pdf=True)
bundle.should_have_a_pdf = should_have_a_pdf
bundle.get_individual_filled_pdfs = get_individual_filled_pdfs
BundlesService.build_bundled_pdf_if_necessary(bundle)
logger.assert_not_called()
slack.assert_not_called()
get_individual_filled_pdfs.assert_called_once_with()
def test_build_bundled_pdf_if_has_pdfs(self, logger, get_parser, slack):
sf_pubdef = auth_models.Organization.objects.get(
slug=constants.Organizations.SF_PUBDEF)
subs = [
SubmissionsService.create_for_organizations(
[sf_pubdef], answers={})
for i in range(2)]
should_have_a_pdf = Mock(return_value=True)
get_individual_filled_pdfs = Mock(
return_value=[Mock(pdf=b'pdf') for sub in subs])
get_parser.return_value.join_pdfs.return_value = b'pdf'
bundle = BundlesService.create_bundle_from_submissions(
organization=sf_pubdef, submissions=subs, skip_pdf=True)
bundle.should_have_a_pdf = should_have_a_pdf
bundle.get_individual_filled_pdfs = get_individual_filled_pdfs
BundlesService.build_bundled_pdf_if_necessary(bundle)
logger.assert_not_called()
slack.assert_not_called()
get_individual_filled_pdfs.assert_called_once_with()
def build_seed_submissions():
create_seed_users()
from user_accounts.models import Organization
from formation.forms import county_form_selector
cc_pubdef = Organization.objects.get(
slug=constants.Organizations.COCO_PUBDEF)
a_pubdef = Organization.objects.get(
slug=constants.Organizations.ALAMEDA_PUBDEF)
ebclc = Organization.objects.get(
slug=constants.Organizations.EBCLC)
sf_pubdef = Organization.objects.get(
slug=constants.Organizations.SF_PUBDEF)
monterey_pubdef = Organization.objects.get(
slug=constants.Organizations.MONTEREY_PUBDEF)
solano_pubdef = Organization.objects.get(
slug=constants.Organizations.SOLANO_PUBDEF)
san_diego_pubdef = Organization.objects.get(
slug=constants.Organizations.SAN_DIEGO_PUBDEF)
san_joaquin_pubdef = Organization.objects.get(
slug=constants.Organizations.SAN_JOAQUIN_PUBDEF)
santa_clara_pubdef = Organization.objects.get(
slug=constants.Organizations.SANTA_CLARA_PUBDEF)
fresno_pubdef = Organization.objects.get(
slug=constants.Organizations.FRESNO_PUBDEF)
receiving_orgs = [
cc_pubdef, a_pubdef, ebclc, sf_pubdef, monterey_pubdef,
solano_pubdef, san_diego_pubdef, san_joaquin_pubdef,
santa_clara_pubdef, fresno_pubdef]
answer_pairs = {
sf_pubdef.slug: fake.sf_county_form_answers,
cc_pubdef.slug: fake.contra_costa_county_form_answers,
ebclc.slug: fake.ebclc_answers,
a_pubdef.slug: fake.alameda_pubdef_answers,
monterey_pubdef.slug: fake.monterey_pubdef_answers,
solano_pubdef.slug: fake.solano_pubdef_answers,
san_diego_pubdef.slug: fake.san_diego_pubdef_answers,
san_joaquin_pubdef.slug: fake.san_joaquin_pubdef_answers,
santa_clara_pubdef.slug: fake.santa_clara_pubdef_answers,
fresno_pubdef.slug: fake.fresno_pubdef_answers,
}
form_pairs = {
org.slug: county_form_selector.get_combined_form_class(
counties=[org.county.slug])
for org in receiving_orgs
}
# make 2 submissions to each org
applicants = []
subs = []
for org in receiving_orgs:
for i in range(2):
raw_answers = answer_pairs[org.slug]()
Form = form_pairs[org.slug]
form = Form(raw_answers, validate=True)
applicant = models.Applicant()
applicant.save()
applicants.append(applicant)
sub = models.FormSubmission(
applicant=applicant,
answers=form.cleaned_data
)
if org in (a_pubdef, santa_clara_pubdef, monterey_pubdef):
letter = fake.declaration_letter_answers()
sub.answers.update(letter)
sub.save()
application = models.Application(
organization=org, form_submission=sub)
application.save()
StatusUpdateFactory.create(
application=application, author=org.profiles.first().user)
subs.append(sub)
# make 1 submission to multiple orgs
target_orgs = [
a_pubdef, cc_pubdef, sf_pubdef, monterey_pubdef, solano_pubdef,
san_diego_pubdef, san_joaquin_pubdef, santa_clara_pubdef,
fresno_pubdef]
answers = fake.all_county_answers()
Form = county_form_selector.get_combined_form_class(
counties=[org.county.slug for org in target_orgs])
form = Form(answers, validate=True)
applicant = models.Applicant()
applicant.save()
applicants.append(applicant)
multi_org_sub = models.FormSubmission(
applicant=applicant, answers=form.cleaned_data)
multi_org_sub.answers.update(fake.declaration_letter_answers())
multi_org_sub.save()
applications = [
models.Application(organization=org, form_submission=multi_org_sub)
for org in target_orgs
]
models.Application.objects.bulk_create(applications)
subs.append(multi_org_sub)
# fake the date received for each sub
for sub in subs:
sub.date_received = local(fake.date_time_between('-2w', 'now'))
sub.save()
# make a bundle for each org
for org in receiving_orgs:
org_subs = []
for sub in subs:
has_app = sub.applications.filter(organization=org).exists()
if has_app and sub != multi_org_sub:
org_subs.append(sub)
bundle = BundlesService.create_bundle_from_submissions(
organization=org,
submissions=org_subs,
skip_pdf=True)
# save bundle
filename = 'mock_1_bundle_to_' + org.slug + ".json"
dump_as_json([bundle], fixture_path(filename))
filename = 'mock_{}_submissions_to_{}.json'.format(
len(org_subs), org.slug)
serialize_subs(org_subs, fixture_path(filename))
serialize_subs(
[multi_org_sub],
fixture_path('mock_1_submission_to_multiple_orgs.json'))
events = []
for applicant in applicants:
events.extend(
make_mock_submission_event_sequence(applicant))
dump_as_json(events, fixture_path('mock_application_events.json'))
