def startFillout():
aId = recordId[ASSESS]
assessInfo = getItem(clientOwner, ASSESS, aId)
criteriaEntries = findDetails(assessInfo["text"], CRITERIA_ENTRY)
nCId = len(criteriaEntries)
assert nCId == CRITERIA_ENTRIES_N[TYPE1]
cIds = []
for (i, (cId, material)) in enumerate(criteriaEntries):
cIds.append(cId)
assert ELLIPS_DIV in material
scores = getScores(cId)
(scoreValue, scoreId) = sorted(scores.items())[1]
assertModifyField(
clientOwner, CRITERIA_ENTRY, cId, SCORE, (scoreId, scoreValue), True,
)
theEvidence = [f"evidence for {i + 1}", "see the internet"]
theEvidenceRep = ",".join(theEvidence)
assertModifyField(
clientOwner,
CRITERIA_ENTRY,
cId,
EVIDENCE,
(theEvidence, theEvidenceRep),
True,
)
recordId[CRITERIA_ENTRY] = cIds
assertStage(clientOwner, ASSESS, aId, COMPLETE)
if submit:
startSubmit()
def test_addAssessment2(clientOwner):
recordId = startInfo["recordId"]
recordInfo = startInfo["recordInfo"]
ids = startInfo["ids"]
eid = G(recordId, CONTRIB)
aId = G(recordId, ASSESS)
assessInfo = getItem(clientOwner, ASSESS, aId)
recordInfo[ASSESS] = assessInfo
fields = assessInfo["fields"]
aTitle = G(fields, TITLE)
assertModifyField(clientOwner, CONTRIB, eid, TYPE, (ids["TYPE2"], TYPE2),
True)
assessInfo = getItem(clientOwner, ASSESS, aId)
text = assessInfo["text"]
assert checkWarning(text, aTitle)
assertStartTask(clientOwner, START_ASSESSMENT, eid, True)
aIds = getEid(clientOwner, ASSESS, multiple=True)
assert len(aIds) == 2
newAId = [i for i in aIds if i != aId][0]
assertDelItem(clientOwner, ASSESS, newAId, True)
assertModifyField(clientOwner, CONTRIB, eid, TYPE, (ids["TYPE1"], TYPE1),
True)
assessInfo = getItem(clientOwner, ASSESS, aId)
text = assessInfo["text"]
assert not checkWarning(text, aTitle)
def test_Revise(clientOwner):
recordId = startInfo["recordId"]
aId = G(recordId, ASSESS)
cIds = recordId[CRITERIA_ENTRY]
cIdFirst = cIds[0]
assertStage(clientOwner, ASSESS, aId, COMPLETE_REVISED)
assertModifyField(
clientOwner,
CRITERIA_ENTRY,
cIdFirst,
EVIDENCE,
([], E),
True,
)
assertStage(clientOwner, ASSESS, aId, INCOMPLETE_REVISED)
theEvidence = [f"revised evidence for 1", "see the internet"]
theEvidenceRep = ",".join(theEvidence)
assertModifyField(
clientOwner,
CRITERIA_ENTRY,
cIdFirst,
EVIDENCE,
(theEvidence, theEvidenceRep),
True,
)
assertStage(clientOwner, ASSESS, aId, COMPLETE_REVISED)
assertStatus(clientOwner, f"/api/task/{SUBMIT_ASSESSMENT}/{aId}", False)
assertStatus(clientOwner, f"/api/task/{RESUBMIT_ASSESSMENT}/{aId}", False)
assertStatus(clientOwner, f"/api/task/{SUBMIT_REVISED}/{aId}", True)
def test_modifyTypeWrong(clientOwner):
valueTables = startInfo["valueTables"]
recordId = startInfo["recordId"]
eid = G(recordId, CONTRIB)
wrongValue = list(valueTables[TADIRAH_OBJECT].values())[0]
assertModifyField(clientOwner, CONTRIB, eid, TYPE, wrongValue, False)
def test_addMetaWrong(clientOwner, field):
recordId = startInfo["recordId"]
eid = G(recordId, CONTRIB)
updateValues = [["xxx"]]
assertModifyField(clientOwner, CONTRIB, eid, field, updateValues, False)
def test_modifyTypeEx2(clientOwner):
valueTables = startInfo["valueTables"]
recordId = startInfo["recordId"]
eid = G(recordId, CONTRIB)
assertModifyField(
clientOwner, CONTRIB, eid, TYPE, (valueTables[TYPE][TYPE2], TYPE2), True
)
def test_modifyTypeMult(clientOwner):
valueTables = startInfo["valueTables"]
recordId = startInfo["recordId"]
eid = G(recordId, CONTRIB)
types = valueTables[TYPE]
newValue = (types[TYPE2], types[TYPE1])
assertModifyField(clientOwner, CONTRIB, eid, TYPE, (newValue, None), False)
def test_modifyVccError(clientOwner):
valueTables = startInfo["valueTables"]
recordId = startInfo["recordId"]
eid = G(recordId, CONTRIB)
vccs = valueTables[VCC]
vccVal = ["monkey", vccs[VCC2]]
assertModifyField(clientOwner, CONTRIB, eid, VCC, (vccVal, None), False)
def test_modifyVcc(clientOwner):
valueTables = startInfo["valueTables"]
recordId = startInfo["recordId"]
eid = G(recordId, CONTRIB)
vccs = valueTables[VCC]
vcc12 = [vccs[VCC1], vccs[VCC2]]
assertModifyField(clientOwner, CONTRIB, eid, VCC, (vcc12, VCC12), True)
def test_modifyVccWrong(clientOwner):
valueTables = startInfo["valueTables"]
recordId = startInfo["recordId"]
eid = G(recordId, CONTRIB)
vccs = valueTables[VCC]
wrongValue = list(valueTables[TADIRAH_OBJECT].values())[0]
vccVal = [wrongValue, vccs["vcc2"]]
assertModifyField(clientOwner, CONTRIB, eid, VCC, (vccVal, None), False)
def startAssign():
aId = recordId[ASSESS]
users = G(valueTables, USER)
for (field, user) in ((REVIEWER_E, EXPERT), (REVIEWER_F, FINAL)):
value = G(users, user)
assertModifyField(clientOffice, ASSESS, aId, field, (value, user), True)
if review:
startReviews()
def startAssessment():
eid = recordId[CONTRIB]
assertModifyField(
clientOwner, CONTRIB, eid, TYPE, (ids["TYPE1"], TYPE1), True,
)
aId = makeItem(clientOwner, ASSESS, cId=eid)
recordId[ASSESS] = aId
assertEditor(clientOwner, ASSESS, aId, valueTables, True)
if fillout:
startFillout()
def test_tryStartAgainAll(clients):
recordId = startInfo["recordId"]
ids = startInfo["ids"]
eid = G(recordId, CONTRIB)
assertModifyField(clients[OWNER], CONTRIB, eid, TYPE,
(ids["TYPE1"], TYPE1), True)
expect = {user: False for user in USERS}
expect.update({user: True for user in {OWNER, EDITOR}})
startAssessment(clients, eid, expect)
def assertIt(cl, exp):
user = cl.user
for (kind, renId) in reviewEntryId.items():
thisExp = exp and (kind == user or user in POWER_USERS)
newValue = [f"{user}'s comment"]
newValueRep = ",".join(newValue)
assertModifyField(cl, REVIEW_ENTRY, renId, COMMENTS,
(newValue, newValueRep), thisExp)
if thisExp:
assertModifyField(cl, REVIEW_ENTRY, renId, COMMENTS, ([], E),
True)
def assertIt(cl, exp):
user = cl.user
for (i, crId) in enumerate(cIds):
criteriaEntryInfo = getItem(cl, CRITERIA_ENTRY, crId)
text = criteriaEntryInfo["text"]
reviewEntries = findReviewEntries(text)
rId = reviewEntries[user][0]
newValue = [f"{user}'s comment on criteria {i + 1}"]
newValueRep = ",".join(newValue)
assertModifyField(cl, REVIEW_ENTRY, rId, COMMENTS,
(newValue, newValueRep), exp)
def test_addMetaRight(clientOwner, clientOffice, field, value):
recordId = startInfo["recordId"]
eid = G(recordId, CONTRIB)
updateValues = ((value,),)
assertModifyField(clientOwner, CONTRIB, eid, field, (updateValues, value), True)
assertModifyField(clientOwner, CONTRIB, eid, field, (None, ""), True)
client = MongoClient()
db = client[DB]
mid = list(db[field].find({REP: value}))[0][_ID]
assertDelItem(clientOffice, field, mid, True)
def test_modifyMeta(clientOwner, field):
valueTables = startInfo["valueTables"]
recordId = startInfo["recordId"]
eid = G(recordId, CONTRIB)
meta = valueTables[field]
checkValues = EXAMPLE[field][0:3]
updateValues = tuple(meta[ex] for ex in checkValues)
assertModifyField(
clientOwner, CONTRIB, eid, field, (updateValues, ",".join(checkValues)), True
)
def test_modifyCost(clientOwner, clientOffice):
recordId = startInfo["recordId"]
eid = G(recordId, CONTRIB)
value = EXAMPLE[COST_BARE]
expect = EXAMPLE[COST_TOTAL]
assertModifyField(clientOwner, CONTRIB, eid, COST_TOTAL, (value, expect),
True)
value = EXAMPLE[COST_DESCRIPTION][0]
expect = value.strip()
assertModifyField(clientOwner, CONTRIB, eid, COST_DESCRIPTION,
(value, expect), True)
def startReviews():
aId = recordId[ASSESS]
cIds = recordId[CRITERIA_ENTRY]
recordId.setdefault(REVIEW, {})
clr = {EXPERT: clientExpert, FINAL: clientFinal}
for (user, cl) in clr.items():
rId = makeItem(cl, REVIEW, aId=aId)
recordId[REVIEW][user] = rId
for (user, cl) in clr.items():
rId = recordId[REVIEW][user]
for (i, cId) in enumerate(cIds):
rEId = recordId[REVIEW][EXPERT]
rFId = recordId[REVIEW][FINAL]
reId = getReviewEntryId(clr, cId, rEId, rFId)
reId = reId[user]
newValue = [f"{user}'s comment on criteria {i + 1}"]
newValueRep = ",".join(newValue)
assertModifyField(
cl, REVIEW_ENTRY, reId, COMMENTS, (newValue, newValueRep), True
)
def test_resetType(clientOwner, clientOffice):
recordId = startInfo["recordId"]
eid = G(recordId, CONTRIB)
assertModifyField(clientOwner, CONTRIB, eid, TYPE, (None, UNDEF_VALUE),
True)
def assertIt(cl, exp):
assertModifyField(cl, CONTRIB, eid, field, (value, expectVal), exp)
def assertIt(cl, exp):
assertModifyField(cl, CONTRIB, eid, CONTACT_PERSON_EMAIL,
(value, expectVal), exp)
def assertIt(cl, exp):
assertModifyField(cl, CONTRIB, eid, COST_TOTAL, (value, expectVal),
exp)
def assertIt(cl, exp):
assertModifyField(cl, CONTRIB, eid, field, (value, value.strip()), exp)
def assertIt(cl, exp):
assertModifyField(cl, CONTRIB, eid, TITLE, TITLE2, exp)
if exp:
assertModifyField(cl, CONTRIB, eid, TITLE, TITLE1, exp)
def assertIt(cl, exp):
assertFieldValue((cl, USER, mycoord), COUNTRY, BELGIUM)
assertModifyField(cl, USER, mycoord, COUNTRY, (luxemburg, LUXEMBURG),
exp)
assertModifyField(cl, USER, mycoord, COUNTRY, (belgium, BELGIUM), exp)
def assertIt(cl, exp):
assertModifyField(cl, CONTRIB, eid, TITLE, TITLE2, exp[CONTRIB])
assertModifyField(cl, ASSESS, aId, TITLE, TITLE_A2, exp[ASSESS])
reviewerFId = G(users, FINAL)
reviewerEId = G(users, EXPERT)
assertModifyField(cl, ASSESS, aId, REVIEWER_E, (reviewerFId, FINAL),
exp["assign"])
assertModifyField(cl, ASSESS, aId, REVIEWER_E, (reviewerEId, EXPERT),
exp["assign"])
assertModifyField(
cl,
CRITERIA_ENTRY,
cIdFirst,
EVIDENCE,
([EVIDENCE1], EVIDENCE1),
exp[CRITERIA_ENTRY],
)
for (rId, remarks, kind) in (
(rExpertId, REMARKS_E, EXPERT),
(rFinalId, REMARKS_F, FINAL),
):
assertModifyField(cl, REVIEW, rId, REMARKS, ([remarks], remarks),
exp[f"{REVIEW}_{kind}"])
for (kind, reid) in renId.items():
comments = COMMENTS_E if kind == EXPERT else COMMENTS_F
assertModifyField(
cl,
REVIEW_ENTRY,
reid,
COMMENTS,
([comments], comments),
exp[f"{REVIEW_ENTRY}_{kind}"],
)
def assertIt(cl, exp):
assertModifyField(cl, ASSESS, aId, TYPEA, (ids["TYPE2"], None), exp)
def assertIt(cl, exp):
assertModifyField(cl, ASSESS, aId, TITLE, TITLE_A2, exp)
if exp:
assertModifyField(cl, ASSESS, aId, TITLE, aTitle, exp)
def assertIt(cl, exp):
assertModifyField(cl, CONTRIB, eid, TITLE, TITLE2, exp)
assertModifyField(cl, ASSESS, aId, TITLE, TITLE_A2, exp)
reviewerFId = G(users, FINAL)
assertModifyField(cl, ASSESS, aId, REVIEWER_E, (reviewerFId, FINAL),
exp)
assertModifyField(cl, CRITERIA_ENTRY, cIdFirst, EVIDENCE,
([EVIDENCE1], EVIDENCE1), exp)
for (rId, remarks) in ((rExpertId, REMARKS_E), (rFinalId, REMARKS_F)):
assertModifyField(cl, REVIEW, rId, REMARKS, ([remarks], remarks),
exp)
for (u, reid) in renId.items():
comments = COMMENTS_E if u == EXPERT else COMMENTS_F
assertModifyField(cl, REVIEW_ENTRY, reid, COMMENTS,
([comments], comments), exp)
