def lot_create_tender_question(self):
cancellation = dict(**test_cancellation)
cancellation.update({
"status": "active",
"cancellationOf": "lot",
"relatedLot": self.initial_lots[0]["id"],
})
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(
self.tender_id, self.tender_token),
{"data": cancellation},
)
self.assertEqual(response.status, "201 Created")
cancellation_id = response.json["data"]["id"]
if RELEASE_2020_04_19 < get_now():
activate_cancellation_after_2020_04_19(self, cancellation_id)
response = self.app.post_json(
"/tenders/{}/questions".format(self.tender_id, self.tender_token),
{
"data": {
"title": "question title",
"description": "question description",
"questionOf": "lot",
"relatedItem": self.initial_lots[0]["id"],
"author": self.author_data,
}
},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["errors"][0]["description"],
"Can add question only in active lot status")
response = self.app.post_json(
"/tenders/{}/questions".format(self.tender_id, self.tender_token),
{
"data": {
"title": "question title",
"description": "question description",
"questionOf": "lot",
"relatedItem": self.initial_lots[1]["id"],
"author": self.author_data,
}
},
)
self.assertEqual(response.status, "201 Created")
self.assertEqual(response.content_type, "application/json")
question = response.json["data"]
self.assertEqual(question["author"]["name"], self.author_data["name"])
self.assertIn("id", question)
self.assertIn(question["id"], response.headers["Location"])
def delete_first_lot_second_cancel(self):
""" One lot we delete another cancel and check tender status """
self.app.patch_json(
"/tenders/{}?acc_token={}".format(self.tender_id, self.tender_token),
{"data": {
"items": [{
"relatedLot": self.initial_lots[1]["id"]
}]
}},
)
response = self.app.delete("/tenders/{}/lots/{}?acc_token={}".format(
self.tender_id, self.initial_lots[0]["id"], self.tender_token))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
response = self.app.get("/tenders/{}/lots?acc_token={}".format(
self.tender_id, self.tender_token))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(len(response.json["data"]), 1)
cancellation = dict(**test_cancellation)
cancellation.update({
"status": "active",
"cancellationOf": "lot",
"relatedLot": self.initial_lots[1]["id"],
})
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(
self.tender_id, self.tender_token),
{"data": cancellation},
)
self.assertEqual(response.status, "201 Created")
self.assertEqual(response.content_type, "application/json")
cancellation = response.json["data"]
self.assertEqual(cancellation["reason"], "cancellation reason")
self.assertIn("id", cancellation)
self.assertIn(cancellation["id"], response.headers["Location"])
if RELEASE_2020_04_19 > get_now():
self.assertEqual(cancellation["status"], "active")
else:
activate_cancellation_after_2020_04_19(self, cancellation["id"])
response = self.app.get("/tenders/{}?acc_token={}".format(
self.tender_id, self.tender_token))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["data"]["status"], "cancelled")
def patch_tender_lot_cancellation(self):
lot_id = self.initial_lots[0]["id"]
cancellation = dict(**test_cancellation)
cancellation.update({
"cancellationOf": "lot",
"relatedLot": lot_id,
})
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(self.tender_id, self.tender_token),
{"data": cancellation},
)
self.assertEqual(response.status, "201 Created")
self.assertEqual(response.content_type, "application/json")
cancellation = response.json["data"]
if RELEASE_2020_04_19 > get_now():
response = self.app.patch_json(
"/tenders/{}/cancellations/{}?acc_token={}".format(self.tender_id, cancellation["id"], self.tender_token),
{"data": {"status": "active"}},
)
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["data"]["status"], "active")
else:
activate_cancellation_after_2020_04_19(self, cancellation["id"])
response = self.app.get("/tenders/{}".format(self.tender_id))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["data"]["lots"][0]["status"], "cancelled")
self.assertEqual(response.json["data"]["status"], "cancelled")
response = self.app.patch_json(
"/tenders/{}/cancellations/{}?acc_token={}".format(self.tender_id, cancellation["id"], self.tender_token),
{"data": {"status": "pending"}},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(
response.json["errors"][0]["description"], "Can't update tender in current (cancelled) status"
)
response = self.app.get("/tenders/{}/cancellations/{}".format(self.tender_id, cancellation["id"]))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["data"]["status"], "active")
self.assertEqual(response.json["data"]["reason"], "cancellation reason")
def lot2_patch_tender_contract(self):
auth = self.app.authorization
self.app.authorization = ("Basic", ("token", ""))
response = self.app.post_json(
"/tenders/{}/contracts".format(self.tender_id),
{"data": {"title": "contract title", "description": "contract description", "awardID": self.award_id}},
)
self.assertEqual(response.status, "201 Created")
self.assertEqual(response.content_type, "application/json")
contract = response.json["data"]
self.app.authorization = auth
response = self.app.patch_json(
"/tenders/{}/contracts/{}?acc_token={}".format(self.tender_id, contract["id"], self.tender_token),
{"data": {"status": "active"}},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.content_type, "application/json")
self.assertIn("Can't sign contract before stand-still period end (", response.json["errors"][0]["description"])
self.set_status("complete", {"status": "active.awarded"})
cancellation = dict(**test_cancellation)
cancellation.update({
"status": "active",
"cancellationOf": "lot",
"relatedLot": self.initial_lots[0]["id"],
})
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(self.tender_id, self.tender_token),
{"data": cancellation},
)
cancellation_id = response.json["data"]["id"]
if RELEASE_2020_04_19 < get_now():
activate_cancellation_after_2020_04_19(self, cancellation_id)
response = self.app.patch_json(
"/tenders/{}/contracts/{}?acc_token={}".format(self.tender_id, contract["id"], self.tender_token),
{"data": {"status": "active"}},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["errors"][0]["description"], "Can update contract only in active lot status")
def cancellation_on_not_active_lot(self):
lot = self.initial_lots[0]
# Create cancellation on lot with status cancelled
cancellation = dict(**test_cancellation)
cancellation.update({
"status": "active",
"cancellationOf": "lot",
"relatedLot": lot["id"],
})
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(
self.tender_id, self.tender_token),
{"data": cancellation},
)
self.assertEqual(response.status, "201 Created")
self.assertEqual(response.content_type, "application/json")
cancellation_id = response.json["data"]["id"]
if RELEASE_2020_04_19 < get_now():
activate_cancellation_after_2020_04_19(self, cancellation_id)
# check lot status
response = self.app.get("/tenders/{}/lots/{}".format(
self.tender_id, lot["id"]))
self.assertEqual(response.json["data"]["status"], "cancelled")
# Try to create cancellation on lot with status cancelled
cancellation = dict(**test_cancellation)
cancellation.update({
"status": "active",
"cancellationOf": "lot",
"relatedLot": lot["id"],
})
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(
self.tender_id, self.tender_token),
{"data": cancellation},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["errors"][0]["description"],
"Can perform cancellation only in active lot status")
def create_tender_cancellation_with_post(self):
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(
self.tender_id, self.tender_token),
{"data": test_cancellation},
)
self.assertEqual(response.status, "201 Created")
self.assertEqual(response.content_type, "application/json")
cancellation = response.json["data"]
self.assertEqual(cancellation["reason"], "cancellation reason")
self.assertIn("id", cancellation)
self.assertIn(cancellation["id"], response.headers["Location"])
response = self.app.get("/tenders/{}".format(self.tender_id))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["data"]["status"], "active")
cancellation = dict(**test_cancellation)
cancellation.update({"status": "active"})
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(
self.tender_id, self.tender_token),
{"data": cancellation},
)
self.assertEqual(response.status, "201 Created")
self.assertEqual(response.content_type, "application/json")
cancellation = response.json["data"]
self.assertEqual(cancellation["reason"], "cancellation reason")
if get_now() < RELEASE_2020_04_19:
self.assertEqual(cancellation["status"], "active")
self.assertIn("id", cancellation)
self.assertIn(cancellation["id"], response.headers["Location"])
else:
self.assertEqual(cancellation["status"], "draft")
activate_cancellation_after_2020_04_19(self, cancellation["id"])
response = self.app.get("/tenders/{}".format(self.tender_id))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["data"]["status"], "cancelled")
def cancel_lots_check_awards(self):
# create first lot
response = self.app.post_json(
"/tenders/{}/lots?acc_token={}".format(self.tender_id, self.tender_token), {"data": self.test_lots_data[0]}
)
self.assertEqual(response.status, "201 Created")
self.assertEqual(response.content_type, "application/json")
first_lot = response.json["data"]
# create second lot
response = self.app.post_json(
"/tenders/{}/lots?acc_token={}".format(self.tender_id, self.tender_token), {"data": self.test_lots_data[0]}
)
self.assertEqual(response.status, "201 Created")
self.assertEqual(response.content_type, "application/json")
second_lot = response.json["data"]
# first award
response = self.app.post_json(
"/tenders/{}/awards?acc_token={}".format(self.tender_id, self.tender_token),
{"data": {"suppliers": [test_organization], "status": "pending", "lotID": first_lot["id"], "qualified": True}},
)
self.assertEqual(response.status, "201 Created")
self.assertEqual(response.content_type, "application/json")
first_award = response.json["data"]
# second award
response = self.app.post_json(
"/tenders/{}/awards?acc_token={}".format(self.tender_id, self.tender_token),
{"data": {"suppliers": [test_organization], "status": "pending", "lotID": second_lot["id"], "qualified": True}},
)
self.assertEqual(response.status, "201 Created")
self.assertEqual(response.content_type, "application/json")
second_award = response.json["data"]
# cancellation for first lot
cancellation = dict(**test_cancellation)
cancellation.update({
"cancellationOf": "lot",
"relatedLot": first_lot["id"],
})
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(self.tender_id, self.tender_token),
{"data": cancellation},
)
self.assertEqual(response.status, "201 Created")
cancellation = response.json["data"]
cancellation_id = cancellation["id"]
if RELEASE_2020_04_19 > get_now():
self.app.patch_json(
"/tenders/{}/cancellations/{}?acc_token={}".format(
self.tender_id, cancellation_id, self.tender_token
),
{"data": {"status": "active"}},
)
else:
activate_cancellation_after_2020_04_19(self, cancellation_id)
# check corresponding lot
response = self.app.get("/tenders/{}/lots/{}".format(self.tender_id, first_lot["id"]))
self.assertEqual(response.json["data"]["status"], "cancelled")
# check corresponding award
response = self.app.get("/tenders/{}/awards/{}".format(self.tender_id, first_award["id"]))
self.assertEqual(response.json["data"]["status"], "pending")
def cancel_lot_with_complaint(self):
# Create lot
response = self.app.post_json(
"/tenders/{}/lots?acc_token={}".format(self.tender_id, self.tender_token), {"data": self.test_lots_data[0]}
)
self.assertEqual(response.status, "201 Created")
self.assertEqual(response.content_type, "application/json")
lot = response.json["data"]
self.app.patch_json(
"/tenders/{}?acc_token={}".format(self.tender_id, self.tender_token),
{"data": {"items": [{"relatedLot": lot["id"]}]}},
)
# Create award
response = self.app.post_json(
"/tenders/{}/awards?acc_token={}".format(self.tender_id, self.tender_token),
{
"data": {
"suppliers": [test_organization],
"status": "pending",
"qualified": True,
"value": {"amount": 469, "currency": "UAH", "valueAddedTaxIncluded": True},
"lotID": lot["id"],
}
},
)
self.assertEqual(response.status, "201 Created")
award = response.json["data"]
response = self.app.patch_json(
"/tenders/{}/awards/{}?acc_token={}".format(self.tender_id, award["id"], self.tender_token),
{"data": {"status": "active"}},
)
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.json["data"]["status"], "active")
# Create complaints
response = self.app.post_json(
"/tenders/{}/awards/{}/complaints".format(self.tender_id, award["id"]),
{
"data": test_complaint
},
)
self.assertEqual(response.status, "201 Created")
complaint = response.json["data"]
owner_token = response.json["access"]["token"]
if RELEASE_2020_04_19 < get_now():
self.assertEqual(response.json["data"]["status"], "draft")
response = self.app.patch_json(
"/tenders/{}/awards/{}/complaints/{}?acc_token={}".format(
self.tender_id, award["id"], complaint["id"], owner_token),
{"data": {"status": "pending"}},
)
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["data"]["status"], "pending")
# set complaint status stopping to be able to cancel the lot
response = self.app.patch_json(
"/tenders/{}/awards/{}/complaints/{}?acc_token={}".format(
self.tender_id, award["id"], response.json["data"]["id"], owner_token
),
{"data": {
"status": "stopping",
"cancellationReason": "want this test to pass",
}},
)
assert response.status_code == 200
# Try to cancel lot
cancellation = dict(**test_cancellation)
cancellation.update({
"cancellationOf": "lot",
"relatedLot": lot["id"],
})
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(self.tender_id, self.tender_token),
{"data": cancellation},
)
self.assertEqual(response.status, "201 Created")
cancellation = response.json["data"]
cancellation_id = cancellation["id"]
if RELEASE_2020_04_19 > get_now():
self.app.patch_json(
"/tenders/{}/cancellations/{}?acc_token={}".format(
self.tender_id, cancellation_id, self.tender_token
),
{"data": {"status": "active"}},
)
else:
activate_cancellation_after_2020_04_19(self, cancellation_id)
# Check lot status
response = self.app.get("/tenders/{}/lots".format(self.tender_id))
self.assertEqual(response.json["data"][0]["status"], "cancelled")
def put_tender_award_complaint_document(self):
response = self.app.post(
"/tenders/{}/awards/{}/complaints/{}/documents?acc_token={}".format(
self.tender_id, self.award_id, self.complaint_id,
self.complaint_owner_token),
upload_files=[("file", "name.doc", "content")],
)
self.assertEqual(response.status, "201 Created")
self.assertEqual(response.content_type, "application/json")
doc_id = response.json["data"]["id"]
self.assertIn(doc_id, response.headers["Location"])
response = self.app.put(
"/tenders/{}/awards/{}/complaints/{}/documents/{}".format(
self.tender_id, self.award_id, self.complaint_id, doc_id),
status=404,
upload_files=[("invalid_name", "name.doc", "content")],
)
self.assertEqual(response.status, "404 Not Found")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["status"], "error")
self.assertEqual(response.json["errors"], [{
u"description": u"Not Found",
u"location": u"body",
u"name": u"file"
}])
response = self.app.put(
"/tenders/{}/awards/{}/complaints/{}/documents/{}".format(
self.tender_id, self.award_id, self.complaint_id, doc_id),
upload_files=[("file", "name.doc", "content2")],
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["errors"][0]["description"],
"Can update document only author")
response = self.app.put(
"/tenders/{}/awards/{}/complaints/{}/documents/{}?acc_token={}".format(
self.tender_id, self.award_id, self.complaint_id, doc_id,
self.complaint_owner_token),
upload_files=[("file", "name.doc", "content2")],
)
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(doc_id, response.json["data"]["id"])
key = response.json["data"]["url"].split("?")[-1]
response = self.app.get(
"/tenders/{}/awards/{}/complaints/{}/documents/{}?{}".format(
self.tender_id, self.award_id, self.complaint_id, doc_id, key))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/msword")
self.assertEqual(response.content_length, 8)
self.assertEqual(response.body, "content2")
response = self.app.get(
"/tenders/{}/awards/{}/complaints/{}/documents/{}".format(
self.tender_id, self.award_id, self.complaint_id, doc_id))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(doc_id, response.json["data"]["id"])
self.assertEqual("name.doc", response.json["data"]["title"])
response = self.app.put(
"/tenders/{}/awards/{}/complaints/{}/documents/{}?acc_token={}".format(
self.tender_id, self.award_id, self.complaint_id, doc_id,
self.complaint_owner_token),
"content3",
content_type="application/msword",
)
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(doc_id, response.json["data"]["id"])
key = response.json["data"]["url"].split("?")[-1]
response = self.app.get(
"/tenders/{}/awards/{}/complaints/{}/documents/{}?{}".format(
self.tender_id, self.award_id, self.complaint_id, doc_id, key))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/msword")
self.assertEqual(response.content_length, 8)
self.assertEqual(response.body, "content3")
response = self.app.put(
"/tenders/{}/awards/{}/complaints/{}/documents/{}?acc_token={}".format(
self.tender_id, self.award_id, self.complaint_id, doc_id,
self.complaint_owner_token),
"content4",
content_type="application/msword",
)
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
key = response.json["data"]["url"].split("?")[-1]
response = self.app.get(
"/tenders/{}/awards/{}/complaints/{}/documents/{}?{}".format(
self.tender_id, self.award_id, self.complaint_id, doc_id, key))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/msword")
self.assertEqual(response.content_length, 8)
self.assertEqual(response.body, "content4")
if RELEASE_2020_04_19 < get_now():
self.set_all_awards_complaint_period_end()
cancellation = dict(**test_cancellation)
cancellation.update({
"status": "active",
"cancellationOf": "lot",
"relatedLot": self.lots[0]["id"],
})
response = self.app.post_json(
"/tenders/{}/cancellations".format(self.tender_id),
{"data": cancellation},
)
self.assertEqual(response.status, "201 Created")
cancellation_id = response.json["data"]["id"]
if RELEASE_2020_04_19 < get_now():
activate_cancellation_after_2020_04_19(self, cancellation_id)
response = self.app.put(
"/tenders/{}/awards/{}/complaints/{}/documents/{}?acc_token={}".format(
self.tender_id, self.award_id, self.complaint_id, doc_id,
self.complaint_owner_token),
upload_files=[("file", "name.doc", "content3")],
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["errors"][0]["description"],
"Can update document only in active lot status")
def patch_tender_award_complaint_document(self):
response = self.app.post(
"/tenders/{}/awards/{}/complaints/{}/documents?acc_token={}".format(
self.tender_id, self.award_id, self.complaint_id,
self.complaint_owner_token),
upload_files=[("file", "name.doc", "content")],
)
self.assertEqual(response.status, "201 Created")
self.assertEqual(response.content_type, "application/json")
doc_id = response.json["data"]["id"]
self.assertIn(doc_id, response.headers["Location"])
response = self.app.patch_json(
"/tenders/{}/awards/{}/complaints/{}/documents/{}".format(
self.tender_id, self.award_id, self.complaint_id, doc_id),
{"data": {
"description": "document description"
}},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["errors"][0]["description"],
"Can update document only author")
response = self.app.patch_json(
"/tenders/{}/awards/{}/complaints/{}/documents/{}?acc_token={}".format(
self.tender_id, self.award_id, self.complaint_id, doc_id,
self.complaint_owner_token),
{"data": {
"description": "document description"
}},
)
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(doc_id, response.json["data"]["id"])
response = self.app.get(
"/tenders/{}/awards/{}/complaints/{}/documents/{}".format(
self.tender_id, self.award_id, self.complaint_id, doc_id))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(doc_id, response.json["data"]["id"])
self.assertEqual("document description",
response.json["data"]["description"])
if get_now() < RELEASE_2020_04_19:
response = self.app.patch_json(
"/tenders/{}/awards/{}/complaints/{}?acc_token={}".format(
self.tender_id, self.award_id, self.complaint_id,
self.complaint_owner_token),
{"data": {
"status": "pending"
}},
)
else:
with change_auth(self.app, ("Basic", ("bot", ""))):
response = self.app.patch_json(
"/tenders/{}/awards/{}/complaints/{}".format(
self.tender_id, self.award_id, self.complaint_id),
{"data": {
"status": "pending"
}},
)
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.json["data"]["status"], "pending")
response = self.app.patch_json(
"/tenders/{}/awards/{}/complaints/{}/documents/{}?acc_token={}".format(
self.tender_id, self.award_id, self.complaint_id, doc_id,
self.complaint_owner_token),
{"data": {
"description": "document description2"
}},
)
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["data"]["description"],
"document description2")
cancellation = dict(**test_cancellation)
cancellation.update({
"status": "active",
"cancellationOf": "lot",
"relatedLot": self.lots[0]["id"],
})
response = self.app.post_json(
"/tenders/{}/cancellations".format(self.tender_id),
{"data": cancellation},
)
self.assertEqual(response.status, "201 Created")
cancellation_id = response.json["data"]["id"]
if RELEASE_2020_04_19 < get_now():
activate_cancellation_after_2020_04_19(self, cancellation_id)
response = self.app.patch_json(
"/tenders/{}/awards/{}/complaints/{}/documents/{}?acc_token={}".format(
self.tender_id, self.award_id, self.complaint_id, doc_id,
self.complaint_owner_token),
{"data": {
"description": "document description"
}},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["errors"][0]["description"],
"Can update document only in active lot status")
def patch_tender_contract(self):
response = self.app.get("/tenders/{}/contracts".format(self.tender_id))
contract = response.json["data"][0]
self.contract_id = contract["id"]
response = self.app.patch_json(
"/tenders/{}/contracts/{}?acc_token={}".format(self.tender_id,
contract["id"],
self.tender_token),
{"data": {
"value": {
"amountNet": contract["value"]["amount"] - 1
}
}},
)
self.assertEqual(response.status, "200 OK")
response = self.app.patch_json(
"/tenders/{}/contracts/{}?acc_token={}".format(self.tender_id,
self.contract_id,
self.tender_token),
{"data": {
"value": {
"currency": "USD"
}
}},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.json["errors"][0]["description"],
"Can't update currency for contract value")
response = self.app.patch_json(
"/tenders/{}/contracts/{}?acc_token={}".format(self.tender_id,
self.contract_id,
self.tender_token),
{"data": {
"status": "active"
}},
)
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["data"]["status"], "active")
self.assertIn("dateSigned", response.json["data"])
response = self.app.patch_json(
"/tenders/{}/contracts/{}?acc_token={}".format(self.tender_id,
self.contract_id,
self.tender_token),
{"data": {
"status": "cancelled"
}},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(
response.json["errors"][0]["description"],
"Can't update contract in current (complete) tender status")
response = self.app.patch_json(
"/tenders/{}/contracts/{}?acc_token={}".format(self.tender_id,
self.contract_id,
self.tender_token),
{"data": {
"status": "pending"
}},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(
response.json["errors"][0]["description"],
"Can't update contract in current (complete) tender status")
response = self.app.patch_json(
"/tenders/{}/contracts/{}?acc_token={}".format(self.tender_id,
self.contract_id,
self.tender_token),
{"data": {
"status": "active"
}},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(
response.json["errors"][0]["description"],
"Can't update contract in current (complete) tender status")
response = self.app.patch_json(
"/tenders/{}/contracts/{}?acc_token={}".format(self.tender_id,
self.contract_id,
self.tender_token),
{"data": {
"awardID": "894917dc8b1244b6aab9ab0ad8c8f48a"
}},
status=422,
)
self.assertEqual(response.status, "422 Unprocessable Entity")
self.assertEqual(response.content_type, "application/json")
# at next steps we test to patch contract in 'cancelled' tender status
response = self.app.post_json("/tenders?acc_token={}",
{"data": self.initial_data})
self.assertEqual(response.status, "201 Created")
tender_id = response.json["data"]["id"]
tender_token = response.json["access"]["token"]
response = self.app.post_json(
"/tenders/{}/awards?acc_token={}".format(tender_id, tender_token),
{"data": {
"suppliers": [test_organization],
"status": "pending"
}},
)
award_id = response.json["data"]["id"]
self.app.patch_json(
"/tenders/{}/awards/{}?acc_token={}".format(tender_id, award_id,
tender_token),
{"data": {
"qualified": True,
"status": "active"
}},
)
response = self.app.get("/tenders/{}/contracts".format(tender_id))
contract_id = response.json["data"][0]["id"]
cancellation = dict(**test_cancellation)
cancellation.update({
"status": "active",
})
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(
tender_id, tender_token),
{"data": cancellation},
)
self.assertEqual(response.status, "201 Created")
cancellation_id = response.json["data"]["id"]
if get_now() > RELEASE_2020_04_19:
activate_cancellation_after_2020_04_19(self, cancellation_id,
tender_id, tender_token)
response = self.app.get("/tenders/{}".format(tender_id))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.json["data"]["status"], "cancelled")
response = self.app.patch_json(
"/tenders/{}/contracts/{}?acc_token={}".format(tender_id, contract_id,
tender_token),
{"data": {
"awardID": "894917dc8b1244b6aab9ab0ad8c8f48a"
}},
status=422,
)
self.assertEqual(response.status, "422 Unprocessable Entity")
self.assertEqual(response.content_type, "application/json")
response = self.app.patch_json(
"/tenders/{}/contracts/{}?acc_token={}".format(tender_id, contract_id,
tender_token),
{"data": {
"status": "active"
}},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(
response.json["errors"][0]["description"],
"Can't update contract in current (cancelled) tender status")
response = self.app.patch_json(
"/tenders/{}/contracts/some_id?acc_token={}".format(
self.tender_id, self.tender_token),
{"data": {
"status": "active"
}},
status=404,
)
self.assertEqual(response.status, "404 Not Found")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["status"], "error")
self.assertEqual(response.json["errors"], [{
u"description": u"Not Found",
u"location": u"url",
u"name": u"contract_id"
}])
response = self.app.patch_json("/tenders/some_id/contracts/some_id",
{"data": {
"status": "active"
}},
status=404)
self.assertEqual(response.status, "404 Not Found")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["status"], "error")
self.assertEqual(response.json["errors"], [{
u"description": u"Not Found",
u"location": u"url",
u"name": u"tender_id"
}])
response = self.app.get("/tenders/{}/contracts/{}".format(
self.tender_id, self.contract_id))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["data"]["status"], "active")
def lot_patch_tender_question(self):
response = self.app.get("/tenders/{}".format(self.tender_id))
tender = response.json["data"]
response = self.app.post_json(
"/tenders/{}/questions".format(self.tender_id, self.tender_token),
{
"data": {
"title": "question title",
"description": "question description",
"questionOf": "lot",
"relatedItem": self.initial_lots[0]["id"],
"author": self.author_data,
}
},
)
self.assertEqual(response.status, "201 Created")
self.assertEqual(response.content_type, "application/json")
question = response.json["data"]
without_complaints = [
"reporting", "belowThreshold", "closeFrameworkAgreementSelectionUA"
]
if RELEASE_2020_04_19 > get_now(
) or tender["procurementMethodType"] in without_complaints:
# For procedures: openua, openuadefense, openeu, negotiation, negotiation.quick, esco, copetitivedialogue, cfaua
# validation after RELEASE_2020_04_19 is useless, because enquiryPeriod ended before complaintPeriod
cancellation = dict(**test_cancellation)
cancellation.update({
"status": "active",
"cancellationOf": "lot",
"relatedLot": self.initial_lots[0]["id"],
})
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(
self.tender_id, self.tender_token),
{"data": cancellation},
)
self.assertEqual(response.status, "201 Created")
cancellation_id = response.json["data"]["id"]
if RELEASE_2020_04_19 < get_now():
activate_cancellation_after_2020_04_19(self, cancellation_id)
response = self.app.patch_json(
"/tenders/{}/questions/{}?acc_token={}".format(
self.tender_id, question["id"], self.tender_token),
{"data": {
"answer": "answer"
}},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["errors"][0]["description"],
"Can update question only in active lot status")
response = self.app.post_json(
"/tenders/{}/questions".format(self.tender_id, self.tender_token),
{
"data": {
"title": "question title",
"description": "question description",
"questionOf": "lot",
"relatedItem": self.initial_lots[1]["id"],
"author": self.author_data,
}
},
)
self.assertEqual(response.status, "201 Created")
self.assertEqual(response.content_type, "application/json")
question = response.json["data"]
response = self.app.patch_json(
"/tenders/{}/questions/{}?acc_token={}".format(self.tender_id,
question["id"],
self.tender_token),
{"data": {
"answer": "answer"
}},
)
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["data"]["answer"], "answer")
self.assertIn("dateAnswered", response.json["data"])
response = self.app.get("/tenders/{}/questions/{}?acc_token={}".format(
self.tender_id, question["id"], self.tender_token))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["data"]["answer"], "answer")
self.assertIn("dateAnswered", response.json["data"])
def create_tender_contract(self):
response = self.app.get("/tenders/{}/contracts".format(self.tender_id))
contract = response.json["data"][0]
self.contract_id = contract["id"]
response = self.app.post_json(
"/tenders/{}/contracts?acc_token={}".format(self.tender_id,
self.tender_token),
{
"data": {
"title": "contract title",
"description": "contract description",
"awardID": self.award_id
}
},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.content_type, "application/json")
# at next steps we test to create contract in 'complete' tender status
# time travel
tender = self.db.get(self.tender_id)
for i in tender.get("awards", []):
if i.get("complaintPeriod",
{}): # reporting procedure does not have complaintPeriod
i["complaintPeriod"]["endDate"] = i["complaintPeriod"]["startDate"]
self.db.save(tender)
response = self.app.patch_json(
"/tenders/{}/contracts/{}?acc_token={}".format(self.tender_id,
contract["id"],
self.tender_token),
{"data": {
"value": {
"amountNet": contract["value"]["amount"] - 1
}
}},
)
self.assertEqual(response.status, "200 OK")
response = self.app.patch_json(
"/tenders/{}/contracts/{}?acc_token={}".format(self.tender_id,
self.contract_id,
self.tender_token),
{"data": {
"status": "active"
}},
)
self.assertEqual(response.status, "200 OK")
response = self.app.get("/tenders/{}".format(self.tender_id))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.json["data"]["status"], "complete")
response = self.app.post_json(
"/tenders/{}/contracts?acc_token={}".format(self.tender_id,
self.tender_token),
{
"data": {
"title": "contract title",
"description": "contract description",
"awardID": self.award_id
}
},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
# at next steps we test to create contract in 'cancelled' tender status
response = self.app.post_json("/tenders?acc_token={}",
{"data": self.initial_data})
self.assertEqual(response.status, "201 Created")
tender_id = self.tender_id = response.json["data"]["id"]
tender_token = self.tender_token = response.json["access"]["token"]
cancellation = dict(**test_cancellation)
cancellation.update({
"status": "active",
})
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(
tender_id, tender_token),
{"data": cancellation},
)
self.assertEqual(response.status, "201 Created")
cancellation_id = response.json["data"]["id"]
if get_now() > RELEASE_2020_04_19:
activate_cancellation_after_2020_04_19(self, cancellation_id)
response = self.app.get("/tenders/{}".format(tender_id))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.json["data"]["status"], "cancelled")
response = self.app.post_json(
"/tenders/{}/contracts?acc_token={}".format(tender_id, tender_token),
{
"data": {
"title": "contract title",
"description": "contract description",
"awardID": self.award_id
}
},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
def patch_tender_negotiation_contract(self):
response = self.app.get("/tenders/{}/contracts".format(self.tender_id))
self.contract_id = response.json["data"][0]["id"]
response = self.app.patch_json(
"/tenders/{}/contracts/{}?acc_token={}".format(self.tender_id,
self.contract_id,
self.tender_token),
{"data": {
"status": "active"
}},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.content_type, "application/json")
self.assertIn("Can't sign contract before stand-still period end (",
response.json["errors"][0]["description"])
response = self.app.get("/tenders/{}/awards".format(self.tender_id))
self.assertEqual(response.content_type, "application/json")
self.assertEqual(len(response.json["data"]), 1)
award = response.json["data"][0]
start = parse_date(award["complaintPeriod"]["startDate"])
end = parse_date(award["complaintPeriod"]["endDate"])
delta = end - start
self.assertEqual(delta.days,
0 if SANDBOX_MODE else self.stand_still_period_days)
# at next steps we test to patch contract in 'complete' tender status
tender = self.db.get(self.tender_id)
for i in tender.get("awards", []):
i["complaintPeriod"]["endDate"] = i["complaintPeriod"]["startDate"]
self.db.save(tender)
response = self.app.patch_json(
"/tenders/{}/contracts/{}?acc_token={}".format(self.tender_id,
self.contract_id,
self.tender_token),
{"data": {
"value": {
"currency": "USD"
}
}},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.json["errors"][0]["description"],
"Can't update currency for contract value")
response = self.app.patch_json(
"/tenders/{}/contracts/{}?acc_token={}".format(self.tender_id,
self.contract_id,
self.tender_token),
{"data": {
"value": {
"amount": 238,
"amountNet": 200
}
}},
)
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.json["data"]["value"]["amount"], 238)
response = self.app.patch_json(
"/tenders/{}/contracts/{}?acc_token={}".format(self.tender_id,
self.contract_id,
self.tender_token),
{"data": {
"status": "active"
}},
)
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["data"]["status"], "active")
self.assertIn(u"dateSigned", response.json["data"])
response = self.app.patch_json(
"/tenders/{}/contracts/{}?acc_token={}".format(self.tender_id,
self.contract_id,
self.tender_token),
{"data": {
"status": "cancelled"
}},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(
response.json["errors"][0]["description"],
"Can't update contract in current (complete) tender status")
response = self.app.patch_json(
"/tenders/{}/contracts/{}?acc_token={}".format(self.tender_id,
self.contract_id,
self.tender_token),
{"data": {
"status": "pending"
}},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(
response.json["errors"][0]["description"],
"Can't update contract in current (complete) tender status")
response = self.app.patch_json(
"/tenders/{}/contracts/{}?acc_token={}".format(self.tender_id,
self.contract_id,
self.tender_token),
{"data": {
"status": "active"
}},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(
response.json["errors"][0]["description"],
"Can't update contract in current (complete) tender status")
# at next steps we test to patch contract in 'cancelled' tender status
response = self.app.post_json("/tenders?acc_token={}",
{"data": self.initial_data})
self.assertEqual(response.status, "201 Created")
old_tender_id = self.tender_id
old_tender_token = self.tender_token
tender_id = self.tender_id = response.json["data"]["id"]
tender_token = self.tender_token = response.json["access"]["token"]
response = self.app.post_json(
"/tenders/{}/awards?acc_token={}".format(tender_id, tender_token),
{"data": {
"suppliers": [test_organization],
"status": "pending"
}},
)
award_id = response.json["data"]["id"]
response = self.app.patch_json(
"/tenders/{}/awards/{}?acc_token={}".format(tender_id, award_id,
tender_token),
{"data": {
"qualified": True,
"status": "active"
}},
)
response = self.app.get("/tenders/{}/contracts".format(tender_id))
contract_id = response.json["data"][0]["id"]
cancellation = dict(**test_cancellation)
cancellation.update({
"status": "active",
})
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(
tender_id, tender_token),
{"data": cancellation},
)
self.assertEqual(response.status, "201 Created")
cancellation_id = response.json["data"]["id"]
if get_now() > RELEASE_2020_04_19:
activate_cancellation_after_2020_04_19(self, cancellation_id)
response = self.app.get("/tenders/{}".format(tender_id))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.json["data"]["status"], "cancelled")
response = self.app.patch_json(
"/tenders/{}/contracts/{}?acc_token={}".format(tender_id, contract_id,
tender_token),
{"data": {
"awardID": "894917dc8b1244b6aab9ab0ad8c8f48a"
}},
status=422,
)
self.assertEqual(response.status, "422 Unprocessable Entity")
self.assertEqual(response.content_type, "application/json")
response = self.app.patch_json(
"/tenders/{}/contracts/{}?acc_token={}".format(tender_id, contract_id,
tender_token),
{"data": {
"status": "active"
}},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(
response.json["errors"][0]["description"],
"Can't update contract in current (cancelled) tender status")
response = self.app.patch_json(
"/tenders/{}/contracts/some_id?acc_token={}".format(
old_tender_id, old_tender_token),
{"data": {
"status": "active"
}},
status=404,
)
self.assertEqual(response.status, "404 Not Found")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["status"], "error")
self.assertEqual(response.json["errors"], [{
u"description": u"Not Found",
u"location": u"url",
u"name": u"contract_id"
}])
response = self.app.patch_json("/tenders/some_id/contracts/some_id",
{"data": {
"status": "active"
}},
status=404)
self.assertEqual(response.status, "404 Not Found")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["status"], "error")
self.assertEqual(response.json["errors"], [{
u"description": u"Not Found",
u"location": u"url",
u"name": u"tender_id"
}])
response = self.app.get("/tenders/{}/contracts/{}".format(
old_tender_id, self.contract_id))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["data"]["status"], "active")
def last_lot_complete(self):
# Create 3 lots and update related items
response = self.app.post_json(
"/tenders/{}/lots?acc_token={}".format(self.tender_id, self.tender_token), {"data": self.test_lots_data[0]}
)
self.assertEqual(response.status, "201 Created")
first_lot = response.json["data"]
response = self.app.post_json(
"/tenders/{}/lots?acc_token={}".format(self.tender_id, self.tender_token), {"data": self.test_lots_data[0]}
)
self.assertEqual(response.status, "201 Created")
second_lot = response.json["data"]
response = self.app.post_json(
"/tenders/{}/lots?acc_token={}".format(self.tender_id, self.tender_token), {"data": self.test_lots_data[0]}
)
self.assertEqual(response.status, "201 Created")
third_lot = response.json["data"]
self.app.patch_json(
"/tenders/{}?acc_token={}".format(self.tender_id, self.tender_token),
{"data": {"items": [{"relatedLot": first_lot["id"]}]}},
)
self.app.patch_json(
"/tenders/{}?acc_token={}".format(self.tender_id, self.tender_token),
{"data": {"items": [{"relatedLot": second_lot["id"]}]}},
)
self.app.patch_json(
"/tenders/{}?acc_token={}".format(self.tender_id, self.tender_token),
{"data": {"items": [{"relatedLot": third_lot["id"]}]}},
)
# Cancel 1 lot
cancellation = dict(**test_cancellation)
cancellation.update({
"cancellationOf": "lot",
"relatedLot": first_lot["id"],
})
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(self.tender_id, self.tender_token),
{"data": cancellation},
)
cancellation_id = response.json["data"]["id"]
if RELEASE_2020_04_19 > get_now():
self.app.patch_json(
"/tenders/{}/cancellations/{}?acc_token={}".format(
self.tender_id, cancellation_id, self.tender_token
),
{"data": {"status": "active"}},
)
else:
activate_cancellation_after_2020_04_19(self, cancellation_id)
response = self.app.get("/tenders/{}/lots/{}".format(self.tender_id, first_lot["id"]))
self.assertEqual(response.json["data"]["status"], "cancelled")
# create awards for second and third
response = self.app.post_json(
"/tenders/{}/awards?acc_token={}".format(self.tender_id, self.tender_token),
{
"data": {
"suppliers": [test_organization],
"status": "pending",
"qualified": True,
"value": {"amount": 469, "currency": "UAH", "valueAddedTaxIncluded": True},
"lotID": second_lot["id"],
}
},
)
response = self.app.patch_json(
"/tenders/{}/awards/{}?acc_token={}".format(self.tender_id, response.json["data"]["id"], self.tender_token),
{"data": {"status": "active"}},
)
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.json["data"]["status"], "active")
response = self.app.post_json(
"/tenders/{}/awards?acc_token={}".format(self.tender_id, self.tender_token),
{
"data": {
"suppliers": [test_organization],
"status": "pending",
"qualified": True,
"value": {"amount": 469, "currency": "UAH", "valueAddedTaxIncluded": True},
"lotID": third_lot["id"],
}
},
)
response = self.app.patch_json(
"/tenders/{}/awards/{}?acc_token={}".format(self.tender_id, response.json["data"]["id"], self.tender_token),
{"data": {"status": "active"}},
)
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.json["data"]["status"], "active")
# time travel
tender = self.db.get(self.tender_id)
for i in tender.get("awards", []):
if i.get("complaintPeriod", {}): # reporting procedure does not have complaintPeriod
i["complaintPeriod"]["endDate"] = i["complaintPeriod"]["startDate"]
self.db.save(tender)
# Sign in contracts
response = self.app.get("/tenders/{}/contracts".format(self.tender_id))
first_contract = response.json["data"][0]
second_contract = response.json["data"][1]
response = self.app.patch_json(
"/tenders/{}/contracts/{}?acc_token={}".format(self.tender_id, first_contract["id"], self.tender_token),
{"data": {"status": "active", "value": {"valueAddedTaxIncluded": False}}},
)
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.json["data"]["status"], "active")
response = self.app.patch_json(
"/tenders/{}/contracts/{}?acc_token={}".format(self.tender_id, second_contract["id"], self.tender_token),
{"data": {"status": "active", "value": {"valueAddedTaxIncluded": False}}},
)
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.json["data"]["status"], "active")
# Check tender status
response = self.app.get("/tenders/{}".format(self.tender_id))
self.assertEqual(response.json["data"]["status"], "complete")
def create_tender_cancellation(self):
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(
self.tender_id, self.tender_token),
{"data": test_cancellation},
)
self.assertEqual(response.status, "201 Created")
self.assertEqual(response.content_type, "application/json")
cancellation = response.json["data"]
self.assertEqual(cancellation["reason"], "cancellation reason")
self.assertIn("id", cancellation)
self.assertIn(cancellation["id"], response.headers["Location"])
response = self.app.get("/tenders/{}".format(self.tender_id))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["data"]["status"], "active")
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(
self.tender_id, self.tender_token),
{"data": test_cancellation},
)
self.assertEqual(response.status, "201 Created")
self.assertEqual(response.content_type, "application/json")
first_cancellation = response.json["data"]
self.assertEqual(first_cancellation["reason"], "cancellation reason")
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(
self.tender_id, self.tender_token),
{"data": test_cancellation},
)
self.assertEqual(response.status, "201 Created")
self.assertEqual(response.content_type, "application/json")
second_cancellation = response.json["data"]
self.assertEqual(second_cancellation["reason"], "cancellation reason")
if get_now() < RELEASE_2020_04_19:
response = self.app.patch_json(
"/tenders/{}/cancellations/{}?acc_token={}".format(
self.tender_id, second_cancellation["id"], self.tender_token),
{"data": {
"status": "active"
}},
)
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["data"]["status"], "active")
else:
activate_cancellation_after_2020_04_19(self, second_cancellation["id"])
response = self.app.get("/tenders/{}".format(self.tender_id))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["data"]["status"], "cancelled")
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(
self.tender_id, self.tender_token),
{"data": test_cancellation},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["errors"][0]["description"],
"Can't update tender in current (cancelled) status")
def patch_tender_lots_award_complaint(self):
response = self.app.post_json(
"/tenders/{}/awards/{}/complaints?acc_token={}".format(
self.tender_id, self.award_id,
self.initial_bids_tokens[self.initial_bids[0]["id"]]),
{"data": test_draft_complaint},
)
self.assertEqual(response.status, "201 Created")
self.assertEqual(response.content_type, "application/json")
complaint = response.json["data"]
owner_token = response.json["access"]["token"]
if RELEASE_2020_04_19 < get_now():
response = self.app.patch_json(
"/tenders/{}/awards/{}/complaints/{}?acc_token={}".format(
self.tender_id, self.award_id, complaint["id"],
owner_token), {"data": {
"status": "pending"
}},
status=403)
self.assertEqual(
response.json, {
"status":
"error",
"errors": [{
"location":
"body",
"name":
"data",
"description":
"Can't update draft complaint into pending status"
}]
})
else:
response = self.app.patch_json(
"/tenders/{}/awards/{}/complaints/{}?acc_token={}".format(
self.tender_id, self.award_id, complaint["id"],
owner_token), {"data": {
"status": "pending"
}},
status=200)
self.assertEqual(response.status, "200 OK")
with patch(
"openprocurement.tender.openuadefense.validation.NO_DEFENSE_AWARD_CLAIMS_FROM",
get_now() + timedelta(days=1)):
response = self.app.post_json(
"/tenders/{}/awards/{}/complaints?acc_token={}".format(
self.tender_id, self.award_id,
self.initial_bids_tokens[self.initial_bids[0]["id"]]),
{"data": test_draft_claim},
)
self.assertEqual(response.status, "201 Created")
self.assertEqual(response.content_type, "application/json")
complaint = response.json["data"]
owner_token = response.json["access"]["token"]
if RELEASE_2020_04_19:
self.set_all_awards_complaint_period_end()
cancellation = dict(**test_cancellation)
cancellation.update({
"status": "active",
"cancellationOf": "lot",
"relatedLot": self.initial_lots[0]["id"],
})
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(
self.tender_id, self.tender_token),
{"data": cancellation},
)
self.assertEqual(response.status, "201 Created")
cancellation_id = response.json["data"]["id"]
if RELEASE_2020_04_19 < get_now():
activate_cancellation_after_2020_04_19(self, cancellation_id)
response = self.app.patch_json(
"/tenders/{}/awards/{}/complaints/{}?acc_token={}".format(
self.tender_id, self.award_id, complaint["id"], owner_token),
{"data": {
"status": "pending"
}},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["errors"][0]["description"],
"Can update complaint only in active lot status")
def all_cancelled_lots(self):
# Create 2 lots and update related items
response = self.app.post_json(
"/tenders/{}/lots?acc_token={}".format(self.tender_id, self.tender_token), {"data": self.test_lots_data[0]}
)
self.assertEqual(response.status, "201 Created")
first_lot = response.json["data"]
response = self.app.post_json(
"/tenders/{}/lots?acc_token={}".format(self.tender_id, self.tender_token), {"data": self.test_lots_data[0]}
)
self.assertEqual(response.status, "201 Created")
second_lot = response.json["data"]
self.app.patch_json(
"/tenders/{}?acc_token={}".format(self.tender_id, self.tender_token),
{"data": {"items": [{"relatedLot": first_lot["id"]}]}},
)
self.app.patch_json(
"/tenders/{}?acc_token={}".format(self.tender_id, self.tender_token),
{"data": {"items": [{"relatedLot": second_lot["id"]}]}},
)
# Cancel lots
cancellation = dict(**test_cancellation)
cancellation.update({
"cancellationOf": "lot",
"relatedLot": first_lot["id"],
})
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(self.tender_id, self.tender_token),
{"data": cancellation},
)
cancellation_id = response.json["data"]["id"]
if RELEASE_2020_04_19 > get_now():
self.app.patch_json(
"/tenders/{}/cancellations/{}?acc_token={}".format(
self.tender_id, cancellation_id, self.tender_token
),
{"data": {"status": "active"}},
)
else:
activate_cancellation_after_2020_04_19(self, cancellation_id)
response = self.app.get("/tenders/{}/lots/{}".format(self.tender_id, first_lot["id"]))
self.assertEqual(response.json["data"]["status"], "cancelled")
cancellation = dict(**test_cancellation)
cancellation.update({
"cancellationOf": "lot",
"relatedLot": second_lot["id"],
})
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(self.tender_id, self.tender_token),
{"data": cancellation},
)
cancellation_id = response.json["data"]["id"]
if RELEASE_2020_04_19 > get_now():
self.app.patch_json(
"/tenders/{}/cancellations/{}?acc_token={}".format(
self.tender_id, cancellation_id, self.tender_token
),
{"data": {"status": "active"}},
)
else:
activate_cancellation_after_2020_04_19(self, cancellation_id)
response = self.app.get("/tenders/{}/lots/{}".format(self.tender_id, second_lot["id"]))
self.assertEqual(response.json["data"]["status"], "cancelled")
# Check tender status
response = self.app.get("/tenders/{}".format(self.tender_id))
self.assertEqual(response.json["data"]["status"], "cancelled")
def create_tender_lots_cancellation(self):
lot_id = self.initial_lots[0]["id"]
cancellation = dict(**test_cancellation)
cancellation.update({"cancellationOf": "lot", "relatedLot": lot_id})
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(
self.tender_id, self.tender_token),
{"data": cancellation},
)
self.assertEqual(response.status, "201 Created")
self.assertEqual(response.content_type, "application/json")
cancellation = response.json["data"]
self.assertEqual(cancellation["reason"], "cancellation reason")
self.assertIn("id", cancellation)
self.assertIn(cancellation["id"], response.headers["Location"])
response = self.app.get("/tenders/{}".format(self.tender_id))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["data"]["lots"][0]["status"], "active")
self.assertEqual(response.json["data"]["status"], "active")
cancellation = dict(**test_cancellation)
cancellation.update({
"cancellationOf": "lot",
"relatedLot": lot_id,
"status": "active"
})
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(
self.tender_id, self.tender_token),
{"data": cancellation},
)
self.assertEqual(response.status, "201 Created")
self.assertEqual(response.content_type, "application/json")
cancellation = response.json["data"]
self.assertEqual(cancellation["reason"], "cancellation reason")
self.assertIn("id", cancellation)
self.assertIn(cancellation["id"], response.headers["Location"])
if RELEASE_2020_04_19 > get_now():
self.assertEqual(cancellation["status"], "active")
else:
activate_cancellation_after_2020_04_19(self, cancellation["id"])
response = self.app.get("/tenders/{}".format(self.tender_id))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["data"]["lots"][0]["status"], "cancelled")
self.assertNotEqual(response.json["data"]["status"], "cancelled")
cancellation = dict(**test_cancellation)
cancellation.update({
"cancellationOf": "lot",
"relatedLot": lot_id,
"status": "active"
})
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(
self.tender_id, self.tender_token),
{"data": cancellation},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["errors"][0]["description"],
"Can perform cancellation only in active lot status")
cancellation = dict(**test_cancellation)
cancellation.update({
"status": "active",
"cancellationOf": "lot",
"relatedLot": self.initial_lots[1]["id"],
})
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(
self.tender_id, self.tender_token),
{"data": cancellation},
)
self.assertEqual(response.status, "201 Created")
self.assertEqual(response.content_type, "application/json")
cancellation = response.json["data"]
self.assertEqual(cancellation["reason"], "cancellation reason")
self.assertIn("id", cancellation)
self.assertIn(cancellation["id"], response.headers["Location"])
if RELEASE_2020_04_19 > get_now():
self.assertEqual(cancellation["status"], "active")
else:
activate_cancellation_after_2020_04_19(self, cancellation["id"])
response = self.app.get("/tenders/{}".format(self.tender_id))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(response.json["data"]["lots"][0]["status"], "cancelled")
self.assertEqual(response.json["data"]["lots"][1]["status"], "cancelled")
self.assertEqual(response.json["data"]["status"], "cancelled")
