def do_test(): #pylint: disable=missing-docstring
# initialize
init_webapp(webapp, webdriver, vlog_persistence=1, lfa_persistence=1)
# analyze the log file
_analyze_vlogs("download-test.vlog")
# download the data
marker = set_stored_msg_marker("_lfa-download_")
find_child("#lfa button.download").click()
wait_for(2, lambda: get_stored_msg("_lfa-download_") != marker)
data = get_stored_msg("_lfa-download_")
# check the results
data = data.split("\n")
rows = list(csv.reader(data, quoting=csv.QUOTE_NONNUMERIC))
assert rows == [[
"Log file", "Phase", "Player", "Type", "Die 1", "Die 2"
], ["download-test.vlog", "", 'Joey "The Lips" Blow', "IFT", 4, 1],
["", "", 'Joey "The Lips" Blow', "IFT", 2, 5],
["", "", 'Joey "The Lips" Blow', "RS", 2, ""],
["", "UN 1 PFPh", "\u65e5\u672c Guy", "IFT", 4, 6],
["", "", "\u65e5\u672c Guy", "IFT", 2, 6],
["", "", "\u65e5\u672c Guy", "RS", 3, ""],
["", "UN 1 MPh", 'Joey "The Lips" Blow', "IFT", 2, 6],
["", "", 'Joey "The Lips" Blow', "IFT", 2, 3],
["", "", 'Joey "The Lips" Blow', "RS", 3, ""]]
def do_test(): #pylint: disable=missing-docstring
# initialize
init_webapp(webapp, webdriver, vlog_persistence=1, lfa_persistence=1)
# analyze the log file
_analyze_vlogs("custom-labels.vlog")
# download the data
marker = set_stored_msg_marker("_lfa-download_")
find_child("#lfa button.download").click()
wait_for(2, lambda: get_stored_msg("_lfa-download_") != marker)
data = get_stored_msg("_lfa-download_")
# check the results
data = data.split("\n")
rows = list(csv.reader(data, quoting=csv.QUOTE_NONNUMERIC))
assert rows == [[
"Log file", "Phase", "Player", "Type", "Die 1", "Die 2"
], ["custom-labels.vlog", "", "test", "Other", 5, 3],
["", "", "test", "Other", 3, ""],
["", "Custom Label 1", "test", "Other", 6, 6],
["", "", "test", "RS", 6, ""],
["", "Axis 1 PFPh", "test", "Other", 4, 4],
["", "", "test", "RS", 6, ""],
["", "Custom label 2", "test", "Other", 2, 1],
["", "", "test", "RS", 1, ""]]
def save_scenario():
"""Save the scenario."""
marker = set_stored_msg_marker("_scenario-persistence_")
select_menu_option("save_scenario")
wait_for(2, lambda: get_stored_msg("_scenario-persistence_") != marker)
data = get_stored_msg("_scenario-persistence_")
return json.loads(data)
def _test_snippet(btn, params, expected, expected2):
"""Do a single test."""
# set the template parameters and generate the snippet
set_template_params(params)
marker = set_stored_msg_marker("_last-warning_")
btn.click()
def reformat(clipboard): #pylint: disable=missing-docstring
lines = [l.strip() for l in clipboard.split("\n")]
return " | ".join(l for l in lines if l)
wait_for_clipboard(2, expected, transform=reformat)
# check warnings for mandatory parameters
last_warning = get_stored_msg("_last-warning_")
if isinstance(expected2, list):
# check for mandatory parameters
param_names = ["scenario name", "scenario location", "scenario date"]
for pname in param_names:
if pname in expected2:
assert pname in last_warning
else:
assert pname not in last_warning
elif isinstance(expected2, str):
# check for a specific error message
assert expected2 == last_warning
else:
# make sure there was no warning message
assert expected2 is None
assert last_warning == marker
def do_check_snippets( btn, date, expected, warning ):
"""Check that snippets are being generated correctly."""
# change the scenario date, check that the button is displayed correctly
set_scenario_date( "{:02}/01/{:04}".format( date[1], date[0] ) )
select_tab( "ob1" )
classes = btn.get_attribute( "class" )
classes = classes.split() if classes else []
if warning:
assert "inactive" in classes
else:
assert "inactive" not in classes
# test snippet generation
marker = set_stored_msg_marker( "_last-warning_" )
btn.click()
wait_for_clipboard( 2, expected )
# check if a warning was issued
last_warning = get_stored_msg( "_last-warning_" )
if warning:
assert "are only available" in last_warning
expected_image_url = "snippet-disabled.png"
else:
assert last_warning == marker
expected_image_url = "snippet.png"
wait_for( 2,
lambda: expected_image_url in find_child( "img", btn ).get_attribute( "src" )
)
def _update_vsav(fname, expected):
"""Update a VASL scenario."""
# read the VSAV data
with open(fname, "rb") as fp:
vsav_data = fp.read()
# send the VSAV data to the front-end to be updated
set_stored_msg("_vsav-persistence_",
base64.b64encode(vsav_data).decode("utf-8"))
_ = set_stored_msg_marker("_last-info_")
_ = set_stored_msg_marker("_last-warning_")
select_menu_option("update_vsav")
# wait for the front-end to receive the data
def check_response():
# NOTE: If something is misconfigured, the error response can get stored in the persistence buffer
# really quickly i.e. before we get a chance to detect it here being cleared first.
resp = get_stored_msg("_vsav-persistence_")
return resp == "" or resp.startswith("ERROR:")
wait_for(2, check_response)
# wait for the updated data to come back
timeout = 120 if os.name == "nt" else 60
wait_for(timeout, lambda: get_stored_msg("_vsav-persistence_") != "")
updated_vsav_data = get_stored_msg("_vsav-persistence_")
if updated_vsav_data.startswith("ERROR: "):
raise RuntimeError(updated_vsav_data)
updated_vsav_data = base64.b64decode(updated_vsav_data)
# parse the VASSAL shim report
if expected:
report = {}
msg = get_stored_msg("_last-warning_" if "deleted" in
expected else "_last-info_")
assert "The VASL scenario was updated:" in msg
for mo2 in re.finditer("<li>([^<]+)", msg):
mo3 = re.search(r"^(\d+) labels? (were|was) ([a-z]+)",
mo2.group(1))
report[mo3.group(3)] = int(mo3.group(1))
assert report == expected
else:
assert "No changes were made" in get_stored_msg("_last-info_")
return updated_vsav_data
def _do_upload_template_pack(data, error_expected):
"""Upload a template pack."""
# upload the template pack
set_stored_msg("_template-pack-persistence_", data)
info_marker = set_stored_msg_marker("_last-info_")
error_marker = set_stored_msg_marker("_last-error_")
select_menu_option("template_pack")
# wait for the front-end to finish
if error_expected:
func = lambda: get_stored_msg("_last-error_") != error_marker
else:
func = lambda: "was loaded" in get_stored_msg("_last-info_")
wait_for(2, func)
return info_marker, error_marker
def load_scenario(scenario, webdriver=None):
"""Load a scenario into the UI."""
set_stored_msg("_scenario-persistence_", json.dumps(scenario), webdriver)
_ = set_stored_msg_marker("_last-info_", webdriver)
select_menu_option("load_scenario", webdriver)
wait_for(
2, lambda: get_stored_msg("_last-info_", webdriver) ==
"The scenario was loaded.")
def test_invalid_vo_image_ids( webapp, webdriver ):
"""Test loading scenarios that contain invalid V/O image ID's."""
# initialize
init_webapp( webapp, webdriver, scenario_persistence=1 )
# test each save file
dname = os.path.join( os.path.split(__file__)[0], "fixtures/invalid-vo-image-ids" )
for root,_,fnames in os.walk(dname):
for fname in fnames:
fname = os.path.join( root, fname )
if os.path.splitext( fname )[1] != ".json":
continue
# load the next scenario, make sure a warning was issued for the V/O image ID
with open( fname, "r", encoding="utf-8" ) as fp:
data = json.load( fp )
set_stored_msg_marker( "_last-warning_" )
load_scenario( data )
last_warning = get_stored_msg( "_last-warning_" )
assert "Invalid V/O image ID" in last_warning
def analyze_vsav(fname, expected_ob1, expected_ob2, expected_report):
"""Analyze a VASL scenario."""
# read the VSAV data
fname = os.path.join(
os.path.split(__file__)[0], "fixtures/analyze-vsav/" + fname)
with open(fname, "rb") as fp:
vsav_data = fp.read()
# send the VSAV data to the front-end to be analyzed
set_stored_msg("_vsav-persistence_",
base64.b64encode(vsav_data).decode("utf-8"))
prev_info_msg = set_stored_msg_marker("_last-info_")
set_stored_msg_marker("_last-warning_")
select_menu_option("analyze_vsav")
# wait for the analysis to finish
wait_for(2, lambda: find_child("#please-wait").is_displayed())
wait_for(60, lambda: not find_child("#please-wait").is_displayed())
# check the results
saved_scenario = save_scenario()
def get_ids(key): #pylint: disable=missing-docstring
return set(
(v["id"], v.get("image_id")) for v in saved_scenario.get(key, []))
def adjust_expected(vals): #pylint: disable=missing-docstring
return set(v if isinstance(v, tuple) else (v, None) for v in vals)
assert get_ids("OB_VEHICLES_1") == adjust_expected(expected_ob1[0])
assert get_ids("OB_ORDNANCE_1") == adjust_expected(expected_ob1[1])
assert get_ids("OB_VEHICLES_2") == adjust_expected(expected_ob2[0])
assert get_ids("OB_ORDNANCE_2") == adjust_expected(expected_ob2[1])
# check the report
msg = get_stored_msg("_last-info_")
if msg == prev_info_msg:
msg = get_stored_msg("_last-warning_")
assert all(e in msg for e in expected_report)
def do_test(tab_id, param):
"""Test checking for a dirty scenario."""
# change the specified field
check_is_dirty(False)
select_tab(tab_id)
state = change_field(param)
check_is_dirty(True)
# make sure we get asked to confirm a "new scenario" operation
select_menu_option("new_scenario")
wait_for(2, lambda: find_child("#ask") is not None)
elem = find_child("#ask")
assert "This scenario has been changed" in elem.text
# cancel the confirmation request, make sure the change we made is still there
click_dialog_button("Cancel")
select_tab(tab_id)
check_field(param, state)
check_is_dirty(True)
# revert the change
revert_field(param, state)
check_is_dirty(False)
# we should now be able to reset the scenario without a confirmation
_ = set_stored_msg_marker("_last-info_")
select_menu_option("new_scenario")
wait_for(
2,
lambda: get_stored_msg("_last-info_") == "The scenario was reset.")
# change the field again
select_tab(tab_id)
state = change_field(param)
check_is_dirty(True)
# make sure we get asked to confirm a "load scenario" operation
select_menu_option("load_scenario")
wait_for(2, lambda: find_child("#ask") is not None)
elem = find_child("#ask")
assert "This scenario has been changed" in elem.text
# cancel the confirmation request, make sure the change we made is still there
click_dialog_button("Cancel")
select_tab(tab_id)
check_field(param, state)
check_is_dirty(True)
# revert the change
revert_field(param, state)
check_is_dirty(False)
def test_unknown_vo(webapp, webdriver):
"""Test detection of unknown vehicles/ordnance."""
# initialize
init_webapp(webapp, webdriver, scenario_persistence=1)
# load a scenario that has unknown vehicles/ordnance
SCENARIO_PARAMS = {
"PLAYER_1":
"german",
"OB_VEHICLES_1": [
{
"name": "unknown vehicle 1a"
},
{
"name": "unknown vehicle 1b"
},
],
"OB_ORDNANCE_1": [
{
"name": "unknown ordnance 1a"
},
{
"name": "unknown ordnance 1b"
},
],
"PLAYER_2":
"russian",
"OB_VEHICLES_2": [{
"name": "unknown vehicle 2"
}],
"OB_ORDNANCE_2": [{
"name": "unknown ordnance 2"
}],
}
_ = set_stored_msg_marker("_last-warning_")
load_scenario(SCENARIO_PARAMS)
last_warning = get_stored_msg("_last-warning_")
assert last_warning.startswith("Unknown vehicles/ordnance:")
for key, vals in SCENARIO_PARAMS.items():
if not key.startswith(("OB_VEHICLES_", "OB_ORDNANCE_")):
continue
assert all(v["name"] in last_warning for v in vals)
def test_scenario_persistence(webapp, webdriver): #pylint: disable=too-many-statements,too-many-locals,too-many-branches
"""Test loading/saving scenarios."""
# initialize
init_webapp(webapp, webdriver, scenario_persistence=1)
def check_ob_tabs(*args):
"""Check that the OB tabs have been set correctly."""
for player_no in [1, 2]:
elem = find_child(
"#tabs .ui-tabs-nav a[href='#tabs-ob{}']".format(player_no))
nat = args[player_no - 1]
assert elem.text.strip() == "{} OB".format(
get_nationality_display_name(nat))
def check_window_title(expected):
"""Check the window title."""
if expected:
expected = "{} - {}".format(APP_NAME, expected)
else:
expected = APP_NAME
assert webdriver.title == expected
# load the scenario fields
SCENARIO_PARAMS = {
"scenario": {
"SCENARIO_NAME":
"my test scenario",
"SCENARIO_ID":
"xyz123",
"SCENARIO_LOCATION":
"right here",
"SCENARIO_THEATER":
"PTO",
"SCENARIO_DATE":
"12/31/1945",
"SCENARIO_WIDTH":
"101",
"ASA_ID":
"",
"ROAR_ID":
"",
"PLAYER_1":
"russian",
"PLAYER_1_ELR":
"1",
"PLAYER_1_SAN":
"2",
"PLAYER_1_DESCRIPTION":
"The Army of Player 1",
"PLAYER_2":
"german",
"PLAYER_2_ELR":
"3",
"PLAYER_2_SAN":
"4",
"PLAYER_2_DESCRIPTION":
"The Army of Player 2",
"PLAYERS_WIDTH":
"42",
"VICTORY_CONDITIONS":
"just do it!",
"VICTORY_CONDITIONS_WIDTH":
"102",
"SCENARIO_NOTES": [{
"caption": "note #1",
"width": ""
}, {
"caption": "note #2",
"width": "100px"
}],
"SSR": ["This is an SSR.", "This is another SSR."],
"SSR_WIDTH":
"103",
},
"ob1": {
"OB_SETUPS_1": [{
"caption": "ob setup 1a",
"width": ""
}, {
"caption": "ob setup 1b",
"width": "200px"
}],
"OB_NOTES_1": [{
"caption": "ob note 1a",
"width": "10em"
}, {
"caption": "ob note 1b",
"width": ""
}],
"OB_VEHICLES_1": ["a russian vehicle", "another russian vehicle"],
"OB_VEHICLES_WIDTH_1":
"202",
"OB_VEHICLES_MA_NOTES_WIDTH_1":
"203",
"OB_ORDNANCE_1":
["a russian ordnance", "another russian ordnance"],
"OB_ORDNANCE_WIDTH_1":
"204",
"OB_ORDNANCE_MA_NOTES_WIDTH_1":
"205",
},
"ob2": {
"OB_SETUPS_2": [{
"caption": "ob setup 2",
"width": ""
}],
"OB_NOTES_2": [{
"caption": "ob note 2",
"width": ""
}],
"OB_VEHICLES_2": ["a german vehicle"],
"OB_VEHICLES_WIDTH_2": "302",
"OB_VEHICLES_MA_NOTES_WIDTH_2": "303",
"OB_ORDNANCE_2": ["a german ordnance"],
"OB_ORDNANCE_WIDTH_2": "304",
"OB_ORDNANCE_MA_NOTES_WIDTH_2": "305",
},
}
load_scenario_params(SCENARIO_PARAMS)
check_window_title("my test scenario (xyz123) (*)")
check_ob_tabs("russian", "german")
assert_scenario_params_complete(SCENARIO_PARAMS, True)
# save the scenario and check the results
saved_scenario = save_scenario()
assert saved_scenario["_app_version"] == APP_VERSION
scenario_creation_time = saved_scenario["_creation_time"]
assert saved_scenario["_last_update_time"] == scenario_creation_time
expected = {
k: v
for tab in SCENARIO_PARAMS.values() for k, v in tab.items()
}
mo = re.search(r"^(\d{2})/(\d{2})/(\d{4})$", expected["SCENARIO_DATE"])
expected["SCENARIO_DATE"] = "{}-{}-{}".format(
mo.group(3), mo.group(1), mo.group(2)) # nb: convert from ISO-8601
saved_scenario2 = {
k: v
for k, v in saved_scenario.items() if not k.startswith("_")
}
for key in saved_scenario2:
if re.search(r"^OB_(VEHICLES|ORDNANCE)_\d$", key):
for vo_entry in saved_scenario2[key]:
del vo_entry["id"]
for key in expected:
if re.search(r"^OB_(VEHICLES|ORDNANCE)_\d$", key):
expected[key] = [{"name": name} for name in expected[key]]
for player_no in (1, 2):
for vo_type in ("OB_SETUPS", "OB_NOTES"):
entries = expected["{}_{}".format(vo_type, player_no)]
for i, entry in enumerate(entries):
entry["id"] = 1 + i
for vo_type in ("OB_VEHICLES", "OB_ORDNANCE"):
entries = expected["{}_{}".format(vo_type, player_no)]
for i, entry in enumerate(entries):
entry["seq_id"] = 1 + i
for i, entry in enumerate(expected["SCENARIO_NOTES"]):
entry["id"] = 1 + i
assert saved_scenario2 == expected
# make sure that our list of scenario parameters is correct
lhs = set(saved_scenario2.keys())
rhs = set(itertools.chain(*ALL_SCENARIO_PARAMS.values()))
assert lhs == rhs
# reset the scenario and check the save results
_ = set_stored_msg_marker("_last-info_")
select_menu_option("new_scenario")
wait_for(
2, lambda: get_stored_msg("_last-info_") == "The scenario was reset.")
check_window_title("")
check_ob_tabs("german", "russian")
data = save_scenario()
assert data["_app_version"] == APP_VERSION
assert data["_last_update_time"] == data["_creation_time"]
assert data["_creation_time"] > scenario_creation_time
data2 = {k: v for k, v in data.items() if not k.startswith("_") and v}
assert data2 == {
"SCENARIO_THEATER": "ETO",
"PLAYER_1": "german",
"OB_VEHICLES_MA_NOTES_WIDTH_1": "300px",
"OB_ORDNANCE_MA_NOTES_WIDTH_1": "300px",
"PLAYER_2": "russian",
"OB_VEHICLES_MA_NOTES_WIDTH_2": "300px",
"OB_ORDNANCE_MA_NOTES_WIDTH_2": "300px",
}
# initialize
ssrs = find_child("#ssr-sortable")
ob_setups1, ob_notes1 = find_child("#ob_setups-sortable_1"), find_child(
"#ob_notes-sortable_1")
ob_setups2, ob_notes2 = find_child("#ob_setups-sortable_2"), find_child(
"#ob_notes-sortable_2")
vehicles1, ordnance1 = find_child("#ob_vehicles-sortable_1"), find_child(
"#ob_ordnance-sortable_1")
vehicles2, ordnance2 = find_child("#ob_vehicles-sortable_2"), find_child(
"#ob_ordnance-sortable_2")
elems = {
c.get_attribute("name"): c
for elem_type in ("input", "textarea", "select")
for c in find_children(elem_type)
}
# load a scenario and make sure it was loaded into the UI correctly
load_scenario(saved_scenario)
check_window_title("my test scenario (xyz123)")
check_ob_tabs("russian", "german")
for tab_id, params in SCENARIO_PARAMS.items():
select_tab(tab_id)
for field, val in params.items():
if field in ("SCENARIO_NOTES", "SSR"):
continue # nb: these require special handling, we do it below
if field in ("OB_SETUPS_1", "OB_SETUPS_2", "OB_NOTES_1",
"OB_NOTES_2"):
continue # nb: these require special handling, we do it below
if field in ("OB_VEHICLES_1", "OB_ORDNANCE_1", "OB_VEHICLES_2",
"OB_ORDNANCE_2"):
continue # nb: these require special handling, we do it below
elem = elems[field]
if elem.tag_name == "select":
assert Select(elem).first_selected_option.get_attribute(
"value") == val
else:
assert elem.get_attribute("value") == val
select_tab("scenario")
scenario_notes = [
c.text for c in find_children("#scenario_notes-sortable li")
]
assert scenario_notes == [
sn["caption"] for sn in SCENARIO_PARAMS["scenario"]["SCENARIO_NOTES"]
]
assert get_sortable_entry_text(ssrs) == SCENARIO_PARAMS["scenario"]["SSR"]
select_tab("ob1")
assert get_sortable_entry_text(ob_setups1) == [
obs["caption"] for obs in SCENARIO_PARAMS["ob1"]["OB_SETUPS_1"]
]
assert get_sortable_entry_text(ob_notes1) == [
obs["caption"] for obs in SCENARIO_PARAMS["ob1"]["OB_NOTES_1"]
]
# NOTE: We deleted the "id" fields above, so we rely on the legacy handling of loading by name :-/
assert get_sortable_vo_names(
vehicles1) == SCENARIO_PARAMS["ob1"]["OB_VEHICLES_1"]
assert get_sortable_vo_names(
ordnance1) == SCENARIO_PARAMS["ob1"]["OB_ORDNANCE_1"]
select_tab("ob2")
assert get_sortable_entry_text(ob_setups2) == [
obs["caption"] for obs in SCENARIO_PARAMS["ob2"]["OB_SETUPS_2"]
]
assert get_sortable_entry_text(ob_notes2) == [
obs["caption"] for obs in SCENARIO_PARAMS["ob2"]["OB_NOTES_2"]
]
assert get_sortable_vo_names(
vehicles2) == SCENARIO_PARAMS["ob2"]["OB_VEHICLES_2"]
assert get_sortable_vo_names(
ordnance2) == SCENARIO_PARAMS["ob2"]["OB_ORDNANCE_2"]
# save the scenario, make sure the timestamps are correct
data = save_scenario()
assert data["_creation_time"] == scenario_creation_time
assert data["_last_update_time"] > scenario_creation_time
