class test_help_documentation(): driver = lcc.inject_fixture("driver_obj") @lcc.test("Verify that help documentation is displayed") def help_doc(self): try: utilities.wait(2) utilities.click_element(self.driver, By.LINK_TEXT, locators.MENU_SEARCH_PAGE_LINK_TEXT) utilities.page_reload(self.driver) utilities.wait(1) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.HELP_ICON_CLASS_NAME) utilities.click_element(self.driver, By.LINK_TEXT, locators.USER_GUIDE_LINK_TEXT) utilities.wait(2) utilities.switch_to_latest_tab(self.driver) lcc.log_info(self.driver.current_url) check_that("page url", self.driver.current_url, contains_string(constants.help_user_guide_url)) title_of_user_guide = utilities.find_shadow_dom_element(self.driver, locators.TITLE_OF_USER_GUIDE_CSS, locators.USER_GUIDE_PARENT_CSS).text check_that("title of the page", title_of_user_guide, contains_string("Help")) except (TimeoutException, NoSuchElementException) as e: lcc.log_error(e) finally: self.driver.close() utilities.switch_to_first_tab(self.driver)
class test_login(Screenshot): driver = lcc.inject_fixture("driver_obj") @lcc.test( "Verify that user is able to login successfully and the username is displayed on top right" ) def verify_login_success(self): # 'driver' param is the webdriver object that is being called from 'setup' fixture and used through the scope # of the session. username = base.config_reader('login', 'username') logged_in_user = login_page.get_logged_in_username(self.driver) lcc.log_info("Logged in username: %s" % logged_in_user) assert_that("Logged in username is visible", logged_in_user, contains_string(username), quiet=False)
class test_search: api_auth = lcc.inject_fixture("api_auth") @lcc.test( "Verify that the recently uploaded modules are present in search results: %s" % module_title_prefix) def search(self, api_auth): lcc.log_info("Making a search request for prefix: API test module") search_endpoint = fixture.url + "pantheon/internal/modules.json?search=" + module_title_prefix lcc.log_info(str(search_endpoint)) search_request = api_auth.get(search_endpoint) search_results = search_request.json() number_of_results = search_results["size"] lcc.log_info(str(search_request.json())) check_that("The search request should be successful", search_request.status_code, equal_to(200)) check_that( "Number of search results should be >= %s as per the test data; " % number_of_modules, int(number_of_results), greater_than_or_equal_to(int(number_of_results)))
class test_product: api_auth = lcc.inject_fixture("api_auth") path_to_product = fixture.url + "content/products/" + product_name_uri @lcc.test( "Verify if the product is created successfully and check for: uuid, name, sling:resourceType," " jcr:primaryType") def verify_product_info(self, api_auth): lcc.log_info("Test Product node being created at: %s" % self.path_to_product) create_product_payload = { "name": product_name, "description": "Test product Setup description", "sling:resourceType": "pantheon/product", "jcr:primaryType": "pant:product", "locale": "en-US", "urlFragment": product_name_uri } # Hit the api for create product response = self.api_auth.post(self.path_to_product, data=create_product_payload) check_that("The Product is created successfully", response.status_code, any_of(equal_to(201), equal_to(200))) # Hit the api to get id of created product get_product_id_endpoint = self.path_to_product + ".json" product_id_request = api_auth.get(get_product_id_endpoint) check_that("%s API status code" % get_product_id_endpoint, product_id_request.status_code, equal_to(200)) product_id = product_id_request.json() lcc.log_info("Response for product creation: %s" % str(product_id)) check_that("Product uuid", product_id["jcr:uuid"], is_not_none()) check_that("sling:resourceType", product_id["sling:resourceType"], equal_to("pantheon/product")) check_that("jcr:primaryType", product_id["jcr:primaryType"], equal_to("pant:product")) check_that("product name", product_id["name"], equal_to(product_name)) @lcc.test( "Verify that product version is created successfully and check for: uuid, name, sling:resourceType," " jcr:primaryType") def verify_product_version_info(self, api_auth): path_to_version = self.path_to_product + "/versions/{}".format( constants.product_version) lcc.log_info( "Product version being created for the above product: %s" % path_to_version) create_version_payload = { "name": constants.product_version, "sling:resourceType": "pantheon/productVersion", "jcr:primaryType": "pant:productVersion", "urlFragment": constants.product_version_uri } # Hit the api for create version for the above product response = self.api_auth.post(path_to_version, data=create_version_payload) check_that("The Product version is created successfully", response.status_code, any_of(equal_to(201), equal_to(200))) # Hit the api to get id of product version path_to_product_id = self.path_to_product + "/versions/" + constants.product_version + ".json" product_version_id_req = api_auth.get(path_to_product_id) check_that("%s API status code" % path_to_product_id, product_version_id_req.status_code, equal_to(200)) product_version_id = product_version_id_req.json() check_that("Product version uuid", product_version_id["jcr:uuid"], is_not_none()) check_that("sling:resourceType", product_version_id["sling:resourceType"], equal_to("pantheon/productVersion")) check_that("jcr:primaryType", product_version_id["jcr:primaryType"], equal_to("pant:productVersion")) check_that("product version", product_version_id["name"], equal_to(constants.product_version)) def teardown_suite(self): lcc.log_info( "Deleting test products created as a part of the tests.. ") path_to_new_product_node = fixture.url + "bin/cpm/nodes/node.json/content/products/" + product_name_uri lcc.log_info("Test Product node being deleted at: %s" % path_to_new_product_node) response1 = requests.delete(path_to_new_product_node, auth=(fixture.admin_username, fixture.admin_auth)) check_that("Test product version created was deleted successfully", response1.status_code, equal_to(200))
class test_bulk_operations(Screenshot): driver = lcc.inject_fixture("driver_obj") @lcc.test('Verify user can bulk add metadata for modules') # @lcc.disabled() def modules_bulk_edit_metadata(self): utilities.click_element(self.driver, By.LINK_TEXT, locators.MENU_SEARCH_PAGE_LINK_TEXT) utilities.page_reload(self.driver) search_beta_page.select_repo(self.driver, fixture.repo_name) search_beta_page.search_titles(self.driver, constants.bulk_operations_modules) poll(lambda: len( utilities.find_elements_by_css_selector(self.driver, locators. MODULES_LIST_CSS)) == 4, ignore_exceptions=[NoSuchElementException], timeout=5, step=0.5) utilities.click_element(self.driver, By.XPATH, locators.MODULES_SELECT_ALL_TITLE_XPATH) bulk_edit_metadata = utilities.find_element( self.driver, By.XPATH, locators.BULK_EDIT_METADATA_XPATH) bulk_publish = utilities.find_element(self.driver, By.CSS_SELECTOR, locators.BULK_PUBLISH_CSS) bulk_unpublish = utilities.find_element(self.driver, By.CSS_SELECTOR, locators.BULK_UNPUBLISH_CSS) check_that("Edit metadata button is enabled after selecting modules", bulk_edit_metadata.get_attribute("aria-disabled"), equal_to("false")) check_that("Publish button is enabled after selecting modules", bulk_publish.get_attribute("aria-disabled"), equal_to("false")) check_that("Unpublish button is enabled after selecting modules", bulk_unpublish.get_attribute("aria-disabled"), equal_to("false")) bulk_edit_metadata.click() check_that( "Edit metadata modal title", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.EDIT_METADATA_MODAL_TITLE), equal_to("Edit Metadata")) check_that( "Count of selected titles", utilities.get_text(self.driver, By.ID, locators.SELECTED_MODULES_COUNT_ID), contains_string("4")) search_beta_page.add_bulk_metadata(self.driver) poll(lambda: utilities.get_text(self.driver, By.CSS_SELECTOR, locators. PROGRESS_SUCCESS_STATUS) == "100%", ignore_exceptions=[NoSuchElementException], timeout=20, step=1) utilities.wait(3) utilities.click_element(self.driver, By.XPATH, locators.VIEW_DETAILS_LINK) utilities.wait(3) modules_updated = utilities.find_elements_by_css_selector( self.driver, locators.UPDATED_TITLES_LIST_CSS) check_that("Count of successfully updated modules", len(modules_updated), equal_to(4)) check_that( "Skipped modules section text", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.SKIPPED_TITLE_LIST_CSS), equal_to("n/a")) check_that( "Failed modules section text", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.FAILED_TITLES_LIST_CSS), equal_to("n/a")) utilities.click_element(self.driver, By.XPATH, locators.CLOSE_DETAILS_XPATH) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.CLOSE_STATUS_ALERT) @lcc.test('Verify user can bulk publish modules') # @lcc.disabled() def modules_bulk_publish(self): poll(lambda: len( utilities.find_elements_by_css_selector(self.driver, locators. MODULES_LIST_CSS)) == 4, ignore_exceptions=[NoSuchElementException], timeout=5, step=0.5) utilities.click_element(self.driver, By.XPATH, locators.MODULES_SELECT_ALL_TITLE_XPATH) bulk_publish = utilities.find_element(self.driver, By.CSS_SELECTOR, locators.BULK_PUBLISH_CSS) bulk_publish.click() check_that( "Confirmation modal title", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.MODAL_TITLE_CSS), equal_to("Publish")) check_that( "Count of modules being published", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.TITLES_FOR_PUBLISH_CSS), contains_string("4")) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.CONFIRM_BUTTON_CSS) poll(lambda: utilities.get_text(self.driver, By.CSS_SELECTOR, locators. PROGRESS_SUCCESS_STATUS) == "100%", ignore_exceptions=[NoSuchElementException], timeout=20, step=1) utilities.click_element(self.driver, By.XPATH, locators.VIEW_DETAILS_LINK) modules_updated = utilities.find_elements_by_css_selector( self.driver, locators.UPDATED_TITLES_LIST_CSS) check_that("Count of successfully updated modules", len(modules_updated), equal_to(4)) check_that( "Skipped modules section text", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.SKIPPED_TITLE_LIST_CSS), equal_to("n/a")) check_that( "Failed modules section text", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.FAILED_TITLES_LIST_CSS), equal_to("n/a")) utilities.click_element(self.driver, By.XPATH, locators.CLOSE_DETAILS_XPATH) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.CLOSE_STATUS_ALERT) @lcc.test('Verify user can bulk unpublish modules') # @lcc.disabled() def modules_bulk_unpublish(self): poll(lambda: len( utilities.find_elements_by_css_selector(self.driver, locators. MODULES_LIST_CSS)) == 4, ignore_exceptions=[NoSuchElementException], timeout=5, step=0.5) utilities.wait(3) utilities.click_element(self.driver, By.XPATH, locators.MODULES_SELECT_ALL_TITLE_XPATH) utilities.wait(3) # Deselect first title utilities.click_element(self.driver, By.XPATH, locators.FIRST_MODULE_CHECKBOX_XPATH) utilities.wait(2) bulk_unpublish = utilities.find_element(self.driver, By.CSS_SELECTOR, locators.BULK_UNPUBLISH_CSS) bulk_unpublish.click() check_that( "Confirmation modal title", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.MODAL_TITLE_CSS), equal_to("Unpublish")) check_that( "Count of modules being unpublished", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.TITLES_FOR_UNPUBLISH_CSS), contains_string("3")) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.CONFIRM_BUTTON_CSS) poll(lambda: utilities.get_text(self.driver, By.CSS_SELECTOR, locators. PROGRESS_SUCCESS_STATUS) == "100%", ignore_exceptions=[NoSuchElementException], timeout=20, step=1) utilities.click_element(self.driver, By.XPATH, locators.VIEW_DETAILS_LINK) modules_updated = utilities.find_elements_by_css_selector( self.driver, locators.UPDATED_TITLES_LIST_CSS) check_that("Count of successfully updated modules", len(modules_updated), equal_to(3)) check_that( "Failed modules section text", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.FAILED_TITLES_LIST_CSS), equal_to("n/a")) utilities.click_element(self.driver, By.XPATH, locators.CLOSE_DETAILS_XPATH) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.CLOSE_STATUS_ALERT) @lcc.test('Verify cannot edit metadata for published document') # @lcc.disabled() def published_title_add_metadata(self): utilities.click_element(self.driver, By.XPATH, locators.FIRST_MODULE_CHECKBOX_XPATH) utilities.wait(2) bulk_edit_metadata = utilities.find_element( self.driver, By.XPATH, locators.BULK_EDIT_METADATA_XPATH) bulk_edit_metadata.click() utilities.wait(2) search_beta_page.add_bulk_metadata(self.driver) utilities.wait(2) check_that( "Alert message displayed when trying to add metadata to published title", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.ALERT_TITLE_CSS), equal_to(constants.error_message_on_edit_metadata)) utilities.click_element(self.driver, By.XPATH, locators.CLOSE_DETAILS_XPATH) utilities.wait(15) lcc.log_info("End of tests, executing teardown")
class test_assembly_content: api_auth = lcc.inject_fixture("api_auth") path_for_assembly = "" request_url = "" @lcc.test("Verify response of assembly variant api for pantheon endpoints") def verify_assembly_content(self, api_auth, setup_test_products): # Publishing module included in assembly self.variant = utilities.read_variant_name_from_pantheon2config() lcc.log_info(str(self.variant)) self.variant = str(self.variant) self.path_for_module = utilities.select_nth_item_from_search_results( 0, fixture.url, module_title_prefix + " Include", api_auth) if "/assemblies" in self.path_for_module: self.path_for_module = utilities.select_nth_item_from_search_results( 2, fixture.url, module_title_prefix, api_auth) res, product_name_uri = utilities.add_metadata(fixture.url, self.path_for_module, self.variant, api_auth, setup_test_products, content_type="module") utilities.publish_content(fixture.url, self.path_for_module, self.variant, api_auth) module_uuid = utilities.fetch_uuid(fixture.url, self.path_for_module, self.variant, api_auth) published_module_url = fixture.url + "api/module/variant.json/" + module_uuid published_module_relative_url = "api/module/variant.json/" + module_uuid print("published module url: \n" + published_module_url) lcc.log_info("Published Module api endpoint: %s" % published_module_url) data_from_published_module = api_auth.get(published_module_url) print(data_from_published_module.json()) self.path_for_assembly = utilities.select_nth_item_from_search_results( 0, fixture.url, assembly_prefix, api_auth) if "/modules" in self.path_for_assembly: self.path_for_assembly = utilities.select_nth_item_from_search_results( 1, fixture.url, assembly_prefix, api_auth) res, product_name_uri = utilities.add_metadata(fixture.url, self.path_for_assembly, self.variant, api_auth, setup_test_products, content_type="assembly") # print(res.content) utilities.publish_content(fixture.url, self.path_for_assembly, self.variant, api_auth) assembly_uuid = utilities.fetch_uuid(fixture.url, self.path_for_assembly, self.variant, api_auth) published_assembly_url = fixture.url + "api/assembly/variant.json/" + assembly_uuid print("published assembly url: \n" + published_assembly_url) lcc.log_info("Published Assembly api endpoint: %s" % published_assembly_url) data_from_published_assembly = api_auth.get(published_assembly_url) print(data_from_published_assembly.content) check_that( "The /api/assembly/variant.json/<assembly_uuid> endpoint for a published assembly", data_from_published_assembly.status_code, equal_to(200)) # print("Response from published assembly API endpoint: \n" + str(data_from_published_assembly.content)) check_that("The response is ", data_from_published_assembly.json()["message"], equal_to("Assembly Found")) check_that("The title of the assembly ", data_from_published_assembly.json()["assembly"]["title"], contains_string(assembly_prefix)) check_that("The status of the assembly ", data_from_published_assembly.json()["assembly"]["status"], equal_to("published")) # check_that("The uuid of the assembly", data_from_published_assembly.json()["assembly"]["uuid"], # equal_to(assembly_uuid)) check_that("The uuid of the assembly", data_from_published_assembly.json()["assembly"]["uuid"], equal_to(assembly_uuid)) check_that( "The abstract of the assembly", data_from_published_assembly.json()["assembly"]["description"], equal_to(constants.assembly_abstract)) keywords = constants.assembly_searchkeywords.split(',') print(keywords) all_of( check_that( "Search keywords", data_from_published_assembly.json()["assembly"] ["search_keywords"], has_items(keywords))) check_that( "The assembly type", data_from_published_assembly.json()["assembly"]["content_type"], equal_to("assembly")) # date_published and #date_modified test pending path = self.path_for_assembly.split("repositories/")[1] path = path + "/en_US/variants/" + self.variant check_that( "The assembly url fragment", data_from_published_assembly.json()["assembly"] ["assembly_url_fragment"], equal_to(path)) check_that( "The view_uri", data_from_published_assembly.json()["assembly"]["view_uri"], equal_to(fixture.cp_url + "documentation/en-us/" + product_name_uri + "/" + constants.product_version_uri + "/guide/" + assembly_uuid)) check_that( "The revision_id", data_from_published_assembly.json()["assembly"]["revision_id"], equal_to("released")) # print(data_from_published_assembly.json()["assembly"]["products"][0]["product_name"]) check_that( "The product name url", data_from_published_assembly.json()["assembly"]["products"][0] ["product_url_fragment"], equal_to(product_name_uri)) check_that( "The product version", data_from_published_assembly.json()["assembly"]["products"][0] ["product_version"], equal_to(constants.product_version)) lcc.log_info("Modules included from the API response: %s" % str(data_from_published_assembly.json()["assembly"] ["modules_included"])) number_of_modules_included = len(data_from_published_assembly.json() ["assembly"]["modules_included"]) check_that("Number of Modules included", number_of_modules_included, greater_than_or_equal_to(1)) relative_url = [] for i in range(number_of_modules_included): print(data_from_published_assembly.json()["assembly"] ["modules_included"][i]["relative_url"]) relative_url.append(data_from_published_assembly.json()["assembly"] ["modules_included"][i]["relative_url"]) check_that( "Modules included", data_from_published_assembly.json()["assembly"] ["modules_included"][i], all_of(has_entry("canonical_uuid"), has_entry("level_offset"), has_entry("module_uuid"), has_entry("title"), has_entry("url"), has_entry("pantheon_env"), has_entry("relative_url"))) check_that( "Modules included-> pantheon_env", data_from_published_assembly.json()["assembly"] ["modules_included"][i]["pantheon_env"], equal_to(env)) print(*relative_url) check_that("Relative url to", relative_url, has_item("/" + published_module_relative_url)) lcc.log_info( "hasPart from the API response: %s" % str(data_from_published_assembly.json()["assembly"]["hasPart"])) number_of_modules_hasPart = len( data_from_published_assembly.json()["assembly"]["hasPart"]) check_that("Number of Modules in hasPart", number_of_modules_hasPart, greater_than_or_equal_to(1)) relative_url1 = [] for i in range(number_of_modules_hasPart): print(data_from_published_assembly.json()["assembly"]["hasPart"][i] ["relative_url"]) relative_url1.append(data_from_published_assembly.json() ["assembly"]["hasPart"][i]["relative_url"]) check_that( "hasPart section ", data_from_published_assembly.json()["assembly"]["hasPart"][i], all_of(has_entry("canonical_uuid"), has_entry("level_offset"), has_entry("module_uuid"), has_entry("title"), has_entry("url"), has_entry("pantheon_env"), has_entry("relative_url"))) any_of( check_that( "hasPart-> pantheon_env", data_from_published_assembly.json()["assembly"]["hasPart"] [i]["pantheon_env"], equal_to(env))) print(*relative_url1) check_that("Relative url to", relative_url1, has_item("/" + published_module_relative_url)) @lcc.test("Verify response of assembly variant api behind akamai") def verify_assembly_content_behind_akamai(self, api_auth): assembly_uuid = utilities.fetch_uuid(fixture.url, self.path_for_assembly, self.variant, api_auth) published_assembly_url = fixture.url + "api/assembly/variant.json/" + assembly_uuid print("published assembly url: \n" + published_assembly_url) lcc.log_info("Published Assembly api endpoint: %s" % published_assembly_url) data_from_published_assembly = api_auth.get(published_assembly_url, proxies=proxies) print(data_from_published_assembly.content) check_that( "The /api/assembly/variant.json/<assembly_uuid> endpoint for a published assembly", data_from_published_assembly.status_code, equal_to(200)) # print("Response from published assembly API endpoint: \n" + str(data_from_published_assembly.content)) check_that("The response is ", data_from_published_assembly.json()["message"], equal_to("Assembly Found")) check_that("The title of the assembly ", data_from_published_assembly.json()["assembly"]["title"], contains_string(assembly_prefix)) check_that("The status of the assembly ", data_from_published_assembly.json()["assembly"]["status"], equal_to("published")) # check_that("The uuid of the assembly", data_from_published_assembly.json()["assembly"]["uuid"], # equal_to(assembly_uuid)) check_that("The uuid of the assembly", data_from_published_assembly.json()["assembly"]["uuid"], equal_to(assembly_uuid)) check_that( "The abstract of the assembly", data_from_published_assembly.json()["assembly"]["description"], equal_to(constants.assembly_abstract)) keywords = constants.assembly_searchkeywords.split(',') print(keywords) all_of( check_that( "Search keywords", data_from_published_assembly.json()["assembly"] ["search_keywords"], has_items(keywords))) check_that( "The assembly type", data_from_published_assembly.json()["assembly"]["content_type"], equal_to("assembly")) # date_published and #date_modified test pending path = self.path_for_assembly.split("repositories/")[1] path = path + "/en_US/variants/" + self.variant check_that( "The assembly url fragment", data_from_published_assembly.json()["assembly"] ["assembly_url_fragment"], equal_to(path)) check_that( "The revision_id", data_from_published_assembly.json()["assembly"]["revision_id"], equal_to("released")) check_that( "The product version", data_from_published_assembly.json()["assembly"]["products"][0] ["product_version"], equal_to(constants.product_version)) lcc.log_info("Modules included from the API response: %s" % str(data_from_published_assembly.json()["assembly"] ["modules_included"])) number_of_modules_included = len(data_from_published_assembly.json() ["assembly"]["modules_included"]) check_that("Number of Modules included", number_of_modules_included, greater_than_or_equal_to(1)) relative_url = [] for i in range(number_of_modules_included): print(data_from_published_assembly.json()["assembly"] ["modules_included"][i]["relative_url"]) relative_url.append(data_from_published_assembly.json()["assembly"] ["modules_included"][i]["relative_url"]) check_that( "Modules included", data_from_published_assembly.json()["assembly"] ["modules_included"][i], all_of(has_entry("canonical_uuid"), has_entry("level_offset"), has_entry("module_uuid"), has_entry("title"), has_entry("url"), has_entry("pantheon_env"), has_entry("relative_url"))) check_that( "Modules included-> pantheon_env", data_from_published_assembly.json()["assembly"] ["modules_included"][i]["pantheon_env"], equal_to(env)) lcc.log_info( "hasPart from the API response: %s" % str(data_from_published_assembly.json()["assembly"]["hasPart"])) number_of_modules_hasPart = len( data_from_published_assembly.json()["assembly"]["hasPart"]) check_that("Number of Modules in hasPart", number_of_modules_hasPart, greater_than_or_equal_to(1)) relative_url1 = [] for i in range(number_of_modules_hasPart): print(data_from_published_assembly.json()["assembly"]["hasPart"][i] ["relative_url"]) relative_url1.append(data_from_published_assembly.json() ["assembly"]["hasPart"][i]["relative_url"]) check_that( "hasPart section ", data_from_published_assembly.json()["assembly"]["hasPart"][i], all_of(has_entry("canonical_uuid"), has_entry("level_offset"), has_entry("module_uuid"), has_entry("title"), has_entry("url"), has_entry("pantheon_env"), has_entry("relative_url"))) any_of( check_that( "hasPart-> pantheon_env", data_from_published_assembly.json()["assembly"]["hasPart"] [i]["pantheon_env"], equal_to(env))) @lcc.test("Verify response of assembly variant api for external proxy API") def verify_assembly_content_ext_proxy(self, api_auth): assembly_uuid = utilities.fetch_uuid(fixture.url, self.path_for_assembly, self.variant, api_auth) published_assembly_url = fixture.external_proxy_url + "assembly/variant.json/" + assembly_uuid print("published assembly url: \n" + published_assembly_url) lcc.log_info("Published Assembly api endpoint: %s" % published_assembly_url) data_from_published_assembly = api_auth.get(published_assembly_url, proxies=proxies) print(data_from_published_assembly.content) check_that( "The /api/assembly/variant.json/<assembly_uuid> endpoint for a published assembly", data_from_published_assembly.status_code, equal_to(200)) # print("Response from published assembly API endpoint: \n" + str(data_from_published_assembly.content)) check_that("The response is ", data_from_published_assembly.json()["message"], equal_to("Assembly Found")) check_that("The title of the assembly ", data_from_published_assembly.json()["assembly"]["title"], contains_string(assembly_prefix)) check_that("The status of the assembly ", data_from_published_assembly.json()["assembly"]["status"], equal_to("published")) # check_that("The uuid of the assembly", data_from_published_assembly.json()["assembly"]["uuid"], # equal_to(assembly_uuid)) check_that("The uuid of the assembly", data_from_published_assembly.json()["assembly"]["uuid"], equal_to(assembly_uuid)) check_that( "The abstract of the assembly", data_from_published_assembly.json()["assembly"]["description"], equal_to(constants.assembly_abstract)) keywords = constants.assembly_searchkeywords.split(',') print(keywords) all_of( check_that( "Search keywords", data_from_published_assembly.json()["assembly"] ["search_keywords"], has_items(keywords))) check_that( "The assembly type", data_from_published_assembly.json()["assembly"]["content_type"], equal_to("assembly")) # date_published and #date_modified test pending path = self.path_for_assembly.split("repositories/")[1] path = path + "/en_US/variants/" + self.variant check_that( "The assembly url fragment", data_from_published_assembly.json()["assembly"] ["assembly_url_fragment"], equal_to(path)) check_that( "The revision_id", data_from_published_assembly.json()["assembly"]["revision_id"], equal_to("released")) check_that( "The product version", data_from_published_assembly.json()["assembly"]["products"][0] ["product_version"], equal_to(constants.product_version)) lcc.log_info("Modules included from the API response: %s" % str(data_from_published_assembly.json()["assembly"] ["modules_included"])) number_of_modules_included = len(data_from_published_assembly.json() ["assembly"]["modules_included"]) check_that("Number of Modules included", number_of_modules_included, greater_than_or_equal_to(1)) relative_url = [] for i in range(number_of_modules_included): print(data_from_published_assembly.json()["assembly"] ["modules_included"][i]["relative_url"]) relative_url.append(data_from_published_assembly.json()["assembly"] ["modules_included"][i]["relative_url"]) check_that( "Modules included", data_from_published_assembly.json()["assembly"] ["modules_included"][i], all_of(has_entry("canonical_uuid"), has_entry("level_offset"), has_entry("module_uuid"), has_entry("title"), has_entry("url"), has_entry("pantheon_env"), has_entry("relative_url"))) check_that( "Modules included-> pantheon_env", data_from_published_assembly.json()["assembly"] ["modules_included"][i]["pantheon_env"], equal_to(env)) lcc.log_info( "hasPart from the API response: %s" % str(data_from_published_assembly.json()["assembly"]["hasPart"])) number_of_modules_hasPart = len( data_from_published_assembly.json()["assembly"]["hasPart"]) check_that("Number of Modules in hasPart", number_of_modules_hasPart, greater_than_or_equal_to(1)) relative_url1 = [] for i in range(number_of_modules_hasPart): print(data_from_published_assembly.json()["assembly"]["hasPart"][i] ["relative_url"]) relative_url1.append(data_from_published_assembly.json() ["assembly"]["hasPart"][i]["relative_url"]) check_that( "hasPart section ", data_from_published_assembly.json()["assembly"]["hasPart"][i], all_of(has_entry("canonical_uuid"), has_entry("level_offset"), has_entry("module_uuid"), has_entry("title"), has_entry("url"), has_entry("pantheon_env"), has_entry("relative_url"))) any_of( check_that( "hasPart-> pantheon_env", data_from_published_assembly.json()["assembly"]["hasPart"] [i]["pantheon_env"], equal_to(env)))
class MySuite: fixt1 = lcc.inject_fixture() @lcc.test("sometest") def sometest(self): marker.append(self.fixt1)
class test_module_content: api_auth = lcc.inject_fixture("api_auth") path_for_module = "" request_url = "" @lcc.test( "Verify response of module variant api also verify external proxy url, pantheon URL and CP url resolve imageassets correctly" ) def verify_module_content(self, api_auth, setup_test_products): #publishing related assembly self.variant = utilities.read_variant_name_from_pantheon2config() lcc.log_info(str(self.variant)) self.variant = str(self.variant) lcc.log_info( "In order to verify content for a module, publishing a related assembly..." ) self.path_for_assembly = utilities.select_nth_item_from_search_results( 0, fixture.url, assembly_title_prefix, api_auth) if "/modules" in self.path_for_assembly: self.path_for_assembly = utilities.select_nth_item_from_search_results( 1, fixture.url, assembly_title_prefix, api_auth) res, product_name_uri = utilities.add_metadata(fixture.url, self.path_for_assembly, self.variant, api_auth, setup_test_products, content_type="assembly") check_that("Edit metadata request response for the above assembly", res.status_code, equal_to(200)) lcc.log_info("Edit metadata response content: %s" % str(res.content)) publish_req_assembly = utilities.publish_content( fixture.url, self.path_for_assembly, self.variant, api_auth) check_that("Expect the above assembly to be published, response code ", publish_req_assembly.status_code, equal_to(200)) lcc.log_info("Publish assembly response content: %s" % str(publish_req_assembly.content)) assembly_uuid = utilities.fetch_uuid(fixture.url, self.path_for_assembly, self.variant, api_auth) published_assembly_url = fixture.url + "api/assembly/variant.json/" + assembly_uuid published_assembly_relative_url = "api/assembly/variant.json/" + assembly_uuid print("published assembly url: \n" + published_assembly_url) lcc.log_info("Published Assembly api endpoint: %s" % published_assembly_url) data_from_published_assembly = api_auth.get(published_assembly_url) self.path_for_module = utilities.select_nth_item_from_search_results( 0, fixture.url, module_prefix, api_auth) if "/assemblies" in self.path_for_module: self.path_for_module = utilities.select_nth_item_from_search_results( 1, fixture.url, module_prefix, api_auth) res, product_name_uri = utilities.add_metadata(fixture.url, self.path_for_module, self.variant, api_auth, setup_test_products, content_type="module") lcc.log_info( "Publishing a module now to test for included content: %s" % self.path_for_module) publish_req_module = utilities.publish_content(fixture.url, self.path_for_module, self.variant, api_auth) check_that("Module has been published ", publish_req_module.status_code, equal_to(200)) module_uuid = utilities.fetch_uuid(fixture.url, self.path_for_module, self.variant, api_auth) published_module_url = fixture.url + "api/module/variant.json/" + module_uuid # print("published module url: \n" + published_module_url) lcc.log_info("Published Module api endpoint: %s" % published_module_url) data_from_published_module = api_auth.get(published_module_url) check_that( "The /api/module/variant.json/<module_uuid> endpoint for a published module", data_from_published_module.status_code, equal_to(200)) # print("Response from published module API endpoint: \n" + str(data_from_published_module.content)) check_that("The response is ", data_from_published_module.json()["message"], equal_to("Module Found")) check_that("The title of the module ", data_from_published_module.json()["module"]["title"], contains_string(module_prefix)) check_that("The status of the module ", data_from_published_module.json()["module"]["status"], equal_to("published")) check_that("The variant uuid of the module", data_from_published_module.json()["module"]["variant_uuid"], equal_to(module_uuid)) check_that("The uuid of the module", data_from_published_module.json()["module"]["uuid"], equal_to(module_uuid)) check_that("The abstract of the module", data_from_published_module.json()["module"]["description"], is_not_none()) keywords = constants.searchKeywords.split(',') print(keywords) check_that( "Search keywords", data_from_published_module.json()["module"]["search_keywords"], has_items(keywords)) check_that("The module type", data_from_published_module.json()["module"]["content_type"], equal_to("module")) #date_published and #date_modified test pending path = self.path_for_module.split("repositories/")[1] path = path + "/en_US/variants/" + self.variant check_that( "The module url fragment", data_from_published_module.json()["module"]["module_url_fragment"], equal_to(path)) check_that( "The view_uri", data_from_published_module.json()["module"]["view_uri"], equal_to(fixture.cp_url + "documentation/en-us/" + product_name_uri + "/" + constants.product_version_uri + "/topic/" + module_uuid)) check_that("The revision_id", data_from_published_module.json()["module"]["revision_id"], equal_to("released")) # print(data_from_published_module.json()["module"]["products"][0]["product_name"]) check_that( "The product name url", data_from_published_module.json()["module"]["products"][0] ["product_url_fragment"], equal_to(product_name_uri)) check_that( "The product version", data_from_published_module.json()["module"]["products"][0] ["product_version"], equal_to(constants.product_version)) lcc.log_info("Included in guides from the API response: %s" % str( data_from_published_module.json()["module"]["included_in_guides"])) count = len( data_from_published_module.json()["module"]["included_in_guides"]) check_that("Number of guides included in", count, greater_than_or_equal_to(1)) relative_url = [] for i in range(count): print(data_from_published_module.json()["module"] ["included_in_guides"][i]["relative_url"]) relative_url.append(data_from_published_module.json()["module"] ["included_in_guides"][i]["relative_url"]) check_that( "Included in guides", data_from_published_module.json()["module"] ["included_in_guides"][i]["title"], contains_string(assembly_title_prefix) or contains_string(assembly_prefix)) check_that( "Included in guides data", data_from_published_module.json()["module"] ["included_in_guides"][i], all_of(has_entry("title"), has_entry("uuid"), has_entry("url"), has_entry("view_uri"), has_entry("relative_url"), has_entry("pantheon_env"))) check_that( "Included in guides-> pantheon_env", data_from_published_module.json()["module"] ["included_in_guides"][i]["pantheon_env"], equal_to(env)) print(*relative_url) check_that("Relative url to", relative_url, has_item("/" + published_assembly_relative_url)) is_part_of_content = data_from_published_module.json( )["module"]["isPartOf"] lcc.log_info("Is part of content from the API response: %s " % str(is_part_of_content)) is_part_of_count = len( data_from_published_module.json()["module"]["isPartOf"]) check_that("Is part of count", is_part_of_count, greater_than_or_equal_to(1)) relative_url1 = [] for i in range(is_part_of_count): print(data_from_published_module.json()["module"]["isPartOf"][i] ["relative_url"]) relative_url1.append(data_from_published_module.json()["module"] ["isPartOf"][i]["relative_url"]) check_that( "Is part of", data_from_published_module.json()["module"]["isPartOf"][i] ["title"], contains_string(assembly_title_prefix) or contains_string(assembly_prefix)) check_that( "isPartOf data", data_from_published_module.json()["module"]["isPartOf"][i], all_of(has_entry("title"), has_entry("uuid"), has_entry("url"), has_entry("view_uri"), has_entry("relative_url"), has_entry("pantheon_env"))) check_that( "isPartOf-> pantheon_env", data_from_published_module.json()["module"]["isPartOf"][i] ["pantheon_env"], equal_to(env)) print(*relative_url1) check_that("Relative url to", relative_url1, has_item("/" + published_assembly_relative_url)) time.sleep(10) # Test to verify external proxy url, pantheon URL and CP url resolve image assets correctly proxies = { "http": proxy_server, "https": proxy_server, } body = data_from_published_module.json()["module"]["body"] src = collect(body, {"Path": ["img", "src", []]}) path = (src["Path"]).lstrip("/") print(cp_url + path) resp1 = requests.get(cp_url + path, proxies=proxies) print(cp_pantheon_url + path) resp2 = requests.get(cp_pantheon_url + path, proxies=proxies) print(proxy_url + path) resp3 = requests.get(proxy_url + path, proxies=proxies) check_that("Imageassets for url behind akamai", resp1.status_code, equal_to(200)) check_that("Imageassets for Pantheon url", resp2.status_code, equal_to(200)) check_that("Imageassets for external proxy url", resp3.status_code, equal_to(200)) @lcc.test("Verify response of module variant api behind akamai") def verify_module_content_behind_akamai_endpoints(self, api_auth, setup_test_products): module_uuid = utilities.fetch_uuid(fixture.url, self.path_for_module, self.variant, api_auth) published_module_url = fixture.behind_akamai_url + "api/module/variant.json/" + module_uuid # print("published module url: \n" + published_module_url) lcc.log_info("Published Module api endpoint: %s" % published_module_url) data_from_published_module = api_auth.get(published_module_url, proxies=proxies) check_that( "The /api/module/variant.json/<module_uuid> endpoint for a published module", data_from_published_module.status_code, equal_to(200)) lcc.log_info("Response from published module API endpoint: \n" + str(data_from_published_module.content)) check_that("The response is ", data_from_published_module.json()["message"], equal_to("Module Found")) check_that("The title of the module ", data_from_published_module.json()["module"]["title"], contains_string(module_prefix)) check_that("The status of the module ", data_from_published_module.json()["module"]["status"], equal_to("published")) check_that("The variant uuid of the module", data_from_published_module.json()["module"]["variant_uuid"], equal_to(module_uuid)) check_that("The uuid of the module", data_from_published_module.json()["module"]["uuid"], equal_to(module_uuid)) check_that("The abstract of the module", data_from_published_module.json()["module"]["description"], is_not_none()) keywords = constants.searchKeywords.split(',') print(keywords) check_that( "Search keywords", data_from_published_module.json()["module"]["search_keywords"], has_items(keywords)) check_that("The module type", data_from_published_module.json()["module"]["content_type"], equal_to("module")) # date_published and #date_modified test pending path = self.path_for_module.split("repositories/")[1] path = path + "/en_US/variants/" + self.variant check_that( "The module url fragment", data_from_published_module.json()["module"]["module_url_fragment"], equal_to(path)) check_that("The revision_id", data_from_published_module.json()["module"]["revision_id"], equal_to("released")) check_that( "The product version", data_from_published_module.json()["module"]["products"][0] ["product_version"], equal_to(constants.product_version)) lcc.log_info("Included in guides from the API response: %s" % str( data_from_published_module.json()["module"]["included_in_guides"])) count = len( data_from_published_module.json()["module"]["included_in_guides"]) check_that("Number of guides included in", count, greater_than_or_equal_to(1)) relative_url = [] for i in range(count): print(data_from_published_module.json()["module"] ["included_in_guides"][i]["relative_url"]) relative_url.append(data_from_published_module.json()["module"] ["included_in_guides"][i]["relative_url"]) check_that( "Included in guides", data_from_published_module.json()["module"] ["included_in_guides"][i]["title"], contains_string(assembly_title_prefix) or contains_string(assembly_prefix)) check_that( "Included in guides data", data_from_published_module.json()["module"] ["included_in_guides"][i], all_of(has_entry("title"), has_entry("uuid"), has_entry("url"), has_entry("view_uri"), has_entry("relative_url"), has_entry("pantheon_env"))) check_that( "Included in guides-> pantheon_env", data_from_published_module.json()["module"] ["included_in_guides"][i]["pantheon_env"], equal_to(env)) is_part_of_content = data_from_published_module.json( )["module"]["isPartOf"] lcc.log_info("Is part of content from the API response: %s " % str(is_part_of_content)) is_part_of_count = len( data_from_published_module.json()["module"]["isPartOf"]) check_that("Is part of count", is_part_of_count, greater_than_or_equal_to(1)) relative_url1 = [] for i in range(is_part_of_count): print(data_from_published_module.json()["module"]["isPartOf"][i] ["relative_url"]) relative_url1.append(data_from_published_module.json()["module"] ["isPartOf"][i]["relative_url"]) check_that( "Is part of", data_from_published_module.json()["module"]["isPartOf"][i] ["title"], contains_string(assembly_title_prefix) or contains_string(assembly_prefix)) check_that( "isPartOf data", data_from_published_module.json()["module"]["isPartOf"][i], all_of(has_entry("title"), has_entry("uuid"), has_entry("url"), has_entry("view_uri"), has_entry("relative_url"), has_entry("pantheon_env"))) check_that( "isPartOf-> pantheon_env", data_from_published_module.json()["module"]["isPartOf"][i] ["pantheon_env"], equal_to(env)) @lcc.test("Verify response of module variant api for external proxy API") def verify_module_content_ext_proxy(self, api_auth, setup_test_products): module_uuid = utilities.fetch_uuid(fixture.url, self.path_for_module, self.variant, api_auth) published_module_url = fixture.external_proxy_url + "module/variant.json/" + module_uuid # print("published module url: \n" + published_module_url) lcc.log_info("Published Module api endpoint: %s" % published_module_url) data_from_published_module = api_auth.get(published_module_url, proxies=proxies) check_that( "The /api/module/variant.json/<module_uuid> endpoint for a published module", data_from_published_module.status_code, equal_to(200)) lcc.log_info("Response from published module API endpoint: \n" + str(data_from_published_module.content)) check_that("The response is ", data_from_published_module.json()["message"], equal_to("Module Found")) check_that("The title of the module ", data_from_published_module.json()["module"]["title"], contains_string(module_prefix)) check_that("The status of the module ", data_from_published_module.json()["module"]["status"], equal_to("published")) check_that("The variant uuid of the module", data_from_published_module.json()["module"]["variant_uuid"], equal_to(module_uuid)) check_that("The uuid of the module", data_from_published_module.json()["module"]["uuid"], equal_to(module_uuid)) check_that("The abstract of the module", data_from_published_module.json()["module"]["description"], is_not_none()) keywords = constants.searchKeywords.split(',') print(keywords) check_that( "Search keywords", data_from_published_module.json()["module"]["search_keywords"], has_items(keywords)) check_that("The module type", data_from_published_module.json()["module"]["content_type"], equal_to("module")) # date_published and #date_modified test pending path = self.path_for_module.split("repositories/")[1] path = path + "/en_US/variants/" + self.variant check_that( "The module url fragment", data_from_published_module.json()["module"]["module_url_fragment"], equal_to(path)) check_that("The revision_id", data_from_published_module.json()["module"]["revision_id"], equal_to("released")) check_that( "The product version", data_from_published_module.json()["module"]["products"][0] ["product_version"], equal_to(constants.product_version)) lcc.log_info("Included in guides from the API response: %s" % str( data_from_published_module.json()["module"]["included_in_guides"])) count = len( data_from_published_module.json()["module"]["included_in_guides"]) check_that("Number of guides included in", count, greater_than_or_equal_to(1)) relative_url = [] for i in range(count): print(data_from_published_module.json()["module"] ["included_in_guides"][i]["relative_url"]) relative_url.append(data_from_published_module.json()["module"] ["included_in_guides"][i]["relative_url"]) check_that( "Included in guides", data_from_published_module.json()["module"] ["included_in_guides"][i]["title"], contains_string(assembly_title_prefix) or contains_string(assembly_prefix)) check_that( "Included in guides data", data_from_published_module.json()["module"] ["included_in_guides"][i], all_of(has_entry("title"), has_entry("uuid"), has_entry("url"), has_entry("view_uri"), has_entry("relative_url"), has_entry("pantheon_env"))) check_that( "Included in guides-> pantheon_env", data_from_published_module.json()["module"] ["included_in_guides"][i]["pantheon_env"], equal_to(env)) is_part_of_content = data_from_published_module.json( )["module"]["isPartOf"] lcc.log_info("Is part of content from the API response: %s " % str(is_part_of_content)) is_part_of_count = len( data_from_published_module.json()["module"]["isPartOf"]) check_that("Is part of count", is_part_of_count, greater_than_or_equal_to(1)) relative_url1 = [] for i in range(is_part_of_count): print(data_from_published_module.json()["module"]["isPartOf"][i] ["relative_url"]) relative_url1.append(data_from_published_module.json()["module"] ["isPartOf"][i]["relative_url"]) check_that( "Is part of", data_from_published_module.json()["module"]["isPartOf"][i] ["title"], contains_string(assembly_title_prefix) or contains_string(assembly_prefix)) check_that( "isPartOf data", data_from_published_module.json()["module"]["isPartOf"][i], all_of(has_entry("title"), has_entry("uuid"), has_entry("url"), has_entry("view_uri"), has_entry("relative_url"), has_entry("pantheon_env"))) check_that( "isPartOf-> pantheon_env", data_from_published_module.json()["module"]["isPartOf"][i] ["pantheon_env"], equal_to(env))
class test_publish_module(Screenshot): driver = lcc.inject_fixture("driver_obj") first_pub_date_details_page = "" last_pub_date_details_page = "" # updated_date_view_page = "" # published_date_view_page = "" @lcc.test( "Verify that warning is displayed for publish module with no product metadata" ) def no_product_info_publish_module(self): utilities.click_element(self.driver, By.LINK_TEXT, "Search") utilities.page_reload(self.driver) # # Click on the title if it is displayed on the first page utilities.wait(5) # search_page.search_for_module_and_click(self.driver, constants.unpublished_module) search_beta_page.select_repo(self.driver, fixture.repo_name) search_beta_page.search_module_and_click(self.driver, constants.unpublished_module) utilities.wait(5) tooltip_icon = utilities.find_element(self.driver, By.CSS_SELECTOR, locators.NO_URL_TOOLTIP_ICON) check_that("No url tooltip icon is displayed", tooltip_icon.is_displayed(), is_true()) utilities.click_element(self.driver, By.ID, locators.MODULE_DISPLAY_PUBLISH_BUTTON_ID) check_that( "Button contains text", utilities.get_text(self.driver, By.ID, locators.MODULE_DISPLAY_PUBLISH_BUTTON_ID), contains_string("Publish")) @lcc.test( "Verify that user is able to successfully publish module with product metadata added, also checks for Pre-live URL functionality" ) @lcc.depends_on('test_edit_metadata.edit_metadata_successfully') def publish_module(self): utilities.click_element(self.driver, By.LINK_TEXT, "Search") utilities.page_reload(self.driver) # search_page.search_for_module_and_click(self.driver, constants.module_to_be_published) search_beta_page.select_repo(self.driver, fixture.repo_name) search_beta_page.search_module_and_click( self.driver, constants.module_to_be_published) utilities.wait(10) pre_live_url = utilities.find_element(self.driver, By.LINK_TEXT, "Pre-live Customer Portal URL") print(pre_live_url.get_attribute('href')) check_that("Pre-live URL link is displayed", pre_live_url.is_displayed(), is_true()) copy_pre_live_url = utilities.find_element(self.driver, By.LINK_TEXT, "Copy pre-live URL") check_that("Copy Pre-live URL is displayed", copy_pre_live_url.is_displayed(), is_true()) utilities.click_element(self.driver, By.ID, locators.MODULE_DISPLAY_PUBLISH_BUTTON_ID) utilities.wait(20) print("Clicked publish") # The page needs a refresh because of an existing bug about the "View on Customer Portal not appearing" self.driver.refresh() utilities.find_element(self.driver, By.PARTIAL_LINK_TEXT, "View on Customer Portal") check_that( "Button contains text", utilities.get_text(self.driver, By.ID, locators.MODULE_DISPLAY_UNPUBLISH_BUTTON_ID), contains_string("Unpublish")) check_that( "Button contains text", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.MODULE_DISPLAY_PREVIEW_BUTTON_CSS), contains_string("Preview")) check_that( "Copy permanent url link is displayed", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.COPY_URL_LINK_CSS), contains_string(constants.copy_url_link)) check_that( "View on portal link is displayed", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.VIEW_ON_PORTAL_LINK_CSS), contains_string(constants.view_on_portal_link)) # get UPLOADED date in variable and covert into desired format- (DD Month YYYY) self.first_pub_date_details_page = (utilities.get_text( self.driver, By.CSS_SELECTOR, locators.FIRST_PUB_DATE_MODULE_PAGE_CSS)) lcc.log_info("captured 1st published date from module info page : " + self.first_pub_date_details_page) # get published date in variable and convert into desired format-(DD Month YYYY) self.last_pub_date_details_page = (utilities.get_text( self.driver, By.CSS_SELECTOR, locators.LAST_PUB_DATE_MODULE_PAGE_CSS)) lcc.log_info("captured last published date from module info page : " + test_publish_module.last_pub_date_details_page) # adding checks if the module is displayed on the UI utilities.click_element(self.driver, By.CSS_SELECTOR, locators.VIEW_ON_PORTAL_LINK_CSS) utilities.wait(5) try: utilities.switch_to_latest_tab(self.driver) utilities.wait(10) check_that("View on Portal URL path", self.driver.current_url, contains_string(constants.view_on_portal_page_url)) except (TimeoutException, StaleElementReferenceException, NoSuchElementException) as e: lcc.log_error("Element could not be located!!!") lcc.log_error(e) finally: if (len(self.driver.window_handles) > 1): self.driver.close() utilities.switch_to_first_tab(self.driver) @lcc.test("Verify product info on view page") def product_info_on_view_page(self): utilities.click_element(self.driver, By.CSS_SELECTOR, locators.MODULE_DISPLAY_PREVIEW_BUTTON_CSS) try: utilities.switch_to_latest_tab(self.driver) utilities.wait(2) product_name = utilities.find_shadow_dom_element( self.driver, locators.PRODUCT_NAME_ON_PREVIEW_CSS, locators.MODULE_BODY_CONTENT_CSS).text check_that("Product name reflected on view page", product_name, contains_string(constants.product_name)) product_version = utilities.find_shadow_dom_element( self.driver, locators.PRODUCT_VERSION_ON_PREVIEW_CSS, locators.MODULE_BODY_CONTENT_CSS).text check_that("Product version reflected on view page", product_version, contains_string(constants.product_version)) updated_date_view_page = utilities.find_shadow_dom_element( self.driver, locators.UPDATED_DATE_ON_PREVIEW_CSS, locators.MODULE_BODY_CONTENT_CSS).text.strip("Updated ") check_that("updated date reflected on view page", updated_date_view_page, contains_string(self.first_pub_date_details_page)) published_date_view_page = utilities.find_shadow_dom_element( self.driver, locators.PUBLISHED_DATE_ON_PREVIEW_CSS, locators.MODULE_BODY_CONTENT_CSS).text.strip("Published ") check_that("published date reflected on view page", published_date_view_page, contains_string(self.last_pub_date_details_page)) legal_notice = utilities.find_shadow_dom_element( self.driver, locators.LEGAL_NOTICE_ON_PREVIEW_CSS, locators.MODULE_BODY_CONTENT_CSS) check_that( "legal notice is displayed at the bottom of preview page", legal_notice.text, contains_string("Legal Notices for Trademarks")) legal_notice_href = legal_notice.get_attribute("href") check_that("verify legal notice link", legal_notice_href, contains_string(constants.legal_notice_link)) except (TimeoutException, StaleElementReferenceException, NoSuchElementException) as e: lcc.log_error("Element could not be located!!!") lcc.log_error(e) finally: if (len(self.driver.window_handles) > 1): self.driver.close() utilities.switch_to_first_tab(self.driver) @lcc.test("Verify info on customer portal") def product_info_on_customer_portal(self): utilities.wait(5) utilities.page_reload(self.driver) utilities.click_element(self.driver, By.PARTIAL_LINK_TEXT, "View on Customer Portal") try: utilities.wait(5) utilities.switch_to_latest_tab(self.driver) utilities.wait(6) updated_date_on_portal = utilities.find_shadow_dom_element( self.driver, locators.UPDATED_DATE_ON_PORTAL_CSS, locators.MODULE_BODY_ON_PORTAL_CSS).get_attribute( "textContent") check_that("updated date reflected on view page", updated_date_on_portal, contains_string(self.first_pub_date_details_page)) published_date_on_portal = utilities.find_shadow_dom_element( self.driver, locators.PUBLISHED_DATE_ON_PORTAL_CSS, locators.MODULE_BODY_ON_PORTAL_CSS).get_attribute( "textContent") check_that("published date reflected on view page", published_date_on_portal, contains_string(self.last_pub_date_details_page)) except (TimeoutException, StaleElementReferenceException, NoSuchElementException) as e: lcc.log_error( "Some problem accessing the Customer Portal, please check.") lcc.log_error(e) finally: if (len(self.driver.window_handles) > 1): self.driver.close() utilities.switch_to_first_tab(self.driver) def teardown_suite(self): response = unpublish_module(self, constants.module_to_unpublish, constants.variant) check_that("Unpublish request status code", response.status_code, equal_to(200)) lcc.log_info( "Module published for above test is unpublished successfully..")
class test_assembly_edit_publish: api_auth = lcc.inject_fixture("api_auth") global product_id @lcc.test( "Verify that authenticated user can edit metadata for an assembly successfully also verify response of pre-live URL before and after adding metadata" ) def verify_edit_metadata(self, setup_test_products, api_auth): self.variant = utilities.read_variant_name_from_pantheon2config() lcc.log_info(str(self.variant)) self.variant = str(self.variant) self.path_for_assembly = utilities.select_nth_item_from_search_results( 1, fixture.url, assembly_title_prefix, api_auth) edit_metadata_url = fixture.url + self.path_for_assembly + "/en_US/variants/" + \ self.variant + "/draft/metadata" lcc.log_info("Edit metadata request for assembly at : %s " % edit_metadata_url) cp_url_path = fixture.url + self.path_for_assembly + "/en_US/variants/" + self.variant + ".url.json" print(cp_url_path) lcc.log_info("Checking Get CP URL api") resp = self.api_auth.get(cp_url_path) print(resp.json()) check_that("Get CP url response", resp.json(), has_entry("type", "ERROR")) check_that( "Get CP url response", resp.json(), has_entry( "url", "Document does not have associated product/version metadata.")) # Fetch the product id from fixtures/fixtures.py, the test product and version was created as a setup step. product_id, product_name_uri = setup_test_products payload = { "productVersion": product_id, "documentUsecase": constants.assembly_documentusecase, "urlFragment": constants.assembly_urlfragment, "searchKeywords": constants.assembly_searchkeywords } # payload = urlencode(payload) print("Payload::", payload) # headers = {'content-type': "application/x-www-form-urlencoded"} edit_metadata_request = self.api_auth.post(edit_metadata_url, data=payload) print(edit_metadata_request) time.sleep(10) check_that("Edit metadata request to be successful", edit_metadata_request.status_code, equal_to(200)) request_url = fixture.url + self.path_for_assembly + ".7.json" #check that metadata has been added successfully. response = self.api_auth.get(request_url) metadata_response = response.json()["en_US"]["variants"][ self.variant]["draft"]["metadata"] check_that("The edit metadata request was successful", edit_metadata_request.status_code, any_of(equal_to(200), equal_to(201))) check_that("The product version has been updated successfully", metadata_response["productVersion"], equal_to(product_id)) check_that("The document use case has been updated successfully", metadata_response["documentUsecase"], equal_to(constants.assembly_documentusecase)) check_that("The search keywords have been updated successfully", metadata_response["searchKeywords"], equal_to(constants.assembly_searchkeywords)) check_that("The URL fragment has been updated successfully", metadata_response["urlFragment"], equal_to(constants.assembly_urlfragment)) resp = self.api_auth.get(cp_url_path) print(resp.json()) url_test = cp_url + "documentation/en-us/" + product_name_uri + "/" + constants.product_version_uri + "/guide/" check_that("Get CP url response", resp.json(), has_entry("type", "PRELIVE")) check_that("Get CP url response", resp.json(), has_entry("url")) check_that("Get CP URL response", resp.json()["url"], contains_string(url_test)) @lcc.test( "Verify that the user can publish an assembly successfully and check for /api/assembly/variant.json/" "<assembly_uuid> endpoint") def verify_publish_assembly(self, api_auth): # print("variant: " + self.variant) payload = { ":operation": "pant:publish", "locale": "en_US", "variant": self.variant } # headers = {'content-type': "application/x-www-form-urlencoded"} # payload = json.dumps(payload) # payload = urlencode(payload) print("Payload: ", payload) publish_url = fixture.url + self.path_for_assembly lcc.log_info("API end point used for publish request: %s" % publish_url) time.sleep(15) publish_request = api_auth.post(publish_url, data=payload, headers={'Accept': 'application/json'}) lcc.log_info("Publish request response: \n %s" % str(publish_request.content)) time.sleep(10) check_that("The publish request is successful", publish_request.status_code, equal_to(200)) # Check if the publish request response returns "url" for Customer Portal: CCS-3860 cp_url_returned = publish_request.json()["location"] check_that( "Publish assembly response contains The Customer Portal URL", cp_url_returned, contains_string(fixture.cp_url + "documentation")) req = api_auth.get(fixture.url + self.path_for_assembly + ".7.json") check_that("The status node in variants > variant >: ", req.json()["en_US"]["variants"][self.variant], has_entry("released"), quiet=True) self.assembly_uuid = utilities.fetch_uuid(fixture.url, self.path_for_assembly, self.variant, api_auth) published_assembly_url = fixture.url + "api/assembly/variant.json/" + self.assembly_uuid print("published assembly url: \n" + published_assembly_url) lcc.log_info("Published Assembly api endpoint: %s" % published_assembly_url) published_assembly_request = api_auth.get(published_assembly_url) check_that( "The /api/assembly/variant.json/<assembly_uuid> endpoint for a published assembly", published_assembly_request.status_code, equal_to(200)) # print("Response from published assembly API endpoint: \n" + str(published_assembly_request.content)) check_that("The response is ", published_assembly_request.json()["message"], equal_to("Assembly Found")) check_that("The title of the assembly ", published_assembly_request.json()["assembly"]["title"], contains_string(assembly_title_prefix)) check_that("The status of the assembly ", published_assembly_request.json()["assembly"]["status"], equal_to("published")) check_that( "The content type of the assembly", published_assembly_request.json()["assembly"]["content_type"], equal_to("assembly")) check_that("The body of the assembly", published_assembly_request.json()["assembly"]["body"], is_not_none()) #add a check for date_published, search_keywords, etc. @lcc.test( "Verify that acknowledgement was received from Hydra on publishing assembly" ) def ack_status_check(self, api_auth): self.request_url = fixture.url + self.path_for_assembly + ".10.json" response = api_auth.get(self.request_url) time.sleep(60) #calling the get request twice response = api_auth.get(self.request_url) lcc.log_info("Checking for ack_status at url: %s" % str(self.request_url)) check_that( "The published assembly now has a released node with ack_status node ", response.json()["en_US"]["variants"][self.variant]["released"], has_entry("ack_status")) lcc.log_info("Ack status node response: %s" % str(response.json()["en_US"]["variants"][self.variant] ["released"]["ack_status"])) check_that( "The published assembly has a successful message from Hydra", response.json()["en_US"]["variants"][self.variant]["released"] ["ack_status"]["pant:message"], equal_to("Solr call for index was successful")) check_that( "The published assembly has a successful ACK from Hydra", response.json()["en_US"]["variants"][self.variant]["released"] ["ack_status"]["pant:status"], equal_to("SUCCESSFUL")) @lcc.test( "Verify that the assembly was indexed in Solr in docv2 collection") def verify_solr_docv2_indexing_assembly(self): # Reusing the module id fetched in the above test time.sleep(15) solr_request_url = fixture.solr_url + "solr/docv2/select?indent=on&q=id:" + self.assembly_uuid + "&wt=json" lcc.log_info("Checking docv2 collection in Solr: %s" % solr_request_url) solr_request = requests.get(solr_request_url) time.sleep(10) solr_request = requests.get(solr_request_url) solr_request_json = solr_request.json() lcc.log_info("Response from Solr: %s " % str(solr_request_json)) check_that("The assembly is indexed in docv2 collection in Solr", solr_request_json["response"]["numFound"], equal_to(1)) check_that("The content type", solr_request_json["response"]["docs"][0]["content_type"][0], equal_to("assembly")) check_that("The uri", solr_request_json["response"]["docs"][0]["uri"], equal_to(self.assembly_uuid)) @lcc.disabled() @lcc.test( "Verify if the assembly is available for search in access collection") def verify_solr_access_collection_assembly(self): time.sleep(40) solr_request_url = fixture.solr_url + "solr/access/select?indent=on&q=id:" + self.assembly_uuid + "&wt=json" lcc.log_info("Checking access collection in Solr: %s" % solr_request_url) solr_request = requests.get(solr_request_url) time.sleep(10) solr_request = requests.get(solr_request_url) solr_request_json = solr_request.json() lcc.log_info("Response from Solr: %s " % str(solr_request_json)) check_that("The assembly is indexed in access collection in Solr", solr_request_json["response"]["numFound"], equal_to(1)) #add more checks here. check_that("The content type source ", solr_request_json["response"]["docs"][0]["source"], equal_to("assembly")) @lcc.test( "Verify that the assembly is successfully unpublished, Hydra sends an ACK" ) def unpublish_assembly(self, api_auth): unpublish_url = fixture.url + self.path_for_assembly lcc.log_info("Unpublishing the assembly: %s" % unpublish_url) payload = { ":operation": "pant:unpublish", "locale": "en_US", "variant": self.variant } unpublish_assembly_request = self.api_auth.post( unpublish_url, data=payload, headers={'Accept': 'application/json'}) time.sleep(12) check_that("Unpublish request status code", unpublish_assembly_request.status_code, equal_to(200)) # Check if the unpublish request response does not return "url" for Customer Portal: CCS-3860 cp_url_returned = unpublish_assembly_request.json()["location"] check_that( "UnPublish Assembly response does not contain The Customer Portal URL", cp_url_returned, not_(contains_string(fixture.cp_url + "documentation"))) time.sleep(20) response = api_auth.get(self.request_url) lcc.log_info("Checking for ack_status at url after unpublish: %s" % str(self.request_url)) check_that( "The unpublished assembly now has a draft node with ack_status node ", response.json()["en_US"]["variants"][self.variant]["draft"], has_entry("ack_status")) lcc.log_info("Ack status node response: %s" % str(response.json()["en_US"]["variants"][self.variant] ["draft"]["ack_status"])) # this is a place holder check check_that( "The unpublished assembly has a successful message from Hydra", response.json()["en_US"]["variants"][self.variant]["draft"] ["ack_status"]["pant:message"], equal_to("Solr call for delete was successful")) check_that( "The unpublished assembly has a successful ACK from Hydra", response.json()["en_US"]["variants"][self.variant]["draft"] ["ack_status"]["pant:status"], equal_to("SUCCESSFUL")) @lcc.test( "Verify if the assembly is successfully removed from docv2 collection") def removed_from_docv2_Solr(self): time.sleep(15) solr_request_url = fixture.solr_url + "solr/docv2/select?indent=on&q=id:" + self.assembly_uuid + "&wt=json" lcc.log_info("Checking docv2 collection in Solr: %s" % solr_request_url) solr_request = requests.get(solr_request_url) time.sleep(5) solr_request = requests.get(solr_request_url) solr_request_json = solr_request.json() lcc.log_info("Response from Solr: %s " % str(solr_request_json)) check_that("The assembly is removed from docv2 collection in Solr", solr_request_json["response"]["numFound"], equal_to(0)) @lcc.disabled() @lcc.test( "Verify is the assembly is successfully removed from access collection in Solr" ) def removed_from_access_Solr(self): lcc.log_info( "Checking if the assembly is removed from search results, access collection" ) time.sleep(20) solr_request_url = fixture.solr_url + "solr/access/select?indent=on&q=id:" + self.assembly_uuid + "&wt=json" lcc.log_info("Checking access collection in Solr: %s" % solr_request_url) solr_request = requests.get(solr_request_url) solr_request_json = solr_request.json() lcc.log_info("Response from Solr: %s " % str(solr_request_json)) check_that("The assembly is removed from access collection in Solr", solr_request_json["response"]["numFound"], equal_to(0))
class test_new_draft(Screenshot): driver = lcc.inject_fixture("driver_obj") now = datetime.now(timezone.utc) print("Now::", now) now_plus_15 = now + timedelta(minutes=15) now_minus_15 = now - timedelta(minutes=15) print("Range::", now_minus_15, "--", now_plus_15) flag = False def check_date_in_range(self, date): flag = False if (self.now_minus_15 <= date <= self.now_plus_15): flag = True print("date-time::", date) return flag def setup_suite(self): utilities.wait(5) # Navigate to search page # Select repo and search for the assembly # Add metadata and publish the assembly using api endpoints and wait for the unpublish button to display utilities.click_element(self.driver, By.LINK_TEXT, "Search") utilities.page_reload(self.driver) # search_page.search_for_module_and_click(self.driver, constants.published_module) search_beta_page.select_repo(self.driver, fixture.repo_name) search_beta_page.search_module_and_click( self.driver, constants.assembly_new_draft_version) display_module_page.add_metadata_and_publish(self.driver) utilities.wait_for_element(self.driver, By.ID, locators.MODULE_DISPLAY_UNPUBLISH_BUTTON_ID) # Navigate to search page # Select repo and search for the module # Add metadata and publish the module using api endpoints and wait for the unpublish button to display utilities.click_element(self.driver, By.LINK_TEXT, "Search") # search_page.search_for_module_and_click(self.driver, constants.published_module) search_beta_page.select_repo(self.driver, fixture.repo_name) search_beta_page.search_module_and_click( self.driver, constants.module_new_draft_version) display_module_page.add_metadata_and_publish(self.driver) utilities.wait_for_element(self.driver, By.ID, locators.MODULE_DISPLAY_UNPUBLISH_BUTTON_ID) @lcc.test("Upload the repo via uploader script 2nd time") def upload_repo_again(self): lcc.log_info("Uploaded the repo again") os.chdir(fixture.project_dir_git) repo = Repo(fixture.project_dir_git) git = repo.git git.checkout("at-uploader2") subprocess.check_call( ('pantheon --user={} --password={} --server={} push'.format( uploader_username, uploader_password, url)), shell=True) # search_page.search_for_module_and_click(self.driver, constants.published_module) search_beta_page.select_repo(self.driver, fixture.repo_name) search_beta_page.search_module_and_click( self.driver, constants.assembly_new_draft_version + " 2") check_that( "Draft card is displayed", utilities.find_element(self.driver, By.CSS_SELECTOR, locators.DRAFT_CARD).is_displayed(), is_true()) check_that( "Published card is displayed", utilities.find_element(self.driver, By.CSS_SELECTOR, locators.PUBLISHED_CARD).is_displayed(), is_true()) # Modify the datetime string to be in same format as datetime.now() draft_date1 = (utilities.find_element( self.driver, By.CSS_SELECTOR, locators.UPLOAD_TIME_ON_DRAFT_CARD).text) draft_date2 = draft_date1.split("GMT") pub_date1 = (utilities.find_element( self.driver, By.CSS_SELECTOR, locators.UPLOAD_TIME_ON_PUBLISHED_CARD).text) pub_date2 = pub_date1.split("GMT") print("Date time now::", self.now) draft_date = datetime.strptime(draft_date2[0].strip(), '%a %b %d %Y %H:%M:%S') draft_date = draft_date.replace(tzinfo=pytz.utc) pub_date = datetime.strptime(pub_date2[0].strip(), '%a %b %d %Y %H:%M:%S') pub_date = pub_date.replace(tzinfo=pytz.utc) print("Type of date is now::", draft_date) lcc.log_info("pub_date::%s" % pub_date) lcc.log_info("draft_date::%s" % draft_date) check_that( "Draft text displayed on card", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.DRAFT_CARD_TITLE), equal_to("Draft")) check_that( "Published text displayed on card", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.PUBLISHED_CARD_TITLE), equal_to("Published")) check_that("Draft upload date in expected range", self.check_date_in_range(draft_date), is_true()) check_that("Uploaded date for published card in expected range", self.check_date_in_range(pub_date), is_true()) check_that( "Uploaded date for published card should be less than draft uploaded date", pub_date < draft_date, is_true()) draft_card = utilities.find_element(self.driver, By.CSS_SELECTOR, locators.DRAFT_CARD) published_card = utilities.find_element(self.driver, By.CSS_SELECTOR, locators.PUBLISHED_CARD) check_that( "Add metadata link present of draft card", draft_card.find_element( By.XPATH, locators.ADD_METADATA_BUTTON_XPATH).is_displayed(), is_true()) check_that( "Add metadata link present of published card", published_card.find_element( By.XPATH, locators.ADD_METADATA_BUTTON_XPATH).is_displayed(), is_true()) check_that( "Preview link present of draft card", draft_card.find_element( By.CSS_SELECTOR, locators.MODULE_DISPLAY_PREVIEW_BUTTON_CSS).is_displayed(), is_true()) check_that( "Preview link present of published card", published_card.find_element( By.CSS_SELECTOR, locators.MODULE_DISPLAY_PREVIEW_BUTTON_CSS).is_displayed(), is_true()) check_that( "Publish button displayed on draft card", draft_card.find_element( By.ID, locators.MODULE_DISPLAY_PUBLISH_BUTTON_ID).is_displayed(), is_true()) check_that( "Unpublish button displayed on published card", published_card.find_element( By.ID, locators.MODULE_DISPLAY_UNPUBLISH_BUTTON_ID).is_displayed(), is_true()) check_that( "Attributes file path on draft card", draft_card.find_element(By.CSS_SELECTOR, locators.ATTRIBUTE_FILE_CSS).text, equal_to("enterprise/meta/attributes.adoc")) check_that( "Attributes file path on published card", published_card.find_element(By.CSS_SELECTOR, locators.ATTRIBUTE_FILE_CSS).text, equal_to("enterprise/meta/attributes.adoc")) def teardown_suite(self): response = unpublish_module(self, constants.module_new_draft_unpublish, constants.variant) check_that("Unpublish request status code for module", response.status_code, equal_to(200)) response = unpublish_module(self, constants.assembly_new_draft_unpublish, constants.variant) check_that("Unpublish request status code for assembly", response.status_code, equal_to(200))
class test_edit_metadata(Screenshot): driver = lcc.inject_fixture("driver_obj") @lcc.test("Verify that warning should be displayed on Edit Metadata modal when no data is entered") def edit_metadata_blank_data(self): utilities.click_element(self.driver, By.LINK_TEXT, "Search") utilities.page_reload(self.driver) # # Click on the title if it is displayed on the first page utilities.wait(5) # search_page.search_for_module_and_click(self.driver, constants.module_to_be_published) search_beta_page.select_repo(self.driver, fixture.repo_name) search_beta_page.search_module_and_click(self.driver, constants.module_to_be_published) self.driver.refresh() utilities.click_element(self.driver, By.XPATH, locators.ADD_METADATA_BUTTON_XPATH) check_that("Edit metadata modal title", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.EDIT_METADATA_MODAL_TITLE_CSS), contains_string(constants.edit_metadata_modal_title)) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.EDIT_METADATA_SAVE_CSS) check_that("Warning displayed", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.WARNING_ALERT_CSS), contains_string(constants.edit_metadata_modal_warning)) utilities.wait(2) @lcc.test("Verify that warning should be displayed on Edit Metadata modal when Product name field is blank") def edit_metadata_empty_productname(self): display_module_page.reset_edit_metadata_from(self.driver) display_module_page.fill_edit_metadata_form(self.driver, constants.default_product_name, constants.default_product_version, constants.use_case, constants.url_fragment) check_that("Warning displayed", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.WARNING_ALERT_CSS), contains_string(constants.edit_metadata_modal_warning)) utilities.wait(2) @lcc.test("Verify that warning should be displayed on Edit Metadata modal when Product version field is blank") def edit_metadata_empty_version(self): display_module_page.reset_edit_metadata_from(self.driver) display_module_page.fill_edit_metadata_form(self.driver, constants.product_name, constants.default_product_version, constants.use_case, constants.url_fragment) check_that("Warning displayed", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.WARNING_ALERT_CSS), contains_string(constants.edit_metadata_modal_warning)) utilities.wait(2) @lcc.test("Verify that warning should be displayed on Edit Metadata modal when Usecase field is blank") def edit_metadata_empty_usecase(self): display_module_page.reset_edit_metadata_from(self.driver) display_module_page.fill_edit_metadata_form(self.driver, constants.product_name, constants.product_version, constants.default_use_case, constants.url_fragment) check_that("Warning displayed", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.WARNING_ALERT_CSS), contains_string(constants.edit_metadata_modal_warning)) utilities.wait(2) @lcc.test("Verify that user should be able to add product metadata successfully") def edit_metadata_successfully(self): display_module_page.reset_edit_metadata_from(self.driver) display_module_page.fill_edit_metadata_form(self.driver, constants.product_name, constants.product_version, constants.use_case, constants.url_fragment) check_that("Success message displayed", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.UPDATE_SUCCESS_MESSAGE_CSS), contains_string(constants.success_message)) check_that("Product name reflected on displayed module page", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.PRODUCT_INFO_CSS), contains_string(constants.product_name)) check_that("Product version reflected on displayed module page", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.PRODUCT_INFO_CSS), contains_string(constants.product_version))
class test_view_module(Screenshot): driver = lcc.inject_fixture("driver_obj") def setup_suite(self): # Add metadata utilities.wait(5) utilities.click_element(self.driver, By.LINK_TEXT, "Search") utilities.page_reload(self.driver) # search_page.search_for_module_and_click(self.driver, constants.published_module) search_beta_page.select_repo(self.driver, fixture.repo_name) search_beta_page.search_module_and_click(self.driver, constants.published_module) display_module_page.add_metadata_and_publish(self.driver) utilities.wait_for_element(self.driver, By.ID, locators.MODULE_DISPLAY_UNPUBLISH_BUTTON_ID) @lcc.test( "Verify that for authenticated user, unpublished module displays all expected checks: Preview, ability to" " Publish, and status") # @lcc.depends_on('test_publish_module.publish_module') def authenticated_user_view_unpublished_module(self): utilities.click_element(self.driver, By.LINK_TEXT, "Search") utilities.page_reload(self.driver) # search_page.search_for_module_and_click(self.driver, constants.unpublished_module) search_beta_page.select_repo(self.driver, fixture.repo_name) search_beta_page.search_module_and_click(self.driver, constants.unpublished_module) check_that( "Button", utilities.get_text(self.driver, By.ID, locators.MODULE_DISPLAY_PUBLISH_BUTTON_ID), contains_string("Publish")) check_that( "Button", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.MODULE_DISPLAY_PREVIEW_BUTTON_CSS), contains_string("Preview")) check_that( "First Published date", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.MODULE_DISPLAY_FIRST_PUBLISHED_CSS), contains_string("--")) check_that( "Last Published date", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.MODULE_DISPLAY_LAST_PUBLISHED_CSS), contains_string("--")) check_that( "Module display page title", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.MODULE_DISPLAY_TITLE_CSS), contains_string(constants.unpublished_module)) @lcc.test( "Verify that for authenticated user, a previously published module displays all expected checks: " "Unpublish and View buttons") # @lcc.depends_on('test_publish_module.publish_module') def authenticated_user_view_published_module(self): utilities.click_element(self.driver, By.LINK_TEXT, "Search") # search_page.search_for_module_and_click(self.driver, constants.published_module) search_beta_page.select_repo(self.driver, fixture.repo_name) search_beta_page.search_module_and_click(self.driver, constants.published_module) # utilities.find_element(self.driver, By.ID, locators.MODULE_DISPLAY_PUBLISH_BUTTON_ID) check_that( "Button", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.MODULE_DISPLAY_PREVIEW_BUTTON_CSS), contains_string("Preview")) check_that( "Button", utilities.get_text(self.driver, By.ID, locators.MODULE_DISPLAY_UNPUBLISH_BUTTON_ID), contains_string("Unpublish")) # Add a check that the Published column contains some Published time. @lcc.test( "Verify that 'View on Customer Portal' link navigates to correct page and verify the presence of content" ) # @lcc.depends_on('test_publish_module.publish_module') def view_on_portal_link_test(self): try: utilities.wait(5) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.VIEW_ON_PORTAL_LINK_CSS) utilities.wait(5) utilities.switch_to_latest_tab(self.driver) utilities.wait(7) lcc.log_info( "Find the CP preview in the attachment below for debugging purposes" ) self.driver.save_screenshot("cp_preview_module.png") lcc.save_attachment_file("cp_preview_module.png") check_that("View on Portal URL path", self.driver.current_url, contains_string(constants.view_on_portal_page_url)) module_id_regex = re.compile( r'^[a-zA-Z0-9]{8}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{12}$' ) current__module_id = self.driver.current_url.split("/topic/")[1] check_that("View on Portal URL id", current__module_id, match_pattern(module_id_regex)) # content_body_on_portal = utilities.find_element(self.driver, By.CSS_SELECTOR, locators.MODULE_BODY_ON_PORTAL_CSS) except (TimeoutException, StaleElementReferenceException, NoSuchElementException) as e: lcc.log_error("Error finding element!!!") lcc.log_error(e) finally: if (len(self.driver.window_handles) > 1): self.driver.close() utilities.switch_to_first_tab(self.driver) @lcc.test("Verify that module content displays as expected on CP") def view_content_on_cp(self): # # try: test_repo_name = base.config_reader('test_repo', 'repo_name') utilities.click_element(self.driver, By.LINK_TEXT, "Search") utilities.wait(5) # search_page.search_for_module_and_click(self.driver, constants.published_module) search_beta_page.select_repo(self.driver, fixture.repo_name) search_beta_page.search_module_and_click(self.driver, constants.published_module) utilities.wait(5) try: adoc_file_path = display_module_page.get_path_to_adoc(self.driver) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.VIEW_ON_PORTAL_LINK_CSS) utilities.switch_to_latest_tab(self.driver) utilities.wait(6) content_body_on_portal = self.driver.find_element_by_css_selector( locators.MODULE_BODY_ON_PORTAL_CSS) # Verify content displayed on CP check_that( "Module title is displayed", utilities.find_shadow_dom_element( self.driver, locators.MODULE_TITLE_ON_PORTAL_CSS, locators.MODULE_BODY_ON_PORTAL_CSS).get_attribute( "textContent"), equal_to(constants.published_module)) check_that( "Product name displayed on Customer Portal", utilities.find_shadow_dom_element( self.driver, locators.CP_PRODUCT_NAME_CSS, locators.MODULE_BODY_ON_PORTAL_CSS).get_attribute( "textContent"), equal_to(constants.product_name)) check_that( "Product version displayed on Customer Portal", utilities.find_shadow_dom_element( self.driver, locators.CP_PRODUCT_VERSION_CSS, locators.MODULE_BODY_ON_PORTAL_CSS).get_attribute( "textContent"), equal_to(constants.product_version)) legal_notice = utilities.find_shadow_dom_element( self.driver, locators.LEGAL_NOTICE_ON_PORTAL_CSS, locators.MODULE_BODY_ON_PORTAL_CSS) check_that( "legal notice is displayed at the bottom of preview page", legal_notice.get_attribute("textContent"), contains_string("Legal Notices for Trademarks")) legal_notice_href = legal_notice.get_attribute("href") check_that("verify legal notice link", legal_notice_href, contains_string(constants.legal_notice_link)) image = utilities.find_shadow_dom_element( self.driver, locators.IMAGE_CSS, locators.MODULE_BODY_ON_PORTAL_CSS) src = image.get_attribute("src") imageasset = urlparse(src) imageasset = imageasset.path.split("/")[2] cmd = "echo " + imageasset + "|base64 -d" try: # subprocess.check_call(cmd, shell=True) path = subprocess.getoutput(cmd) print("Image file path::", path) print("File name::", constants.image_file_name) print("Path to adoc::", adoc_file_path) p1 = os.path.split(adoc_file_path) image_file = "/" + p1[ 0] + "/images/" + constants.image_file_name # image_file = "/content/repositories/" + test_repo_name + "/entities/enterprise/modules/images/" + constants.image_file_name check_that("Path to image1", path, equal_to(image_file)) except subprocess.CalledProcessError as e: lcc.log_info("Unable to decode imageasset") except Exception as e: lcc.log_info(e) finally: if (len(self.driver.window_handles) > 1): self.driver.close() utilities.switch_to_first_tab(self.driver) @lcc.test("verify attribute is resolving correctly on preview page") def verify_attribute_text(self): try: utilities.click_element(self.driver, By.LINK_TEXT, "Search") # search_page.search_for_module_and_click(self.driver, constants.search_module_with_attribute) search_beta_page.select_repo(self.driver, fixture.repo_name) search_beta_page.search_module_and_click( self.driver, constants.search_module_with_attribute) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.MODULE_DISPLAY_PREVIEW_BUTTON_CSS) utilities.wait(2) utilities.switch_to_latest_tab(self.driver) attribute_text = utilities.find_shadow_dom_element( self.driver, locators.ATTRIBUTE_ON_PREVIEW_CSS, locators.MODULE_BODY_CONTENT_CSS).text check_that( "verify attribute is resolving correctly on preview page", attribute_text, contains_string(constants.attribute)) except Exception as e: lcc.log_info(e) finally: if (len(self.driver.window_handles) > 1): self.driver.close() utilities.switch_to_first_tab(self.driver) def teardown_suite(self): response = unpublish_module(self, constants.view_module_unpubish, constants.variant) check_that("Unpublish request status code", response.status_code, equal_to(200)) lcc.log_info( "module published for above test is unpublished successfully..")
class test_module_edit_publish: api_auth = lcc.inject_fixture("api_auth") path_for_module = "" request_url = "" @lcc.test( "Verify that authenticated user can edit metadata successfully also verify response of pre-live URL before and after adding metadata" ) def edit_metadata(self, api_auth, setup_test_products): self.variant = utilities.read_variant_name_from_pantheon2config() lcc.log_info(str(self.variant)) self.variant = str(self.variant) self.path_for_module = utilities.select_nth_item_from_search_results( 0, fixture.url, module_title_prefix, api_auth) edit_metadata_url = fixture.url + self.path_for_module + "/en_US/variants/" + self.variant + "/draft/metadata" cp_url_path = fixture.url + self.path_for_module + "/en_US/variants/" + self.variant + ".url.json" print(cp_url_path) lcc.log_info("Checking Get CP URL api") resp = self.api_auth.get(cp_url_path) print(resp.json()) check_that("Get CP url response", resp.json(), has_entry("type", "ERROR")) check_that( "Get CP url response", resp.json(), has_entry( "url", "Document does not have associated product/version metadata.")) lcc.log_info("Edit metadata request for module: %s " % edit_metadata_url) # Fetch the product id from fixtures, ta test product and version was created as setup step. product_id, product_name_uri = setup_test_products payload = { "productVersion": product_id, "documentUsecase": constants.documentUsecase, "urlFragment": constants.urlFragment, "searchKeywords": constants.searchKeywords } # payload = urlencode(payload) print("PAyload::", payload) # headers = {'content-type': "application/x-www-form-urlencoded"} edit_metadata_request = self.api_auth.post(edit_metadata_url, data=payload) time.sleep(10) print("Response::", edit_metadata_request) self.request_url = fixture.url + self.path_for_module + ".10.json" #check that metadata has been added successfully. response = api_auth.get(self.request_url) print("Response::", response) metadata_response = response.json()["en_US"]["variants"][ self.variant]["draft"]["metadata"] print("Metadata response::", metadata_response) check_that("The edit metadata request was successful", edit_metadata_request.status_code, any_of(equal_to(200), equal_to(201))) check_that("The product version has been updated successfully", metadata_response["productVersion"], equal_to(product_id)) check_that("The document use case has been updated successfully", metadata_response["documentUsecase"], equal_to(constants.documentUsecase)) resp = self.api_auth.get(cp_url_path) print(resp.json()) url_test = cp_url + "documentation/en-us/" + product_name_uri + "/" + constants.product_version_uri + "/topic/" check_that("Get CP url response", resp.json(), has_entry("type", "PRELIVE")) check_that("Get CP url response", resp.json(), has_entry("url")) check_that("Get CP URL response", resp.json()["url"], contains_string(url_test)) @lcc.test("Verify that authenticated user can publish module successfully") def publish_module(self, api_auth): # Get path of the module for which metadata was added publish_url = fixture.url + self.path_for_module print("\n API end point used for publish request: " + publish_url) payload = { ":operation": "pant:publish", "locale": "en_US", "variant": self.variant } print("Payload: ", payload) time.sleep(10) publish_module_request = self.api_auth.post( publish_url, data=payload, headers={'Accept': 'application/json'}) time.sleep(10) check_that("The publish request was successful", publish_module_request.status_code, equal_to(200)) # Check if the publish request response returns "url" for Customer Portal: CCS-3860 cp_url_returned = publish_module_request.json()["location"] check_that("Publish module response contains The Customer Portal URL", cp_url_returned, contains_string(fixture.cp_url + "documentation")) response = api_auth.get(self.request_url) # Check that the node has been marked as released check_that("The published module now has a 'released' node", response.json()["en_US"]["variants"][self.variant], has_entry("released")) self.module_uuid = utilities.fetch_uuid(fixture.url, self.path_for_module, self.variant, api_auth) published_module_url = fixture.url + "api/module/variant.json/" + self.module_uuid print("published module url: \n" + published_module_url) lcc.log_info("Published Module api endpoint: %s" % published_module_url) data_from_published_module = api_auth.get(published_module_url) check_that( "The /api/module/variant.json/<module_uuid> endpoint for a published module", data_from_published_module.status_code, equal_to(200)) # print("Response from published module API endpoint: \n" + str(data_from_published_module.content)) check_that("The response is ", data_from_published_module.json()["message"], equal_to("Module Found")) check_that("The title of the module ", data_from_published_module.json()["module"]["title"], contains_string(module_title_prefix)) check_that("The status of the module ", data_from_published_module.json()["module"]["status"], equal_to("published")) check_that("The body of the module", data_from_published_module.json()["module"]["body"], is_not_none()) @lcc.test("Verify that acknowledgement was received from Hydra") def ack_status_check(self, api_auth): #self.request_module_url = fixture.url + self.path_for_module + ".10.json" time.sleep(40) response = api_auth.get(self.request_url) lcc.log_info("Checking for ack_status at url: %s" % str(self.request_url)) check_that( "The published module now has a released node with ack_status node ", response.json()["en_US"]["variants"][self.variant]["released"], has_entry("ack_status")) lcc.log_info("Ack status node response: %s" % str(response.json()["en_US"]["variants"][self.variant] ["released"]["ack_status"])) check_that( "The published module has a successful message from Hydra", response.json()["en_US"]["variants"][self.variant]["released"] ["ack_status"]["pant:message"], equal_to("Solr call for index was successful")) check_that( "The published module has a successful ACK from Hydra", response.json()["en_US"]["variants"][self.variant]["released"] ["ack_status"]["pant:status"], equal_to("SUCCESSFUL")) @lcc.test("Verify that the module was indexed in Solr in docv2 collection") def verify_solr_indexing(self): # Reusing the module id fetched in the above test time.sleep(15) solr_request_url = fixture.solr_url + "solr/docv2/select?indent=on&q=id:" + self.module_uuid + "&wt=json" lcc.log_info("Checking docv2 collection in Solr: %s" % solr_request_url) solr_request = requests.get(solr_request_url) solr_request_json = solr_request.json() lcc.log_info("Response from Solr: %s " % str(solr_request_json)) check_that("The module is indexed in docv2 collection in Solr", solr_request_json["response"]["numFound"], equal_to(1)) check_that("The content type", solr_request_json["response"]["docs"][0]["content_type"][0], equal_to("module")) @lcc.disabled() @lcc.test( "Verify if the module is available for search in access collection") def verify_solr_access_collection_module(self): time.sleep(40) solr_request_url = fixture.solr_url + "solr/access/select?indent=on&q=id:" + self.module_uuid + "&wt=json" lcc.log_info("Checking access collection in Solr: %s" % solr_request_url) solr_request = requests.get(solr_request_url) time.sleep(10) solr_request = requests.get(solr_request_url) solr_request_json = solr_request.json() lcc.log_info("Response from Solr: %s " % str(solr_request_json)) check_that("The module is indexed in access collection in Solr", solr_request_json["response"]["numFound"], equal_to(1)) # add more checks here. check_that("The content type source ", solr_request_json["response"]["docs"][0]["source"], equal_to("module")) @lcc.test( "Verify that the module is successfully unpublished, Hydra sends an ACK" ) def unpublish_module(self, api_auth): unpublish_url = fixture.url + self.path_for_module lcc.log_info("Unpublishing the module: %s" % unpublish_url) payload = { ":operation": "pant:unpublish", "locale": "en_US", "variant": self.variant } unpublish_module_request = self.api_auth.post( unpublish_url, data=payload, headers={'Accept': 'application/json'}) time.sleep(15) check_that("Unpublish request status code", unpublish_module_request.status_code, equal_to(200)) # Check if the unpublish request response does not return "url" for Customer Portal: CCS-3860 cp_url_returned = unpublish_module_request.json()["location"] check_that( "UnPublish module response does not contain The Customer Portal URL", cp_url_returned, not_(contains_string(fixture.cp_url + "documentation"))) time.sleep(20) response = api_auth.get(self.request_url) lcc.log_info("Checking for ack_status at url after unpublish: %s" % str(self.request_url)) check_that( "The unpublished module now has a draft node with ack_status node ", response.json()["en_US"]["variants"][self.variant]["draft"], has_entry("ack_status")) lcc.log_info("Ack status node response: %s" % str(response.json()["en_US"]["variants"][self.variant] ["draft"]["ack_status"])) # this is a place holder check check_that( "The unpublished module has a successful message from Hydra", response.json()["en_US"]["variants"][self.variant]["draft"] ["ack_status"]["pant:message"], equal_to("Solr call for delete was successful")) check_that( "The unpublished module has a successful ACK from Hydra", response.json()["en_US"]["variants"][self.variant]["draft"] ["ack_status"]["pant:status"], equal_to("SUCCESSFUL")) @lcc.test( "Verify if the module is successfully removed from docv2 collection in Solr" ) def removed_from_solr(self): time.sleep(20) solr_request_url = fixture.solr_url + "solr/docv2/select?indent=on&q=id:" + self.module_uuid + "&wt=json" lcc.log_info("Checking docv2 collection in Solr: %s" % solr_request_url) solr_request = requests.get(solr_request_url) solr_request_json = solr_request.json() lcc.log_info("Response from Solr: %s " % str(solr_request_json)) check_that("The module is removed from docv2 collection in Solr", solr_request_json["response"]["numFound"], equal_to(0)) @lcc.disabled() @lcc.test( "Verify if the module is successfully removed from access collection in Solr" ) def removed_from_access_Solr(self): lcc.log_info( "Checking if the module is removed from search results, access collection" ) time.sleep(20) solr_request_url = fixture.solr_url + "solr/access/select?indent=on&q=id:" + self.module_uuid + "&wt=json" lcc.log_info("Checking access collection in Solr: %s" % solr_request_url) solr_request = requests.get(solr_request_url) solr_request_json = solr_request.json() lcc.log_info("Response from Solr: %s " % str(solr_request_json)) check_that("The module is removed from access collection in Solr", solr_request_json["response"]["numFound"], equal_to(0))
class MySuite: fix3 = lcc.inject_fixture() @lcc.test("test") def sometest(self): pass
class test_git_import: api_auth = lcc.inject_fixture("api_auth") status_key = "" @lcc.test( "Verify that git clone API is able to upload files successfully and get status_key from response" ) def git_clone_api(self): payload = { "branch": git_import_repo_branch, "repo": git_import_repo_URL } payload = json.dumps(payload) lcc.log_info(str(payload)) git_import_req = requests.post(fixture.git_import_server + "/api/clone", data=payload) check_that("POST request to git clone was done", git_import_req.status_code, equal_to(202)) self.status_key = git_import_req.content time.sleep(5) git_status_response = requests.post(fixture.git_import_server + "/api/status", data=self.status_key) check_that("git import status", git_status_response.json()["status"], contains_string("uploading")) @lcc.test("Verify that resources are uploaded") def check_resources_api(self): poll(lambda: requests.post(fixture.git_import_server + "/api/progress-update/resources", data=self.status_key), check_success=check_current_status, step=5, timeout=60) resources_response = requests.post(fixture.git_import_server + "/api/progress-update/resources", data=self.status_key) check_that("resources API status code", resources_response.status_code, equal_to(200)) check_that("current status", resources_response.json()["current_status"], equal_to("done")) check_that("number of resources uploaded", resources_response.json()["total_files_uploaded"], equal_to(int(number_of_resources_uploaded))) check_that("resources not uploaded", resources_response.json()["resources_not_uploaded"], equal_to([])) check_that("server message", resources_response.json()["server_message"], equal_to("Accepting requests")) check_that("server status", resources_response.json()["server_status"], equal_to("OK")) check_that("last_uploaded_file", resources_response.json()["last_uploaded_file"], is_not_none()) check_that("modules not uploaded", resources_response.json()["resources_not_uploaded"], equal_to([])) resources_uploaded = resources_response.json()["resources_uploaded"] check_response_code(resources_uploaded, "response_code", int(number_of_resources_uploaded)) check_not_null(resources_uploaded, "path", int(number_of_resources_uploaded)) check_not_null(resources_uploaded, "response_details", int(number_of_resources_uploaded)) @lcc.test("Verify that modules are uploaded") def check_modules_api(self): poll(lambda: requests.post(fixture.git_import_server + "/api/progress-update/modules", data=self.status_key), check_success=check_current_status, step=5, timeout=20) modules_response = requests.post(fixture.git_import_server + "/api/progress-update/modules", data=self.status_key) check_that("modules API status code", modules_response.status_code, equal_to(200)) check_that("current status", modules_response.json()["current_status"], equal_to("done")) check_that("number of modules uploaded", modules_response.json()["total_files_uploaded"], equal_to(int(number_of_modules_uploaded))) check_that("modules not uploaded", modules_response.json()["modules_not_uploaded"], equal_to([])) check_that("server message", modules_response.json()["server_message"], equal_to("Accepting requests")) check_that("server status", modules_response.json()["server_status"], equal_to("OK")) check_that("last_uploaded_file", modules_response.json()["last_uploaded_file"], is_not_none()) modules_uploaded = modules_response.json()["modules_uploaded"] check_response_code(modules_uploaded, "response_code", int(number_of_modules_uploaded)) check_not_null(modules_uploaded, "path", int(number_of_modules_uploaded)) check_not_null(modules_uploaded, "response_details", int(number_of_modules_uploaded)) @lcc.test("Verify that assemblies are uploaded") def check_assemblies_api(self): poll(lambda: requests.post(fixture.git_import_server + "/api/progress-update/assemblies", data=self.status_key), check_success=check_current_status, step=5, timeout=20) assemblies_response = requests.post(fixture.git_import_server + "/api/progress-update/assemblies", data=self.status_key) check_that("modules API status code", assemblies_response.status_code, equal_to(200)) check_that("current status", assemblies_response.json()["current_status"], equal_to("done")) check_that("number of assemblies uploaded", assemblies_response.json()["total_files_uploaded"], equal_to(int(number_of_assemblies_uploaded))) check_that("assemblies not uploaded", assemblies_response.json()["assemblies_not_uploaded"], equal_to([])) check_that("server message", assemblies_response.json()["server_message"], equal_to("Accepting requests")) check_that("server status", assemblies_response.json()["server_status"], equal_to("OK")) check_that("last_uploaded_file", assemblies_response.json()["last_uploaded_file"], is_not_none()) assemblies_uploaded = assemblies_response.json()["assemblies_uploaded"] check_response_code(assemblies_uploaded, "response_code", int(number_of_assemblies_uploaded)) check_not_null(assemblies_uploaded, "path", int(number_of_assemblies_uploaded)) check_not_null(assemblies_uploaded, "response_details", int(number_of_assemblies_uploaded)) @lcc.test("Verify progress-update/all API works as expected") def check_progress_update_all_api(self): response = requests.post(fixture.git_import_server + "/api/progress-update/all", data=self.status_key) check_that("progress-update/all API status code", response.status_code, equal_to(200)) check_that("current status", response.json()["current_status"], equal_to("done")) check_that( "status code for module variant created", response.json()["module_variants_created"][0]["response_code"], equal_to(201)) git_status_response = requests.post(fixture.git_import_server + "/api/status", data=self.status_key) check_that("git import status", git_status_response.json()["status"], contains_string("done")) def teardown_suite(self): # Deleting the git repo uploaded via git import in the test suite. lcc.log_info("Deleting the git repo imported...") path_to_git_repo = fixture.url + "bin/cpm/nodes/node.json/content/repositories/" + git_import_repo_Name lcc.log_info( "Test repo node used for git import functionality being deleted at: %s" % path_to_git_repo) response_git_delete = requests.delete(path_to_git_repo, auth=(fixture.admin_username, fixture.admin_auth)) # print(str(response_git_delete.content)) check_that( "The git import test repo was deleted successfully from backend", response_git_delete.status_code, equal_to(200))
class test_view_assembly(Screenshot): driver = lcc.inject_fixture("driver_obj") modules_count = 0 module_titles = [] @lcc.test("Verify that user can add metadata to assembly") def add_metadata(self): utilities.wait(5) utilities.click_element(self.driver, By.LINK_TEXT, "Search") utilities.page_reload(self.driver) # search_page.search_for_module_and_click(self.driver, constants.assembly_to_be_published) search_beta_page.select_repo(self.driver, fixture.repo_name) search_beta_page.search_module_and_click( self.driver, constants.assembly_to_be_published) utilities.click_element(self.driver, By.XPATH, locators.ADD_METADATA_BUTTON_XPATH) check_that( "Edit metadata modal title", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.EDIT_METADATA_MODAL_TITLE_CSS), contains_string(constants.edit_metadata_modal_title)) display_module_page.fill_edit_metadata_form(self.driver, constants.product_name, constants.product_version, constants.use_case, constants.url_fragment) check_that( "Success message displayed", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.UPDATE_SUCCESS_MESSAGE_CSS), contains_string(constants.success_message)) check_that( "Product name reflected on displayed module page", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.PRODUCT_INFO_CSS), contains_string(constants.product_name)) check_that( "Product version reflected on displayed module page", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.PRODUCT_INFO_CSS), contains_string(constants.product_version)) utilities.wait(2) @lcc.test("Verify that user is able to publish assembly successfully") def publish_assembly(self): utilities.wait(5) utilities.click_element(self.driver, By.ID, locators.MODULE_DISPLAY_PUBLISH_BUTTON_ID) check_that( "Button", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.MODULE_DISPLAY_PREVIEW_BUTTON_CSS), contains_string("Preview")) check_that( "Button", utilities.get_text(self.driver, By.ID, locators.MODULE_DISPLAY_UNPUBLISH_BUTTON_ID), contains_string("Unpublish")) # Add a check that the Published column contains some Published time. @lcc.test("Verify contents of assembly preview in pantheon") # 1. Verify assembly title is displayed as expected # 2. Verify product name is displayed as expected # 3. Verify product version is displayed as expected # 4. Verify image path is resolved and contains expected value # 5. Verify all included modules are displayed in assembly preview def preview_assembly(self): test_repo_name = base.config_reader('test_repo', 'repo_name') try: # Get list of modules included modules_included = utilities.find_elements_by_css_selector( self.driver, locators.MODULES_INCLUDED_LIST_CSS) test_view_assembly.modules_count = len(modules_included) for i in range(test_view_assembly.modules_count): test_view_assembly.module_titles.append( modules_included[i].text) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.MODULE_DISPLAY_PREVIEW_BUTTON_CSS) utilities.wait(5) utilities.switch_to_latest_tab(self.driver) utilities.wait(7) assembly_title = utilities.find_shadow_dom_element( self.driver, locators.DOCUMENT_TITLE, locators.MODULE_BODY_CONTENT_CSS).text print(assembly_title) check_that("Assembly title", constants.assembly_to_be_published, contains_string(assembly_title)) product_name = utilities.find_shadow_dom_element( self.driver, locators.PRODUCT_NAME_ON_PREVIEW_CSS, locators.MODULE_BODY_CONTENT_CSS).text print(product_name) check_that("Product name reflected on view page", product_name, contains_string(constants.product_name)) product_version = utilities.find_shadow_dom_element( self.driver, locators.PRODUCT_VERSION_ON_PREVIEW_CSS, locators.MODULE_BODY_CONTENT_CSS).text print(product_version) check_that("Product version reflected on view page", product_version, contains_string(constants.product_version)) image = utilities.find_shadow_dom_element( self.driver, locators.IMAGE_CSS, locators.MODULE_BODY_CONTENT_CSS) src = image.get_attribute("src") imageasset = urlparse(src) imageasset = imageasset.path.split("/")[2] cmd = "echo " + imageasset + "|base64 -d" try: # subprocess.check_call(cmd, shell=True) path = subprocess.getoutput(cmd) print("Image file path::", path) image_file = "/content/repositories/" + test_repo_name + "/entities/enterprise/assemblies/images/" + constants.image_file_name check_that("Path to image1", path, equal_to(image_file)) except subprocess.CalledProcessError as e: lcc.log_info("Unable to decode imageasset") assembly_body = utilities.get_text( self.driver, By.CSS_SELECTOR, locators.ASSEMBLY_BODY_PREVIEW_CSS) for i in range(test_view_assembly.modules_count): check_that( "Assembly body", assembly_body, contains_string(test_view_assembly.module_titles[i])) except Exception as e: lcc.log_error(e) finally: if (len(self.driver.window_handles) > 1): self.driver.close() utilities.switch_to_first_tab(self.driver) @lcc.test("Verify contents of assembly on CP") def view_assembly_on_cp(self): test_repo_name = base.config_reader('test_repo', 'repo_name') try: utilities.page_reload(self.driver) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.VIEW_ON_PORTAL_LINK_CSS) utilities.wait(5) utilities.switch_to_latest_tab(self.driver) utilities.wait(7) check_that( "URL portal is", self.driver.current_url, contains_string( "https://access.qa.redhat.com/documentation/en-us/" + constants.product_name_uri + "/" + constants.product_version + "/guide/")) assembly_title = utilities.find_shadow_dom_element( self.driver, locators.DOCUMENT_TITLE_CP, locators.MODULE_BODY_ON_PORTAL_CSS).text check_that("Assembly title", assembly_title, contains_string(constants.assembly_to_be_published)) product_name = utilities.find_shadow_dom_element( self.driver, locators.PRODUCT_NAME_ON_PREVIEW_CSS, locators.MODULE_BODY_ON_PORTAL_CSS).text check_that("Product name reflected on view page", product_name, contains_string(constants.product_name)) product_version = utilities.find_shadow_dom_element( self.driver, locators.PRODUCT_VERSION_ON_PREVIEW_CSS, locators.MODULE_BODY_ON_PORTAL_CSS).text check_that("Product version reflected on view page", product_version, contains_string(constants.product_version)) image = utilities.find_shadow_dom_element( self.driver, locators.IMAGE_CSS, locators.MODULE_BODY_ON_PORTAL_CSS) src = image.get_attribute("src") imageasset = urlparse(src) imageasset = imageasset.path.split("/")[2] cmd = "echo " + imageasset + "|base64 -d" try: # subprocess.check_call(cmd, shell=True) path = subprocess.getoutput(cmd) print("Image file path::", path) image_file = "/content/repositories/" + test_repo_name + "/entities/enterprise/assemblies/images/" + constants.image_file_name check_that("Path to image1", path, equal_to(image_file)) except subprocess.CalledProcessError as e: lcc.log_info("Unable to decode imageasset") assembly_body = utilities.get_text( self.driver, By.CSS_SELECTOR, locators.ASSEMBLY_BODY_PREVIEW_CSS) for i in range(test_view_assembly.modules_count): check_that( "Assembly body", assembly_body, contains_string(test_view_assembly.module_titles[i])) guides_content_related = utilities.find_shadow_dom_element( self.driver, locators.CONTENT_RELATED_TO_GUIDES, locators.MODULE_BODY_ON_PORTAL_CSS) self.driver.execute_script("arguments[0].scrollIntoView();", guides_content_related) utilities.wait(20) check_that("Content related to this guide setcion", guides_content_related.is_displayed(), equal_to(True)) # utilities.click_element(self.driver, By.XPATH, "//summary[text()='Content related to this guide']") additional_res_guide = utilities.find_shadow_dom_element( self.driver, locators.CONTENT_RELATED_GUIDES_RESOURCES, locators.MODULE_BODY_ON_PORTAL_CSS) check_that( "Content related to this guide setcion to contain Addtional resources setion", additional_res_guide.is_displayed(), equal_to(True)) except Exception as e: lcc.log_error(e) finally: if (len(self.driver.window_handles) > 1): self.driver.close() utilities.switch_to_first_tab(self.driver) def teardown_suite(self): response = unpublish_module(self, constants.assembly_to_unpublish, constants.variant) check_that("Unpublish request status code", response.status_code, equal_to(200)) lcc.log_info( "Assembly published for above test is unpublished successfully..")
class test_search_and_filter(Screenshot): driver = lcc.inject_fixture("driver_obj") @lcc.test('Verify that search results are as expected') @lcc.disabled() def search_for_module(self): utilities.click_element(self.driver, By.LINK_TEXT, "Search") utilities.page_reload(self.driver) utilities.wait(2) utilities.enter_text(self.driver, By.ID, locators.SEARCH_BOX_ID, constants.module_to_search) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.SEARCH_BUTTON_CSS) utilities.wait(3) check_that( "module is found on search page", utilities.get_text(self.driver, By.XPATH, locators.SEARCH_MODULE_XPATH), contains_string(constants.module_to_search)) @lcc.test( "Verify that warning should be displayed when module is not found") @lcc.disabled() def search_for_random_text(self): utilities.find_elements_by_id(self.driver, locators.SEARCH_BOX_ID).clear() utilities.enter_text(self.driver, By.ID, locators.SEARCH_BOX_ID, constants.random_string_search) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.SEARCH_BUTTON_CSS) utilities.wait(2) check_that( "warning alert displayed", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.ALERT_TITLE_CSS), contains_string(constants.no_module_found)) utilities.click_element(self.driver, By.XPATH, locators.CANCEL_BUTTON_XPATH) utilities.wait(2) @lcc.test( "verify that the search results for asian characters such as '安装术语' should give accurate results." ) @lcc.disabled() def search_for_module_with_asian_chars(self): utilities.find_elements_by_id(self.driver, locators.SEARCH_BOX_ID).clear() utilities.enter_text(self.driver, By.ID, locators.SEARCH_BOX_ID, constants.asian_char_module) # module will be searchable once CCS-3754 is fixed # verifying warning alert as of now utilities.click_element(self.driver, By.CSS_SELECTOR, locators.SEARCH_BUTTON_CSS) utilities.wait(2) check_that( "module with asian character should be found once CCS-3754 is fixed, checking for warning alert as of now..", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.ALERT_TITLE_CSS), contains_string(constants.no_module_found)) utilities.click_element(self.driver, By.XPATH, locators.CANCEL_BUTTON_XPATH) utilities.wait(2) @lcc.test("Verify search results from body of the module") @lcc.disabled() def search_for_body_of_module(self): try: utilities.find_elements_by_id(self.driver, locators.SEARCH_BOX_ID).clear() utilities.enter_text(self.driver, By.ID, locators.SEARCH_BOX_ID, constants.body_of_module_search) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.SEARCH_BUTTON_CSS) utilities.wait(2) utilities.click_element(self.driver, By.XPATH, locators.SEARCH_MODULE_XPATH) utilities.wait(2) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.MODULE_DISPLAY_PREVIEW_BUTTON_CSS) utilities.wait(2) utilities.switch_to_latest_tab(self.driver) body_of_module_on_preview = utilities.find_shadow_dom_element( self.driver, locators.SEARCH_BODY_ON_PREVIEW_CSS, locators.MODULE_BODY_CSS).text check_that("content of module is displayed", body_of_module_on_preview, contains_string(constants.body_of_module_search)) utilities.wait(2) except (TimeoutException, StaleElementReferenceException, NoSuchElementException) as e: lcc.log_error("Error finding element: %s" % e) lcc.log_error(e) finally: self.driver.close() utilities.switch_to_first_tab(self.driver) @lcc.test("Verify that product and version filter works as expected") @lcc.disabled() def select_product_and_version_filter(self): utilities.click_element(self.driver, By.LINK_TEXT, "Search") utilities.wait(2) utilities.select_value_from_dropdown(self.driver, By.CSS_SELECTOR, locators.SELECT_PRODUCT_NAME_CSS, constants.product_name) utilities.select_value_from_dropdown( self.driver, By.CSS_SELECTOR, locators.SELECT_PRODUCT_VERSION_CSS, constants.product_version) lcc.log_info( "product and version selected and displayed on search page") utilities.find_element( self.driver, By.XPATH, locators.PRODUCT_FILTER_DISPLAY_XPATH).is_displayed() utilities.click_element(self.driver, By.CSS_SELECTOR, locators.SEARCH_BUTTON_CSS) utilities.wait(2) utilities.click_element(self.driver, By.XPATH, locators.SEARCH_MODULE_XPATH) utilities.wait(2) check_that( "verify that 'filter by product and version' functionality filters results correctly", utilities.get_text(self.driver, By.XPATH, locators.PRODUCT_VERSION_DISPLAY_PAGE_XPATH), contains_string(constants.product_name + " " + constants.product_version)) @lcc.test( "Verify that 'Filter by content Type': Assembly functionality filters results correctly" ) @lcc.disabled() def select_content_type_filter(self): verify_filter_by_content_type(self.driver, "Assembly")
class test_create_product(Screenshot): driver = lcc.inject_fixture("driver_obj") @lcc.test('Verify that Warning is displayed when no product name is being entered') def create_product_blank_name(self): utilities.click_element(self.driver, By.XPATH, locators.MENU_PRODUCTS_LINK_XPATH) utilities.click_element(self.driver, By.LINK_TEXT, locators.MENU_NEW_PRODUCT_LINK_TEXT) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.SAVE_PRODUCT_BUTTON_CSS) check_that("Warning is displayed", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.WARNING_ALERT_CSS), contains_string(constants.blank_product_name_warning)) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.CLOSE_WARNING_ALERT_CSS) @lcc.test("Verify that Warning is displayed when no url fragment is entered") def create_product_blank_url_fragment(self): # utilities.click_element(self.driver, By.LINK_TEXT, locators.MENU_PRODUCTS_LINK_TEXT) # utilities.click_element(self.driver, By.LINK_TEXT, locators.MENU_NEW_PRODUCT_LINK_TEXT) lcc.log_info("Product name input: %s " % product_name) # Reload new product to clear old values utilities.page_reload(self.driver) utilities.wait(3) # Fill new product form utilities.enter_text(self.driver, By.ID, locators.PRODUCT_NAME_TEXTBOX_ID, product_name) utilities.enter_text(self.driver, By.ID, locators.NEW_PRODUCT_VERSION_TEXTBOX_ID, constants.product_version) utilities.enter_text(self.driver, By.ID, locators.PRODUCT_VERSION_URL_FRAGMENT_ID, constants.product_version) utilities.enter_text(self.driver, By.ID, locators.PRODUCT_DESCRIPTION_TEXTBOX_ID, constants.new_product_description) utilities.find_element(self.driver, By.ID, locators.PRODUCT_URL_FRAGMENT_TEXTBOX_ID).clear() utilities.click_element(self.driver, By.CSS_SELECTOR, locators.SAVE_PRODUCT_BUTTON_CSS) check_that("Warning is displayed", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.WARNING_ALERT_CSS), contains_string(constants.blank_product_name_warning)) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.CLOSE_WARNING_ALERT_CSS) @lcc.test("Verify that Warning is displayed when version is not entered") def create_product_blank_version(self): # utilities.click_element(self.driver, By.LINK_TEXT, locators.MENU_NEW_PRODUCT_LINK_TEXT) lcc.log_info("Product name input: %s " % product_name) # Reload new product to clear old values utilities.page_reload(self.driver) utilities.wait(3) # Fill new product form utilities.enter_text(self.driver, By.ID, locators.PRODUCT_NAME_TEXTBOX_ID, product_name) utilities.enter_text(self.driver, By.ID, locators.PRODUCT_URL_FRAGMENT_TEXTBOX_ID, constants.url_fragment) utilities.find_element(self.driver, By.ID, locators.NEW_PRODUCT_VERSION_TEXTBOX_ID).clear() utilities.enter_text(self.driver, By.ID, locators.PRODUCT_VERSION_URL_FRAGMENT_ID, constants.product_version) utilities.enter_text(self.driver, By.ID, locators.PRODUCT_DESCRIPTION_TEXTBOX_ID, constants.new_product_description) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.SAVE_PRODUCT_BUTTON_CSS) check_that("Warning is displayed", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.WARNING_ALERT_CSS), contains_string(constants.blank_product_name_warning)) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.CLOSE_WARNING_ALERT_CSS) @lcc.test("Verify that the product is created successfully and listed in the Products list") def create_product(self): # utilities.click_element(self.driver, By.LINK_TEXT, locators.MENU_NEW_PRODUCT_LINK_TEXT) lcc.log_info("Product name input: %s " % product_name) # Reload new product page to clear old values utilities.page_reload(self.driver) # Fill new product form utilities.enter_text(self.driver, By.ID, locators.PRODUCT_NAME_TEXTBOX_ID, product_name) utilities.enter_text(self.driver, By.ID, locators.PRODUCT_URL_FRAGMENT_TEXTBOX_ID, constants.url_fragment) utilities.enter_text(self.driver, By.ID, locators.NEW_PRODUCT_VERSION_TEXTBOX_ID, constants.product_version) utilities.enter_text(self.driver, By.ID, locators.PRODUCT_VERSION_URL_FRAGMENT_ID, constants.product_version) utilities.enter_text(self.driver, By.ID, locators.PRODUCT_DESCRIPTION_TEXTBOX_ID, constants.new_product_description) utilities.enter_text(self.driver, By.ID, locators.NEW_PRODUCT_VERSION_TEXTBOX_ID, constants.product_version) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.SAVE_PRODUCT_BUTTON_CSS) utilities.wait(5) products = utilities.find_elements_by_css_selector(self.driver, locators.PRODUCT_NAME_LIST_CSS) lcc.log_info(str(len(products))) products_list = [] for product in products: products_list.append(product.text) check_that("Product created is listed successfully", products_list, has_item(product_name), quiet=False) @lcc.test("Verify that user is unable to create duplicate product names, Warning is displayed") def duplicate_product_name(self): # Navigate to New product page from Product listing page utilities.click_element(self.driver, By.XPATH, locators.MENU_PRODUCTS_LINK_XPATH) utilities.click_element(self.driver, By.LINK_TEXT, locators.MENU_NEW_PRODUCT_LINK_TEXT) lcc.log_info("Product name input: %s " % product_name) # Reload new product page to clear old values utilities.page_reload(self.driver) # Fill new product form utilities.enter_text(self.driver, By.ID, locators.PRODUCT_NAME_TEXTBOX_ID, product_name) utilities.enter_text(self.driver, By.ID, locators.PRODUCT_URL_FRAGMENT_TEXTBOX_ID, constants.url_fragment) utilities.enter_text(self.driver, By.ID, locators.NEW_PRODUCT_VERSION_TEXTBOX_ID, constants.product_version) utilities.enter_text(self.driver, By.ID, locators.PRODUCT_VERSION_URL_FRAGMENT_ID, constants.product_version) utilities.enter_text(self.driver, By.ID, locators.PRODUCT_DESCRIPTION_TEXTBOX_ID, constants.new_product_description) utilities.enter_text(self.driver, By.ID, locators.NEW_PRODUCT_VERSION_TEXTBOX_ID, constants.product_version) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.SAVE_PRODUCT_BUTTON_CSS) check_that("Duplicate Product warning is displayed", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.WARNING_ALERT_CSS), contains_string(constants.duplicate_product_name_warning)) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.CLOSE_WARNING_ALERT_CSS) @lcc.test("Verify that user is unable to create duplicate product names with different version, Warning is displayed") def duplicate_product_name_different_version(self): # utilities.click_element(self.driver, By.LINK_TEXT, locators.MENU_NEW_PRODUCT_LINK_TEXT) lcc.log_info("Product name input: %s " % product_name) # Reload new product page to clear old values utilities.page_reload(self.driver) # Fill new product form utilities.enter_text(self.driver, By.ID, locators.PRODUCT_NAME_TEXTBOX_ID, product_name) utilities.enter_text(self.driver, By.ID, locators.PRODUCT_URL_FRAGMENT_TEXTBOX_ID, constants.url_fragment) utilities.enter_text(self.driver, By.ID, locators.NEW_PRODUCT_VERSION_TEXTBOX_ID, constants.product_version_2) utilities.enter_text(self.driver, By.ID, locators.PRODUCT_VERSION_URL_FRAGMENT_ID, constants.product_version_url_fragment_2) utilities.enter_text(self.driver, By.ID, locators.PRODUCT_DESCRIPTION_TEXTBOX_ID, constants.new_product_description) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.SAVE_PRODUCT_BUTTON_CSS) check_that("Duplicate Product warning is displayed", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.WARNING_ALERT_CSS), contains_string(constants.duplicate_product_name_warning)) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.CLOSE_WARNING_ALERT_CSS) @lcc.test("Verify that blank product gives error message") def blank_product_versions(self): utilities.click_element(self.driver, By.XPATH, locators.MENU_PRODUCTS_LINK_XPATH) utilities.click_element(self.driver, By.LINK_TEXT, locators.MENU_PRODUCT_LISTING_LINK_TEXT) # User clicks on 'Product details' button for the product created above. lcc.log_info("Product name to add versions for: %s " % product_name) utilities.wait(10) products = utilities.find_elements_by_class_name(self.driver, locators.PRODUCT_NAMES_LIST_CLASS_NAME) lcc.log_info("Number of products found in the list %s" % str(len(products))) for product in products: if product_name in product.text: lcc.log_info("Adding versions to %s" % product.text) product.find_element_by_class_name("pf-c-options-menu").click() lcc.log_info("Clicking on the dropdown to add product details") product.find_element_by_class_name(locators.PRODUCT_DETAILS_BUTTON_CLASS_NAME).click() break #Verify blank product version and url fragment utilities.find_element(self.driver, By.ID, locators.NEW_PRODUCT_VERSION_TEXTBOX_ID).clear() utilities.find_element(self.driver, By.ID, locators.VERSION_URL_FRAGMENT_ID).clear() utilities.click_element(self.driver, By.CSS_SELECTOR, locators.PRODUCT_VERSION_SAVE_BUTTON_CSS) check_that("Warning is displayed", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.WARNING_ALERT_CSS), contains_string(constants.blank_product_name_warning)) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.CLOSE_WARNING_ALERT_CSS) @lcc.test("Verify that invalid product version url_fragment gives error") def invalid_product_version_url_fragment(self): #Verify invalid input for url fragment utilities.enter_text(self.driver, By.ID, locators.NEW_PRODUCT_VERSION_TEXTBOX_ID, constants.product_version_1) utilities.enter_text(self.driver, By.ID, locators.VERSION_URL_FRAGMENT_ID, "#") check_that("Warning is displayed", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.WARNING_ALERT_CSS), contains_string(constants.version_url_fragment_warning)) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.CLOSE_WARNING_ALERT_CSS) utilities.find_element(self.driver, By.ID, locators.NEW_PRODUCT_VERSION_TEXTBOX_ID).clear() @lcc.test("Verify that user is able to create versions of the above product") def create_product_versions(self): # User adds versions to the 'Add Product versions' and verifies if the versions were added successfully. utilities.enter_text(self.driver, By.ID, locators.NEW_PRODUCT_VERSION_TEXTBOX_ID, constants.product_version_1) utilities.enter_text(self.driver,By.ID,locators.VERSION_URL_FRAGMENT_ID, constants.product_version_url_fragment_1) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.PRODUCT_VERSION_SAVE_BUTTON_CSS) utilities.wait(3) utilities.find_element(self.driver, By.ID, locators.NEW_PRODUCT_VERSION_TEXTBOX_ID).clear() utilities.enter_text(self.driver, By.ID, locators.NEW_PRODUCT_VERSION_TEXTBOX_ID, constants.product_version_2) utilities.enter_text(self.driver, By.ID, locators.VERSION_URL_FRAGMENT_ID, constants.product_version_url_fragment_2) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.PRODUCT_VERSION_SAVE_BUTTON_CSS) utilities.wait(3) utilities.find_element(self.driver, By.ID,locators.NEW_PRODUCT_VERSION_TEXTBOX_ID).clear() utilities.enter_text(self.driver, By.ID, locators.NEW_PRODUCT_VERSION_TEXTBOX_ID, constants.product_version_3) utilities.enter_text(self.driver, By.ID, locators.VERSION_URL_FRAGMENT_ID, constants.product_version_url_fragment_3) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.PRODUCT_VERSION_SAVE_BUTTON_CSS) utilities.wait(3) utilities.find_element(self.driver, By.ID, locators.NEW_PRODUCT_VERSION_TEXTBOX_ID).clear() versions_ul = utilities.find_element(self.driver, By.CLASS_NAME, locators.PRODUCT_VERSIONS_UL_CLASS_NAME) versions_list = versions_ul.find_elements_by_tag_name(locators.PRODUCT_VERSIONS_LI_TAG_NAME) versions = [] for version in versions_list: versions.append(version.text) lcc.log_info("Versions added: %s" % str(versions)) check_that("Product version entered is added successfully ", versions, has_item(constants.product_version_1)) check_that("Product version entered is added successfully ", versions, has_item(constants.product_version_2)) check_that("Product version entered is added successfully ", versions, has_item(constants.product_version_3)) def teardown_suite(self): lcc.log_info("Deleting the product created above...") product_name_node = product_name.replace(" ", "_").lower() path_to_product_node = url + "content/products/" + product_name_node lcc.log_info("Test Product node being deleted at: %s" % path_to_product_node) body = {":operation": "delete"} response = requests.post(path_to_product_node, data=body, auth=(fixture.admin_username, fixture.admin_auth)) check_that("The Product created was deleted successfully", response.status_code, equal_to(200))
class MySuite: fxt = lcc.inject_fixture("fixt1") @lcc.test("sometest") def sometest(self): marker.append(self.fxt)
class test_search_beta(Screenshot): driver = lcc.inject_fixture("driver_obj") repo_name = base.config_reader('test_repo', 'repo_name') module_prefix = base.config_reader('test_repo', 'module_prefix') assembly_prefix = base.config_reader('test_repo', 'assembly_prefix') @lcc.test( "Verify that main filter toggle, filter by Repository toggle view works as expected; " "warning error msg is displayed when no repo is selected ") def no_repo_selected(self): utilities.wait(2) utilities.click_element(self.driver, By.LINK_TEXT, locators.MENU_SEARCH_PAGE_LINK_TEXT) utilities.page_reload(self.driver) utilities.wait(1) # clicking on filter funnel icon twice to close and re-open the filter by repo pannel utilities.click_element(self.driver, By.ID, locators.TOGGLE_ID) utilities.wait(1) utilities.click_element(self.driver, By.ID, locators.TOGGLE_ID) utilities.wait(1) check_that( "Filter by repo section is displayed", utilities.find_element( self.driver, By.CLASS_NAME, locators.FILTER_BY_REPO_SECTION_CLASS_NAME).is_displayed(), is_true()) check_that( "No results found warning message", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.NO_MODULE_RESULTS_FOUND_CSS), contains_string(constants.no_results_found)) utilities.click_element(self.driver, By.XPATH, locators.FILTER_BY_REPO_TOGGLE_XPATH) utilities.wait(1) utilities.click_element(self.driver, By.XPATH, locators.FILTER_BY_REPO_TOGGLE_XPATH) utilities.wait(1) check_that( "Repository list is displayed after expanding Filter by Repo", utilities.find_element(self.driver, By.XPATH, locators.REPO_LIST_XPATH).is_displayed(), is_true()) @lcc.test( "Verify that user is able to see results when he uses Filter by Repository search bar" ) def search_for_repo(self): utilities.enter_text(self.driver, By.XPATH, locators.FILTER_BY_REPO_SEARCH_BAR_XPATH, self.repo_name) utilities.wait(1) repo_list = utilities.find_elements_by_css_selector( self.driver, locators.REPOSITORY_CHECKBOX_CSS) repo_list_count = len(repo_list) for i in range(repo_list_count): if repo_list[i].text == self.repo_name: check_that("Entered repo name is displayed on search results", repo_list[i].text, equal_to(self.repo_name)) utilities.click_element( self.driver, By.CLASS_NAME, locators.CANCEL_BUTTON_ON_REPO_SEARCH_BAR_CLASS_NAME) utilities.wait(1) @lcc.test( "Verify user is able to select a repo; Module and Assemblies section has content displayed and toggles." ) def select_repo_filter(self): search_beta_page.select_repo(self.driver, self.repo_name) utilities.wait(1) utilities.find_element(self.driver, By.CSS_SELECTOR, locators.REPOSITORY_CHECKBOX_CSS).is_selected() check_that( "Repository name displayed correctly on right side panel", utilities.get_text(self.driver, By.XPATH, locators.REPOSITORY_NAME_XPATH), equal_to(self.repo_name)) check_that( "Modules section has data displayed for selected repo", utilities.find_element(self.driver, By.CSS_SELECTOR, locators.MODULES_CSS).is_displayed(), is_true()) check_that( "Assemblies section has data displayed for selected repo", utilities.find_element(self.driver, By.CSS_SELECTOR, locators.ASSEMBLY_CSS).is_displayed(), is_true()) utilities.click_element(self.driver, By.XPATH, locators.MODULES_TOGGLE_BUTTON_XPATH) utilities.wait(1) check_that( "Modules section is collapsible", utilities.find_element( self.driver, By.XPATH, locators.MODULE_ASSEMBLY_TOGGLE_XPATH).is_displayed(), is_true()) utilities.click_element(self.driver, By.XPATH, locators.MODULES_TOGGLE_BUTTON_XPATH) utilities.wait(1) utilities.click_element(self.driver, By.XPATH, locators.ASSEMBLY_TOGGLE_BUTTON_XPATH) utilities.wait(1) check_that( "Assemblies section is collapsible", utilities.find_element( self.driver, By.XPATH, locators.MODULE_ASSEMBLY_TOGGLE_XPATH).is_displayed(), is_true()) utilities.wait(1) utilities.click_element(self.driver, By.XPATH, locators.ASSEMBLY_TOGGLE_BUTTON_XPATH) @lcc.test("Verify that modules and assemblies are listed for selected repo" ) def modules_assemblies_list(self): utilities.wait(1) module_title_list = utilities.find_elements_by_css_selector( self.driver, locators.MODULE_TITLES_CSS) modules_count = len(module_title_list) modules = modules_count - 1 lcc.log_info("Modules displayed: %s " % str(modules)) for i in range(1, modules_count): check_that("Modules listed for selected repo", module_title_list[i].text, contains_string(self.module_prefix)) assembly_title_list = utilities.find_elements_by_css_selector( self.driver, locators.ASSEMBLY_TITLES_CSS) assembly_count = len(assembly_title_list) assemblies = assembly_count - 1 lcc.log_info("Assemblies displayed: %s" % str(assemblies)) for i in range(1, assembly_count): check_that("Assemblies listed for selected repo", assembly_title_list[i].text, contains_string(self.assembly_prefix)) lcc.log_info( "Find the Search beta page preview in the attachment below:") self.driver.save_screenshot("search_beta_repo_selected.png") lcc.save_attachment_file("search_beta_repo_selected.png") @lcc.test("Verify Status and Content Type filter on search page") def filters_on_search_page(self): utilities.click_element(self.driver, By.CLASS_NAME, locators.STATUS_FILTER_CLASS_NAME) utilities.click_element(self.driver, By.CLASS_NAME, locators.DRAFT_STATUS_CLASS_NAME) check_that( "Draft Status filter chip is displayed on search page", utilities.find_element( self.driver, By.CLASS_NAME, locators.STATUS_TOOLBAR_CHIP_CLASS_NAME).is_displayed(), is_true()) last_published_date_list = utilities.find_elements_by_XPATH( self.driver, locators.LAST_PUBLISHED_DATE_XPATH) published_date_list = [] for i in last_published_date_list: published_date_list.append(i.text) for i in published_date_list: check_that( "Published date for all titles should be '-' when draft status filter is selected", i, contains_string("-")) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.CLEAR_ALL_FILTER_CSS) utilities.wait(1) search_beta_page.search_module_and_click(self.driver, constants.publish_module) utilities.wait(1) display_module_page.add_metadata_and_publish(self.driver) utilities.wait(2) utilities.click_element(self.driver, By.LINK_TEXT, "Search") search_beta_page.select_repo(self.driver, self.repo_name) utilities.wait(2) utilities.click_element(self.driver, By.CLASS_NAME, locators.STATUS_FILTER_CLASS_NAME) utilities.click_element(self.driver, By.CLASS_NAME, locators.PUBLISHED_STATUS_CLASS_NAME) utilities.wait(2) check_that( "Published module is filtered", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.FIRST_MODULE_LISTED_CSS), contains_string(constants.publish_module)) check_that( "Green check is displayed for published module", utilities.find_element( self.driver, By.CLASS_NAME, locators.GREEN_CHECK_CLASS_NAME).is_displayed(), is_true()) utilities.wait(3) utilities.click_element(self.driver, By.CSS_SELECTOR, locators.CLEAR_ALL_FILTER_CSS) utilities.wait(1) utilities.click_element(self.driver, By.CLASS_NAME, locators.CONTENT_TYPE_CLASS_NAME) utilities.click_element( self.driver, By.CLASS_NAME, locators.CONCEPT_CONTENT_TYPE_FILTER_CLASS_NAME) check_that( "Content Type filter chip is displayed on search page", utilities.find_element( self.driver, By.CLASS_NAME, locators.STATUS_TOOLBAR_CHIP_CLASS_NAME).is_displayed(), is_true()) utilities.wait(3) check_that( "'Concept' content type filter is selected", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.FIRST_MODULE_LISTED_CSS), contains_string("Concept")) utilities.wait(1) utilities.click_element( self.driver, By.CLASS_NAME, locators.CONCEPT_CONTENT_TYPE_FILTER_CLASS_NAME) utilities.click_element( self.driver, By.CLASS_NAME, locators.PROCEDURE_CONTENT_TYPE_FILTER_CLASS_NAME) utilities.wait(3) check_that( "'Procedure' content type filter is selected", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.FIRST_MODULE_LISTED_CSS), contains_string("Procedure")) utilities.wait(1) utilities.click_element( self.driver, By.CLASS_NAME, locators.PROCEDURE_CONTENT_TYPE_FILTER_CLASS_NAME) utilities.click_element( self.driver, By.CLASS_NAME, locators.REFERENCE_CONTENT_TYPE_FILTER_CLASS_NAME) utilities.wait(3) check_that( "'Reference' content type filter is selected", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.FIRST_MODULE_LISTED_CSS), contains_string("Reference")) utilities.wait(2) def teardown_suite(self): response = unpublish_module(self, constants.search_module_unpublish, constants.variant) check_that("Unpublish request status code", response.status_code, equal_to(200)) lcc.log_info( "module published for above test is unpublished successfully..")
class Suite: foo = lcc.inject_fixture()
class test_module_type(Screenshot): driver = lcc.inject_fixture("driver_obj") @lcc.test( "Verify that 'Filter by Module Type': CONCEPT functionality filters results correctly" ) def verify_filter_by_content_type_concept(self): verify_filter_by_content_type(self.driver, "Concept") @lcc.test( "Verify module type: CONCEPT is shown correctly when added as filename 'con_file.adoc' verified using the api" ) @lcc.depends_on("test_module_type.verify_filter_by_content_type_concept") def verify_module_type_from_backend_module_type_in_filename_con(self): open_module_display_page(self.driver, constants.con_module_title) verify_module_type_from_backend(self.driver, "Concept") @lcc.test( "Verify module type: CONCEPT appears as in on UI when module type is added as filename 'con_file.adoc'" ) @lcc.depends_on( "test_module_type.verify_module_type_from_backend_module_type_in_filename_con" ) def verify_module_type_from_ui_module_type_in_filename_con(self): verify_module_type_from_UI(self.driver, "Concept") @lcc.test( "Verify module type: CONCEPT does not disappear from the UI after the module is published." ) @lcc.depends_on( "test_module_type.verify_module_type_from_backend_module_type_in_filename_con" ) def verify_module_type_after_publising_con(self): verify_module_type_after_publishing(self.driver, "Concept") @lcc.test( "Verify module type: CONCEPT shows correctly when mentioned inside asccidoc file as ':pantheon-module-type: CONCEPT'" ) def verify_module_type_from_backend_module_type_inside_file_con(self): utilities.click_element(self.driver, By.LINK_TEXT, locators.MENU_SEARCH_PAGE_LINK_TEXT) search_beta_page.select_repo(self.driver, fixture.repo_name) search_beta_page.filter_by_content_type(self.driver, "Concept") # search_page.filter_by_module_type(self.driver, "Concept") open_module_display_page(self.driver, constants.con_module_title1) verify_module_type_from_backend(self.driver, "Concept") @lcc.test( "Verify that 'Filter by Module Type': PROCEDURE functionality filters results correctly" ) def verify_filter_by_content_type_procedure(self): verify_filter_by_content_type(self.driver, "Procedure") @lcc.test( "Verify module type: PROCEDURE is shown correctly when added as filename 'proc_file.adoc' verified using the api" ) @lcc.depends_on("test_module_type.verify_filter_by_content_type_procedure") def verify_module_type_from_backend_module_type_in_filename_proc(self): open_module_display_page(self.driver, constants.proc_module_title) verify_module_type_from_backend(self.driver, "Procedure") @lcc.test( "Verify module type: PROCEDURE appears as in on UI when module type is added as filename 'proc_file.adoc'" ) @lcc.depends_on( "test_module_type.verify_module_type_from_backend_module_type_in_filename_proc" ) def verify_module_type_from_ui_module_type_in_filename_proc(self): verify_module_type_from_UI(self.driver, "Procedure") @lcc.test( "Verify module type: PROCEDURE does not disappear from the UI after the module is published." ) @lcc.depends_on( "test_module_type.verify_module_type_from_backend_module_type_in_filename_proc" ) def verify_module_type_after_publising_proc(self): verify_module_type_after_publishing(self.driver, "Procedure") @lcc.test( "Verify module type: PROCEDURE shows correctly when mentioned inside asccidoc file as ':pantheon-module-type: PROCEDURE'" ) def verify_module_type_from_backend_module_type_inside_file_proc(self): utilities.click_element(self.driver, By.LINK_TEXT, locators.MENU_SEARCH_PAGE_LINK_TEXT) # search_page.filter_by_module_type(self.driver, "Procedure") search_beta_page.select_repo(self.driver, fixture.repo_name) search_beta_page.filter_by_content_type(self.driver, "Procedure") open_module_display_page(self.driver, constants.proc_module_title1) verify_module_type_from_backend(self.driver, "Procedure") @lcc.test( "Verify that 'Filter by Module Type': REFERENCE functionality filters results correctly" ) def verify_filter_by_content_type_reference(self): verify_filter_by_content_type(self.driver, "Reference") @lcc.test( "Verify module type: REFERENCE is shown correctly when added as filename 'ref_file.adoc' verified using the api" ) @lcc.depends_on("test_module_type.verify_filter_by_content_type_reference") def verify_module_type_from_backend_module_type_in_filename_ref(self): open_module_display_page(self.driver, constants.ref_module_title) verify_module_type_from_backend(self.driver, "Reference") @lcc.test( "Verify module type: REFERENCE appears as in on UI when module type is added as filename 'ref_file.adoc'" ) @lcc.depends_on( "test_module_type.verify_module_type_from_backend_module_type_in_filename_ref" ) def verify_module_type_from_ui_module_type_in_filename_ref(self): verify_module_type_from_UI(self.driver, "Reference") @lcc.test( "Verify module type: REFERENCE does not disappear from the UI after the module is published." ) @lcc.depends_on( "test_module_type.verify_module_type_from_backend_module_type_in_filename_ref" ) def verify_module_type_after_publising_ref(self): verify_module_type_after_publishing(self.driver, "Reference") @lcc.test( "Verify module type: REFERENCE shows correctly when mentioned inside asccidoc file as ':pantheon-module-type: REFERENCE'" ) def verify_module_type_from_backend_module_type_inside_file_ref(self): utilities.click_element(self.driver, By.LINK_TEXT, locators.MENU_SEARCH_PAGE_LINK_TEXT) # search_page.filter_by_module_type(self.driver, "Reference") search_beta_page.select_repo(self.driver, fixture.repo_name) search_beta_page.filter_by_content_type(self.driver, "Reference") open_module_display_page(self.driver, constants.ref_module_title1) verify_module_type_from_backend(self.driver, "Reference") @lcc.test("Verify module with invalid type defined") def verify_no_module_type(self): utilities.click_element(self.driver, By.LINK_TEXT, locators.MENU_SEARCH_PAGE_LINK_TEXT) utilities.page_reload(self.driver) # try: # search_page.search_for_module_and_click(self.driver, constants.no_module_type_title) # except (TimeoutException, StaleElementReferenceException) as e: # lcc.log_error("Module not listed on listed in the results after applying module type filter.") # utilities.wait(2) # search_page.search_for_module_and_click(self.driver, constants.no_module_type_title) search_beta_page.select_repo(self.driver, fixture.repo_name) search_beta_page.search_module_and_click( self.driver, constants.no_module_type_title) lcc.log_info( "Verifying no module type is displayed for modules with invalid type mentioned inside " "the asciidoc file") # Once landed on the module display page, get path to adoc from the module display page url path_to_adoc_file = display_module_page.get_path_to_adoc(self.driver) path = path_to_adoc_file + constants.path_for_module_type response = requests.get(url=url + path, auth=(fixture.username, fixture.api_auth)) check_that("Module type node in backend", response.status_code, equal_to(404)) def teardown_suite(self): response = unpublish_module(self, constants.proc_module_unpublish, constants.variant) check_that("Unpublish request status code", response.status_code, equal_to(200)) lcc.log_info( "Module published for module_type:PROCEDURE test is unpublished successfully.." ) response = unpublish_module(self, constants.ref_module_unpublish, constants.variant) check_that("Unpublish request status code", response.status_code, equal_to(200)) lcc.log_info( "Module published for module_type:REFERENCE test is unpublished successfully.." ) response = unpublish_module(self, constants.con_module_unpublish, constants.variant) check_that("Unpublish request status code", response.status_code, equal_to(200)) lcc.log_info( "Module published for module_type:CONCEPT test is unpublished successfully.." )
class test_sitemap: api_auth = lcc.inject_fixture("api_auth") now = datetime.now(timezone.utc) # now_hour = int(datetime.now(timezone.utc).hour) # now_hour_plus_one = now_hour + 1 # now_min = int(datetime.now(timezone.utc).minute) # now_min_minus_ten = now_min - 15 # now_min_plus_ten = now_min + 15 # if(now_min_plus_ten >= 60): # now_min_plus_ten = now_min_plus_ten-60 # if(now_min_minus_ten < 0): # now_min_minus_ten = 0 # # def check_time_range(time_read): range = now + timedelta(minutes=15) def setup_suite(self, setup_test_products, api_auth): lcc.log_info( "Setup: Adding metadata and publishing module, assembly to test the sitemap endpoint..." ) lcc.log_info("Adding metadata, publishing the assembly first...") assembly_title_prefix = base.config_reader('test_repo', 'assembly_prefix') self.variant = utilities.read_variant_name_from_pantheon2config() self.assembly_path = utilities.select_nth_item_from_search_results( 1, fixture.url, assembly_title_prefix, api_auth) lcc.log_info("Assembly path for tests: %s" % self.assembly_path) # Add metadata to the assembly res, self.product_name_uri = utilities.add_metadata( fixture.url, self.assembly_path, self.variant, self.api_auth, setup_test_products, content_type="assembly") # Publish the assembly publish_response = utilities.publish_content(fixture.url, self.assembly_path, self.variant, self.api_auth) check_that("Publish Assembly response status ", publish_response.status_code, equal_to(200)) # Verify if the assembly was marked released response = api_auth.get(fixture.url + self.assembly_path + "/en_US/variants/" + self.variant + ".10.json") check_that("Assembly was published", response.json(), has_entry("released")) self.assembly_uuid = response.json()["jcr:uuid"] lcc.log_info("Assembly published uuid: %s" % self.assembly_uuid) lcc.log_info("Publishing a module now...") module_title_prefix = base.config_reader('test_repo', 'module_prefix') self.module_path = utilities.select_nth_item_from_search_results( 0, fixture.url, module_title_prefix, api_auth) print(self.module_path) # Add metadat to module module_res, self.product_name_uri = utilities.add_metadata( fixture.url, self.module_path, self.variant, self.api_auth, setup_test_products, content_type="module") # Publish the module m_publish_response = utilities.publish_content(fixture.url, self.module_path, self.variant, self.api_auth) # Verify if the module was marked released module_response = api_auth.get(fixture.url + self.module_path + "/en_US/variants/" + self.variant + ".10.json") check_that("Document published", module_response.json(), has_entry("released")) self.module_uuid = module_response.json()["jcr:uuid"] lcc.log_info("Module published uuid: %s " % self.module_uuid) @lcc.test( "Verify api endpoint for assembly sitemap: api/sitemap/assembly.sitemap.xml contains published assembly" ) def verify_assembly_sitemap(self, api_auth): lcc.log_info("Verifying sitemap for assemblies") req = fixture.url + "api/sitemap/assembly.sitemap.xml" response = api_auth.get(req) url_loc = fixture.cp_url + "documentation/en-us/" + self.product_name_uri + "/" + constants.product_version_uri + "/guide/" + self.assembly_uuid # Verify that assembly sitemap response contains recently published assembly url check_that("Assembly Sitemap response at endpoint: %s" % req, response.text, contains_string(url_loc)) xml_dict = {} root = ET.fromstring(response.content) lcc.log_info( "Creating a dict for the sitemap endpoint responses for verification..." ) for sitemap in root: children = sitemap.getchildren() xml_dict[children[0].text] = children[1].text print(str(xml_dict)) # Extract published date for recent assembly from the sitemap publish_date = xml_dict[url_loc] lcc.log_info("Extracting the publish date for %s as %s" % (url_loc, publish_date)) # date = publish_date.split("T") # # # Verify that published date is same as current date # check_that("Published date", date[0], equal_to(str(self.now.date()))) # # t = date[1].split(".")[0].split(":") # hour = t[0] # min = t[1] # sec = t[2] # lcc.log_info("Time now: %s" % str(self.now.time())) # lcc.log_info("Published time to match: %s " % str(t)) publish_date = publish_date.replace("Z", "+00:00") published_date = datetime.fromisoformat(publish_date) flag = False if (self.now <= published_date <= self.range): flag = True check_that( "Published date and time is in range %s to %s" % (self.now, self.range), flag, is_true()) # # Verify that assembly publish time is within current time range # all_of(check_that("Published time (Hour)", int(hour), is_between(self.now_hour, self.now_hour_plus_one)), # check_that("Published time (Min)", int(min), is_between(self.now_min_minus_ten, self.now_min_plus_ten))) lcc.log_info( "Verifying if unpublishing the assembly removes it from the sitemap..." ) # Unpublishing the assembly res = utilities.unpublish_content(fixture.url, self.assembly_path, self.variant, self.api_auth) draft = api_auth.get(fixture.url + self.assembly_path + "/en_US/variants/" + self.variant + ".10.json") # Check that assembly is unpublished successfully assert_that("Document unpublished", draft.json(), has_entry("draft")) response1 = api_auth.get(req) # Verify unpublished module not listed in sitemap check_that("Assembly Sitemap response", response1.text, not_(contains_string(url_loc))) @lcc.test( "Verify api endpoint for module sitemap: api/sitemap/module.sitemap.xml contains published module" ) def verify_module_sitemap(self, api_auth): lcc.log_info("Verifying sitemap for module") req = fixture.url + "api/sitemap/module.sitemap.xml" response = api_auth.get(req) url_loc = fixture.cp_url + "documentation/en-us/" + self.product_name_uri + "/" + constants.product_version_uri + "/topic/" + self.module_uuid check_that("Module Sitemap response at endpoint: %s" % req, response.text, contains_string(url_loc)) xml_dict = {} root = ET.fromstring(response.content) lcc.log_info( "Creating a dict for the sitemap endpoint responses for verification..." ) for sitemap in root: children = sitemap.getchildren() xml_dict[children[0].text] = children[1].text print(str(xml_dict)) # Extract published date for recent assembly from the sitemap publish_date = xml_dict[url_loc] lcc.log_info("Extracting the publish date for %s as %s" % (url_loc, publish_date)) # date = publish_date.split("T") # # # Verify that published date is same as current date # check_that("Published date", date[0], equal_to(str(self.now.date()))) # # t = date[1].split(".")[0].split(":") # hour = t[0] # min = t[1] # sec = t[2] # lcc.log_info("Time now: %s" % str(self.now.time())) # lcc.log_info("Published time to match: %s " % str(t)) # # Verify that module publish time is withing current time range # all_of(check_that("Published time (Hour)", int(hour), is_between(self.now_hour, self.now_hour_plus_one)), # check_that("Published time (Min)", int(min), # is_between(self.now_min_minus_ten, self.now_min_plus_ten))) publish_date = publish_date.replace("Z", "+00:00") published_date = datetime.fromisoformat(publish_date) flag = False if (self.now <= published_date <= self.range): flag = True check_that( "Published date and time is in range %s to %s" % (self.now, self.range), flag, is_true()) lcc.log_info( "Verifying if unpublishing a module removes it from the sitemap.xml... " ) # Unpublishing the module res = utilities.unpublish_content(fixture.url, self.module_path, self.variant, self.api_auth) draft = api_auth.get(fixture.url + self.module_path + "/en_US/variants/" + self.variant + ".10.json") # Check that the modules was unpublished successfully assert_that("Document unpublished", draft.json(), has_entry("draft")) response1 = api_auth.get(req) # Verify unpublished module not listed in sitemap check_that("Module Sitemap response", response1.text, not_(contains_string(url_loc))) @lcc.test("Verify sitemap API endpoint behind akamai") def verify_module_sitemap_behind_akamai(self, api_auth): req1 = fixture.behind_akamai_url + "api/sitemap/module.sitemap.xml" lcc.log_info(req1) response1 = api_auth.get(req1, proxies=proxies) check_that("status code for Module Sitemap API behind akamai", response1.status_code, equal_to(200)) req2 = fixture.behind_akamai_url + "api/sitemap/assembly.sitemap.xml" lcc.log_info(req2) response2 = api_auth.get(req2, proxies=proxies) check_that("status code for Assembly Sitemap API behind akamai", response2.status_code, equal_to(200)) @lcc.test("Verify sitemap API endpoint external proxy") def verify_module_sitemap_ext_proxy(self, api_auth): req1 = fixture.external_proxy_url + "sitemap/module.sitemap.xml" lcc.log_info(req1) response1 = api_auth.get(req1, proxies=proxies) check_that("status code for Module Sitemap API for external proxy", response1.status_code, equal_to(200)) req2 = fixture.external_proxy_url + "sitemap/assembly.sitemap.xml" lcc.log_info(req2) response2 = api_auth.get(req2, proxies=proxies) check_that("status code for Assembly Sitemap API for external proxy", response2.status_code, equal_to(200))
class test_git_import(Screenshot): driver = lcc.inject_fixture("driver_obj") # @lcc.disabled() @lcc.test( "Verify that warning message should be displayed when repository URL is empty" ) def git_import_for_empty_git_repo(self): utilities.click_element(self.driver, By.LINK_TEXT, locators.MENU_GIT_IMPORT_LINK_TEXT) git_import_page.import_git_repo(self.driver, None, None) check_that( "Empty git repo url warning message", utilities.get_text(self.driver, By.CSS_SELECTOR, locators.WARNING_ALERT_CSS), contains_string(constants.repo_url_empty_warning_message)) # @lcc.disabled() @lcc.test( "Verify that error message should be displayed when repository url has invalid" ) def git_import_for_invalid_git_repo_url(self): git_import_page.import_git_repo(self.driver, constants.invalid_git_repo_url, git_import_repo_branch) text = utilities.get_text(self.driver, By.CSS_SELECTOR, locators.GIT_IMPORT_ALERT_CSS) print(text) check_that("Invalid git repo url error alert", text, contains_string(constants.failure_alert_message)) check_that("Invalid git repo url files count", text, contains_string(constants.failure_alert_files_uploaded)) utilities.verify_and_accept_confirmation_modal( self.driver, locators.GIT_IMPORT_REQUEST_SUBMITTED_TITLE, constants.git_import_submitted_modal_title, locators.GIT_IMPORT_REQUEST_SUBMITTED_NO) # @lcc.disabled() @lcc.test( "Verify that user should be able to upload modules successfully using git import" ) def git_import_for_sample_repo(self): git_import_page.import_git_repo(self.driver, git_import_repo_URL, git_import_repo_branch) utilities.verify_and_accept_confirmation_modal( self.driver, locators.GIT_IMPORT_REQUEST_SUBMITTED_TITLE, constants.git_import_submitted_modal_title, locators.GIT_IMPORT_REQUEST_SUBMITTED_YES) utilities.wait(20) # utilities.click_element(self.driver, By.LINK_TEXT, "Search") poll(lambda: utilities.find_element( self.driver, By.CSS_SELECTOR, locators.GIT_IMPORT_SUCCESS_ALERT_CSS ).is_displayed(), step=1, timeout=150) # screenshot_filename = "git_import" + utilities.generate_random_string(3) + ".png" # self.driver.save_screenshot(screenshot_filename) # lcc.save_attachment_file(screenshot_filename) text = utilities.get_text(self.driver, By.CSS_SELECTOR, locators.GIT_IMPORT_SUCCESS_ALERT_CSS) print(text) check_that("Git import successful alert", text, contains_string(constants.success_alert_message)) check_that( "Git import successfully uploaded files count", text, contains_string(constants.success_alert_files_uploaded + number_of_files_imported)) utilities.page_reload(self.driver) repo_list = utilities.find_elements_by_css_selector( self.driver, locators.LIST_OF_REPOS_CSS) name = [] for i in repo_list: name.append(i.text) check_that("Git import repo is listed on search page", name, has_item(git_import_repo_Name)) # utilities.page_reload(self.driver) search_url = fixture.url + 'pantheon/internal/modules.json?repo=' + fixture.git_import_repo \ + '&search=' + module_title_prefix + '&key=Updated&direction=desc' lcc.log_info("Git import functionality verified using endpoint: %s" % search_url) lcc.log_info( "Trying to poll the endpoint until we get the required number of search results as" " per the test data ...") req = requests.get(search_url) print(req.content) # poll(lambda: requests.get(search_url).json()["size"] == 9, step=5, timeout=120) imported_modules_request = requests.get(search_url) imported_modules = imported_modules_request.json() lcc.log_info(str(imported_modules)) total_modules = imported_modules["size"] lcc.log_info( "Number of modules listed with the similar title name: %s" % str(total_modules)) lcc.log_info( "Capturing the number of modules uploaded from the repo: %s ..." % git_import_repo_Name) results = imported_modules["results"] imported_modules_array = [] for result in results: if result["pant:transientSourceName"] == git_import_repo_Name: imported_modules_array.append(result["jcr:title"]) lcc.log_info( "Modules imported successfully via git import: %s with title prefix" % str(imported_modules_array)) lcc.log_info( "Number of modules imported successfully from repo: %s is %s" % (git_import_repo_URL, str(len(imported_modules_array)))) check_that("Count of modules uploaded using git import", len(imported_modules_array), equal_to(int(number_of_modules)))