def manifests(client: FlaskClient, election_id: str,
jurisdiction_ids: List[str]):
set_logged_in_user(client, UserType.JURISDICTION_ADMIN, DEFAULT_JA_EMAIL)
rv = client.put(
f"/api/election/{election_id}/jurisdiction/{jurisdiction_ids[0]}/ballot-manifest",
data={
"manifest": (
io.BytesIO(b"Batch Name,Number of Ballots\n"
b"1,200000\n"
b"2,200000\n"
b"3,200000\n"
b"4,200000\n"
b"5,200000"),
"manifest.csv",
)
},
)
assert_ok(rv)
rv = client.put(
f"/api/election/{election_id}/jurisdiction/{jurisdiction_ids[1]}/ballot-manifest",
data={
"manifest": (
io.BytesIO(b"Batch Name,Number of Ballots\n"
b"1,200000\n"
b"2,200000\n"
b"3,200000\n"
b"4,200000\n"
b"5,200000"),
"manifest.csv",
)
},
)
assert_ok(rv)
bgcompute_update_ballot_manifest_file()
def test_api_source_put(
test_client: FlaskClient, example_ledger: FavaLedger
) -> None:
path = Path(example_ledger.beancount_file_path)
url = "/long-example/api/source"
# test bad request
response = test_client.put(url)
assert_api_error(response, "Invalid JSON request.")
payload = path.read_text("utf-8")
sha256sum = hashlib.sha256(path.read_bytes()).hexdigest()
# change source
response = test_client.put(
url,
json={
"source": "asdf" + payload,
"sha256sum": sha256sum,
"file_path": path,
},
)
sha256sum = hashlib.sha256(path.read_bytes()).hexdigest()
assert_api_success(response, sha256sum)
# check if the file has been written
assert path.read_text("utf-8") == "asdf" + payload
# write original source file
result = test_client.put(
url,
json={"source": payload, "sha256sum": sha256sum, "file_path": path},
)
assert result.status_code == 200
assert path.read_text("utf-8") == payload
def test_search_pagination(client: FlaskClient):
"""
Test pagination param on search request
Arguments:
client {FlaskClient} -- client to access flask web ressource
"""
# generate may matching groups
groups_1: List[Group] = create_groups(search_query="v",
valid_groups=True,
amount=50)
# test page 0 with 25 entries
response_1: JSONResponse = client.put(
url_for("meetupsearchapi"),
data=generate_search_dict(query="v", page=0, limit=25),
)
assert response_1.status_code == 200
assert response_1.json["results"][0]["urlname"] == groups_1[0].urlname
assert len(response_1.json["results"]) == 25
assert response_1.json["hits"] == 50
assert isinstance(response_1, JSONResponse)
# test page 1 with 25 entries
response_2: JSONResponse = client.put(
url_for("meetupsearchapi"),
data=generate_search_dict(query="v", page=1, limit=25),
)
assert response_2.status_code == 200
assert response_2.json["results"][0]["urlname"] == groups_1[25].urlname
assert len(response_2.json["results"]) == 25
assert response_2.json["hits"] == 50
assert isinstance(response_2, JSONResponse)
def test_api_add_document(
app: Flask,
test_client: FlaskClient,
tmp_path: Path,
monkeypatch: MonkeyPatch,
) -> None:
with app.test_request_context("/long-example/"):
app.preprocess_request()
monkeypatch.setitem(
g.ledger.options, "documents", [str(tmp_path)] # type: ignore
)
request_data = {
"folder": str(tmp_path),
"account": "Expenses:Food:Restaurant",
"file": (BytesIO(b"asdfasdf"), "2015-12-12 test"),
}
url = url_for("json_api.put_add_document")
response = test_client.put(url)
assert_api_error(response, "No file uploaded.")
filename = (
tmp_path / "Expenses" / "Food" / "Restaurant" / "2015-12-12 test"
)
response = test_client.put(url, data=request_data)
assert_api_success(response, f"Uploaded to {filename}")
assert Path(filename).is_file()
request_data["file"] = (BytesIO(b"asdfasdf"), "2015-12-12 test")
response = test_client.put(url, data=request_data)
assert_api_error(response, f"{filename} already exists.")
def test_ballot_manifest_replace(
client: FlaskClient, election_id: str, jurisdiction_ids: List[str]
):
set_logged_in_user(client, UserType.JURISDICTION_ADMIN, DEFAULT_JA_EMAIL)
rv = client.put(
f"/api/election/{election_id}/jurisdiction/{jurisdiction_ids[0]}/ballot-manifest",
data={
"manifest": (
io.BytesIO(
b"Batch Name,Number of Ballots,Storage Location,Tabulator\n"
b"1,23,Bin 2,Tabulator 1\n"
b"12,100,Bin 3,Tabulator 2\n"
b"6,0,,\n"
),
"manifest.csv",
)
},
)
assert_ok(rv)
file_id = Jurisdiction.query.get(jurisdiction_ids[0]).manifest_file_id
bgcompute_update_ballot_manifest_file()
rv = client.put(
f"/api/election/{election_id}/jurisdiction/{jurisdiction_ids[0]}/ballot-manifest",
data={
"manifest": (
io.BytesIO(
b"Batch Name,Number of Ballots,Storage Location,Tabulator\n"
b"1,23,Bin 2,Tabulator 1\n"
b"12,6,Bin 6,Tabulator 2\n"
),
"manifest.csv",
)
},
)
assert_ok(rv)
# The old file should have been deleted
jurisdiction = Jurisdiction.query.get(jurisdiction_ids[0])
assert File.query.get(file_id) is None
assert jurisdiction.manifest_file_id != file_id
bgcompute_update_ballot_manifest_file()
jurisdiction = Jurisdiction.query.get(jurisdiction_ids[0])
assert jurisdiction.manifest_num_batches == 2
assert jurisdiction.manifest_num_ballots == 29
assert len(jurisdiction.batches) == 2
assert jurisdiction.batches[0].name == "1"
assert jurisdiction.batches[0].num_ballots == 23
assert jurisdiction.batches[0].storage_location == "Bin 2"
assert jurisdiction.batches[0].tabulator == "Tabulator 1"
assert jurisdiction.batches[1].name == "12"
assert jurisdiction.batches[1].num_ballots == 6
assert jurisdiction.batches[1].storage_location == "Bin 6"
assert jurisdiction.batches[1].tabulator == "Tabulator 2"
def test_activate_client(test_client: FlaskClient, admin_headers: dict,
user_password: str):
hash_password = bcrypt.generate_password_hash(user_password)
hash_password = hash_password.decode('utf-8')
user = User(
email='*****@*****.**',
password=hash_password,
role='client',
active=False,
)
session.add(user)
session.commit()
data = {
"email": user.email,
"password": user_password,
}
response = test_client.post('/api/client/v1/login/', json=data)
actual = response.status_code
expected = 400
assert actual == expected
data = {
"active": True,
}
test_client.put(f"/api/admin/v1/users/{user.id}/",
json=data,
headers=admin_headers)
actual = user.active
expected = True
assert actual == expected
data = {
"email": user.email,
"password": user_password,
}
response = test_client.post('/api/client/v1/login/', json=data)
actual = response.status_code
expected = 200
assert actual == expected
def test_sub_pass(client: FlaskClient, calc_url: str) -> None:
# given
x, y = 2, 1
# when (sub)
client.put(calc_url, json={'operator': 'push', 'operand': x})
client.put(calc_url, json={'operator': 'push', 'operand': y})
client.put(calc_url, json={'operator': 'sub'})
# then
response = client.get(calc_url)
assert 200 == response.status_code
response_data = response.get_json()
assert x - y == response_data['result']
def test_add_pass(client: FlaskClient, calc_url: str) -> None:
# given
x, y = 1, 2
# when (add)
client.put(calc_url, json={'operator': 'push', 'operand': x})
client.put(calc_url, json={'operator': 'push', 'operand': y})
client.put(calc_url, json={'operator': 'add'})
# then
# response = authorize(client.get, calc_url, auth_token=auth_token)
response = client.get(calc_url)
assert 200 == response.status_code
response_data = response.get_json()
assert x + y == response_data['result']
def test_update(test_client: FlaskClient, admin_headers: dict,
user_password: str):
hash_password = bcrypt.generate_password_hash(user_password)
hash_password = hash_password.decode('utf-8')
user = User(
email='*****@*****.**',
password=hash_password,
role='admin',
active=True,
)
session.add(user)
session.commit()
data = ({
"email": '*****@*****.**',
"password": f'{user_password}1',
"role": 'client',
})
response = test_client.put(f"/api/admin/v1/users/{user.id}/",
json=data,
headers=admin_headers)
actual = response.json['result']
expected = UserClientSchema().dump(user)
assert actual == expected
def get_dynamic_input_schema(
client: FlaskClient,
endpoint: str,
headers: Optional[Dict[str, str]],
method: str = "post",
) -> List[Dict[str, Any]]:
"""
Retrieve a dynamic data schema associated with a endpoint
"""
method = method.lower()
if method == "post":
r = client.post(f"{API_URI}/{endpoint}",
json={"get_schema": 1},
headers=headers)
else:
r = client.put(f"{API_URI}/{endpoint}",
json={"get_schema": 1},
headers=headers)
assert r.status_code == 200
schema = orjson.loads(r.data.decode("utf-8"))
assert isinstance(schema, list)
for f in schema:
assert isinstance(f, dict)
return schema
def test_cvrs_wrong_audit_type(
client: FlaskClient,
election_id: str,
jurisdiction_ids: List[str],
manifests, # pylint: disable=unused-argument
):
for audit_type in [AuditType.BALLOT_POLLING, AuditType.BATCH_COMPARISON]:
# Hackily change the audit type
election = Election.query.get(election_id)
election.audit_type = audit_type
db_session.add(election)
db_session.commit()
set_logged_in_user(client, UserType.JURISDICTION_ADMIN,
DEFAULT_JA_EMAIL)
rv = client.put(
f"/api/election/{election_id}/jurisdiction/{jurisdiction_ids[0]}/cvrs",
data={"cvrs": (
io.BytesIO(TEST_CVRS.encode()),
"cvrs.csv",
)},
)
assert rv.status_code == 409
assert json.loads(rv.data) == {
"errors": [{
"errorType":
"Conflict",
"message":
"Can only upload CVR file for ballot comparison audits.",
}]
}
def test_cvrs_upload_bad_csv(
client: FlaskClient,
election_id: str,
jurisdiction_ids: List[str],
manifests, # pylint: disable=unused-argument
):
set_logged_in_user(client, UserType.JURISDICTION_ADMIN, DEFAULT_JA_EMAIL)
rv = client.put(
f"/api/election/{election_id}/jurisdiction/{jurisdiction_ids[0]}/cvrs",
data={"cvrs": (io.BytesIO(b"not a CSV file"), "random.txt")},
)
assert_ok(rv)
bgcompute_update_cvr_file()
rv = client.get(
f"/api/election/{election_id}/jurisdiction/{jurisdiction_ids[0]}/cvrs")
compare_json(
json.loads(rv.data),
{
"file": {
"name": "random.txt",
"uploadedAt": assert_is_date,
},
"processing": {
"status": ProcessingStatus.ERRORED,
"startedAt": assert_is_date,
"completedAt": assert_is_date,
"error": "Could not parse CVR file",
},
},
)
def test_update_time_entry_calls_partial_update_with_incoming_payload(
client: FlaskClient,
mocker: MockFixture,
valid_header: dict,
valid_id: str,
owner_id: str,
time_entries_dao,
):
valid_time_entry_input_to_update = valid_time_entry_input.copy()
valid_time_entry_input_to_update["owner_id"] = owner_id
time_entries_dao.repository.partial_update = Mock(return_value={})
time_entries_dao.repository.find = Mock(return_value={})
time_entries_dao.check_whether_current_user_owns_item = Mock()
response = client.put(
f'/time-entries/{valid_id}',
headers=valid_header,
json=valid_time_entry_input_to_update,
follow_redirects=True,
)
assert HTTPStatus.OK == response.status_code
time_entries_dao.repository.partial_update.assert_called_once_with(
valid_id, valid_time_entry_input_to_update, ANY)
time_entries_dao.repository.find.assert_called_once()
time_entries_dao.check_whether_current_user_owns_item.assert_called_once()
def test_update_project_should_reject_bad_request(
client: FlaskClient, mocker: MockFixture, valid_header: dict
):
from time_tracker_api.projects.projects_namespace import project_dao
invalid_project_data = valid_project_data.copy()
invalid_project_data.update(
{
"project_type_id": fake.pyint(min_value=1, max_value=100),
}
)
repository_update_mock = mocker.patch.object(
project_dao.repository, 'partial_update', return_value=fake_project
)
valid_id = fake.random_int(1, 9999)
response = client.put(
"/projects/%s" % valid_id,
headers=valid_header,
json=invalid_project_data,
follow_redirects=True,
)
assert HTTPStatus.BAD_REQUEST == response.status_code
repository_update_mock.assert_not_called()
def test_batch_tallies_before_manifests(
client: FlaskClient,
election_id: str,
jurisdiction_ids: List[str],
contest_ids: List[str], # pylint: disable=unused-argument
):
set_logged_in_user(client, UserType.JURISDICTION_ADMIN, DEFAULT_JA_EMAIL)
rv = client.put(
f"/api/election/{election_id}/jurisdiction/{jurisdiction_ids[0]}/batch-tallies",
data={
"batchTallies": (
io.BytesIO(b"Batch Name,candidate 1,candidate 2,candidate 3\n"
b"Batch 1,300,10,100\n"
b"Batch 2,2,20,200\n"
b"Batch 3,3,30,300\n"),
"batchTallies.csv",
)
},
)
assert rv.status_code == 409
assert json.loads(rv.data) == {
"errors": [{
"errorType":
"Conflict",
"message":
"Must upload ballot manifest before uploading batch tallies.",
}]
}
def test_update_time_entry_raise_not_found(
client: FlaskClient,
mocker: MockFixture,
valid_header: dict,
valid_id: str,
owner_id: str,
time_entries_dao,
):
from werkzeug.exceptions import NotFound
valid_time_entry_input_to_update = valid_time_entry_input.copy()
valid_time_entry_input_to_update["owner_id"] = owner_id
time_entries_dao.repository.partial_update = Mock(side_effect=NotFound)
time_entries_dao.repository.find = Mock(return_value={})
time_entries_dao.check_whether_current_user_owns_item = Mock()
response = client.put(
f'/time-entries/{valid_id}',
headers=valid_header,
json=valid_time_entry_input_to_update,
follow_redirects=True,
)
assert HTTPStatus.NOT_FOUND == response.status_code
time_entries_dao.repository.partial_update.assert_called_once_with(
valid_id, valid_time_entry_input_to_update, ANY)
time_entries_dao.repository.find.assert_called_once()
time_entries_dao.check_whether_current_user_owns_item.assert_called_once()
def test_batch_tallies_bad_jurisdiction(
client: FlaskClient,
election_id: str,
jurisdiction_ids: List[str],
contest_ids: List[str], # pylint: disable=unused-argument
manifests, # pylint: disable=unused-argument
):
set_logged_in_user(client, UserType.JURISDICTION_ADMIN, "*****@*****.**")
rv = client.put(
f"/api/election/{election_id}/jurisdiction/{jurisdiction_ids[2]}/batch-tallies",
data={
"batchTallies": (
io.BytesIO(b"Batch Name,candidate 1,candidate 2,candidate 3\n"
b"Batch 1,300,10,100\n"
b"Batch 2,2,20,200\n"
b"Batch 3,3,30,300\n"),
"batchTallies.csv",
)
},
)
assert rv.status_code == 409
assert json.loads(rv.data) == {
"errors": [{
"errorType":
"Conflict",
"message":
"Jurisdiction does not have any contests assigned",
}]
}
def test_standardized_contests_wrong_audit_type(
client: FlaskClient,
election_id: str,
jurisdiction_ids: List[str], # pylint: disable=unused-argument
):
for audit_type in [AuditType.BALLOT_POLLING, AuditType.BATCH_COMPARISON]:
# Hackily change the audit type
election = Election.query.get(election_id)
election.audit_type = audit_type
db_session.add(election)
db_session.commit()
rv = client.put(
f"/api/election/{election_id}/standardized-contests/file",
data={
"standardized-contests": (
io.BytesIO(b"Contest Name,Jurisdictions\n"
b"Contest 1,all\n"),
"standardized-contests.csv",
)
},
)
assert rv.status_code == 409
assert json.loads(rv.data) == {
"errors": [{
"errorType":
"Conflict",
"message":
"Can only upload standardized contests file for ballot comparison audits.",
}]
}
def test_ballot_manifest_clear(client: FlaskClient, election_id: str,
jurisdiction_ids: List[str]):
set_logged_in_user(client, UserType.JURISDICTION_ADMIN, DEFAULT_JA_EMAIL)
rv = client.put(
f"/api/election/{election_id}/jurisdiction/{jurisdiction_ids[0]}/ballot-manifest",
data={
"manifest": (
io.BytesIO(b"Batch Name,Number of Ballots\n"
b"1,23\n"),
"manifest.csv",
)
},
)
assert_ok(rv)
file_id = Jurisdiction.query.get(jurisdiction_ids[0]).manifest_file_id
bgcompute_update_ballot_manifest_file()
rv = client.delete(
f"/api/election/{election_id}/jurisdiction/{jurisdiction_ids[0]}/ballot-manifest",
)
assert_ok(rv)
rv = client.get(
f"/api/election/{election_id}/jurisdiction/{jurisdiction_ids[0]}/ballot-manifest"
)
assert json.loads(rv.data) == {"file": None, "processing": None}
jurisdiction = Jurisdiction.query.get(jurisdiction_ids[0])
assert jurisdiction.manifest_num_batches is None
assert jurisdiction.manifest_num_ballots is None
assert jurisdiction.batches == []
assert jurisdiction.manifest_file_id is None
assert File.query.get(file_id) is None
def test_update_time_entry_calls_update_last_entry(
client: FlaskClient,
mocker: MockFixture,
valid_header: dict,
valid_id: str,
time_entries_dao,
):
time_entries_dao.repository.partial_update = Mock(return_value={})
time_entries_dao.repository.find = Mock(return_value={})
time_entries_dao.check_whether_current_user_owns_item = Mock()
time_entries_dao.repository.update_last_entry = Mock(return_value={})
update_time_entry = valid_time_entry_input.copy()
update_time_entry['update_last_entry_if_overlap'] = True
response = client.put(
f'/time-entries/{valid_id}',
headers=valid_header,
json=update_time_entry,
follow_redirects=True,
)
assert HTTPStatus.OK == response.status_code
time_entries_dao.repository.partial_update.assert_called_once()
time_entries_dao.repository.find.assert_called_once()
time_entries_dao.check_whether_current_user_owns_item.assert_called_once()
time_entries_dao.repository.update_last_entry.assert_called_once()
def test_ballot_manifest_upload_invalid_num_ballots(
client: FlaskClient, election_id: str, jurisdiction_ids: List[str]
):
set_logged_in_user(client, UserType.JURISDICTION_ADMIN, DEFAULT_JA_EMAIL)
rv = client.put(
f"/api/election/{election_id}/jurisdiction/{jurisdiction_ids[0]}/ballot-manifest",
data={
"manifest": (
io.BytesIO(
b"Batch Name,Number of Ballots,Storage Location,Tabulator\n"
b"1,not a number,Bin 2,Tabulator 1\n"
),
"manifest.csv",
)
},
)
assert_ok(rv)
bgcompute_update_ballot_manifest_file()
rv = client.get(
f"/api/election/{election_id}/jurisdiction/{jurisdiction_ids[0]}/ballot-manifest"
)
compare_json(
json.loads(rv.data),
{
"file": {"name": "manifest.csv", "uploadedAt": assert_is_date,},
"processing": {
"status": ProcessingStatus.ERRORED,
"startedAt": assert_is_date,
"completedAt": assert_is_date,
"error": "Expected a number in column Number of Ballots, row 2. Got: not a number.",
},
},
)
def test_ballot_manifest_upload_bad_csv(client: FlaskClient, election_id: str,
jurisdiction_ids: List[str]):
set_logged_in_user(client, UserType.JURISDICTION_ADMIN, DEFAULT_JA_EMAIL)
rv = client.put(
f"/api/election/{election_id}/jurisdiction/{jurisdiction_ids[0]}/ballot-manifest",
data={"manifest": (io.BytesIO(b"not a CSV file"), "random.txt")},
)
assert_ok(rv)
bgcompute_update_ballot_manifest_file()
rv = client.get(
f"/api/election/{election_id}/jurisdiction/{jurisdiction_ids[0]}/ballot-manifest"
)
compare_json(
json.loads(rv.data),
{
"file": {
"name": "random.txt",
"uploadedAt": assert_is_date,
},
"processing": {
"status":
ProcessingStatus.ERRORED,
"startedAt":
assert_is_date,
"completedAt":
assert_is_date,
"error":
"Please submit a valid CSV file with columns separated by commas.",
},
},
)
def test_batch_tallies_ballot_polling(
client: FlaskClient,
election_id: str,
jurisdiction_ids: List[str],
contest_ids: List[str], # pylint: disable=unused-argument
manifests, # pylint: disable=unused-argument
):
# Hackily change the audit type
election = Election.query.get(election_id)
election.audit_type = AuditType.BALLOT_POLLING
db_session.add(election)
db_session.commit()
set_logged_in_user(client, UserType.JURISDICTION_ADMIN, DEFAULT_JA_EMAIL)
rv = client.put(
f"/api/election/{election_id}/jurisdiction/{jurisdiction_ids[0]}/batch-tallies",
data={
"batchTallies": (
io.BytesIO(b"Batch Name,candidate 1,candidate 2,candidate 3\n"
b"Batch 1,300,10,100\n"
b"Batch 2,2,20,200\n"
b"Batch 3,3,30,300\n"),
"batchTallies.csv",
)
},
)
assert rv.status_code == 409
assert json.loads(rv.data) == {
"errors": [{
"errorType":
"Conflict",
"message":
"Can only upload batch tallies file for batch comparison audits.",
}]
}
def edit_project(self, client: FlaskClient, project_id: int, data: dict,
token: str) -> Response:
query_string = {"token": token}
response = client.put(f"/api/projects/{project_id}",
data=json.dumps(data),
query_string=query_string)
return response
def test_update(test_client: FlaskClient, admin_headers: dict):
first_ingredient, second_ingredient, first_step, second_step = prepare_create_receipt(
)
receipt = Receipt(
name='Name',
description='Cool',
calories=200,
ingredients=[first_ingredient, second_ingredient],
steps=[first_step, second_step],
)
session.add(receipt)
session.commit()
data = ({
"name": 'Name1',
"description": 'Cool1',
"calories": 201,
"ingredients": [second_ingredient.id],
"steps": [first_step],
})
response = test_client.put(f"/api/admin/v1/receipts/{receipt.id}/",
json=data,
headers=admin_headers)
actual = response.json['result']
expected = ReceiptClientSchema().dump(receipt)
assert actual == expected
def cvrs(
client: FlaskClient,
election_id: str,
jurisdiction_ids: List[str],
manifests, # pylint: disable=unused-argument
):
j1_cvr_lines = [
f"TABULATOR{tabulator},BATCH{batch},{ballot},{tabulator}-{batch}-{ballot},x,x,1,0,0,1,0"
for tabulator in range(1, 3) for batch in range(1, 5)
for ballot in range(1, 21)
]
j1_cvr = """Test Audit CVR Upload,5.2.16.1,,,,,,,,,,
,,,,,,,Contest 1 (Vote For=1),Contest 1 (Vote For=1),Contest 2 (Vote For=2),Contest 2 (Vote For=2),Contest 2 (Vote For=2)
,,,,,,,Choice 1-1,Choice 1-2,Choice 2-1,Choice 2-2,Choice 2-3
CvrNumber,TabulatorNum,BatchId,RecordId,ImprintedId,PrecinctPortion,BallotType,REP,DEM,LBR,IND,,
""" + "\n".join([f"{i},{line}" for i, line in enumerate(j1_cvr_lines)])
set_logged_in_user(client, UserType.JURISDICTION_ADMIN, DEFAULT_JA_EMAIL)
rv = client.put(
f"/api/election/{election_id}/jurisdiction/{jurisdiction_ids[0]}/cvrs",
data={"cvrs": (
io.BytesIO(j1_cvr.encode()),
"cvrs.csv",
)},
)
assert_ok(rv)
j2_cvr_lines = [
f"TABULATOR{tabulator},BATCH{batch},{ballot},{tabulator}-{batch}-{ballot},x,x,0,0,0,0,0"
for tabulator in range(1, 3) for batch in range(1, 3)
for ballot in range(1, 51)
]
j2_cvr = """Test Audit CVR Upload,5.2.16.1,,,,,,,,,,
,,,,,,,Contest 1 (Vote For=1),Contest 1 (Vote For=1),Contest 2 (Vote For=2),Contest 2 (Vote For=2),Contest 2 (Vote For=2)
,,,,,,,Choice 1-1,Choice 1-2,Choice 2-1,Choice 2-2,Choice 2-3
CvrNumber,TabulatorNum,BatchId,RecordId,ImprintedId,PrecinctPortion,BallotType,REP,DEM,LBR,IND,,
""" + "\n".join([f"{i},{line}" for i, line in enumerate(j2_cvr_lines)])
rv = client.put(
f"/api/election/{election_id}/jurisdiction/{jurisdiction_ids[1]}/cvrs",
data={"cvrs": (
io.BytesIO(j2_cvr.encode()),
"cvrs.csv",
)},
)
assert_ok(rv)
bgcompute_update_cvr_file()
def test_standardized_contests_replace(client: FlaskClient, election_id: str,
jurisdiction_ids: List[str]):
rv = client.put(
f"/api/election/{election_id}/standardized-contests/file",
data={
"standardized-contests": (
io.BytesIO(b"Contest Name,Jurisdictions\n"
b"Contest 1,all\n"
b'Contest 2,"J1, J3"\n'
b"Contest 3,J2 \n"),
"standardized-contests.csv",
)
},
)
assert_ok(rv)
file_id = Election.query.get(election_id).standardized_contests_file_id
bgcompute_update_standardized_contests_file()
rv = client.put(
f"/api/election/{election_id}/standardized-contests/file",
data={
"standardized-contests": (
io.BytesIO(b"Contest Name,Jurisdictions\n"
b"Contest 4,all\n"),
"standardized-contests.csv",
)
},
)
assert_ok(rv)
# The old file should have been deleted
assert File.query.get(file_id) is None
assert Election.query.get(
election_id).standardized_contests_file_id != file_id
assert Election.query.get(election_id).standardized_contests is None
bgcompute_update_standardized_contests_file()
rv = client.get(f"/api/election/{election_id}/standardized-contests")
assert json.loads(rv.data) == [
{
"name": "Contest 4",
"jurisdictionIds": jurisdiction_ids
},
]
def test_update_dataobj(test_app, client: FlaskClient, note_fixture):
lorem = "Updated note content"
resp = client.put("/api/dataobjs/1", json={"content": lorem})
assert resp.status_code == 200
resp = client.get("/api/dataobjs/1")
assert resp.json["content"] == lorem
def test_bad_operator_fail(client: FlaskClient, calc_url: str) -> None:
# given
# when (bad operator)
response = client.put(calc_url, json={'operator': 'bad_oper'})
# then
assert 404 == response.status_code
def test_group_venues(client: FlaskClient):
"""
check if group venues was set right
Arguments:
client {FlaskClient} -- client to access flask web ressource
"""
# add one group without event
groups_1: List[Group] = create_groups(search_query="v",
valid_groups=True,
amount=1)
# test with one group without events
response_1: JSONResponse = client.put(url_for("meetupsearchapi"),
data=generate_search_dict(query="v"))
assert response_1.status_code == 200
assert len(response_1.json["results"][0]["venues"]) == 0
assert isinstance(response_1, JSONResponse)
# add mutile events without venue
create_events_to_group(search_query="b",
valid_events=True,
group=groups_1[0],
amount=10,
venue=False)
# test with one group with events without venues
response_2: JSONResponse = client.put(url_for("meetupsearchapi"),
data=generate_search_dict(query="v"))
assert response_2.status_code == 200
assert len(response_2.json["results"][0]["venues"]) == 0
assert isinstance(response_2, JSONResponse)
# add mutile events with venues
create_events_to_group(search_query="b",
valid_events=True,
group=groups_1[0],
amount=10,
venue=True)
# test with one group with events with venues
response_3: JSONResponse = client.put(url_for("meetupsearchapi"),
data=generate_search_dict(query="v"))
assert response_3.status_code == 200
assert len(response_3.json["results"][0]["venues"]) == 10
assert isinstance(response_3, JSONResponse)
