def test_bonus_nodelay(client, treatment, synchron=True):
# In real conditions, the tasks/webhook are delayed with +500 ms
for _ in range(TASK_REPETITION):
client = get_client()
job_id = "test"
resp_worker_id = generate_worker_id("bonus_resp")
prop_worker_id = generate_worker_id("bonus_prop")
_process_resp_tasks(client,
treatment,
worker_id=resp_worker_id,
min_offer=MIN_OFFER,
bonus_mode="random",
synchron=synchron)
_process_prop_round(client,
treatment,
worker_id=prop_worker_id,
offer=OFFER,
response_available=True,
synchron=synchron)
with app.app_context():
bonus_resp = get_worker_bonus(job_id, resp_worker_id)
assert MIN_OFFER <= bonus_resp
assert bonus_resp <= tasks.MAX_BONUS + (MAX_GAIN - OFFER)
bonus_prop = get_worker_bonus(job_id, prop_worker_id)
assert bonus_prop == OFFER
def test_index(client, treatment, prefix="", completion_code_prefix="resp:", resp_feedback_fields=None):
client = None
job_id = "test"
completion_code_prefix_bytes = completion_code_prefix.encode("utf-8") if completion_code_prefix else b"resp:"
for _ in range(TASK_REPETITION):
client = get_client()
resp_worker_id = generate_worker_id(f"{prefix}index_resp")
path = f"/{treatment}/?worker_id={resp_worker_id}"
with app.test_request_context(path):
res = client.get(path, follow_redirects=True)
assert b"RESPONDER" in res.data
# res = _process_resp_tasks(client, worker_id=worker_id)
res = _process_resp(client, treatment, job_id=job_id, worker_id=resp_worker_id, min_offer=get_min_offer(), resp_feedback_fields=resp_feedback_fields)
process_tasks(client, job_id=job_id, worker_id=resp_worker_id, bonus_mode="random", url_kwargs={"auto_finalize": 1, "treatment": treatment})
assert completion_code_prefix_bytes in res.data
time.sleep(WEBHOOK_DELAY)
# let the auto-responder kick-in
with app.app_context():
# let the auto-responder kick-in
for _ in range(NB_MAX_AUTO_PLAY_RETRIES):
if is_resp_in_prop_result(resp_worker_id, job_id, treatment):
break
time.sleep(AUTO_PROP_DELAY)
assert is_resp_in_prop_result(resp_worker_id, job_id, treatment)
def test_eff(client):
with app.app_context():
job_id = "test"
worker_id = generate_worker_id("task")
res = _process_eff(client, job_id=job_id, worker_id=worker_id)
assert b"eff:" in res
assert is_worker_available(worker_id,
get_table("eff", job_id, "result"))
assert has_worker_and_features("eff", eff, job_id, worker_id)
def test_get_job_config():
job_id = "--------"
with app.app_context():
job_config = get_job_config(get_db(), job_id=job_id)
assert job_config["job_id"] == job_id
assert "api_key" in job_config
assert "nb_rows" in job_config
assert "unique_worker" in job_config
assert "base_code" in job_config
assert "expected_judgments" in job_config
assert "payment_max_cents" in job_config
assert len(job_config) == 7
def test_eff_bonus(client):
with app.app_context():
worker_id = generate_worker_id("eff")
res = _process_eff(client, worker_id=worker_id, bonus_mode="full")
assert b"eff:" in res
assert get_worker_bonus("test", worker_id) == eff.MAX_BONUS
worker_id = generate_worker_id("eff")
res = _process_eff(client, worker_id=worker_id, bonus_mode="random")
assert b"eff:" in res
worker_id = generate_worker_id("eff")
res = _process_eff(client, worker_id=worker_id, bonus_mode="none")
assert b"eff:" in res
assert get_worker_bonus("test", worker_id) == 0
def disabled__test_hexaco_bonus():
with app.app_context():
worker_id = generate_worker_id("hexaco")
res = _process_hexaco(client, worker_id=worker_id)
assert b"hexaco:" in res
assert get_worker_bonus("test", worker_id) == 0
worker_id = generate_worker_id("hexaco")
res = _process_hexaco(client, worker_id=worker_id)
assert b"hexaco:" in res
worker_id = generate_worker_id("hexaco")
res = _process_hexaco(client, worker_id=worker_id)
assert b"hexaco:" in res
assert get_worker_bonus("test", worker_id) == 0
def test_survey_drop(client, treatment):
"""
test if the submissed is dropped without control on other fields when <drop> is set to "1"
"""
with app.app_context():
worker_id = generate_worker_id("survey")
path = f"/survey/{treatment}/?job_id=test&worker_id={worker_id}"
with app.test_request_context(path):
form = MainForm()
form_data = {key: "" for key in form._fields}
form_data["drop"] = "1"
res = client.post(path, data=form_data, follow_redirects=True)
assert b"dropped" in res.data
def test_payment(client, treatment, resp_feedback_fields=None):
with HTTMock(figure_eight_mock):
job_id = "test"
resp_worker_id = generate_worker_id("payment_resp")
_process_resp_tasks(client, treatment, job_id=job_id, worker_id=resp_worker_id, min_offer=MIN_OFFER, resp_feedback_fields=resp_feedback_fields)
time.sleep(WEBHOOK_DELAY)
for _ in range(5):
emit_webhook(client, url=f"/{treatment}/webhook/", treatment=treatment, job_id="test", worker_id=resp_worker_id, by_get=False)
time.sleep(WEBHOOK_DELAY)
with app.app_context():
assert 0 == get_worker_bonus(job_id, resp_worker_id)
worker_paid_bonus = get_worker_paid_bonus(job_id, resp_worker_id)
assert 0 <= worker_paid_bonus <= tasks.MAX_BONUS + MAX_GAIN
def test_goat_bonus(client):
with app.app_context():
worker_id = generate_worker_id("goat")
res = _process_goat(client, worker_id=worker_id, bonus_mode="full")
assert b"goat:" in res
assert get_worker_bonus("test", worker_id) == goat.MAX_BONUS
worker_id = generate_worker_id("goat")
res = _process_goat(client, worker_id=worker_id, bonus_mode="random")
assert b"goat:" in res
worker_id = generate_worker_id("goat")
res = _process_goat(client, worker_id=worker_id, bonus_mode="none")
assert b"goat:" in res
assert get_worker_bonus("test", worker_id) == 0
def test_auto_finalize(client, treatment, resp_feedback_fields=None):
# Test automatic webhook triggering to finalize tasks
job_id = "test"
resp_worker_id = generate_worker_id("auto_resp")
_process_resp(client, treatment, job_id=job_id, worker_id=resp_worker_id, min_offer=get_min_offer(), resp_feedback_fields=resp_feedback_fields)
process_tasks(client, job_id=job_id, worker_id=resp_worker_id, bonus_mode="random", url_kwargs={"auto_finalize": 1, "treatment": treatment})
time.sleep(WEBHOOK_DELAY)
with app.app_context():
# let the auto-responder kick-in
for _ in range(NB_MAX_AUTO_PLAY_RETRIES):
if is_resp_in_prop_result(resp_worker_id, job_id, treatment):
break
time.sleep(AUTO_PROP_DELAY)
assert is_worker_available(resp_worker_id, get_table("resp", job_id=job_id, schema="result", treatment=treatment))
assert is_resp_in_prop_result(resp_worker_id, job_id, treatment)
def test_prop_index(client, treatment, resp_feedback_fields=None):
resp_worker_id = generate_worker_id("resp")
job_id = "test"
_process_resp(client, treatment, job_id=job_id, worker_id=resp_worker_id, min_offer=get_min_offer(), resp_feedback_fields=resp_feedback_fields)
process_tasks(client, job_id=job_id, worker_id=resp_worker_id, bonus_mode="random", url_kwargs={"auto_finalize": 1, "treatment": treatment})
time.sleep(WEBHOOK_DELAY)
time.sleep(WEBHOOK_DELAY)
# let the auto-responder kick-in
with app.app_context():
# let the auto-responder kick-in
for _ in range(NB_MAX_AUTO_PLAY_RETRIES):
if is_resp_in_prop_result(resp_worker_id, job_id, treatment):
break
time.sleep(AUTO_PROP_DELAY)
assert is_resp_in_prop_result(resp_worker_id, job_id, treatment)
def test_webhook(client, treatment, resp_feedback_fields=None):
# In real conditions, the tasks/webhook are delayed with +500 ms
job_id = "test"
resp_worker_id = generate_worker_id("webhook_resp")
process_tasks(client, job_id=job_id, worker_id=resp_worker_id, bonus_mode="random")
_process_resp(client, treatment, job_id=job_id, worker_id=resp_worker_id, min_offer=get_min_offer(), resp_feedback_fields=resp_feedback_fields)
emit_webhook(client, url=f"/{treatment}/webhook/", job_id=job_id, treatment=treatment, worker_id=resp_worker_id, by_get=True)
time.sleep(WEBHOOK_DELAY)
with app.app_context():
# let the auto-responder kick-in
for _ in range(NB_MAX_AUTO_PLAY_RETRIES):
if is_resp_in_prop_result(resp_worker_id, job_id, treatment):
break
time.sleep(AUTO_PROP_DELAY)
assert is_worker_available(resp_worker_id, get_table("resp", job_id=job_id, schema="result", treatment=treatment))
assert is_resp_in_prop_result(resp_worker_id, job_id, treatment)
def test_webhook(client, treatment, resp_feedback_fields=None):
# In real conditions, the tasks/webhook are delayed with +500 ms
job_id = "test"
resp_worker_id = generate_worker_id("webhook_resp")
prop_worker_id = generate_worker_id("webhook_prop")
process_tasks(client,
job_id=job_id,
worker_id=resp_worker_id,
bonus_mode="random")
_process_resp(client,
treatment,
job_id=job_id,
worker_id=resp_worker_id,
min_offer=get_min_offer(),
resp_feedback_fields=resp_feedback_fields)
emit_webhook(client,
url=f"/{treatment}/webhook/",
treatment=treatment,
worker_id=resp_worker_id,
by_get=True)
time.sleep(WEBHOOK_DELAY)
_process_prop(client,
treatment,
job_id=job_id,
worker_id=prop_worker_id,
offer=get_offer(),
response_available=True)
emit_webhook(client,
url=f"/{treatment}/webhook/",
treatment=treatment,
worker_id=prop_worker_id,
by_get=True)
time.sleep(WEBHOOK_DELAY)
with app.app_context():
assert is_worker_available(
resp_worker_id,
get_table("resp",
job_id=job_id,
schema="result",
treatment=treatment))
assert is_worker_available(
prop_worker_id,
get_table("prop",
job_id=job_id,
schema="result",
treatment=treatment))
def test_tasks_bonus(client):
job_id = "test"
worker_id = generate_worker_id("tasks")
with app.app_context():
_process_cg(client, worker_id=worker_id, bonus_mode="full")
exp_bonus = cg.MAX_BONUS
print("worker_id:", worker_id, "bonus: ", exp_bonus)
assert get_worker_bonus(job_id, worker_id) == exp_bonus
_process_crt(client, worker_id=worker_id, bonus_mode="full")
exp_bonus += crt.MAX_BONUS
assert get_worker_bonus(job_id, worker_id) == exp_bonus
_process_eff(client, worker_id=worker_id, bonus_mode="full")
exp_bonus += eff.MAX_BONUS
assert get_worker_bonus(job_id, worker_id) == exp_bonus
_process_hexaco(client, worker_id=worker_id)
exp_bonus += 0 #NO bonus for hexaco actually
assert get_worker_bonus(job_id, worker_id) == exp_bonus
_process_goat(client, worker_id=worker_id, bonus_mode="full")
exp_bonus += goat.MAX_BONUS
assert get_worker_bonus(job_id, worker_id) == exp_bonus
def test_auto_finalize(client, treatment, resp_feedback_fields=None):
# Test automatic webhook triggering to finalize tasks
job_id = "test"
resp_worker_id = generate_worker_id("auto_resp")
prop_worker_id = generate_worker_id("auto_prop")
_process_resp(client,
treatment,
job_id=job_id,
worker_id=resp_worker_id,
min_offer=get_min_offer(),
resp_feedback_fields=resp_feedback_fields)
process_tasks(client,
job_id=job_id,
worker_id=resp_worker_id,
bonus_mode="random",
url_kwargs={
"auto_finalize": 1,
"treatment": treatment
})
time.sleep(WEBHOOK_DELAY)
res = _process_prop(client,
treatment,
job_id=job_id,
worker_id=prop_worker_id,
offer=get_offer(),
response_available=True,
auto_finalize=True)
time.sleep(WEBHOOK_DELAY)
with app.app_context():
assert is_worker_available(
resp_worker_id,
get_table("resp",
job_id=job_id,
schema="result",
treatment=treatment))
assert is_worker_available(
prop_worker_id,
get_table("prop",
job_id=job_id,
schema="result",
treatment=treatment))
def test_bonus_nodelay(client, treatment, synchron=True, resp_feedback_fields=None):
# In real conditions, the tasks/webhook are delayed with +500 ms
# we make sure the offer is accepted!
min_offer = 0
for _ in range(TASK_REPETITION):
client = get_client()
job_id = "test"
resp_worker_id = generate_worker_id("bonus_resp")
_process_resp_tasks(client, treatment, worker_id=resp_worker_id, min_offer=min_offer, bonus_mode="random", synchron=synchron, resp_feedback_fields=resp_feedback_fields)
time.sleep(WEBHOOK_DELAY)
with app.app_context():
# let the auto-responder kick-in
for _ in range(NB_MAX_AUTO_PLAY_RETRIES):
if is_resp_in_prop_result(resp_worker_id, job_id, treatment):
break
time.sleep(AUTO_PROP_DELAY)
bonus_resp = get_worker_bonus(job_id, resp_worker_id)
assert min_offer <= bonus_resp
assert bonus_resp <= tasks.MAX_BONUS + (MAX_GAIN - OFFER)
assert is_resp_in_prop_result(resp_worker_id, job_id, treatment)
def test_payment(client, treatment):
with HTTMock(figure_eight_mock):
job_id = "test"
resp_worker_id = generate_worker_id("payment_resp")
prop_worker_id = generate_worker_id("payment_prop")
_process_resp_tasks(client,
treatment,
job_id=job_id,
worker_id=resp_worker_id,
min_offer=MIN_OFFER)
time.sleep(WEBHOOK_DELAY)
# _process_prop(client, treatment, job_id=job_id, worker_id=prop_worker_id, response_available=True, auto_finalize=True)
_process_prop_round(client,
treatment,
job_id=job_id,
worker_id=prop_worker_id,
response_available=True)
time.sleep(WEBHOOK_DELAY)
for _ in range(5):
emit_webhook(client,
url=f"/{treatment}/webhook/",
treatment=treatment,
job_id="test",
worker_id=prop_worker_id,
by_get=False)
emit_webhook(client,
url=f"/{treatment}/webhook/",
treatment=treatment,
job_id="test",
worker_id=resp_worker_id,
by_get=False)
time.sleep(WEBHOOK_DELAY)
with app.app_context():
bonus_resp = get_worker_bonus(job_id, resp_worker_id)
assert 0 == get_worker_bonus(job_id, resp_worker_id)
assert MIN_OFFER <= get_worker_paid_bonus(
job_id,
resp_worker_id) <= tasks.MAX_BONUS + (MAX_GAIN - OFFER)
assert 0 == get_worker_bonus(job_id, prop_worker_id)
assert get_worker_paid_bonus(job_id, prop_worker_id) == OFFER
def test_survey_no_workerid(client, treatment):
for _ in range(TASK_REPETITION_LOWER):
with app.app_context():
assignment_id = generate_worker_id().upper().replace("_", "")
path = f"/survey/{treatment}/?assignment_id={assignment_id}&preview=true"
with app.test_request_context(path):
client.get(path, follow_redirects=True)
form = MainForm()
form_data = {}
for field, item in form._fields.items():
if field in SURVEY_CONTROL_FIELDS:
form_data[field] = "correct"
elif field == SURVEY_MAIN_TASK_CODE_FIELD:
form_data[field] = "resp:"
elif field.startswith("code_"):
form_data[field] = get_completion_code(field)
elif field in SURVEY_CHOICE_FIELDS:
form_data[field] = random.choice(item.choices)[0]
else:
form_data[field] = "abc"
res = client.post(path, data=form_data, follow_redirects=True)
print("RESULT", res.data)
def test_survey_prop(client, treatment):
with app.app_context():
worker_id = generate_worker_id("survey")
assignment_id = worker_id.upper().replace("_", "")
path = f"/survey/{treatment}/?job_id=test&worker_id={worker_id}&assignment_id={assignment_id}"
with app.test_request_context(path):
client.get(path, follow_redirects=True)
form = MainForm()
form_data = {}
for field, item in form._fields.items():
if field in SURVEY_CONTROL_FIELDS:
form_data[field] = "correct"
elif field == SURVEY_MAIN_TASK_CODE_FIELD:
form_data[field] = "prop:"
elif field.startswith("code_"):
form_data[field] = ""
elif field in SURVEY_CHOICE_FIELDS:
form_data[field] = random.choice(item.choices)[0]
else:
form_data[field] = "abc"
res = client.post(path, data=form_data, follow_redirects=True)
assert b"Your survey completion code is:" in res.data
assert b"dropped" not in res.data
