def illegalize(clients, url, **kwargs):
"""Append illegal/long arguments to an url and trigger a 400 response.
Parameters
----------
clients: dict
Mapping from users to client fixtures
kwargs: dict
Additional parameters to illegalize.
The url will be expanded by formatting it with the `kwargs` values.
"""
kwargsx = {k: v + "a" * 200 for (k, v) in kwargs.items()}
base = url.format(**kwargs)
basex = url.format(**kwargsx)
uxs = [
base,
basex,
f"{base}?action=xxx",
f"{base}?xxx=xxx",
f"{base}?action=" + "a" * 200,
f"{base}?" + "a" * 2000,
]
passable = {200, 301, 302, 303}
for (i, ux) in enumerate(uxs):
expectx = {
user: 400 if i > 2 or i == 1 and len(kwargsx) else passable
for user in USERS
if user in clients
}
serverprint(f"LEGAL URL ? ({ux})")
forall(clients, expectx, assertStatus, ux)
def test_reviewEntries(clients):
recordId = startInfo["recordId"]
cIds = recordId[CRITERIA_ENTRY]
reviewId = G(recordId, REVIEW)
rEid = G(reviewId, EXPERT)
rFid = G(reviewId, FINAL)
assert rEid is not None
assert rFid is not None
def assertIt(cl, exp):
user = cl.user
for crId in cIds:
criteriaEntryInfo = getItem(cl, CRITERIA_ENTRY, crId)
text = criteriaEntryInfo["text"]
reviewEntries = findReviewEntries(text)
if exp:
if user in {EXPERT, FINAL}:
assert user in reviewEntries
assert COMMENTS in reviewEntries[user][1]
assert reviewEntries[user][1][COMMENTS] == E
else:
assert EXPERT in reviewEntries
assert FINAL in reviewEntries
expect = {user: False for user in USERS}
expect.update({user: True for user in POWER_USERS | {EXPERT, FINAL}})
forall(clients, expect, assertIt)
def test_modify(clients):
valueTables = startInfo["valueTables"]
recordId = startInfo["recordId"]
users = valueTables[USER]
eid = recordId[CONTRIB]
aId = recordId[ASSESS]
reviewId = recordId[REVIEW]
rExpertId = reviewId[EXPERT]
rFinalId = reviewId[FINAL]
cIdFirst = recordId[CRITERIA_ENTRY][0]
renId = getReviewEntryId(clients, cIdFirst, rExpertId, rFinalId)
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)
expect = {user: False for user in USERS}
forall(clients, expect, assertIt)
def assignReviewers(clients, users, aId, field, user, keep, expect):
"""Verify assigning reviewers to an assessment.
A reviewer will be assigned to an assessment and immediately be unassigned.
But the undo can be suppressed.
Parameters
----------
clients: dict
Mapping from users to client fixtures
users: dict
Mapping of users to ids
aId: string(ObjectId)
Assessment id
field: string
Reviewer field (`reviewerE` or `reviewerF`)
user: string
The reviewer user
keep: boolean
If True, the assignment will not be undone
expect: dict
For each user a boolean saying whether that user can assign the reviewer
"""
value = G(users, user)
def assertIt(cl, exp):
assertModifyField(cl, ASSESS, aId, field, (value, user), exp)
if exp and not keep:
assertModifyField(cl, ASSESS, aId, field, (None, UNDEF_VALUE), True)
forall(clients, expect, assertIt)
def test_addDelAll(clients):
def assertIt(cl, exp):
eid = assertAddItem(cl, CONTRIB, exp)
if exp:
assertDelItem(cl, CONTRIB, eid, True)
expect = {user: True for user in USERS}
expect["public"] = False
forall(clients, expect, assertIt)
def test_modifyUrl(clientsMy, field, value, expectVal):
recordId = startInfo["recordId"]
eid = G(recordId, CONTRIB)
def assertIt(cl, exp):
assertModifyField(cl, CONTRIB, eid, field, (value, expectVal), exp)
expect = {user: True for user in {OWNER, EDITOR}}
forall(clientsMy, expect, assertIt)
def test_tryStartAll(clients, url):
recordId = startInfo["recordId"]
eid = G(recordId, CONTRIB)
theUrl = url.format(eid=eid)
def assertIt(cl, exp):
assertStatus(cl, theUrl, exp)
expect = {user: False for user in USERS}
forall(clients, expect, assertIt)
def test_inspectTypeAll(clients):
recordId = startInfo["recordId"]
aId = G(recordId, ASSESS)
def assertIt(cl, exp):
assertFieldValue((cl, ASSESS, aId), TYPEA, exp)
expect = {user: None for user in USERS}
expect.update({user: TYPE1 for user in RIGHTFUL_USERS})
forall(clients, expect, assertIt)
def test_modifyTypeAll(clients):
recordId = startInfo["recordId"]
ids = startInfo["ids"]
aId = G(recordId, ASSESS)
def assertIt(cl, exp):
assertModifyField(cl, ASSESS, aId, TYPEA, (ids["TYPE2"], None), exp)
expect = {user: False for user in USERS}
forall(clients, expect, assertIt)
def test_modifyTitleAll(clients):
recordId = startInfo["recordId"]
eid = G(recordId, CONTRIB)
def assertIt(cl, exp):
assertModifyField(cl, CONTRIB, eid, TITLE, TITLE2, exp)
if exp:
assertModifyField(cl, CONTRIB, eid, TITLE, TITLE1, exp)
expect = {user: False for user in USERS}
expect.update(
{user: True
for user in {OWNER, EDITOR, OFFICE, SYSTEM, ROOT}})
forall(clients, expect, assertIt)
def test_descriptionMarkdown(clientsMy, field, checks):
recordId = startInfo["recordId"]
eid = G(recordId, CONTRIB)
def assertIt(cl, exp):
response = cl.get(
f"/api/{CONTRIB}/item/{eid}/field/{field}?action=view")
text = response.get_data(as_text=True)
for check in checks:
assert check in text
expect = {user: True for user in {OWNER, EDITOR}}
forall(clientsMy, expect, assertIt)
def test_startReview(clientsReviewer):
recordId = startInfo["recordId"]
aId = G(recordId, ASSESS)
recordId.setdefault(REVIEW, {})
def assertIt(cl, exp):
rId = assertStartTask(cl, START_REVIEW, aId, exp)
assert rId is not None
user = cl.user
recordId[REVIEW][user] = rId
expect = {user: True for user in {EXPERT, FINAL}}
forall(clientsReviewer, expect, assertIt)
def test_makeEditorAll(clients):
valueTables = startInfo["valueTables"]
recordId = startInfo["recordId"]
eid = G(recordId, CONTRIB)
def assertIt(cl, exp):
assertEditor(cl, CONTRIB, eid, valueTables, exp)
if exp:
assertEditor(cl, CONTRIB, eid, valueTables, exp, clear=True)
expect = {user: False for user in USERS}
expect.update({user: True for user in {OWNER, OFFICE, SYSTEM, ROOT}})
forall(clients, expect, assertIt)
def test_viewCost(clients, field):
recordId = startInfo["recordId"]
eid = G(recordId, CONTRIB)
value = EXAMPLE[field]
if field == COST_DESCRIPTION:
value = value[0]
valueStrip = value.strip()
def assertIt(cl, exp):
assertFieldValue((cl, CONTRIB, eid), field, exp)
expect = {user: None for user in USERS}
expect.update({user: valueStrip for user in RIGHTFUL_USERS})
expect.update({MYCOORD: valueStrip})
forall(clients, expect, assertIt)
def test_viewAssessment(clients):
recordId = startInfo["recordId"]
aId = G(recordId, ASSESS)
def assertIt(cl, exp):
assessInfo = getItem(cl, ASSESS, aId)
text = assessInfo["text"]
tasks = findTasks(text)
if exp:
assert len(tasks) == 1
assert tasks[0] == exp
expect = {user: () for user in USERS}
expect.update({user: (START_REVIEW, aId) for user in (EXPERT, FINAL)})
forall(clients, expect, assertIt)
def test_tryStartReviewAll(clients):
recordId = startInfo["recordId"]
aId = G(recordId, ASSESS)
def assertIt(cl, exp):
rId = assertStartTask(cl, START_REVIEW, aId, exp)
if exp:
assert rId is not None
assertDelItem(cl, REVIEW, rId, True)
else:
assert rId is None
expect = {user: False for user in USERS}
expect.update({user: True for user in {EXPERT, FINAL}})
forall(clients, expect, assertIt)
def test_decideOthers(clients):
recordId = startInfo["recordId"]
reviewId = G(recordId, REVIEW)
def assertIt(cl, exp):
user = cl.user
for kind in [EXPERT, FINAL]:
rId = G(reviewId, kind)
expStatus = kind == user if exp else exp
for decision in [REJECT, REVISE, ACCEPT, REVOKE]:
decisionStr = G(G(REVIEW_DECISION, decision), kind)
url = f"/api/task/{decisionStr}/{rId}"
assertStatus(cl, url, expStatus)
expect = {user: False for user in USERS if user not in {EXPERT, FINAL}}
forall(clients, expect, assertIt)
def inspectTitleAll(clients, table, eid, expect):
"""Verify the title of an item, as seen by each user.
Parameters
----------
clients: dict
Mapping from users to client fixtures
table: the table of the item
eid: the id of the item
expect: dict
The expected values, keyed per user
"""
def assertIt(cl, exp):
assertFieldValue((cl, table, eid), TITLE, exp)
forall(clients, expect, assertIt)
def test_modifyTitleAll(clients):
recordId = startInfo["recordId"]
recordInfo = startInfo["recordInfo"]
aId = G(recordId, ASSESS)
contribInfo = recordInfo[CONTRIB]
fields = contribInfo["fields"]
cTitle = G(fields, TITLE)
aTitle = TITLE_A.format(cTitle=cTitle)
def assertIt(cl, exp):
assertModifyField(cl, ASSESS, aId, TITLE, TITLE_A2, exp)
if exp:
assertModifyField(cl, ASSESS, aId, TITLE, aTitle, exp)
expect = {user: False for user in USERS}
expect.update({user: True for user in RIGHTFUL_USERS})
forall(clients, expect, assertIt)
def test_reviewEntryFill(clientsReviewer):
recordId = startInfo["recordId"]
cIds = recordId[CRITERIA_ENTRY]
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)
expect = {user: True for user in {EXPERT, FINAL}}
forall(clientsReviewer, expect, assertIt)
def modifyTitleAll(clients, table, eid, expect):
"""Modify the title of an item, performed by each user.
Parameters
----------
clients: dict
Mapping from users to client fixtures
table: the table of the item
eid: the id of the item
expect: dict
The expected values, keyed per user
"""
def assertIt(cl, exp):
assertModifyField(cl, table, eid, TITLE, TITLE2, exp)
if exp:
assertModifyField(cl, table, eid, TITLE, TITLE1, exp)
forall(clients, expect, assertIt)
def sidebar(clients, amounts):
"""Verify the sidebar.
It will be verified whether each user sees the right entries,
and that following an entry leads to the expected results.
Parameters
----------
clients: dict
Mapping from users to client fixtures
amounts: dict
Keyed by entry, it is a list of instructions to change the expected amount.
Each instruction is a pair `(set of users, amount)`, leading
to setting the indicated amount for the indicated users.
The set of users can be left out, then all users are implied.
"""
expectedCaptions = {}
for (caption, expectedUsers, expectedN, expectedItemSg, expectedItemPl) in CAPTIONS:
for user in expectedUsers:
thisCaption = (
caption.format(country=USER_COUNTRY[user])
if "{country}" in caption
else caption
)
n = expectedN
for instruction in G(amounts, thisCaption, default=[]):
if type(instruction) is tuple or type(instruction) is list:
(theseUsers, thisAmount) = instruction
else:
(theseUsers, thisAmount) = (USERS, instruction)
if user in theseUsers:
n = thisAmount
if n is None:
expectedItem = expectedItemSg or thisCaption
else:
pl = expectedItemPl or thisCaption
sg = expectedItemSg or thisCaption[0:-1]
expectedItem = sg if n == 1 else pl
expectedCaptions.setdefault(user, {})[thisCaption] = (n, expectedItem)
expect = {user: G(expectedCaptions, user) for user in USERS}
forall(clients, expect, assertCaptions)
def test_changeUserCountry(clientsPower):
valueTables = startInfo["valueTables"]
users = valueTables[USER]
countries = valueTables[COUNTRY]
assert MYCOORD in users
assert BELGIUM in countries
assert LUXEMBURG in countries
mycoord = users[MYCOORD]
belgium = countries[BELGIUM]
luxemburg = countries[LUXEMBURG]
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)
expect = {user: True for user in POWER_USERS}
forall(clientsPower, expect, assertIt)
def test_reviewEntryView(clients):
recordId = startInfo["recordId"]
cIds = recordId[CRITERIA_ENTRY]
cIdFirst = cIds[0]
reId = {}
for user in {EXPERT, FINAL}:
criteriaEntryInfo = getItem(clients[user], CRITERIA_ENTRY, cIdFirst)
text = criteriaEntryInfo["text"]
reviewEntries = findReviewEntries(text)
reId[user] = reviewEntries[user][0]
def assertIt(cl, exp):
user = cl.user
for (kind, rId) in reId.items():
value = f"{kind}'s comment on criteria 1"
expValue = (None
if exp is None else value if user in {EXPERT, FINAL}
| POWER_USERS else None)
assertFieldValue((cl, REVIEW_ENTRY, rId), COMMENTS, expValue)
expect = {user: None for user in USERS}
expect.update({user: True for user in {EXPERT, FINAL} | POWER_USERS})
forall(clients, expect, assertIt)
def test_reviewEntryFillFirstAll(clients):
recordId = startInfo["recordId"]
cIds = recordId[CRITERIA_ENTRY]
cIdFirst = cIds[0]
reviewId = recordId[REVIEW]
reviewEntryId = getReviewEntryId(clients, cIdFirst, reviewId[EXPERT],
reviewId[FINAL])
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)
expect = {user: False for user in USERS}
expect.update({user: True for user in {EXPERT, FINAL} | POWER_USERS})
forall(clients, expect, assertIt)
def startAssessment(clients, eid, expect):
"""Starts an assessment and deletes it immediately afterwards.
All users in `clients` for which there is an entry in `expect` do this.
Parameters
----------
clients: dict
Mapping from users to client fixtures
eid: string(ObjectId)
The id of the contribution for an assessment is started
expect: dict
Per user whether the starting of an assessment succeeds or not
"""
def assertIt(cl, exp):
aId = assertStartTask(cl, START_ASSESSMENT, eid, exp)
if exp:
assert aId is not None
assertDelItem(cl, ASSESS, aId, True)
else:
assert aId is None
forall(clients, expect, assertIt)
def test_modify2(clients):
valueTables = startInfo["valueTables"]
recordId = startInfo["recordId"]
users = valueTables[USER]
eid = recordId[CONTRIB]
aId = recordId[ASSESS]
reviewId = recordId[REVIEW]
rExpertId = reviewId[EXPERT]
rFinalId = reviewId[FINAL]
cIdFirst = recordId[CRITERIA_ENTRY][0]
renId = getReviewEntryId(clients, cIdFirst, rExpertId, rFinalId)
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}"],
)
expectDefault = {user: False for user in USERS}
expectPerKind = {
CONTRIB: dict(expectDefault),
ASSESS: dict(expectDefault),
CRITERIA_ENTRY: dict(expectDefault),
"assign": dict(expectDefault),
f"{REVIEW}_{EXPERT}": dict(expectDefault),
f"{REVIEW}_{FINAL}": dict(expectDefault),
f"{REVIEW_ENTRY}_{EXPERT}": dict(expectDefault),
f"{REVIEW_ENTRY}_{FINAL}": dict(expectDefault),
}
expectPerKind["assign"].update({user: True for user in {OFFICE}})
expectPerKind[f"{REVIEW}_{EXPERT}"].update(
{user: True
for user in {EXPERT} | POWER_USERS})
expectPerKind[f"{REVIEW}_{FINAL}"].update(
{user: True
for user in {FINAL} | POWER_USERS})
expectPerKind[f"{REVIEW_ENTRY}_{EXPERT}"].update(
{user: True
for user in {EXPERT} | POWER_USERS})
expectPerKind[f"{REVIEW_ENTRY}_{FINAL}"].update(
{user: True
for user in {FINAL} | POWER_USERS})
expect = {}
for (kind, expectKind) in expectPerKind.items():
for (user, exp) in expectKind.items():
expect.setdefault(user, {})[kind] = exp
forall(clients, expect, assertIt)
def test_workflow(clients):
url = "/workflow"
expect = {user: 302 if user in {SYSTEM, ROOT} else 303 for user in USERS}
forall(clients, expect, assertStatus, url)
illegalize(clients, url)
def test_long(clients):
url = "/" + "a" * 1000
expect = {user: 400 for user in USERS}
forall(clients, expect, assertStatus, url)
