def test_back_dating_update_with_earlier_days(self, sau_stub):
"""For RT-489, specifically"""
# Arrange
StrategicActionUpdateFactory.create(
user=sau_stub["user"],
strategic_action=sau_stub["sa"],
supply_chain=sau_stub["sc"],
status=Staus.SUBMITTED,
implementation_rag_rating=RAGRating.GREEN,
reason_for_delays="some text",
date_created=date.today().replace(day=10) -
relativedelta(months=3),
submission_date=date.today().replace(day=10) -
relativedelta(months=3),
)
# Act
sau = StrategicActionUpdateFactory.build(
user=sau_stub["user"],
strategic_action=sau_stub["sa"],
supply_chain=sau_stub["sc"],
status=Staus.SUBMITTED,
implementation_rag_rating=RAGRating.GREEN,
reason_for_delays="some text",
date_created=date.today().replace(day=20) -
relativedelta(months=3),
submission_date=date.today().replace(day=20) -
relativedelta(months=3),
)
# Assert
self.validate(sau, {ObjectLevelError: ""}, objects_saved=1)
assert (StrategicActionUpdate.objects.given_month(date.today().replace(
day=20) - relativedelta(months=3)).count() == 1)
def test_back_dating_fail(self, sau_stub):
# Arrange
sau1 = StrategicActionUpdateFactory.create(
user=sau_stub["user"],
strategic_action=sau_stub["sa"],
supply_chain=sau_stub["sc"],
status=Staus.SUBMITTED,
implementation_rag_rating=RAGRating.GREEN,
reason_for_delays="some text",
date_created=date.today().replace(day=20) -
relativedelta(months=3),
submission_date=date.today().replace(day=20) -
relativedelta(months=3),
)
# Act
new = StrategicActionUpdateFactory.build(
user=sau_stub["user"],
strategic_action=sau_stub["sa"],
supply_chain=sau_stub["sc"],
status=Staus.IN_PROGRESS,
date_created=date.today().replace(day=20) -
relativedelta(months=3),
)
# Assert
self.validate(new, {ObjectLevelError: ""}, objects_saved=1)
assert (StrategicActionUpdate.objects.given_month(date.today().replace(
day=20) - relativedelta(months=3)).count() == 1)
def test_last_monthly_update():
supply_chain = SupplyChainFactory()
strategic_action = StrategicActionFactory(supply_chain=supply_chain)
march_strategic_action_update: StrategicActionUpdate = StrategicActionUpdateFactory(
strategic_action=strategic_action,
supply_chain=strategic_action.supply_chain,
submission_date=date(year=2021, month=3, day=31),
status=StrategicActionUpdate.Status.SUBMITTED,
)
february_strategic_action_update: StrategicActionUpdate = (
StrategicActionUpdateFactory(
strategic_action=strategic_action,
supply_chain=strategic_action.supply_chain,
submission_date=date(year=2021, month=2, day=17),
status=StrategicActionUpdate.Status.SUBMITTED,
))
january_strategic_action_update: StrategicActionUpdate = (
StrategicActionUpdateFactory(
strategic_action=strategic_action,
supply_chain=strategic_action.supply_chain,
submission_date=date(year=2021, month=1, day=1),
status=StrategicActionUpdate.Status.SUBMITTED,
))
last_submitted: StrategicActionUpdate = strategic_action.last_submitted_update(
)
assert (last_submitted.submission_date ==
march_strategic_action_update.submission_date)
def setup_method(self):
self.supply_chain = SupplyChainFactory()
self.strategic_action = StrategicActionFactory(
supply_chain=self.supply_chain)
self.strategic_action_update = StrategicActionUpdateFactory(
strategic_action=self.strategic_action,
supply_chain=self.strategic_action.supply_chain,
)
def test_sc_homepage_summary_complete_with_archived_SAs(
logged_in_client, test_user):
# Arrange
active_sa = SupplyChainFactory(
name="Medical",
gov_department=test_user.gov_department,
)
sc = SupplyChainFactory(
name="carbon",
gov_department=test_user.gov_department,
)
sa = StrategicActionFactory(supply_chain=active_sa)
StrategicActionFactory.create_batch(3,
supply_chain=sc,
is_archived=True,
archived_reason="Reason")
StrategicActionUpdateFactory()
dummy_qs = QuerySet(model=StrategicActionUpdate)
# Act
with mock.patch(
"supply_chains.models.SupplyChainQuerySet.submitted_since",
return_value=dummy_qs,
):
resp = logged_in_client.get(reverse("sc-home"))
# Assert
assert resp.context["update_complete"]
assert resp.context["num_in_prog_supply_chains"] == 0
assert len(resp.context["supply_chains"]) == 2
def bit_of_everything_queryset(bit_of_everything_item_count,
bit_of_everything_last_modified_times):
"""
Generate a bunch of SCs, SA, and SAUs so we can be sure there's a good mix for the union queryset.
Doing them this rather odd way helps check that the ordering works as expected
by interleaving the last_modified values among the different models,
such that simply concatenating the instances from each queryset would not be ordered by last_modified.
To get an idea of what comes out, run the following at the console:
['sc' if i % 8 == 0 else 'sa' if i % 4 == 1 else 'sau' for i in range(0, 23)]
"""
supply_chain_in_use = None
strategic_action_in_use = None
gov_department: GovDepartment = GovDepartment.objects.first()
user = UserFactory(gov_department=gov_department)
with mock.patch("django.utils.timezone.now") as mock_now:
for i, last_modified in enumerate(
bit_of_everything_last_modified_times):
mock_now.return_value = last_modified
if i % 8 == 0:
supply_chain_in_use = SupplyChainFactory(
gov_department=gov_department)
continue
if i % 5 == 1:
strategic_action_in_use = StrategicActionFactory(
supply_chain=supply_chain_in_use)
continue
StrategicActionUpdateFactory(
supply_chain=supply_chain_in_use,
strategic_action=strategic_action_in_use,
user=user,
status=StrategicActionUpdate.Status.SUBMITTED,
)
def test_detail_form_saves_data_for_inner_form(self):
# the form should only validate the detail form for the submitted option
expected_outer_form_selected_option_value = "RED"
expected_inner_form_field_value = "inner form field value"
not_expected_inner_form_field_value = "this should not be saved"
inner_form_field_values = {
"RED": expected_inner_form_field_value,
"AMBER": not_expected_inner_form_field_value,
}
strategic_action_update = StrategicActionUpdateFactory()
form_data = {
"implementation_rag_rating":
expected_outer_form_selected_option_value,
"RED-reason_for_delays": expected_inner_form_field_value,
"AMBER-reason_for_delays": not_expected_inner_form_field_value,
}
outer_form = OuterTestDetailForm(instance=strategic_action_update,
data=form_data)
outer_form.is_valid()
outer_form.save()
instance = outer_form.instance
instance.refresh_from_db()
assert instance.pk is not None
assert (instance.implementation_rag_rating ==
expected_outer_form_selected_option_value)
assert instance.reason_for_delays == expected_inner_form_field_value
def taskcomp_stub(test_user):
sc_name = "Supply Chain 1"
sc = SupplyChainFactory.create(
name=sc_name,
gov_department=test_user.gov_department,
last_submission_date=date.today(),
)
scs = SupplyChainFactory.create_batch(
2, gov_department=test_user.gov_department)
sa = StrategicActionFactory.create(supply_chain=sc)
StrategicActionUpdateFactory(
status=Status.SUBMITTED,
submission_date=date.today(),
strategic_action=sa,
supply_chain=sc,
)
yield {
"sc_name":
sc_name,
"url":
reverse(
"supply-chain-update-complete",
kwargs={"supply_chain_slug": slugify(sc_name)},
),
}
def test_update_details_ongoing(self, logged_in_client, test_user):
# Arrange
sc_name = "ceramics"
sa_name = "action 01"
update_slug = "05-2021"
sc = SupplyChainFactory.create(
name=sc_name,
gov_department=test_user.gov_department,
last_submission_date=date.today(),
)
sa = StrategicActionFactory.create(name=sa_name,
supply_chain=sc,
is_ongoing=True)
StrategicActionUpdateFactory(
slug=update_slug,
status=Status.SUBMITTED,
submission_date=date.today(),
strategic_action=sa,
supply_chain=sc,
)
# Act
resp = logged_in_client.get(
reverse(
"monthly-update-review",
kwargs={
"supply_chain_slug": sc_name,
"action_slug": slugify(sa_name),
"update_slug": update_slug,
},
))
# Assert
assert resp.context["supply_chain_name"] == sc_name
assert resp.context["completion_estimation"] == "Ongoing"
def test_dump_sau_data_multiple(self):
# Arrange
exp_sc_ids = list()
exp_sa_ids = list()
for _ in range(4):
sc = SupplyChainFactory()
sa = StrategicActionFactory(supply_chain=sc)
StrategicActionUpdateFactory(supply_chain=sc, strategic_action=sa)
exp_sc_ids.append(str(sc.id))
exp_sa_ids.append(str(sa.id))
# Act
self.invoke_dump(MODEL_STRAT_ACTION_UPDATE, self.data_file.name)
rows = self.load_csv()
# Assert
assert len(rows) == 4
ids = [x["id"] for x in rows]
assert len(ids) == len(set(ids))
sc_ids = [x["supply_chain"] for x in rows]
assert all(
[a == b for a, b in zip(sorted(sc_ids), sorted(exp_sc_ids))])
sa_ids = [x["strategic_action"] for x in rows]
assert all(
[a == b for a, b in zip(sorted(sa_ids), sorted(exp_sa_ids))])
def test_auth_no_perm(self, logged_in_client):
# Arrange
sc_name = "ceramics"
dep = GovDepartmentFactory()
sc = SupplyChainFactory(gov_department=dep, name=sc_name)
sa = StrategicActionFactory.create(supply_chain=sc)
sau = StrategicActionUpdateFactory(
status=Status.SUBMITTED,
submission_date=date.today(),
strategic_action=sa,
supply_chain=sc,
)
# Act
resp = logged_in_client.get(
reverse(
"monthly-update-review",
kwargs={
"supply_chain_slug": slugify(sc_name),
"action_slug": sa.slug,
"update_slug": sau.slug,
},
))
# Assert
assert resp.status_code == 403
def test_since_with_filter(self):
# Arrange
sc = SupplyChainFactory.create(name="Supply Chain 1")
sa = StrategicActionFactory.create(name="SA 01", supply_chain=sc)
sau = StrategicActionUpdateFactory.create(
status=StrategicActionUpdate.Status.IN_PROGRESS,
supply_chain=sc,
strategic_action=sa,
)
# Act
sau_prog = StrategicActionUpdate.objects.since(
deadline=date.today() - timedelta(days=1),
supply_chain=sc,
status=StrategicActionUpdate.Status.IN_PROGRESS,
)
sau_comp = StrategicActionUpdate.objects.since(
deadline=date.today() - timedelta(days=1),
supply_chain=sc,
status=StrategicActionUpdate.Status.READY_TO_SUBMIT,
)
# Assert
assert sau_prog[0] == sau
assert sau_comp.count() == 0
def strategic_action_update_queryset(strategic_action_queryset,
last_modified_times):
for strategic_action in strategic_action_queryset:
StrategicActionUpdateFactory(
strategic_action=strategic_action,
supply_chain=strategic_action.supply_chain,
)
return StrategicActionUpdate.objects.all()
def test_back_dating_update_in_gap(self, sau_stub):
# Arrange
StrategicActionUpdateFactory.create(
user=sau_stub["user"],
strategic_action=sau_stub["sa"],
supply_chain=sau_stub["sc"],
status=Staus.SUBMITTED,
implementation_rag_rating=RAGRating.GREEN,
reason_for_delays="some text",
date_created=date.today().replace(day=20) -
relativedelta(months=4),
submission_date=date.today().replace(day=20) -
relativedelta(months=4),
)
StrategicActionUpdateFactory.create(
user=sau_stub["user"],
strategic_action=sau_stub["sa"],
supply_chain=sau_stub["sc"],
status=Staus.SUBMITTED,
implementation_rag_rating=RAGRating.GREEN,
reason_for_delays="some text",
date_created=date.today().replace(day=20) -
relativedelta(months=2),
submission_date=date.today().replace(day=20) -
relativedelta(months=2),
)
# Act
sau = StrategicActionUpdateFactory.build(
user=sau_stub["user"],
strategic_action=sau_stub["sa"],
supply_chain=sau_stub["sc"],
status=Staus.SUBMITTED,
implementation_rag_rating=RAGRating.GREEN,
reason_for_delays="some text",
date_created=date.today().replace(day=20) -
relativedelta(months=3),
submission_date=date.today().replace(day=20) -
relativedelta(months=3),
)
# Assert
self.validate(sau, {}, objects_saved=3)
assert (StrategicActionUpdate.objects.given_month(date.today().replace(
day=20) - relativedelta(months=3)).count() == 1)
def strategic_action_update_with_action_status_red(strategic_action_without_timing):
strategic_action_update = StrategicActionUpdateFactory(
strategic_action=strategic_action_without_timing,
supply_chain=strategic_action_without_timing.supply_chain,
changed_value_for_target_completion_date=date.today() + relativedelta(months=1),
changed_value_for_is_ongoing=False,
implementation_rag_rating=RAGRating.RED,
reason_for_delays="Foo",
)
return strategic_action_update
def update_stub(test_user):
sc_name = "Supply Chain 1"
sa_name = "action 01"
sa_completion = "2021-02-01"
update_slug = "05-2021"
sau_rag = "Amber"
sau_reason = "Brexit negotiations"
sc = SupplyChainFactory.create(
name=sc_name,
gov_department=test_user.gov_department,
last_submission_date=date.today(),
)
sa = StrategicActionFactory.create(name=sa_name,
supply_chain=sc,
target_completion_date=sa_completion)
StrategicActionUpdateFactory(
slug=update_slug,
status=Status.SUBMITTED,
submission_date=date.today(),
strategic_action=sa,
supply_chain=sc,
implementation_rag_rating=sau_rag,
reason_for_delays=sau_reason,
)
yield {
"sc":
sc,
"sa":
sa,
"sc_name":
sc_name,
"sa_name":
sa_name,
"sa_completion":
sa_completion,
"sau_rag":
sau_rag,
"sau_reason":
sau_reason,
"update_slug":
update_slug,
"url":
reverse(
"monthly-update-review",
kwargs={
"supply_chain_slug": slugify(sc_name),
"action_slug": slugify(sa_name),
"update_slug": update_slug,
},
),
}
def strategic_action_update_timing_status_incomplete(strategic_action_without_timing):
strategic_action_update = StrategicActionUpdateFactory(
strategic_action=strategic_action_without_timing,
supply_chain=strategic_action_without_timing.supply_chain,
content="Foo",
changed_value_for_target_completion_date=None,
changed_value_for_is_ongoing=False,
implementation_rag_rating=None,
reason_for_delays="",
reason_for_completion_date_change="",
)
return strategic_action_update
def strategic_action_update_complete_with_changed_is_ongoing(
strategic_action_without_timing,
):
strategic_action_update = StrategicActionUpdateFactory(
strategic_action=strategic_action_without_timing,
supply_chain=strategic_action_without_timing.supply_chain,
content="Foo",
changed_value_for_target_completion_date=None,
changed_value_for_is_ongoing=True,
implementation_rag_rating=RAGRating.GREEN,
reason_for_delays="",
)
return strategic_action_update
def test_SAU_missing_RAG(self, sau_stub):
# Arrange
# Act
sau = StrategicActionUpdateFactory.build(
user=sau_stub["user"],
strategic_action=sau_stub["sa"],
supply_chain=sau_stub["sc"],
status=Staus.SUBMITTED,
implementation_rag_rating=None,
)
# Assert
self.validate(sau, {RagRating: ERROR_MSGS[RagRating]})
def test_SAU_save(self, sau_stub):
# Arrange
# Act
sau = StrategicActionUpdateFactory.build(
user=sau_stub["user"],
strategic_action=sau_stub["sa"],
supply_chain=sau_stub["sc"],
status=Staus.SUBMITTED,
implementation_rag_rating=RAGRating.GREEN,
)
# Assert
self.validate(sau, {}, objects_saved=1)
def model_stub(test_user):
sc = SupplyChainFactory.create(
name=sc_name,
gov_department=test_user.gov_department,
last_submission_date=date.today(),
)
sa = StrategicActionFactory.create(supply_chain=sc, name=sa_name)
StrategicActionUpdateFactory(
status=Status.SUBMITTED,
submission_date=date(day=1, month=1, year=2020),
strategic_action=sa,
supply_chain=sc,
)
def test_SAU_missing_sub_date(self, sau_stub):
# Arrange
# Act
sau = StrategicActionUpdateFactory.build(
user=sau_stub["user"],
strategic_action=sau_stub["sa"],
supply_chain=sau_stub["sc"],
status=Staus.SUBMITTED,
submission_date=None,
)
# Assert
self.validate(sau, {SubDate: ERROR_MSGS[SubDate]})
def test_SAU_missing_content(self, sau_stub):
# Arrange
# Act
sau = StrategicActionUpdateFactory.build(
user=sau_stub["user"],
strategic_action=sau_stub["sa"],
supply_chain=sau_stub["sc"],
status=Staus.SUBMITTED,
content=None,
)
# Assert
self.validate(sau, {Content: ERROR_MSGS[Content]})
def tasklist_in_prog(tasklist_stub):
StrategicActionUpdateFactory(
status=Status.IN_PROGRESS,
strategic_action=tasklist_stub["sa"][0],
supply_chain=tasklist_stub["sc"],
)
yield {
"url":
reverse(
"supply-chain-task-list",
kwargs={"supply_chain_slug": slugify(tasklist_stub["sc_name"])},
),
}
def tasklist_part_comp(tasklist_stub):
StrategicActionUpdateFactory(
status=Status.READY_TO_SUBMIT,
strategic_action=tasklist_stub["sa"][0],
supply_chain=tasklist_stub["sc"],
)
yield {
"url":
reverse(
"supply-chain-task-list",
kwargs={"supply_chain_slug": slugify(tasklist_stub["sc_name"])},
),
}
def test_dump_sau_data(self):
# Arrange
sc = SupplyChainFactory()
sa = StrategicActionFactory(supply_chain=sc)
StrategicActionUpdateFactory(supply_chain=sc, strategic_action=sa)
# Act
self.invoke_dump(MODEL_STRAT_ACTION_UPDATE, self.data_file.name)
rows = self.load_csv()
# Assert
assert len(rows) == 1
assert rows[0]["supply_chain"] == str(sc.id)
assert rows[0]["strategic_action"] == str(sa.id)
def strategic_action_update_complete_with_revised_completion_date(
strategic_action_with_completion_date,
):
strategic_action_update = StrategicActionUpdateFactory(
strategic_action=strategic_action_with_completion_date,
supply_chain=strategic_action_with_completion_date.supply_chain,
content="Foo",
changed_value_for_target_completion_date=date.today() + relativedelta(months=1),
changed_value_for_is_ongoing=False,
implementation_rag_rating=RAGRating.GREEN,
reason_for_delays="",
reason_for_completion_date_change="Foo",
)
return strategic_action_update
def test_back_dating_change_state(self, sau_stub):
# Arrange
StrategicActionUpdateFactory.create(
user=sau_stub["user"],
strategic_action=sau_stub["sa"],
supply_chain=sau_stub["sc"],
status=Staus.IN_PROGRESS,
implementation_rag_rating=RAGRating.GREEN,
date_created=date.today().replace(day=20) -
relativedelta(months=3),
)
StrategicActionUpdateFactory.create_batch(10)
# Act
sau = StrategicActionUpdate.objects.get(
strategic_action=sau_stub["sa"])
sau.status = Staus.SUBMITTED
sau.submission_date = date.today().replace(day=20) - relativedelta(
months=3)
sau.save()
# Assert
assert (StrategicActionUpdate.objects.given_month(date.today().replace(
day=20) - relativedelta(months=3)).count() == 1)
def tasklist_submitted(tasklist_stub):
for sa_index in range(4):
StrategicActionUpdateFactory(
status=Status.SUBMITTED,
strategic_action=tasklist_stub["sa"][sa_index],
supply_chain=tasklist_stub["sc"],
)
yield {
"url":
reverse(
"supply-chain-task-list",
kwargs={"supply_chain_slug": slugify(tasklist_stub["sc_name"])},
),
}
def test_posting_form_saves_changed_target_completion_date_to_strategic_action_update(
self, logged_in_client, test_user):
supply_chain: SupplyChain = SupplyChainFactory()
test_user.gov_department = supply_chain.gov_department
test_user.save()
strategic_action: StrategicAction = StrategicActionFactory(
supply_chain=supply_chain)
strategic_action.target_completion_date = None
strategic_action.is_ongoing = True
strategic_action.save()
strategic_action_update: StrategicActionUpdate = StrategicActionUpdateFactory(
strategic_action=strategic_action,
status=StrategicActionUpdate.Status.IN_PROGRESS,
supply_chain=strategic_action.supply_chain,
reason_for_completion_date_change="All things must pass.",
)
mock_today = date(year=2021, month=4, day=23)
with mock.patch(
"supply_chains.forms.date",
mock.Mock(today=mock.Mock(return_value=mock_today)),
):
expected_target_completion_date = mock_today + relativedelta(
years=+1)
form_data = {
"is_completion_date_known":
YesNoChoices.NO,
f"{YesNoChoices.NO}-surrogate_is_ongoing":
ApproximateTimings.ONE_YEAR,
}
url_kwargs = {
"supply_chain_slug": strategic_action.supply_chain.slug,
"action_slug": strategic_action.slug,
"update_slug": strategic_action_update.slug,
}
url = reverse("monthly-update-timing-edit", kwargs=url_kwargs)
response = logged_in_client.post(url, form_data)
assert response.status_code == 302
strategic_action.refresh_from_db()
assert strategic_action.target_completion_date is None
strategic_action_update.refresh_from_db()
assert (strategic_action_update.
changed_value_for_target_completion_date ==
expected_target_completion_date)
