def _cancel_tender(self):
orig_authorization = self.app.authorization
self.app.authorization = ("Basic", ("broker", ""))
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")
cancellation = response.json["data"]
cancellation_id = cancellation["id"]
if get_now() < RELEASE_2020_04_19:
self.assertEqual(cancellation["status"], "active")
else:
self.assertEqual(cancellation["status"], "draft")
activate_cancellation_with_complaints_after_2020_04_19(self, cancellation_id)
response = self.app.get("/tenders/{}".format(self.tender_id))
tender = response.json["data"]
self.assertIn("bids", tender)
self.assertEqual(tender["status"], "cancelled")
self.app.authorization = orig_authorization
return tender
def cancellation_active_qualification_j1427(self):
bid = deepcopy(self.initial_bids[0])
bid["lotValues"] = bid["lotValues"][:1]
# post three bids
bid_ids = []
for i in range(3):
response = self.app.post_json("/tenders/{}/bids".format(self.tender_id), {"data": bid})
self.assertEqual(response.status, "201 Created")
self.initial_bids_tokens[response.json["data"]["id"]] = response.json["access"]["token"]
self.initial_bids.append(response.json["data"])
bid_ids.append(response.json["data"]["id"])
self.set_status("active.pre-qualification", {"id": self.tender_id, "status": "active.tendering"})
self.app.authorization = ("Basic", ("chronograph", ""))
response = self.app.patch_json("/tenders/{}".format(self.tender_id), {"data": {"id": self.tender_id}})
self.assertEqual(response.json["data"]["status"], "active.pre-qualification")
response = self.app.get("/tenders/{}/qualifications".format(self.tender_id))
qualification_id = [i["id"] for i in response.json["data"] if i["bidID"] == bid_ids[0]][0]
response = self.app.patch_json(
"/tenders/{}/qualifications/{}?acc_token={}".format(self.tender_id, qualification_id, self.tender_token),
{"data": {"status": "unsuccessful"}},
)
response = self.app.get("/tenders/{}/qualifications".format(self.tender_id))
qualification_id = [i["id"] for i in response.json["data"] if i["bidID"] == bid_ids[1]][0]
response = self.app.patch_json(
"/tenders/{}/qualifications/{}?acc_token={}".format(self.tender_id, qualification_id, self.tender_token),
{"data": {"status": "active", "qualified": True, "eligible": True}},
)
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")
self.assertEqual(response.content_type, "application/json")
cancellation_id = response.json["data"]["id"]
if RELEASE_2020_04_19 < get_now():
activate_cancellation_with_complaints_after_2020_04_19(self, cancellation_id)
response = self.app.get("/tenders/{}/bids/{}".format(self.tender_id, bid_ids[0]))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.json["data"]["status"], "unsuccessful")
response = self.app.get("/tenders/{}/bids/{}".format(self.tender_id, bid_ids[1]))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.json["data"]["status"], "invalid.pre-qualification")
response = self.app.get("/tenders/{}/bids/{}".format(self.tender_id, bid_ids[2]))
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.json["data"]["status"], "invalid.pre-qualification")
def tender_has_unanswered_questions(self):
question_id = self.create_question_for("tender", self.tender_id)
self.set_status("active.auction", {"status": "active.tendering"})
self.app.authorization = ("Basic", ("chronograph", ""))
response = self.app.patch_json("/tenders/{}".format(self.tender_id),
{"data": {
"id": self.tender_id
}})
self.assertEqual(response.json["data"]["status"], "active.tendering")
self.app.authorization = ("Basic", ("broker", ""))
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},
)
cancellation_id = response.json["data"]["id"]
self.assertEqual(response.status, "201 Created")
if get_now() > RELEASE_2020_04_19:
activate_cancellation_with_complaints_after_2020_04_19(
self, cancellation_id)
response = self.app.get("/tenders/{}".format(self.tender_id))
self.assertEqual(response.json["data"]["status"], "cancelled")
def two_lot_2can(self):
self.app.authorization = ("Basic", ("broker", ""))
# create tender
response = self.app.post_json("/tenders", {"data": self.test_tender_data})
tender_id = self.tender_id = response.json["data"]["id"]
owner_token = response.json["access"]["token"]
lots = []
for lot in 2 * self.test_lots_data:
# add lot
response = self.app.post_json(
"/tenders/{}/lots?acc_token={}".format(tender_id, owner_token),
{"data": self.test_lots_data[0]})
self.assertEqual(response.status, "201 Created")
lots.append(response.json["data"]["id"])
# add item
response = self.app.patch_json(
"/tenders/{}?acc_token={}".format(tender_id, owner_token),
{"data": {
"items": [self.test_tender_data["items"][0] for i in lots]
}},
)
# add relatedLot for item
response = self.app.patch_json(
"/tenders/{}?acc_token={}".format(tender_id, owner_token),
{"data": {
"items": [{
"relatedLot": i
} for i in lots]
}},
)
self.assertEqual(response.status, "200 OK")
set_complaint_period_end = getattr(self, "set_complaint_period_end", None)
if RELEASE_2020_04_19 < get_now() and set_complaint_period_end:
set_complaint_period_end()
# cancel every lot
for lot_id in lots:
cancellation = dict(**test_cancellation)
cancellation.update({
"status": "active",
"cancellationOf": "lot",
"relatedLot": lot_id,
})
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(
tender_id, owner_token),
{"data": cancellation},
)
cancellation_id = response.json["data"]["id"]
if RELEASE_2020_04_19 < get_now():
activate_cancellation_with_complaints_after_2020_04_19(
self, cancellation_id, tender_id, owner_token)
response = self.app.get("/tenders/{}".format(tender_id))
self.assertTrue(
all([
i["status"] == "cancelled" for i in response.json["data"]["lots"]
]))
self.assertEqual(response.json["data"]["status"], "cancelled")
def bids_on_tender_cancellation_in_tendering(self):
response = self.app.get("/tenders/{}".format(self.tender_id))
tender = response.json["data"]
self.assertNotIn("bids", tender) # bids not visible for others
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")
cancellation = response.json["data"]
cancellation_id = cancellation["id"]
if get_now() < RELEASE_2020_04_19:
self.assertEqual(cancellation["status"], "active")
else:
self.assertEqual(cancellation["status"], "draft")
activate_cancellation_with_complaints_after_2020_04_19(
self, cancellation_id)
response = self.app.get("/tenders/{}".format(self.tender_id))
tender = response.json["data"]
self.assertNotIn("bids", tender)
self.assertEqual(tender["status"], "cancelled")
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 question_blocking(self):
response = self.app.post_json(
"/tenders/{}/questions".format(self.tender_id),
{
"data": {
"title": "question title",
"description": "question description",
"questionOf": "lot",
"relatedItem": self.initial_lots[0]["id"],
"author": test_author,
}
},
)
question = response.json["data"]
self.assertEqual(question["questionOf"], "lot")
self.assertEqual(question["relatedItem"], self.initial_lots[0]["id"])
self.set_status("active.auction", extra={"status": "active.tendering"})
response = self.check_chronograph()
response = self.app.get("/tenders/{}".format(self.tender_id))
self.assertEqual(response.json["data"]["status"], "active.tendering")
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_with_complaints_after_2020_04_19(
self, cancellation_id)
orig_auth = self.app.authorization
self.app.authorization = ("Basic", ("chronograph", ""))
self.app.patch_json("/tenders/{}".format(self.tender_id),
{"data": {
"id": self.tender_id
}})
self.app.authorization = orig_auth
response = self.app.get("/tenders/{}".format(self.tender_id))
self.assertEqual(response.json["data"]["status"], "active.auction")
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_with_complaints_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 next_check_value_with_unanswered_question(self):
response = self.app.post_json(
"/tenders/{}/questions".format(self.tender_id),
{
"data": {
"title": "question title",
"description": "question description",
"questionOf": "lot",
"relatedItem": self.initial_lots[0]["id"],
"author": test_author,
}
},
)
question = response.json["data"]
self.assertEqual(question["questionOf"], "lot")
self.assertEqual(question["relatedItem"], self.initial_lots[0]["id"])
self.set_status("active.auction", extra={"status": "active.tendering"})
response = self.check_chronograph()
self.assertEqual(response.json["data"]["status"], "active.tendering")
self.assertNotIn("next_check", response.json["data"])
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_with_complaints_after_2020_04_19(self, cancellation_id)
else:
response = self.app.get("/tenders/{}".format(self.tender_id))
self.assertIn("next_check", response.json["data"])
self.assertEqual(
parse_date(response.json["data"]["next_check"]),
parse_date(response.json["data"]["tenderPeriod"]["endDate"])
)
response = self.check_chronograph()
self.assertEqual(response.json["data"]["status"], "active.auction")
self.assertIn("next_check", response.json["data"])
self.assertGreater(
parse_date(response.json["data"]["next_check"]),
parse_date(response.json["data"]["tenderPeriod"]["endDate"])
)
def next_check_value_with_unanswered_claim(self):
claim = deepcopy(test_claim)
claim["relatedLot"] = self.initial_lots[0]["id"]
response = self.app.post_json(
"/tenders/{}/complaints".format(self.tender_id),
{
"data": claim
},
)
self.assertEqual(response.status, "201 Created")
complaint = response.json["data"]
self.assertEqual(complaint["relatedLot"], self.initial_lots[0]["id"])
self.set_status("active.auction", extra={"status": "active.tendering"})
orig_auth = self.app.authorization
response = self.check_chronograph()
self.assertEqual(response.json["data"]["status"], "active.tendering")
self.assertNotIn("next_check", response.json["data"])
self.app.authorization = orig_auth
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_with_complaints_after_2020_04_19(self, cancellation_id)
else:
response = self.app.get("/tenders/{}".format(self.tender_id))
self.assertIn("next_check", response.json["data"])
self.assertEqual(
parse_date(response.json["data"]["next_check"]),
parse_date(response.json["data"]["tenderPeriod"]["endDate"])
)
response = self.check_chronograph()
self.assertEqual(response.json["data"]["status"], "active.auction")
self.assertIn("next_check", response.json["data"])
self.assertGreater(
parse_date(response.json["data"]["next_check"]),
parse_date(response.json["data"]["tenderPeriod"]["endDate"])
)
def lot_create_tender_cancellations_and_questions(self):
cancellation = dict(**test_cancellation)
cancellation.update({
"status": "active",
"cancellationOf": "lot",
"relatedLot": self.initial_lots[0]["id"],
})
if RELEASE_2020_04_19 < get_now():
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.json["errors"][0]["description"],
u"Cancellation can't be add when exists active complaint period")
else:
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 get_now() > RELEASE_2020_04_19:
activate_cancellation_with_complaints_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")
def claim_blocking(self):
claim = deepcopy(test_claim)
claim["relatedLot"] = self.initial_lots[0]["id"]
response = self.app.post_json(
"/tenders/{}/complaints".format(self.tender_id),
{"data": claim},
)
self.assertEqual(response.status, "201 Created")
complaint = response.json["data"]
self.assertEqual(complaint["relatedLot"], self.initial_lots[0]["id"])
self.set_status("active.auction", extra={"status": "active.tendering"})
response = self.check_chronograph()
response = self.app.get("/tenders/{}".format(self.tender_id))
self.assertEqual(response.json["data"]["status"], "active.tendering")
# cancel lot
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_with_complaints_after_2020_04_19(
self, cancellation_id)
orig_auth = self.app.authorization
self.app.authorization = ("Basic", ("chronograph", ""))
self.app.patch_json("/tenders/{}".format(self.tender_id),
{"data": {
"id": self.tender_id
}})
self.app.authorization = orig_auth
response = self.app.get("/tenders/{}".format(self.tender_id))
self.assertEqual(response.json["data"]["status"], "active.auction")
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_with_complaints_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 item_has_unanswered_questions(self):
items = self.app.get("/tenders/{}".format(
self.tender_id)).json["data"]["items"]
question_id = self.create_question_for("item", items[0]["id"])
self.set_status("active.auction", {"status": "active.tendering"})
self.app.authorization = ("Basic", ("chronograph", ""))
response = self.app.patch_json("/tenders/{}".format(self.tender_id),
{"data": {
"id": self.tender_id
}})
self.assertEqual(response.json["data"]["status"], "active.tendering")
self.app.authorization = ("Basic", ("broker", ""))
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 get_now() > RELEASE_2020_04_19:
activate_cancellation_with_complaints_after_2020_04_19(
self, cancellation_id)
response = self.app.get("/tenders/{}".format(self.tender_id))
self.assertEqual(response.json["data"]["status"], "unsuccessful")
else:
self.app.authorization = ("Basic", ("chronograph", ""))
response = self.app.patch_json("/tenders/{}".format(self.tender_id),
{"data": {
"id": self.tender_id
}})
self.assertEqual(response.json["data"]["status"], "unsuccessful")
def cancel_tender(self):
cancellation = dict(**test_cancellation)
cancellation.update({
"status": "active",
"cancellationOf": "tender",
})
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:
activate_cancellation_with_complaints_after_2020_04_19(
self, cancellation["id"])
# Check tender
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")
# Check lots
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(response.json["data"][0]["status"], "active")
self.assertEqual(response.json["data"][1]["status"], "active")
def cancel_tender(self, lot_id=None):
"""
:param lot_id: id of lot for cancellation
:return: None
"""
cancellation = dict(**test_cancellation)
cancellation.update({
"status": "active",
})
if lot_id:
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"]
if get_now() < RELEASE_2020_04_19:
self.assertEqual(cancellation["status"], "active")
else:
self.assertEqual(cancellation["status"], "draft")
activate_cancellation_with_complaints_after_2020_04_19(
self, cancellation["id"])
response = self.app.get("/tenders/{}".format(self.tender_id))
tender = response.json["data"]
if lot_id:
for lot in tender["lots"]:
if lot["id"] == lot_id:
self.assertEqual(lot["status"], "cancelled")
else:
self.assertEqual(tender["status"], "cancelled")
def cancellation_active_qualification(self):
self.set_status("active.pre-qualification", {
"id": self.tender_id,
"status": "active.tendering"
})
self.app.authorization = ("Basic", ("chronograph", ""))
response = self.app.patch_json("/tenders/{}".format(self.tender_id),
{"data": {
"id": self.tender_id
}})
self.assertEqual(response.json["data"]["status"],
"active.pre-qualification")
self.app.authorization = ("Basic", ("token", ""))
response = self.app.get("/tenders/{}/qualifications".format(
self.tender_id))
qualification_id = [
i["id"] for i in response.json["data"] if i["status"] == "pending"
and i["lotID"] == self.initial_lots[0]["id"]
][0]
response = self.app.patch_json(
"/tenders/{}/qualifications/{}?acc_token={}".format(
self.tender_id, qualification_id, self.tender_token),
{"data": {
"status": "active",
"qualified": True,
"eligible": True
}},
)
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")
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_with_complaints_after_2020_04_19(
self, cancellation["id"])
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"]
cancellation_id = cancellation["id"]
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_with_complaints_after_2020_04_19(
self, cancellation_id)
def cancellation_active_tendering_j708(self):
bid = deepcopy(self.initial_bids[0])
bid["lotValues"] = bid["lotValues"][:1]
response = self.app.post_json("/tenders/{}/bids".format(self.tender_id),
{"data": bid})
self.assertEqual(response.status, "201 Created")
self.initial_bids_tokens[response.json["data"]
["id"]] = response.json["access"]["token"]
self.initial_bids.append(response.json["data"])
response = self.app.delete("/tenders/{}/bids/{}?acc_token={}".format(
self.tender_id, response.json["data"]["id"],
response.json["access"]["token"]))
self.assertEqual(response.status, "200 OK")
cancellation = dict(**test_cancellation)
cancellation.update({
"status": "pending",
"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")
self.assertEqual(response.content_type, "application/json")
cancellation_id = response.json["data"]["id"]
if RELEASE_2020_04_19 > get_now():
response = self.app.patch_json(
"/tenders/{}/cancellations/{}?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.content_type, "application/json")
else:
activate_cancellation_with_complaints_after_2020_04_19(
self, cancellation_id)
response = self.app.post_json("/tenders/{}/bids".format(self.tender_id),
{"data": bid})
self.assertEqual(response.status, "201 Created")
self.initial_bids_tokens[response.json["data"]
["id"]] = response.json["access"]["token"]
self.initial_bids.append(response.json["data"])
self.set_status("active.pre-qualification", {
"id": self.tender_id,
"status": "active.tendering"
})
self.app.authorization = ("Basic", ("chronograph", ""))
response = self.app.patch_json("/tenders/{}".format(self.tender_id),
{"data": {
"id": self.tender_id
}})
self.assertEqual(response.json["data"]["status"],
"active.pre-qualification")
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_with_complaints_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_with_complaints_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")
def cancellation_unsuccessful_qualification(self):
self.set_status("active.pre-qualification", {
"id": self.tender_id,
"status": "active.tendering"
})
self.app.authorization = ("Basic", ("chronograph", ""))
response = self.app.patch_json("/tenders/{}".format(self.tender_id),
{"data": {
"id": self.tender_id
}})
self.assertEqual(response.json["data"]["status"],
"active.pre-qualification")
self.app.authorization = ("Basic", ("token", ""))
for i in range(self.min_bids_number):
response = self.app.get("/tenders/{}/qualifications".format(
self.tender_id))
qualification_id = [
i["id"] for i in response.json["data"] if i["status"] == "pending"
and i["lotID"] == self.initial_lots[0]["id"]
][0]
response = self.app.patch_json(
"/tenders/{}/qualifications/{}?acc_token={}".format(
self.tender_id, qualification_id, self.tender_token),
{
"data": {
"status": "unsuccessful",
"qualified": True,
"eligible": True
}
},
)
self.assertEqual(response.status, "200 OK")
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},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(
response.json["errors"][0]["description"],
"Can't perform cancellation if all qualifications are unsuccessful")
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},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(
response.json["errors"][0]["description"],
"Can't perform cancellation if all qualifications are unsuccessful")
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_with_complaints_after_2020_04_19(
self, cancellation["id"])
def two_lot_1bid_0com_1can(self):
self.app.authorization = ("Basic", ("broker", ""))
# create tender
response = self.app.post_json("/tenders", {"data": self.initial_data})
tender_id = self.tender_id = response.json["data"]["id"]
owner_token = response.json["access"]["token"]
lots = []
for lot in 2 * self.test_lots_data:
# add lot
response = self.app.post_json(
"/tenders/{}/lots?acc_token={}".format(tender_id, owner_token), {"data": self.test_lots_data[0]}
)
self.assertEqual(response.status, "201 Created")
lots.append(response.json["data"]["id"])
# add item
self.app.patch_json(
"/tenders/{}?acc_token={}".format(tender_id, owner_token),
{"data": {"items": [self.initial_data["items"][0] for i in lots]}},
)
# add relatedLot for item
response = self.app.patch_json(
"/tenders/{}?acc_token={}".format(tender_id, owner_token),
{"data": {"items": [{"relatedLot": i} for i in lots]}},
)
self.assertEqual(response.status, "200 OK")
# switch to active.tendering
start_date = get_now() + timedelta(self.days_till_auction_starts)
self.set_status(
"active.tendering", {"lots": [{"auctionPeriod": {"startDate": start_date.isoformat()}} for i in lots]}
)
# create bid
self.app.authorization = ("Basic", ("broker", ""))
self.app.post_json(
"/tenders/{}/bids".format(tender_id),
{
"data": {
"tenderers": [test_organization],
"lotValues": [{"value": {"amount": 500}, "relatedLot": lot_id} for lot_id in lots],
"selfEligible": True,
"selfQualified": True,
}
},
)
# switch to active.qualification
self.set_status(
"active.auction", {"lots": [{"auctionPeriod": {"startDate": None}} for i in lots], "status": "active.tendering"}
)
self.app.authorization = ("Basic", ("chronograph", ""))
response = self.app.patch_json("/tenders/{}".format(tender_id), {"data": {"id": tender_id}})
self.assertEqual(response.json["data"]["status"], "active.qualification")
# for first lot
lot_id = lots[0]
# cancel lot
self.app.authorization = ("Basic", ("broker", ""))
cancellation = dict(**test_cancellation)
cancellation.update({
"status": "active",
"cancellationOf": "lot",
"relatedLot": lot_id,
})
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(tender_id, owner_token),
{"data": cancellation},
)
cancellation_id = response.json["data"]["id"]
if RELEASE_2020_04_19 < get_now():
activate_cancellation_with_complaints_after_2020_04_19(self, cancellation_id, tender_id, owner_token)
# for second lot
lot_id = lots[1]
# get awards
self.app.authorization = ("Basic", ("broker", ""))
response = self.app.get("/tenders/{}/awards?acc_token={}".format(tender_id, owner_token))
# get pending award
award_id = [i["id"] for i in response.json["data"] if i["status"] == "pending" and i["lotID"] == lot_id][0]
# set award as unsuccessful
self.app.patch_json(
"/tenders/{}/awards/{}?acc_token={}".format(tender_id, award_id, owner_token),
{"data": {"status": "unsuccessful"}},
)
# after stand slill period
self.set_status("complete", {"status": "active.awarded"})
# time travel
tender = self.db.get(tender_id)
for i in tender.get("awards", []):
i["complaintPeriod"]["endDate"] = i["complaintPeriod"]["startDate"]
self.db.save(tender)
# check tender status
self.app.authorization = ("Basic", ("chronograph", ""))
self.app.patch_json("/tenders/{}".format(tender_id), {"data": {"id": tender_id}})
# check status
self.app.authorization = ("Basic", ("broker", ""))
response = self.app.get("/tenders/{}".format(tender_id))
self.assertEqual([i["status"] for i in response.json["data"]["lots"]], [u"cancelled", u"unsuccessful"])
self.assertEqual(response.json["data"]["status"], "unsuccessful")
def two_lot_2bid_0com_1can(self):
self.app.authorization = ("Basic", ("broker", ""))
# create tender
response = self.app.post_json("/tenders", {"data": self.test_tender_data})
tender_id = self.tender_id = response.json["data"]["id"]
owner_token = response.json["access"]["token"]
lots = []
for lot in 2 * self.test_lots_data:
# add lot
response = self.app.post_json(
"/tenders/{}/lots?acc_token={}".format(tender_id, owner_token), {"data": self.test_lots_data[0]}
)
self.assertEqual(response.status, "201 Created")
lots.append(response.json["data"]["id"])
# add item
response = self.app.patch_json(
"/tenders/{}?acc_token={}".format(tender_id, owner_token),
{"data": {"items": [self.test_tender_data["items"][0] for i in lots]}},
)
# add relatedLot for item
response = self.app.patch_json(
"/tenders/{}?acc_token={}".format(tender_id, owner_token),
{"data": {"items": [{"relatedLot": i} for i in lots]}},
)
self.assertEqual(response.status, "200 OK")
# create bid
self.app.authorization = ("Basic", ("broker", ""))
bid_data = deepcopy(self.test_bids_data[0])
del bid_data["value"]
bid_data["lotValues"] = [{"value": {"amount": 500}, "relatedLot": lot_id} for lot_id in lots]
bidder_data = bid_data["tenderers"][0]
bidder_data["identifier"]["id"] = u"00037256"
response = self.app.post_json(
"/tenders/{}/bids".format(tender_id),
{"data": bid_data},
)
bid_data["lotValues"] = [{"value": {"amount": 499}, "relatedLot": lot_id} for lot_id in lots]
bidder_data["identifier"]["id"] = u"00037257"
response = self.app.post_json(
"/tenders/{}/bids".format(tender_id),
{"data": bid_data},
)
bidder_data["identifier"]["id"] = u"00037258"
response = self.app.post_json(
"/tenders/{}/bids".format(tender_id),
{"data": bid_data},
)
set_complaint_period_end = getattr(self, "set_complaint_period_end", None)
if RELEASE_2020_04_19 < get_now() and set_complaint_period_end:
set_complaint_period_end()
self.app.authorization = ("Basic", ("broker", ""))
cancellation = dict(**test_cancellation)
cancellation.update({
"status": "active",
"cancellationOf": "lot",
"relatedLot": lots[0],
})
response = self.app.post_json(
"/tenders/{}/cancellations?acc_token={}".format(tender_id, owner_token),
{"data": cancellation},
)
cancellation_id = response.json["data"]["id"]
if RELEASE_2020_04_19 < get_now():
activate_cancellation_with_complaints_after_2020_04_19(self, cancellation_id, tender_id, owner_token)
response = self.app.get("/tenders/{}?acc_token={}".format(tender_id, owner_token))
self.assertEqual(response.status, "200 OK")
# active.pre-qualification
self.time_shift("active.pre-qualification")
self.check_chronograph()
response = self.app.get("/tenders/{}/qualifications?acc_token={}".format(self.tender_id, owner_token))
self.assertEqual(response.content_type, "application/json")
qualifications = response.json["data"]
self.assertEqual(len(qualifications), 3)
for qualification in qualifications:
response = self.app.patch_json(
"/tenders/{}/qualifications/{}?acc_token={}".format(self.tender_id, qualification["id"], owner_token),
{"data": {"status": "active", "qualified": True, "eligible": True}},
)
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.json["data"]["status"], "active")
response = self.app.patch_json(
"/tenders/{}?acc_token={}".format(tender_id, owner_token),
{"data": {"status": "active.pre-qualification.stand-still"}},
)
self.assertEqual(response.status, "200 OK")
def cancellation_unsuccessful_award(self):
self.set_status("active.pre-qualification", {
"id": self.tender_id,
"status": "active.tendering"
})
self.app.authorization = ("Basic", ("chronograph", ""))
response = self.app.patch_json("/tenders/{}".format(self.tender_id),
{"data": {
"id": self.tender_id
}})
self.assertEqual(response.json["data"]["status"],
"active.pre-qualification")
response = self.app.get("/tenders/{}/qualifications".format(
self.tender_id))
self.app.authorization = ("Basic", ("token", ""))
for qualification in response.json["data"]:
response = self.app.patch_json(
"/tenders/{}/qualifications/{}?acc_token={}".format(
self.tender_id, qualification["id"], self.tender_token),
{
"data": {
"status": "active",
"qualified": True,
"eligible": True
}
},
)
self.assertEqual(response.status, "200 OK")
response = self.app.patch_json(
"/tenders/{}?acc_token={}".format(self.tender_id, self.tender_token),
{"data": {
"status": "active.pre-qualification.stand-still"
}},
)
self.assertEqual(response.json["data"]["status"],
"active.pre-qualification.stand-still")
self.set_status("active.auction", {
"id": self.tender_id,
"status": "active.pre-qualification.stand-still"
})
self.app.authorization = ("Basic", ("chronograph", ""))
response = self.app.patch_json("/tenders/{}".format(self.tender_id),
{"data": {
"id": self.tender_id
}})
self.assertEqual(response.json["data"]["status"], "active.auction")
self.app.authorization = ("Basic", ("auction", ""))
response = self.app.get("/tenders/{}/auction".format(self.tender_id))
auction_bids_data = response.json["data"]["bids"]
for lot_id in self.initial_lots:
response = self.app.post_json(
"/tenders/{}/auction/{}".format(self.tender_id, lot_id["id"]),
{"data": {
"bids": auction_bids_data
}})
self.assertEqual(response.status, "200 OK")
self.assertEqual(response.content_type, "application/json")
response = self.app.get("/tenders/{}".format(self.tender_id))
self.assertEqual(response.json["data"]["status"], "active.qualification")
self.app.authorization = ("Basic", ("token", ""))
# patch all first lot related Awards to unsuccessful
while True:
response = self.app.get("/tenders/{}/awards".format(self.tender_id))
awards = [
i["id"] for i in response.json["data"] if i["status"] == "pending"
and i["lotID"] == self.initial_lots[0]["id"]
]
if awards:
award_id = awards[0]
else:
break
response = self.app.patch_json(
"/tenders/{}/awards/{}?acc_token={}".format(
self.tender_id, award_id, self.tender_token),
{"data": {
"status": "unsuccessful"
}},
)
self.assertEqual(response.status, "200 OK")
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.initial_lots[0]["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't perform cancellation if all awards are unsuccessful")
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},
status=403,
)
self.assertEqual(response.status, "403 Forbidden")
self.assertEqual(response.content_type, "application/json")
self.assertEqual(
response.json["errors"][0]["description"],
"Can't perform cancellation if all awards are unsuccessful")
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_with_complaints_after_2020_04_19(
self, cancellation["id"])
def lot_patch_tender_question(self):
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"]
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"])
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 get_now() > RELEASE_2020_04_19:
activate_cancellation_with_complaints_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't update question in current (cancelled) tender 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[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")
