def test_scenario_notes_snippets(webapp, webdriver): """Test HTML snippet generation.""" # initialize init_webapp(webapp, webdriver) select_tab("scenario") sortable = find_child("#scenario_notes-sortable") add_simple_note(sortable, "scenario <i>note</i> #1", None) add_simple_note(sortable, "scenario note #2", "100px") assert generate_sortable_entry_snippet( sortable, 0) == adjust_html("[scenario <i>note</i> #1]") assert generate_sortable_entry_snippet( sortable, 1) == "[scenario note #2] (width=[100px])" # delete a scenario note by dragging it into the trash assert get_sortable_entry_count(sortable) == 2 drag_sortable_entry_to_trash(sortable, 0) assert get_sortable_entry_count(sortable) == 1 # delete scenario note by emptying its caption edit_simple_note(sortable, 0, "", None) assert get_sortable_entry_count(sortable) == 0 # add a scenario note with non-English content and HTML special characters sortable = find_child("#scenario_notes-sortable") add_simple_note(sortable, "japan <\u65e5\u672c>", None) assert generate_sortable_entry_snippet(sortable, 0) == "[japan <\u65e5\u672c>]"
def _generate_snippet(webdriver, template_id, orig_template_id): """Generate a snippet for the specified template.""" if template_id == "scenario_note": # create a scenario note and generate a snippet for it sortable = find_child("#scenario_notes-sortable") add_simple_note(sortable, "test scenario note", None) elems = find_children("li img.snippet", sortable) elem = elems[0] elif template_id in ("ob_setup", "ob_note"): # create a OB setup/note and generate a snippet for it select_tab("ob1") sortable = find_child("#{}s-sortable_1".format(template_id)) add_simple_note(sortable, "test {}".format(template_id), None) elems = find_children( "#{}s-sortable_1 li img.snippet".format(template_id)) elem = elems[0] elif template_id in ("ob_vehicle_note", "ob_ordnance_note"): # create a vehicle/ordnance and generate a snippet for its note mo = re.search(r"^ob_([a-z]+)_note_(\d)$", orig_template_id) vo_type, player_no = mo.group(1), int(mo.group(2)) vo_type0 = "vehicles" if vo_type == "vehicle" else vo_type player_nat = "german" if player_no == 1 else "russian" sortable = find_child("#ob_{}-sortable_{}".format(vo_type0, player_no)) add_vo(webdriver, vo_type0, player_no, "a {} {}".format(player_nat, vo_type)) elems = find_children("li img.snippet", sortable) elem = elems[0] else: # generate a snippet for the specified template elem = find_child( "button.generate[data-id='{}']".format(orig_template_id)) elem.click() return elem
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 test_players_snippets(webapp, webdriver): """Test HTML snippet generation.""" # initialize init_webapp(webapp, webdriver) select_tab("scenario") btn = find_child("button.generate[data-id='players']") # generate a PLAYERS snippet _test_snippet( btn, { "PLAYER_1": "french", "PLAYER_1_ELR": "1", "PLAYER_1_SAN": "2", "PLAYER_1_DESCRIPTION": "Froggy Army", "PLAYER_2": "british", "PLAYER_2_ELR": "3", "PLAYER_2_SAN": "4", "PLAYER_2_DESCRIPTION": "Barmy Army", }, "player1=[french:French] ; ELR=[1] ; SAN=[2] ; description=[Froggy Army]" \ " | player2=[british:British] ; ELR=[3] ; SAN=[4] ; description=[Barmy Army]", None ) # generate a PLAYERS snippet with both players the same nationality _test_snippet( btn, { "PLAYER_1": "british", }, "player1=[british:British] ; ELR=[1] ; SAN=[2] ; description=[]" \ " | player2=[british:British] ; ELR=[3] ; SAN=[4] ; description=[Barmy Army]", [ "Both players have the same nationality!" ], )
def test_loading_ssrs(webapp, webdriver): """Test loading SSR's.""" # initialize init_webapp(webapp, webdriver, scenario_persistence=1) # initialize select_tab("scenario") sortable = find_child("#ssr-sortable") def do_test(ssrs): # pylint: disable=missing-docstring load_scenario({"SSR": ssrs}) assert get_sortable_entry_text(sortable) == ssrs # load a scenario that has SSR's into a UI with no SSR's do_test(["ssr 1", "ssr 2"]) # load a scenario that has more SSR's than are currently in the UI do_test(["ssr 5", "ssr 6", "ssr 7", "ssr 8"]) # load a scenario that has fewer SSR's than are currently in the UI do_test(["ssr 10", "ssr 11"]) # load a scenario that has no SSR's into a UI that has SSR's do_test([])
def _test_comments(nat, vo_type, vo_name, vals): """Generate and check comments for a series of dates.""" # load the specified vehicle/ordnance new_scenario() load_scenario({ "PLAYER_1": nat, "OB_{}_1".format(vo_type.upper()): [{ "name": vo_name }] }) # check the generated comments for each specified date for date, expected in vals: set_scenario_date(date) select_tab("ob1") btn = find_child("button[data-id='ob_{}_1']".format(vo_type)) btn.click() if expected.startswith("!"): expected, contains = expected[1:].strip(), False else: contains = True wait_for_clipboard(2, expected, transform=_extract_comments, contains=contains)
def _set_width( vo_type, player_no, width ): """Set the snippet width.""" select_tab( "ob{}".format( player_no ) ) elem = find_child( "input[name='OB_{}_WIDTH_{}']".format( vo_type.upper(), player_no ) ) elem.clear() if width is not None: elem.send_keys( str(width) ) _width[ (vo_type,player_no) ] = width
def test_duplicate_vo_entries( webapp, webdriver ): """Test adding duplicate vehicles/ordnance.""" # initialize init_webapp( webapp, webdriver ) set_player( 1, "german" ) select_tab( "ob1" ) def get_available_vo_entries(): """Get the available vehicles/ordnance for selection.""" entries = find_children( "#select-vo .select2-results li" ) return [ e.text for e in entries ] def do_test( vo_type, vo_name ): #pylint: disable=missing-docstring # start to add a vehicle/ordnance add_btn = find_child( "#ob_" + vo_type + "-add_1" ) add_btn.click() assert vo_name in get_available_vo_entries() # add the vehicle/ordnance elem = find_child( ".ui-dialog .select2-search__field" ) elem.send_keys( vo_name ) elem.send_keys( Keys.RETURN ) # make sure it was added to the player's OB sortable = find_child( "#ob_" + vo_type + "-sortable_1" ) assert get_sortable_vo_names( sortable ) == [ vo_name ] # add the vehicle/ordnance, dismiss the warning add_btn.click() elem = find_child( ".ui-dialog .select2-search__field" ) elem.send_keys( vo_name ) elem.send_keys( Keys.RETURN ) elem = find_child( "#ask" ) assert "already in the OB" in elem.text click_dialog_button( "Cancel", find_child(".ui-dialog.ask") ) click_dialog_button( "Cancel" ) # make sure the player's OB is unchanged assert get_sortable_vo_names( sortable ) == [ vo_name ] # add the vehicle/ordnance, accept the warning add_btn.click() elem = find_child( ".ui-dialog .select2-search__field" ) elem.send_keys( vo_name ) elem.send_keys( Keys.RETURN ) elem = find_child( "#ask" ) assert "already in the OB" in elem.text click_dialog_button( "OK", find_child(".ui-dialog.ask") ) # make sure the vehicle/ordnance was added to the player's OB assert get_sortable_vo_names( sortable ) == [ vo_name, vo_name ] # do the test do_test( "vehicles", "a german vehicle" ) do_test( "ordnance", "name only" )
def test_online_images(webapp, webdriver): """Test using online images in VASL scenarios.""" # initialize webapp.control_tests \ .set_data_dir( "{REAL}" ) \ .set_vasl_version( "random", None ) init_webapp(webapp, webdriver, scenario_persistence=1) # load the test scenario load_scenario({ "PLAYER_1": "german", "OB_VEHICLES_1": [{ "name": "PzKpfw IVH" }], }) # configure the user settings set_user_settings({ "include-flags-in-snippets": True, "custom-list-bullets": True, "include-vasl-images-in-snippets": True, }) def do_test(snippet_id, expected1, expected2): #pylint: disable=missing-docstring # generate the snippet with online images enabled set_user_settings( {"scenario-images-source": SCENARIO_IMAGES_SOURCE_INTERNET}) btn = find_child("button[data-id='{}']".format(snippet_id)) btn.click() wait_for_clipboard(2, expected1) # generate the snippet with online images disabled set_user_settings( {"scenario-images-source": SCENARIO_IMAGES_SOURCE_THIS_PROGRAM}) btn.click() wait_for_clipboard(2, expected2) # test player flags do_test( "players", re.compile( r'<img src="http://vasl-templates.org/.+/flags/german.png"'), re.compile(r'<img src="http://[a-z0-9.]+:\d+/flags/german"')) # test custom list bullets do_test("ssr", re.compile(r'url\("http://vasl-templates.org/.+/bullet.png"\)'), re.compile(r'url\("http://[a-z0-9.]+:\d+/.+/bullet.png"\)')) # test VASL counter images select_tab("ob1") do_test( "ob_vehicles_1", re.compile( r'<img src="https://raw.githubusercontent.com/.+/ge/veh/pzivh.gif"' ), re.compile(r'<img src="http://[a-z0-9.]+:\d+/counter/2584/front"'))
def do_test( month, year, expected ): """Set the date and check the vehicle snippet.""" select_tab( "scenario" ) set_template_params( { "SCENARIO_DATE": "{:02d}/01/{}".format(month,year) } ) select_tab( "ob2" ) vehicles2.click() def reformat( clipboard ): #pylint: disable=missing-docstring mo = re.search( r"^- capabilities: (.*)$", clipboard, re.MULTILINE ) return mo.group( 1 ) wait_for_clipboard( 2, expected, transform=reformat )
def test_include_flags_in_snippets(webapp, webdriver): """Test including flags in snippets.""" # initialize webapp.control_tests.set_data_dir("{REAL}") init_webapp(webapp, webdriver) # prepare the scenario set_player(1, "german") select_tab("ob1") sortable = find_child("#ob_setups-sortable_1") add_simple_note(sortable, "OB setup note", None) # enable "show flags in snippets" select_menu_option("user_settings") elem = find_child( ".ui-dialog.user-settings input[name='include-flags-in-snippets']") assert not elem.is_selected() elem.click() click_dialog_button("OK") _check_cookies(webdriver, "include-flags-in-snippets", True) # make sure that it took effect ob_setup_snippet_btn = find_child("li img.snippet", sortable) ob_setup_snippet_btn.click() wait_for_clipboard(2, "/flags/german", contains=True) # make sure it also affects vehicle/ordnance snippets ob_vehicles_snippet_btn = find_child( "button.generate[data-id='ob_vehicles_1']") ob_vehicles_snippet_btn.click() wait_for_clipboard(2, "/flags/german", contains=True) ob_ordnance_snippet_btn = find_child( "button.generate[data-id='ob_ordnance_1']") ob_ordnance_snippet_btn.click() wait_for_clipboard(2, "/flags/german", contains=True) # disable "show flags in snippets" select_menu_option("user_settings") elem = find_child( ".ui-dialog.user-settings input[name='include-flags-in-snippets']") assert elem.is_selected() elem.click() click_dialog_button("OK") _check_cookies(webdriver, "include-flags-in-snippets", False) # make sure that it took effect ob_setup_snippet_btn.click() wait_for_clipboard(2, "/flags/german", contains=False) # make sure it also affects vehicle/ordnance snippets ob_vehicles_snippet_btn.click() wait_for_clipboard(2, "/flags/german", contains=False) ob_ordnance_snippet_btn.click() wait_for_clipboard(2, "/flags/german", contains=False)
def test_vo_notes_image_cache(webapp, webdriver): """Test the vehicle/ordnance notes image cache.""" def init_test(): # initialize the webapp init_webapp(webapp, webdriver, scenario_persistence=1) _enable_vo_no_notes_as_images(True) # load the test scenario load_scenario({ "PLAYER_1": "japanese", "OB_VEHICLES_1": [ { "name": "japanese vehicle" }, ], }) # initialize webapp.control_tests.set_vo_notes_dir("{TEST}") init_test() # get the vehicle note snippet select_tab("ob1") elems = find_children("#ob_vehicles-sortable_1 li") assert len(elems) == 1 btn = find_child("img.snippet", elems[0]) btn.click() expected = ("japanese vehicle", "vehicles/japanese/note/2") snippet = wait_for_clipboard(2, expected, transform=_extract_vo_note) mo = re.search(r"<img src=\"(.+?)\">", snippet) url = mo.group(1) # get the vehicle note image (should be created) with urllib.request.urlopen(url) as resp: assert not resp.headers.get("X-WasCached") image_data = resp.read() # get the vehicle note image (should be re-created) with urllib.request.urlopen(url) as resp: assert not resp.headers.get("X-WasCached") assert resp.read() == image_data # enable image caching webapp.control_tests.set_app_config_val("VO_NOTES_IMAGE_CACHE_DIR", "{{TEMP_DIR}}") init_test() # get the vehicle note image (should be re-created) with urllib.request.urlopen(url) as resp: assert not resp.headers.get("X-WasCached") assert resp.read() == image_data # get the vehicle note image (should be cached) with urllib.request.urlopen(url) as resp: assert resp.headers.get("X-WasCached") assert resp.read() == image_data
def _delete_vo( vo_type, player_no, name, webdriver ): """Delete a vehicle/ordnance.""" # check the hint select_tab( "ob{}".format( player_no ) ) _check_hint( vo_type, player_no ) # delete the vehicle/ordnance delete_vo( vo_type, player_no, name, webdriver ) _expected[ (vo_type,player_no) ].remove( name ) # check the snippet and hint _check_snippet( vo_type, player_no ) _check_hint( vo_type, player_no )
def _add_vo( vo_type, player_no, name ): """Add a vehicle/ordnance.""" # check the hint select_tab( "ob{}".format( player_no ) ) _check_hint( vo_type, player_no ) # add the vehicle/ordnance add_vo( webdriver, vo_type, player_no, name ) _expected[ (vo_type,player_no) ].append( name ) # check the snippet and hint _check_snippet( vo_type, player_no ) _check_hint( vo_type, player_no )
def test_extensions(webapp, webdriver): """Test handling of VASL counters in extensions.""" # initialize webapp.control_tests \ .set_data_dir( "{REAL}" ) \ .set_vasl_version( "random", "{REAL}" ) init_webapp(webapp, webdriver, scenario_persistence=1) # load the test scenario load_scenario({ "PLAYER_1": "russian", "OB_VEHICLES_1": [ { "id": "ru/v:078", "image_id": "f97:178/0" }, # Matilda II(b) (4FP variant) { "id": "ru/v:078", "image_id": "f97:184/0" }, # Matilda II(b) (6FP variant) { "id": "ru/v:004", "image_id": "547/0" }, # T-60 M40 (core module) { "id": "ru/v:004", "image_id": "f97:186/0" }, # T-60 M40 (KGS variant) ], }) # configure the user settings set_user_settings({ "scenario-images-source": SCENARIO_IMAGES_SOURCE_INTERNET, "include-vasl-images-in-snippets": True, }) # generate a snippet for the vehicles select_tab("ob1") btn = find_child("button[data-id='ob_vehicles_1']") btn.click() wait_for_clipboard( 2, re.compile( '<img src="http://vasl-templates.org/.+/f97/matii2-4cmg.gif"' '.+' '<img src="http://vasl-templates.org/.+/f97/matii2-6cmg.gif"' '.+' '<img src="https://raw.githubusercontent.com/.+/ru/veh/T60M40.gif"' '.+' '<img src="http://vasl-templates.org/.+/f97/T60M40.gif"', re.DOTALL))
def test_html_names( webapp, webdriver ): """Test handling of vehicles/ordnance that have HTML in their name.""" # initialize webapp.control_tests.set_data_dir( "{REAL}" ) init_webapp( webapp, webdriver ) def get_available_ivfs(): """Get the PzKw IVF's available for selection.""" entries = find_children( "#select-vo .select2-results li" ) entries = [ e.text for e in entries ] return [ e for e in entries if "IVF" in e ] # start to add a vehicle - make sure the two PzKw IVF's are available set_player( 1, "german" ) select_tab( "ob1" ) add_vehicle_btn = find_child( "#ob_vehicles-add_1" ) add_vehicle_btn.click() assert get_available_ivfs() == [ "PzKpfw IVF1 (MT)", "PzKpfw IVF2 (MT)" ] # add the PzKw IVF2 elem = find_child( ".ui-dialog .select2-search__field" ) elem.send_keys( "IVF2" ) elem.send_keys( Keys.RETURN ) # make sure it was added to the player's OB vehicles_sortable = find_child( "#ob_vehicles-sortable_1" ) assert get_sortable_vo_names( vehicles_sortable ) == [ "PzKpfw IVF2" ] # start to add another vehicle - make sure both PzKw IVF's are still available add_vehicle_btn.click() assert get_available_ivfs() == [ "PzKpfw IVF1 (MT)", "PzKpfw IVF2 (MT)" ] # add the PzKw IVF1 elem = find_child( ".ui-dialog .select2-search__field" ) elem.send_keys( "IVF1" ) elem.send_keys( Keys.RETURN ) # make sure it was added to the player's OB assert get_sortable_vo_names( vehicles_sortable ) == [ "PzKpfw IVF2", "PzKpfw IVF1" ] # start to add another vehicle - make sure both PzKw IVF's are still available add_vehicle_btn.click() assert get_available_ivfs() == [ "PzKpfw IVF1 (MT)", "PzKpfw IVF2 (MT)" ] elem = find_child( ".ui-dialog .select2-search__field" ) elem.send_keys( Keys.ESCAPE ) # delete the PzKw IVF2 delete_vo( "vehicles", 1, "PzKpfw IVF2" , webdriver ) # start to add another vehicle - make sure both PzKw IVF's are still available add_vehicle_btn.click() assert get_available_ivfs() == [ "PzKpfw IVF1 (MT)", "PzKpfw IVF2 (MT)" ]
def do_test(scenario_date): """Check each generated snippet has an ID.""" # configure the scenario set_scenario_date(scenario_date) # check each snippet snippet_btns = find_snippet_buttons() for tab_id, btns in snippet_btns.items(): select_tab(tab_id) for btn in btns: check_snippet(btn)
def test_multiple_images(webapp, webdriver): """Test handling of VASL counters that have multiple images.""" # initialize webapp.control_tests \ .set_data_dir( "{REAL}" ) \ .set_vasl_version( "random", None ) init_webapp(webapp, webdriver, scenario_persistence=1) # load the test scenario load_scenario({ "PLAYER_1": "british", "OB_VEHICLES_1": [{ "name": "2pdr Portee" }], }) # configure the user settings set_user_settings({ "scenario-images-source": SCENARIO_IMAGES_SOURCE_INTERNET, "include-vasl-images-in-snippets": True, }) # generate a snippet for the vehicle (using the default image) select_tab("ob1") btn = find_child("button[data-id='ob_vehicles_1']") btn.click() wait_for_clipboard( 2, re.compile( r'<img src="https://raw.githubusercontent.com/.+/br/vehicles/portee.gif"' )) # select the second image for the vehicle sortable = find_child("#ob_vehicles-sortable_1") elems = find_children("li", sortable) assert len(elems) == 1 ActionChains(webdriver).double_click(elems[0]).perform() btn = wait_for_elem(2, "#edit-vo input.select-vo-image") btn.click() images = find_children(".ui-dialog.select-vo-image .vo-images img") assert len(images) == 2 images[1].click() click_dialog_button("OK") # generate a snippet for the vehicle (using the new image) btn = find_child("button[data-id='ob_vehicles_1']") btn.click() wait_for_clipboard( 2, re.compile( r'<img src="https://raw.githubusercontent.com/.+/br/vehicles/portee0.gif"' ))
def test_ssr( webapp, webdriver ): """Test generating SSR snippets.""" # initialize init_webapp( webapp, webdriver ) select_tab( "scenario" ) sortable = find_child( "#ssr-sortable" ) # initialize expected = [] generate_snippet_btn = find_child( "button[data-id='ssr']" ) def add_ssr( val ): """Add a new SSR.""" expected.append( val ) add_simple_note( sortable, val, None ) check_snippet() def edit_ssr( ssr_no, val ): """Edit an existing SSR.""" expected[ssr_no] = val edit_simple_note( sortable, ssr_no, val, None ) check_snippet() def check_snippet( width=None ): """Check the generated SSR snippet.""" generate_snippet_btn.click() val = "\n".join( "(*) [{}]".format(e) for e in expected ) if width: val += "\nwidth = [{}]".format( width ) wait_for_clipboard( 2, val, transform=lambda v: html.unescape(adjust_html(v)) ) # add an SSR and generate the SSR snippet add_ssr( "This is my first SSR." ) # add an SSR that contains HTML add_ssr( "This snippet contains <b>bold</b> and <i>italic</i> text." ) # add a multi-line SSR add_ssr( "line 1\nline 2\nline 3" ) # edit one of the SSR's edit_ssr( 1, "This SSR was <i>modified</i>." ) # delete one of the SSR's assert get_sortable_entry_count(sortable) == 3 drag_sortable_entry_to_trash( sortable, 1 ) assert get_sortable_entry_count(sortable) == 2 del expected[1] check_snippet() # set the snippet width elem = find_child( "input[name='SSR_WIDTH']" ) elem.send_keys( "300px" ) check_snippet( "300px" )
def test_vo_notes_as_images(webapp, webdriver): """Test showing vehicle/ordnance notes as HTML/images.""" # initialize webapp.control_tests.set_vo_notes_dir("{TEST}") init_webapp(webapp, webdriver, scenario_persistence=1) # load the test vehicle load_scenario({ "PLAYER_1": "greek", "OB_VEHICLES_1": [{ "name": "HTML note" }], }) select_tab("ob1") def check_snippet(expected): """Generate and check the vehicle note snippet.""" sortable = find_child("#ob_vehicles-sortable_1") elems = find_children("li", sortable) assert len(elems) == 1 btn = find_child("img.snippet", elems[0]) btn.click() contains = True if isinstance(expected, str) else None wait_for_clipboard(2, expected, contains=contains) # generate the vehicle snippet (should get the raw HTML) check_snippet("This is an HTML vehicle note (202).") # enable "show vehicle/ordnance notes as images" select_menu_option("user_settings") elem = find_child( ".ui-dialog.user-settings input[name='vo-notes-as-images']") assert not elem.is_selected() elem.click() click_dialog_button("OK") _check_cookies(webdriver, "vo-notes-as-images", True) # generate the vehicle snippet (should get a link to return an image) check_snippet(re.compile(r"http://.+?:\d+/vehicles/greek/note/202")) # disable "show vehicle/ordnance notes as images" select_menu_option("user_settings") elem = find_child( ".ui-dialog.user-settings input[name='vo-notes-as-images']") assert elem.is_selected() elem.click() click_dialog_button("OK") _check_cookies(webdriver, "vo-notes-as-images", False) # generate the vehicle snippet (should get the raw HTML) check_snippet("This is an HTML vehicle note (202).")
def _check_vo_snippets(player_no, vo_type, expected): """Generate and check vehicle/ordnance snippets.""" select_tab("ob{}".format(player_no)) sortable = find_child("#ob_{}-sortable_{}".format(vo_type, player_no)) elems = find_children("li", sortable) assert len(elems) == len(expected) for i, elem in enumerate(elems): btn = find_child("img.snippet", elem) if expected[i]: btn.click() wait_for_clipboard(2, expected[i], transform=_extract_vo_note) else: assert btn is None
def do_test(player_no, nat, vo_type, vo_entries, expected): """Load the specified vehicles and check the resulting snippet.""" load_scenario({ "PLAYER_{}".format(player_no): nat, "OB_{}_{}".format(vo_type.upper(), player_no): [{ "name": v } for v in vo_entries], }) select_tab("ob{}".format(player_no)) btn = find_child("button.generate[data-id='ob_{}_ma_notes_{}']".format( vo_type, player_no)) btn.click() wait_for_clipboard(2, expected, transform=extract_ma_note_keys)
def test_extras_templates( webapp, webdriver ): """Test the extras templates.""" # initialize init_webapp( webapp, webdriver ) select_tab( "extras" ) # check that the extras templates were loaded correctly assert _get_extras_template_index() == [ ( "extras/minimal", None ), ( "Full template", "This is the caption." ), ( "select", None ), ] # check that the "full" template was loaded correctly _select_extras_template( webdriver, "extras/full" ) content = find_child( "#tabs-extras .right-panel" ) assert find_child( "div.name", content ).text == "Full template" assert find_child( "div.caption", content ).text == "This is the caption." assert find_child( "div.description", content ).text == "This is the description." params = find_children( "tr", content ) assert len(params) == 1 assert find_child( "td.caption", params[0] ).text == "The parameter:" textbox = find_child( "td.value input", params[0] ) assert textbox.get_attribute( "value" ) == "default-val" assert textbox.get_attribute( "size" ) == "10" assert textbox.get_attribute( "title" ) == "This is the parameter description." # generate the snippet snippet_btn = find_child( "button.generate", content ) snippet_btn.click() clipboard = wait_for_clipboard( 2, "param = default-val", contains=True ) assert "vasl-templates:comment" not in clipboard # nb: check that the comment was removed # check that the "minimal" template was loaded correctly _select_extras_template( webdriver, "extras/minimal" ) assert find_child( "div.name", content ).text == "extras/minimal" assert find_child( "div.caption", content ) is None assert find_child( "div.description", content ) is None params = find_children( "tr", content ) assert len(params) == 1 assert find_child( "td.caption", params[0] ).text == "PARAM:" textbox = find_child( "td.value input", params[0] ) assert textbox.get_attribute( "value" ) == "" # generate the snippet textbox.send_keys( "boo!" ) snippet_btn = find_child( "button.generate", content ) snippet_btn.click() clipboard = wait_for_clipboard( 2, "param = boo!", contains=True )
def test_hide_unavailable_ma_notes(webapp, webdriver): """Test showing/hiding unavailable multi-applicable notes.""" # initialize webapp.control_tests.set_vo_notes_dir("{TEST}") init_webapp(webapp, webdriver, scenario_persistence=1) # load the test vehicle load_scenario({ "PLAYER_1": "german", "OB_VEHICLES_1": [{ "name": "missing multi-applicable note" }] }) select_tab("ob1") def test_ma_notes(ma_note_q_present): #pylint: disable=missing-docstring expected = [("A", 'German Multi-Applicable Vehicle Note "A".')] if ma_note_q_present: expected.append(("Q", "Unavailable.")) btn = find_child("button[data-id='ob_vehicles_ma_notes_1']") btn.click() wait_for_clipboard(2, expected, transform=extract_ma_notes) # generate the multi-applicable notes test_ma_notes(True) # enable "hide unavailable multi-applicable notes" select_menu_option("user_settings") elem = find_child( ".ui-dialog.user-settings input[name='hide-unavailable-ma-notes']") assert not elem.is_selected() elem.click() click_dialog_button("OK") _check_cookies(webdriver, "hide-unavailable-ma-notes", True) # generate the multi-applicable notes test_ma_notes(False) # disable "hide unavailable multi-applicable notes" select_menu_option("user_settings") elem = find_child( ".ui-dialog.user-settings input[name='hide-unavailable-ma-notes']") assert elem.is_selected() elem.click() click_dialog_button("OK") _check_cookies(webdriver, "hide-unavailable-ma-notes", False) # generate the multi-applicable notes test_ma_notes(True)
def delete_vo( vo_type, player_no, name, webdriver ): """Delete a vehicle/ordnance.""" # delete the vehicle/ordnance select_tab( "ob{}".format( player_no ) ) sortable = find_child( "#ob_{}-sortable_{}".format( vo_type, player_no ) ) elems = [ c for c in find_children( "li .vo-name", sortable ) if c.text == name ] assert len(elems) == 1 elem = elems[0] trash = find_child( "#ob_{}-trash_{}".format( vo_type, player_no ) ) ActionChains(webdriver).drag_and_drop( elem, trash ).perform()
def add_vo( webdriver, vo_type, player_no, name ): #pylint: disable=unused-argument """Add a vehicle/ordnance.""" # add the vehicle/ordnance select_tab( "ob{}".format( player_no ) ) elem = find_child( "#ob_{}-add_{}".format( vo_type, player_no ) ) elem.click() # FUDGE! Locating the vehicle/ordnance by name and selecting it is finicky, I suspect # because select2 is sensitive about where the mouse is, and we sometimes end up # selecting the wrong item :-/ Selecting by name won't work if there are multiple items # that start with the same thing, but that shouldn't be a problem. dlg = find_child( "#select-vo" ) elem = find_child( "input", dlg ) elem.send_keys( name ) entries = find_children( ".select2-results li", dlg ) assert len(entries) == 1 click_dialog_button( "OK" )
def do_test(nat, veh_expected, ord_expected): """Do the test.""" # set the specified player set_player(1, nat) select_tab("ob1") # check that the Multi-Applicable Notes controls are visible/hidden fieldset = find_child("#tabs-ob1 fieldset[name='ob_vehicles_1']") assert find_child(".snippets-notes", fieldset).is_displayed() == veh_expected assert find_child("label[for='ob']", fieldset).is_displayed() == veh_expected fieldset = find_child("#tabs-ob1 fieldset[name='ob_ordnance_1']") assert find_child(".snippets-notes", fieldset).is_displayed() == ord_expected assert find_child("label[for='ob']", fieldset).is_displayed() == ord_expected # the OB snippet controls should always be visible assert find_child(".snippets-ob", fieldset).is_displayed()
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 do_test( month, year, expected ): #pylint: disable=missing-docstring # set the specified year set_template_params( { "SCENARIO_DATE": "{}/01/{}".format( month, year ) if year else "" } ) # select the "count remaining" template and check what's been highlighted select_tab( "extras" ) _select_extras_template( webdriver, "extras/count-remaining" ) for count_type in expected: table = find_child( "table.{}".format( count_type ) ) cells = [] for row in find_children( "tr", table ): row = list( find_children( "td", row ) ) assert len(row) == 2 bgd_col = row[1].value_of_css_property( "background-color" ) assert bgd_col.startswith( ( "rgb(", "rgba(" ) ) cells.append( bgd_col != "rgba(0, 0, 0, 0)" ) assert cells == expected[count_type]
def _check_snippet( vo_type, player_no ): """Check the generated vehicle/ordnance snippet.""" # check the snippet select_tab( "ob{}".format( player_no ) ) btn = find_child( "button[data-id='ob_{}_{}']".format( vo_type, player_no ) ) btn.click() def reformat( clipboard ): #pylint: disable=missing-docstring return [ mo.group(1) for mo in re.finditer( r"^\[\*\] (.*):" , clipboard, re.MULTILINE ) ] clipboard = wait_for_clipboard( 2, _expected[(vo_type,player_no)], transform=reformat ) # check the snippet width expected = _width[ (vo_type,player_no) ] mo = re.search( r"width={}$".format( expected if expected else "" ), clipboard, re.MULTILINE ) assert mo