def testShouldCheckAddonDeactivateAndActivate(self, mozwebqa):
        homepage_obj = HomePage(mozwebqa)
        loginpage_obj = LoginPage(mozwebqa)
        dashboardpage_obj = DashboardPage(mozwebqa)
        addonpage_obj = AddonEditorPage(mozwebqa)

        homepage_obj.go_to_home_page()
        homepage_obj.header.click_signin()
        loginpage_obj.login()
        Assert.true(dashboardpage_obj.is_the_current_page)

        # Go back to homepage and create a new addon to work with.
        dashboardpage_obj.header.click_home_logo()
        homepage_obj.click_create_addon_btn()
        addon_name = addonpage_obj.addon_name
        addonpage_obj.header.click_dashboard()

        #Click on the private button to make it private and then check that the addon is not in the list anymore
        dashboardpage_obj.addon(addon_name).click_private()
        Assert.false(dashboardpage_obj.addon(addon_name).is_displayed, "Addon %s found" % addon_name)

        #Go to the private addons page and check that the addon that you just made private is present there.
        #Click on public to make it public and check on the dashboard that the addon is present there.
        dashboardpage_obj.click_private_addons_link()
        Assert.true(dashboardpage_obj.addon(addon_name).is_displayed, "Addon %s not found" % addon_name)

        # Switch it back to public now, addon should disappear
        dashboardpage_obj.addon(addon_name).click_public()
        Assert.false(dashboardpage_obj.addon(addon_name).is_displayed, "Addon %s found" % addon_name)

        # Should be on main dashboard page
        dashboardpage_obj.header.click_dashboard()
        Assert.true(dashboardpage_obj.addon(addon_name).is_displayed, "Addon %s not found" % addon_name)

        dashboardpage_obj.delete_test_data()
    def testShouldCheckLibDeactivateAndActivate(self, mozwebqa):
        homepage_obj = HomePage(mozwebqa)
        loginpage_obj = LoginPage(mozwebqa)
        dashboardpage_obj = DashboardPage(mozwebqa)
        librarypage_obj = LibraryEditorPage(mozwebqa)

        homepage_obj.go_to_home_page()
        homepage_obj.header.click_signin()
        loginpage_obj.login()
        Assert.true(dashboardpage_obj.is_the_current_page)

        # go back to homepage, create a new library to work with
        dashboardpage_obj.header.click_home_logo()
        homepage_obj.click_create_lib_btn()
        library_name = librarypage_obj.library_name
        librarypage_obj.header.click_dashboard()

        #Click on the private button to make it private and then check that the library is not in the list anymore
        dashboardpage_obj.library(library_name).click_private()
        Assert.false(dashboardpage_obj.library(library_name).is_displayed, "Library %s found" % library_name)

        #Go to the private libraries page and check that the library that you just made private is present there.
        #Click on public to make it public and check on the dashboard that the library is present there.
        dashboardpage_obj.click_private_libraries_link()
        Assert.true(dashboardpage_obj.library(library_name).is_displayed, "Library %s not found" % library_name)

        # Switch it back to public - it should disappaer
        dashboardpage_obj.library(library_name).click_public()
        Assert.false(dashboardpage_obj.library(library_name).is_displayed, "Library %s found" % library_name)

        # Go to main dashboard, should be present
        dashboardpage_obj.header.click_dashboard()
        Assert.true(dashboardpage_obj.library(library_name).is_displayed, "Library %s not found" % library_name)

        dashboardpage_obj.delete_test_data()
    def testShouldCheckAddonLabel(self, mozwebqa):
        #This test is to check the labels of an add-on on the dashboard
        #Create page objects
        homepage_obj = HomePage(mozwebqa)
        loginpage_obj = LoginPage(mozwebqa)
        dashboardpage_obj = DashboardPage(mozwebqa)
        addonpage_obj = AddonEditorPage(mozwebqa)

        loginpage_obj.login()

        #Create an addon. Then go to dashboard and assert that the label is 'initial'.
        homepage_obj.go_to_home_page()
        homepage_obj.click_create_addon_btn()
        addon_name = addonpage_obj.addon_name

        homepage_obj.header.click_dashboard()
        Assert.true(dashboardpage_obj.is_the_current_page)
        Assert.true(dashboardpage_obj.addon(addon_name).is_displayed, "Addon %s not found" % addon_name)

        #Click on the edit button of the addon.Then create a copy of that addon and assert that the label is 'copy'
        dashboardpage_obj.addon(addon_name).click_edit()
        addonpage_obj.click_copy()
        copy_addon_name = addonpage_obj.addon_name

        try:
            Assert.not_equal(addon_name, copy_addon_name)
        except:
            print 'A copy of the addon could not be created'
        homepage_obj.header.click_dashboard()
        Assert.true(dashboardpage_obj.addon(copy_addon_name).is_displayed, "Addon %s not found" % copy_addon_name)

        dashboardpage_obj.delete_test_data()
Esempio n. 4
0
    def testShouldCheckLibraryLabel(self, mozwebqa):
        #This test is to check the labels of a library on the dashboard
        #Create page objects
        homepage_obj = HomePage(mozwebqa)
        loginpage_obj = LoginPage(mozwebqa)
        dashboardpage_obj = DashboardPage(mozwebqa)
        libpage_obj = LibraryEditorPage(mozwebqa)

        loginpage_obj.login()

        #Create a library. Then go to dashboard and assert that the label is present.
        homepage_obj.go_to_home_page()
        homepage_obj.click_create_lib_btn()
        library_name = libpage_obj.library_name

        libpage_obj.header.click_dashboard()
        Assert.true(dashboardpage_obj.is_the_current_page)
        Assert.true(dashboardpage_obj.library(library_name).is_displayed, "Library %s not found" % library_name)

        #Click on the edit button of the library.Then create a copy of that library and assert that the label is 'copy'
        dashboardpage_obj.library(library_name).click_edit()
        libpage_obj.click_copy()
        copy_library_name = libpage_obj.library_name

        try:
            Assert.not_equal(library_name, copy_library_name)
        except:
            print 'A copy of the library could not be created'
        libpage_obj.header.click_dashboard()

        Assert.true(dashboardpage_obj.library(copy_library_name).is_displayed, "Library %s not found" % copy_library_name)
        
        dashboardpage_obj.delete_test_data()
Esempio n. 5
0
    def setUp(self):

        self.driver = webdriver.Firefox()
        self.driver.maximize_window()
        self.driver.get(self.generalProp["url"])
        login = LoginPage(self.driver)
        assert login.check_login_page()
Esempio n. 6
0
    def test_search_by_library_name_returns_library(self, mozwebqa):
        homepage_obj = HomePage(mozwebqa)
        loginpage_obj = LoginPage(mozwebqa)
        dashboard_obj = DashboardPage(mozwebqa)
        librarypage_obj = LibraryEditorPage(mozwebqa)
        searchpage_obj = SearchPage(mozwebqa)

        homepage_obj.go_to_home_page()
        homepage_obj.header.click_signin()
        loginpage_obj.login()

        #create a new library with the valid criteria (version not initial)
        dashboard_obj.header.click_home_logo()
        homepage_obj.click_create_lib_btn()
        librarypage_obj.type_library_version('searchable')
        librarypage_obj.click_save()
        searchterm = librarypage_obj.library_name

        librarypage_obj.header.click_home_logo()
        homepage_obj.header.click_search()

        searchpage_obj.search_until_package_exists(searchterm, searchpage_obj.library(searchterm))
        Assert.true(searchpage_obj.library(searchterm).is_displayed, '%s not found before timeout' % searchterm)

        searchpage_obj.delete_test_data()
    def test_logout(self, mozwebqa):
        loginpage_obj = LoginPage(mozwebqa)

        dashboard_obj = loginpage_obj.login()
        Assert.true(dashboard_obj.header.logged_in)
        homepage_obj = dashboard_obj.header.click_signout()

        Assert.true(homepage_obj.header.logged_out)
    def test_login(self, mozwebqa):
        homepage_obj = HomePage(mozwebqa)
        loginpage_obj = LoginPage(mozwebqa)
        dashboard_obj = DashboardPage(mozwebqa)

        homepage_obj.go_to_home_page()
        homepage_obj.header.click_signin()
        Assert.true(loginpage_obj.is_the_current_page)
        loginpage_obj.login()

        Assert.true(dashboard_obj.is_the_current_page)
        Assert.true(dashboard_obj.header.logged_in)
        Assert.equal(dashboard_obj.logged_in_username, mozwebqa.credentials['default']['name'])
Esempio n. 9
0
    def setUp(self):
        profile = webdriver.FirefoxProfile()
        profile.set_preference('browser.download.folderList', 2)
        profile.set_preference('browser.download.manager.showWhenStarting', False)
        profile.set_preference("browser.download.dir", os.getcwd())
        profile.set_preference('browser.helperApps.neverAsk.saveToDisk', 'text/xml')

        self.driver = webdriver.Firefox(profile)
        self.driver.maximize_window()
        self.driver.implicitly_wait(20)
        login_page = LoginPage(self.driver)
        login_page.navigate()
        self.current_view = login_page.login(LOGIN, PASS)
Esempio n. 10
0
    def test_clicking_library_source_displays_editor(self, mozwebqa):
        homepage_obj = HomePage(mozwebqa)
        loginpage_obj = LoginPage(mozwebqa)
        dashboard_obj = DashboardPage(mozwebqa)
        searchpage_obj = SearchPage(mozwebqa)
        editorpage_obj = LibraryEditorPage(mozwebqa)

        homepage_obj.go_to_home_page()
        homepage_obj.header.click_signin()
        loginpage_obj.login()
        dashboard_obj.header.click_search()

        library_name = searchpage_obj.library(1).name
        searchpage_obj.library(library_name).click()
        Assert.equal(editorpage_obj.library_name, library_name)

        searchpage_obj.delete_test_data()
    def testShouldCheckLibDelete(self, mozwebqa):

        homepage_obj = HomePage(mozwebqa)
        loginpage_obj = LoginPage(mozwebqa)
        dashboardpage_obj = DashboardPage(mozwebqa)
        libpage_obj = LibraryEditorPage(mozwebqa)

        homepage_obj.go_to_home_page()
        loginpage_obj.login()

        homepage_obj.go_to_home_page()
        homepage_obj.click_create_lib_btn()
        library_name = libpage_obj.library_name

        homepage_obj.header.click_dashboard()
        dashboardpage_obj.library(library_name).click_delete()
        dashboardpage_obj.library(library_name).confirm_delete()
        Assert.false(dashboardpage_obj.library(library_name).is_displayed, "Library %s found" % library_name)
    def testShouldCheckAddonDelete(self, mozwebqa):
        homepage_obj = HomePage(mozwebqa)
        loginpage_obj = LoginPage(mozwebqa)
        dashboardpage_obj = DashboardPage(mozwebqa)
        addonpage_obj = AddonEditorPage(mozwebqa)

        loginpage_obj.login()

        homepage_obj.go_to_home_page()
        homepage_obj.click_create_addon_btn()

        # Get the name of the addon on the editor page.
        addon_name = addonpage_obj.addon_name

        # Go the the dashboard and delete the addon that you just created. Then check that the addon at the top of the list is not the same as the one you just deleted.
        homepage_obj.header.click_dashboard()
        dashboardpage_obj.addon(addon_name).click_delete()
        dashboardpage_obj.addon(addon_name).confirm_delete()
        Assert.false(dashboardpage_obj.addon(addon_name).is_displayed, "Addon %s found" % addon_name)
Esempio n. 13
0
    def testAddonCount(self, mozwebqa):
        #This test is to assert that the count of the addons on dashboard is equal to the number of addons present on the page.
        #Create page objects
        homepage_obj = HomePage(mozwebqa)
        loginpage_obj = LoginPage(mozwebqa)
        dashboardpage_obj = DashboardPage(mozwebqa)

        homepage_obj.go_to_home_page()
        homepage_obj.header.click_signin()
        loginpage_obj.login()
        Assert.true(dashboardpage_obj.is_the_current_page)

        #Get the total count of the number of add-ons that are displayed on the dashboard.
        addon_count = dashboardpage_obj.addons_element_count()

        #Get the number of addons that are displayed on the left hand side of the page.(Something like your add-ons(20))
        counter = dashboardpage_obj.addons_count_label

        #Assert that the total addons on the page matches the counter on the left hand side.
        Assert.equal(str(addon_count), str(counter))
 def setUp(self):
     """
     Initialize all page objects
     """
     super(TestAddNotifications, self).setUp()
     self.browser.maximize_window()
     self.home_page = HomePage(self.browser)
     self.registration_page = RegistrationPage(self.browser)
     self.registration_success = RegistrationSuccess(self.browser)
     self.login_page = LoginPage(self.browser)
     self.logged_in_home_page = LoggedInHomePage(self.browser)
     self.notification_target_page = NotificationTargetPage(self.browser)
Esempio n. 15
0
    def test_login_cloud_server(self):
        username = self.generalProp["user"]
        password = self.generalProp["pass"]

        login = LoginPage(self.driver)
        vra = PortalVra(self.driver)

        # Login
        login.type_user_name(username)
        login.type_user_pass(password)
        login.click_on_send()

        # Close tour dialog is displayed
        #dashboard.close_tour_dialog()

        # I'm in dashboard page
        assert vra.check_vra_page()

        # Logout
        vra.logout()
Esempio n. 16
0
 def __init__(self, driver, base_url):
     self.driver = driver
     driver.get(base_url)
     driver.maximize_window()
     self.wait = WebDriverWait(driver, 15)
     self.login_page = LoginPage(driver, base_url)
     self.persons_page = PersonsPage(driver, base_url)
     self.internal_page = InternalPage(driver, base_url)
     self.person_main_page = AddPersonMainPage(driver, base_url)
     self.enrollments_page = EnrollmentsPage(driver, base_url)
     self.dictionaries_page = DictionariesPage(driver, base_url)
     self.person_current_view_page = PersonCurrentViewPage(driver, base_url)
     self.person_main_view_page = PersonMainViewPage(driver, base_url)
     self.person_papers_view_page = PersonPapersViewPage(driver, base_url)
     self.person_enrollment_view_page = PersonEnrollmentViewPage(driver, base_url)
     self.enrollments_main_page = EnrollmentsMainPage(driver, base_url)
     self.enrollments_base_page = EnrollmentsBasePage(driver, base_url)
     self.main_page = AddPersonMainPage(driver, base_url)
     self.extra_page = AddPersonExtraPage(driver, base_url)
     self.address_page = AddPersonAddressesPage(driver, base_url)
     self.contact_page = AddPersonContactsPage(driver, base_url)
     self.papers_page = AddPersonPapersPage(driver, base_url)
     self.person_base_page = AddPersonPage(driver, base_url)
     self.person_enrollment = PersonEnrollmentPage(driver, base_url)
Esempio n. 17
0
 def ClassSetup(self, BrowserSetUp):
     self.loginPage = LoginPage(self.driver)
     yield
     self.driver.quit()
class TestAddNotifications(WebAppTest):

    notification_dict = {
        'open-edx.studio.announcements.new-announcement': 'Gettysburg Address',
        'open-edx.lms.discussions.reply-to-thread': 'testuser responded to your post in ',
        'open-edx.lms.discussions.thread-followed': 'A demo posting to the discussion forums was followed 3 times',
        'open-edx.lms.discussions.post-upvoted': 'post A demo posting to the discussion forums was upvoted 5 times',
        'open-edx.lms.discussions.cohorted-thread-added': 'testuser posted: Four score and seven years ago',
        'open-edx.lms.discussions.cohorted-comment-added': 'testuser responded: Four score and seven years ago',
        'open-edx.lms.discussions.comment-upvoted': 'response to A demo posting to the discussion forums was upvoted',
        'open-edx.lms.leaderboard.progress.rank-changed': 'You are now #2 for Progress in the cohort!',
        'open-edx.lms.leaderboard.gradebook.rank-changed': 'You are now #3 for Proficiency in the cohort!',
        'open-edx.lms.leaderboard.engagement.rank-changed': 'You are now #1 for Engagement in the cohort!',
        'open-edx.xblock.group-project.file-uploaded': 'First Activity: testuser uploaded a file',
        'open-edx.xblock.group-project.stage-open': 'First Activity: Upload(s) are open',
        'open-edx.xblock.group-project.stage-due': 'First Activity: Upload(s) due 4/25',
        'open-edx.xblock.group-project.grades-posted': 'First Activity: Grade(s) are posted',
    }

    short_notification_dict = {
        'open-edx.studio.announcements.new-announcement': 'Gettysburg Address',
        'open-edx.lms.discussions.reply-to-thread': 'testuser responded to your post in ',
        'open-edx.lms.discussions.cohorted-thread-added': 'testuser posted: Four score and seven years ago',
        'open-edx.lms.leaderboard.progress.rank-changed': 'You are now #2 for Progress in the cohort!',
        'open-edx.xblock.group-project.grades-posted': 'First Activity: Grade(s) are posted',
    }

    if HIDE_LINK_IS_VISIBLE:
        notifications_container_tabs = ['View unread', 'View all', 'Mark as read', 'Hide', 'Settings']
    else:
        notifications_container_tabs = ['View unread', 'View all', 'Mark as read', 'Settings']

    namespaces = ['foo/bar/baz', 'test/test/test']

    def setUp(self):
        """
        Initialize all page objects
        """
        super(TestAddNotifications, self).setUp()
        self.browser.maximize_window()
        self.home_page = HomePage(self.browser)
        self.registration_page = RegistrationPage(self.browser)
        self.registration_success = RegistrationSuccess(self.browser)
        self.login_page = LoginPage(self.browser)
        self.logged_in_home_page = LoggedInHomePage(self.browser)
        self.notification_target_page = NotificationTargetPage(self.browser)

    def test_00_show_notification_pane(self):
        """
        Scenario: User is able to show the notification container
        Given that I am on the notification home page
        And notifications container is hidden
        When I click the notification icon
        Then I should see the notification container
        When I click on the hide link
        Then notification container becomes invisible again
        """
        self.login()
        self.logged_in_home_page.verify_notifications_container_is_invisible()
        self.logged_in_home_page.show_notifications_container()
        self.logged_in_home_page.verify_notifications_container_is_visible()
        self.logged_in_home_page.hide_notification_container()
        self.logged_in_home_page.verify_notifications_container_is_invisible()

    def test_01_hide_notification_pane(self):
        """
        Scenario: User is able to hide the notification container
        Given that I am on the notification home page
        And notifications container is visible
        When I click on the notification icon again
        Then notification container should hide
        """
        self.login()
        self.logged_in_home_page.verify_notifications_container_is_invisible()
        self.logged_in_home_page.show_notifications_container()
        self.logged_in_home_page.verify_notifications_container_is_visible()
        self.logged_in_home_page.hide_notification_container()
        self.logged_in_home_page.verify_notifications_container_is_invisible()

    @skipUnless(HIDE_LINK_IS_VISIBLE, "Test only runs if Hide link is visible")
    def test_02_hide_link(self):
        """
        Scenario: User is able to hide the notification container using hide link
        Given that I am on the notification home page
        And notifications container is visible
        When I click on the notification icon again
        Then notification container should hide
        """
        self.login()
        self.logged_in_home_page.verify_notifications_container_is_invisible()
        self.logged_in_home_page.show_notifications_container()
        self.logged_in_home_page.verify_notifications_container_is_visible()
        self.logged_in_home_page.hide_notification_container_using_hide_link()
        self.logged_in_home_page.verify_notifications_container_is_invisible()

    def test_03_verify_tabs(self):
        """
        Scenario: User is able to view 4 tabs namely view unread, view all, Mark as read and hide
        in notification container
        Given that I am on the notification home page
        And notifications container is hidden
        When I click the notification icon
        Then I should see the notification container
        And notification container should display 4 tabs(unread, view all, Mark as read, Hide)
        """
        self.login()
        self.logged_in_home_page.verify_notifications_container_is_invisible()
        self.logged_in_home_page.show_notifications_container()
        self.logged_in_home_page.verify_notifications_container_is_visible()
        fetched_notifications_container_tabs = self.logged_in_home_page.return_notifications_container_tabs()
        self.assertEqual(fetched_notifications_container_tabs, self.notifications_container_tabs)

    def test_04_verify_default_tab(self):
        """
        Scenario: When notification container becomes visible, by default the View Unread tab is selected
        Given that I am on the notification home page
        And notifications container is hidden
        When I click the notification icon
        Then I should see the notification container
        And by default the View Unread tab should be selected
        """
        self.login()
        self.logged_in_home_page.verify_notifications_container_is_invisible()
        self.logged_in_home_page.show_notifications_container()
        self.logged_in_home_page.verify_notifications_container_is_visible()
        fetched_selected_tab = self.logged_in_home_page.return_selected_tab()
        self.assertEqual(fetched_selected_tab, self.notifications_container_tabs[0])

    def test_05_unread_notifications_count(self):
        """
        Scenario: Clicking on the add notification button after selecting a notification type increases the
        unread notification count by 1.
        Given that I am on the notification home page
        When I click the notification icon after adding a notification
        Then I should see the increase in unread notification count by 1
        """
        self.login()
        self.logged_in_home_page.show_notifications_container()
        self.logged_in_home_page.verify_notifications_container_is_visible()
        initial_unread_notification_count = self.logged_in_home_page.return_unread_notifications_count()
        self.logged_in_home_page.hide_notification_container()
        self.logged_in_home_page.verify_notifications_container_is_invisible()
        for key in self.notification_dict:
            self.logged_in_home_page.select_notification_type(key)
            self.logged_in_home_page.add_notification()
            self.logged_in_home_page.show_notifications_container()
            self.logged_in_home_page.verify_notifications_container_is_visible()
            final_unread_notification_count = self.logged_in_home_page.return_unread_notifications_count()
            self.logged_in_home_page.hide_notification_container()
            self.logged_in_home_page.verify_notifications_container_is_invisible()
            self.assertEqual(final_unread_notification_count, initial_unread_notification_count + 1)
            initial_unread_notification_count = final_unread_notification_count

    def test_06_view_all_notification_count(self):
        """
        Scenario: Clicking on the add notification button after selecting a notification type increases the
        notification count in view all tab by 1.
        Given that I am on the notification home page
        When I click the notification icon after adding a notification
        Then I should see the increase in notification count by 1 in view all tab
        """
        self.login()
        self.logged_in_home_page.show_notifications_container()
        self.logged_in_home_page.verify_notifications_container_is_visible()
        self.logged_in_home_page.select_view_all_tab()
        initial_notification_count = self.logged_in_home_page.return_view_all_notifications_count()
        self.logged_in_home_page.hide_notification_container()
        self.logged_in_home_page.verify_notifications_container_is_invisible()
        for key in self.short_notification_dict:
            self.logged_in_home_page.select_notification_type(key)
            self.logged_in_home_page.add_notification()
            self.logged_in_home_page.show_notifications_container()
            self.logged_in_home_page.verify_notifications_container_is_visible()
            self.logged_in_home_page.select_view_all_tab()
            final_notification_count = self.logged_in_home_page.return_view_all_notifications_count()
            self.logged_in_home_page.hide_notification_container()
            self.logged_in_home_page.verify_notifications_container_is_invisible()
            self.assertEqual(final_notification_count, initial_notification_count + 1)
            initial_notification_count = final_notification_count

    def test_07_unread_notifications_text(self):
        """
        Scenario: When user adds a new notification type, the relevant message for this notification type
        appears in unread notifications tab
        Given that I am on the notification home page
        And notifications container is hidden
        When I add a specific notification type
        And click the notification icon
        Then I should see the unread notifications
        And a relevant message for the added notification type should be visible in unread notification tab
        """
        self.login()
        for key, value in self.notification_dict.iteritems():
            self.logged_in_home_page.select_notification_type(key)
            self.logged_in_home_page.add_notification()
            self.logged_in_home_page.show_notifications_container()
            self.logged_in_home_page.verify_notifications_container_is_visible()
            unread_notification_list = self.logged_in_home_page.return_notifications_list(key)
            self.logged_in_home_page.hide_notification_container()
            self.logged_in_home_page.verify_notifications_container_is_invisible()
            self.assertIn(value, unread_notification_list[0])

    def test_08_view_all_notifications_text(self):
        """
        Scenario: When user adds a new notification type, the relevant message for this notification type
        appears in view all notifications tab
        Given that I am on the notification home page
        And notifications container is hidden
        When I add a specific notification type
        And click the notification icon
        Then I should see the unread notifications
        And a relevant message for the added notification type should be visible in view all notification tab
        """
        self.login()
        for key, value in self.short_notification_dict.iteritems():
            self.logged_in_home_page.select_notification_type(key)
            self.logged_in_home_page.add_notification()
            self.logged_in_home_page.show_notifications_container()
            self.logged_in_home_page.verify_notifications_container_is_visible()
            self.logged_in_home_page.select_view_all_tab()
            notification_list = self.logged_in_home_page.return_notifications_list(key)
            self.logged_in_home_page.hide_notification_container()
            self.logged_in_home_page.verify_notifications_container_is_invisible()
            self.assertIn(value, notification_list[0])

    def test_09_mark_as_read(self):
        """
        Scenario: When user clicks on mark as read tab, notifications disappear from unread notifications
        tab
        Given that I am on the notification home page
        And there are some notifications present in unread notification tab
        When I click on mark as read link
        Then all notifications should disappear from unread notifications tab
        And notification count on panel should also become 0
        """
        self.login()
        self.logged_in_home_page.add_notification()
        self.logged_in_home_page.show_notifications_container()
        self.logged_in_home_page.verify_notifications_container_is_visible()
        unread_notification_count = self.logged_in_home_page.return_unread_notifications_count()
        self.assertTrue(unread_notification_count > 0)
        self.logged_in_home_page.mark_as_read()
        unread_notification_count = self.logged_in_home_page.return_unread_notifications_count()
        self.assertEqual(unread_notification_count, 0)
        display_notification_count = self.logged_in_home_page.get_notifications_count()
        self.assertEqual(display_notification_count, 0)

    def test_10_page_redirect(self):
        """
        Scenario: When user clicks on any notification, it should redirect user to a specific page
        Given that I am on the notification home page
        And there are some notifications present
        When I click on any notification
        Then it should redirect me to a specific page
        And the resulting page url should be same as click link
        """
        for key in self.notification_dict:
            if key != 'testserver.type1':
                self.login()
                self.logged_in_home_page.select_notification_type(key)
                self.logged_in_home_page.add_notification()
                self.logged_in_home_page.show_notifications_container()
                self.logged_in_home_page.verify_notifications_container_is_visible()
                notification_link = self.logged_in_home_page.click_on_notification()
                self.notification_target_page.verify_target_page_url(notification_link)
                self.browser.back()
                self.logged_in_home_page.log_out()

    def test_11_page_refresh(self):
        """
        Scenario: When user clicks on any notification without target link, it should just refresh
        the page
        Given that I am on the notification home page
        And there are some notifications present
        When I click on any notification
        Then it should just refresh the page
        """
        self.login()
        self.logged_in_home_page.select_notification_type('testserver.type1')
        self.logged_in_home_page.add_notification()
        self.logged_in_home_page.show_notifications_container()
        self.logged_in_home_page.verify_notifications_container_is_visible()
        notification_link = self.logged_in_home_page.click_on_notification()
        self.assertEqual(notification_link, 'No target link')

    def test_12_status_change_one(self):
        """
        Scenario: When user clicks on any unread notification, it should change
        it's status to read
        When I click on any unread notification
        Then it's status should change to unread
        """
        self.login()
        self.logged_in_home_page.add_notification()
        self.logged_in_home_page.show_notifications_container()
        self.logged_in_home_page.verify_notifications_container_is_visible()
        unread_notification_count = self.logged_in_home_page.return_unread_notifications_count()
        self.logged_in_home_page.click_on_notification()
        self.browser.back()
        self.logged_in_home_page.log_out()
        self.login()
        self.logged_in_home_page.show_notifications_container()
        self.logged_in_home_page.verify_notifications_container_is_visible()
        new_unread_notification_count = self.logged_in_home_page.get_notifications_count()
        self.assertEqual(new_unread_notification_count, unread_notification_count - 1)

    def test_13_status_change_two(self):
        """
        Scenario: When user clicks on any notification without target link, it should change
        it's status to read
        When I click on any unread notification
        Then it's status should change to unread
        """
        self.login()
        self.logged_in_home_page.select_notification_type('testserver.type1')
        self.logged_in_home_page.add_notification()
        self.logged_in_home_page.show_notifications_container()
        self.logged_in_home_page.verify_notifications_container_is_visible()
        unread_notification_count = self.logged_in_home_page.return_unread_notifications_count()
        self.logged_in_home_page.click_on_notification()
        self.logged_in_home_page.hide_notification_container()
        self.logged_in_home_page.show_notifications_container()
        self.logged_in_home_page.verify_notifications_container_is_visible()
        new_unread_notification_count = self.logged_in_home_page.return_unread_notifications_count()
        self.assertEqual(new_unread_notification_count, unread_notification_count - 1)

    def test_14_notification_count_decrease_one(self):
        """
        Scenario: When user clicks on any notification, the notification count should decrease
        by 1
        Given that I am on the notification home page
        And there are some notifications present
        When I click on any unread notification
        Then it the main notification count should be decreased by 1
        """
        self.login()
        self.logged_in_home_page.add_notification()
        self.logged_in_home_page.show_notifications_container()
        self.logged_in_home_page.verify_notifications_container_is_visible()
        notification_count = self.logged_in_home_page.get_notifications_count()
        self.logged_in_home_page.click_on_notification()
        self.browser.back()
        self.logged_in_home_page.log_out()
        self.login()
        new_notification_count = self.logged_in_home_page.get_notifications_count()
        self.assertEqual(new_notification_count, notification_count - 1)

    def test_15_notification_count_decreases_two(self):
        """
        Scenario: When user clicks on any notification without target link, the notification
        count should decrease by 1
        Given that I am on the notification home page
        And there are some notifications present
        When I click on any unread notification
        Then it the main notification count should be decreased by 1
        """
        self.login()
        self.logged_in_home_page.select_notification_type('testserver.type1')
        self.logged_in_home_page.add_notification()
        self.logged_in_home_page.show_notifications_container()
        self.logged_in_home_page.verify_notifications_container_is_visible()
        notification_count = self.logged_in_home_page.get_notifications_count()
        self.logged_in_home_page.click_on_notification()
        new_notification_count = self.logged_in_home_page.get_notifications_count()
        self.assertEqual(new_notification_count, notification_count - 1)

    def test_16_namespace_one(self):
        """
        Scenario: When user adds notification in first namespace, it does not change
        notification count in 2nd namespace
        Given that I am on the notification home page
        And all name spaces have been initialized to 0 count
        When I add notifications in any namespace
        Then the notification count in other namespace remains unchanged
        """
        self.login()
        for namespace in self.namespaces:
            self.logged_in_home_page.set_namespace(namespace)
            self.logged_in_home_page.show_notifications_container()
            self.logged_in_home_page.verify_notifications_container_is_visible()
            self.logged_in_home_page.mark_as_read()
            display_notification_count = self.logged_in_home_page.get_notifications_count()
            self.assertEqual(display_notification_count, 0)
        self.logged_in_home_page.set_namespace(self.namespaces[0])
        self.logged_in_home_page.add_notification()
        notification_count_for_namespace_1 = self.logged_in_home_page.get_notifications_count()
        self.assertEqual(notification_count_for_namespace_1, 1)
        self.logged_in_home_page.set_namespace(self.namespaces[1])
        notification_count_for_namespace_2 = self.logged_in_home_page.get_notifications_count()
        self.assertEqual(notification_count_for_namespace_2, 0)

    def test_18_namespace_two(self):
        """
        Scenario: When user adds notification in first namespace, it does not change
        unread notification count in other namespace
        Given that I am on the notification home page
        And all name spaces have been initialized to 0 count
        When I add notifications in any namespace
        Then the unread notification count in other namespace remains unchanged
        """
        self.login()
        for namespace in self.namespaces:
            self.logged_in_home_page.set_namespace(namespace)
            self.logged_in_home_page.show_notifications_container()
            self.logged_in_home_page.verify_notifications_container_is_visible()
            self.logged_in_home_page.mark_as_read()
            display_notification_count = self.logged_in_home_page.get_notifications_count()
            self.assertEqual(display_notification_count, 0)
        self.logged_in_home_page.set_namespace(self.namespaces[1])
        self.logged_in_home_page.add_notification()
        self.logged_in_home_page.show_notifications_container()
        self.logged_in_home_page.verify_notifications_container_is_visible()
        unread_notification_count_for_namespace_2 = self.logged_in_home_page.return_unread_notifications_count()
        self.assertEqual(unread_notification_count_for_namespace_2, 1)
        self.logged_in_home_page.set_namespace(self.namespaces[0])
        self.logged_in_home_page.show_notifications_container()
        self.logged_in_home_page.verify_notifications_container_is_visible()
        unread_notification_count_for_namespace_1 = self.logged_in_home_page.return_unread_notifications_count()
        self.assertEqual(unread_notification_count_for_namespace_1, 0)

    def test_19_namespace_three(self):
        """
        Scenario: When user marks notifications in first namespace as read, it does not change
        notifications status in 2nd namespace
        Given that I am on the notification home page
        And all name spaces have some notifications
        When I mark notifications as read in one name space
        Then the notification status in other namespace remains unchanged
        """
        self.login()
        for namespace in self.namespaces:
            self.logged_in_home_page.set_namespace(namespace)
            self.logged_in_home_page.add_notification()
        self.logged_in_home_page.set_namespace(self.namespaces[0])
        self.logged_in_home_page.show_notifications_container()
        self.logged_in_home_page.verify_notifications_container_is_visible()
        self.logged_in_home_page.mark_as_read()
        notification_count_for_namespace_1 = self.logged_in_home_page.get_notifications_count()
        self.assertEqual(notification_count_for_namespace_1, 0)
        self.logged_in_home_page.set_namespace(self.namespaces[1])
        notification_count_for_namespace_2 = self.logged_in_home_page.get_notifications_count()
        self.assertTrue(notification_count_for_namespace_2 > 0)

    def test_20_close_icon(self):
        """
        Scenario: When user clicks on close icon of any notification, it should remain on current
        page and notification count along with unread count should decrease by 1
        Given that I am on the notification home page
        And there are some notifications present
        When I click on any notification's close icon
        Then it should stay on the same page
        And the notification count should decrease by one
        And unread notification count should also decrease by one
        """
        self.login()
        self.logged_in_home_page.show_notifications_container()
        self.logged_in_home_page.verify_notifications_container_is_visible()
        self.logged_in_home_page.mark_as_read()
        self.logged_in_home_page.hide_notification_container()
        self.logged_in_home_page.verify_notifications_container_is_invisible()
        for key in self.notification_dict:
            self.logged_in_home_page.select_notification_type(key)
            self.logged_in_home_page.add_notification()
            initial_notification_count = self.logged_in_home_page.get_notifications_count()
            self.assertEqual(initial_notification_count, 1)
            self.logged_in_home_page.show_notifications_container()
            self.logged_in_home_page.verify_notifications_container_is_visible()
            initial_unread_notification_count = self.logged_in_home_page.return_unread_notifications_count()
            self.assertEqual(initial_unread_notification_count, 1)
            self.logged_in_home_page.verify_notifications_container_is_visible()
            self.logged_in_home_page.close_notification()
            self.assertTrue(self.logged_in_home_page.is_browser_on_page())
            final_unread_notification_count = self.logged_in_home_page.return_unread_notifications_count()
            self.assertEqual(final_unread_notification_count, 0)
            final_notification_count = self.logged_in_home_page.get_notifications_count()
            self.assertEqual(final_notification_count, 0)
            self.logged_in_home_page.hide_notification_container()
            self.logged_in_home_page.verify_notifications_container_is_invisible()

    def login(self):
        """
        Go to home page and login using correct credentials
        """
        self.home_page.visit()
        self.home_page.go_to_login_page()
        login_result = self.login_page.login_to_application(user_name, password)
        if login_result == 'User not registered':
            self.home_page.go_to_registration_page()
            self.registration_page.register(user_name, user_email, password)
            self.registration_success.go_to_login_page()
            self.login_page.login_to_application(user_name, password)
            self.assertTrue(self.logged_in_home_page.is_browser_on_page())
        self.assertTrue(self.logged_in_home_page.is_browser_on_page())
Esempio n. 19
0
 def setUp(self):
     self.driver.implicitly_wait(20)
     login_page = LoginPage(self.driver)
     login_page.navigate()
     login_page.do_login(LOGIN, PASS)
class EmergencyContactsTestCase(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Chrome(executable_path=CHROME_EXECUTABLE_PATH)
        self.driver.get(DOMAIN)
        self.wait = WebDriverWait(self.driver, 2)
        self.login_page = LoginPage(self.driver)
        self.personal_details_page = PersonalDetailsPage(self.driver)
        self.add_photograph_page = AddPhotographPage(self.driver)
        self.contact_details_page = ContactDetailsPage(self.driver)
        self.emergency_contacts_page = EmergencyContactsPage(self.driver)

    def tearDown(self):
        self.driver.quit()

    def test_16_add_emergency_contacts(self):
        name = 'Emer'
        relationship = 'wife'
        home_phone = '123456789'
        mobile_phone = '987654321'
        work_phone = '123366654'

        self.login_page.login()
        self.login_page.get_welcome_massage()
        self.personal_details_page.goto_page()
        self.emergency_contacts_page.goto_page()
        self.emergency_contacts_page.add_contact_button()
        self.emergency_contacts_page.set_name(name)
        self.emergency_contacts_page.set_relationship(relationship)
        self.emergency_contacts_page.set_home_phone(home_phone)
        self.emergency_contacts_page.set_mobile_phone(mobile_phone)
        self.emergency_contacts_page.set_work_phone(work_phone)
        self.emergency_contacts_page.save_button()

        self.wait.until(
            expected_conditions.text_to_be_present_in_element(
                (By.CSS_SELECTOR, ".message.success"), 'Successfully Saved'))
        table_name = self.driver.find_element_by_xpath(
            '//*[@id="emgcontact_list"]/tbody/tr[1]/td[2]/a')
        self.assertTrue(table_name.text == name)

        # deleting created emergency contact
        self.driver.find_element_by_css_selector("td>input").click()
        self.driver.find_element_by_id("delContactsBtn").click()
        self.wait.until(
            expected_conditions.text_to_be_present_in_element(
                (By.CSS_SELECTOR, ".message.success"), 'Successfully Deleted'))

    def test_17_emergency_name_requered(self):
        driver = self.driver
        relationship = 'wife'
        home_phone = '123456789'
        mobile_phone = '987654321'
        work_phone = '123366654'

        self.login_page.login()
        self.login_page.get_welcome_massage()
        self.personal_details_page.goto_page()
        self.emergency_contacts_page.goto_page()
        self.emergency_contacts_page.add_contact_button()
        self.emergency_contacts_page.set_relationship(relationship)
        self.emergency_contacts_page.set_home_phone(home_phone)
        self.emergency_contacts_page.set_mobile_phone(mobile_phone)
        self.emergency_contacts_page.set_work_phone(work_phone)
        self.emergency_contacts_page.save_button()

        self.assertTrue(
            driver.find_element_by_xpath(
                '//*[@id="frmEmpEmgContact"]/fieldset/ol/li[1]/span').text ==
            'Required')

    def test_18_emergency_relationship_requered(self):
        driver = self.driver

        name = 'Emer'
        home_phone = '123456789'
        mobile_phone = '987654321'
        work_phone = '123366654'

        self.login_page.login()
        self.login_page.get_welcome_massage()
        self.personal_details_page.goto_page()
        self.emergency_contacts_page.goto_page()
        self.emergency_contacts_page.add_contact_button()
        self.emergency_contacts_page.set_name(name)
        self.emergency_contacts_page.set_home_phone(home_phone)
        self.emergency_contacts_page.set_mobile_phone(mobile_phone)
        self.emergency_contacts_page.set_work_phone(work_phone)
        self.emergency_contacts_page.save_button()

        self.assertTrue(
            driver.find_element_by_xpath(
                '//*[@id="frmEmpEmgContact"]/fieldset/ol/li[2]/span').text ==
            'Required')

    def test_19_emergency_one_phone_enough(self):
        name = 'Emer'
        relationship = 'wife'
        home_phone = '123456789'

        self.login_page.login()
        self.login_page.get_welcome_massage()
        self.personal_details_page.goto_page()
        self.emergency_contacts_page.goto_page()
        self.emergency_contacts_page.add_contact_button()
        self.emergency_contacts_page.set_name(name)
        self.emergency_contacts_page.set_relationship(relationship)
        self.emergency_contacts_page.set_home_phone(home_phone)
        self.emergency_contacts_page.save_button()

        self.wait.until(
            expected_conditions.text_to_be_present_in_element(
                (By.CSS_SELECTOR, ".message.success"), 'Successfully Saved'))

    def test_20_emergency_one_phone_requered(self):
        driver = self.driver
        name = 'Emer'
        relationship = 'wife'

        self.login_page.login()
        self.login_page.get_welcome_massage()
        self.personal_details_page.goto_page()
        self.emergency_contacts_page.goto_page()
        self.emergency_contacts_page.add_contact_button()
        self.emergency_contacts_page.set_name(name)
        self.emergency_contacts_page.set_relationship(relationship)
        self.emergency_contacts_page.save_button()

        self.assertTrue(
            driver.find_element_by_xpath(
                '//*[@id="frmEmpEmgContact"]/fieldset/ol/li[3]/span').text ==
            'At least one phone number is required')

    def test_21_add_multiply_emg_contacts(self):
        name = 'Emer'
        relationship = 'wife'
        home_phone = '123456789'
        mobile_phone = '987654321'
        work_phone = '123366654'

        self.login_page.login()
        self.login_page.get_welcome_massage()
        self.personal_details_page.goto_page()
        self.emergency_contacts_page.goto_page()
        self.emergency_contacts_page.add_contact_button()
        self.emergency_contacts_page.set_name(name)
        self.emergency_contacts_page.set_relationship(relationship)
        self.emergency_contacts_page.set_home_phone(home_phone)
        self.emergency_contacts_page.set_mobile_phone(mobile_phone)
        self.emergency_contacts_page.set_work_phone(work_phone)
        self.emergency_contacts_page.save_button()

        self.wait.until(
            expected_conditions.text_to_be_present_in_element(
                (By.CSS_SELECTOR, ".message.success"), 'Successfully Saved'))

        self.emergency_contacts_page.add_contact_button()
        self.emergency_contacts_page.set_name(name)
        self.emergency_contacts_page.set_relationship(relationship)
        self.emergency_contacts_page.set_home_phone(home_phone)
        self.emergency_contacts_page.set_mobile_phone(mobile_phone)
        self.emergency_contacts_page.set_work_phone(work_phone)
        self.emergency_contacts_page.save_button()
        self.wait.until(
            expected_conditions.text_to_be_present_in_element(
                (By.CSS_SELECTOR, ".message.success"), 'Successfully Saved'))
        # deleting all emergency contacts
        self.driver.find_element_by_id('checkAll').click()
        self.driver.find_element_by_id("delContactsBtn").click()
        self.wait.until(
            expected_conditions.text_to_be_present_in_element(
                (By.CSS_SELECTOR, ".message.success"), 'Successfully Deleted'))

    def test_22_delete_emg_contacts(self):

        name = 'Emer'
        relationship = 'wife'
        home_phone = '123456789'

        self.login_page.login()
        self.login_page.get_welcome_massage()
        self.personal_details_page.goto_page()
        self.emergency_contacts_page.goto_page()
        self.emergency_contacts_page.add_contact_button()
        self.emergency_contacts_page.set_name(name)
        self.emergency_contacts_page.set_relationship(relationship)
        self.emergency_contacts_page.set_home_phone(home_phone)
        self.emergency_contacts_page.save_button()

        self.wait.until(
            expected_conditions.text_to_be_present_in_element(
                (By.CSS_SELECTOR, ".message.success"), 'Successfully Saved'))

        self.driver.find_element_by_css_selector("td>input").click()
        self.driver.find_element_by_id("delContactsBtn").click()
        self.wait.until(
            expected_conditions.text_to_be_present_in_element(
                (By.CSS_SELECTOR, ".message.success"), 'Successfully Deleted'))

    def test_23_add_attachment_emg_contacts(self):
        file_path = Pdf_file_path

        self.login_page.login()
        self.login_page.get_welcome_massage()
        self.personal_details_page.goto_page()
        self.emergency_contacts_page.goto_page()
        self.emergency_contacts_page.add_attachment_button()
        self.emergency_contacts_page.choose_file(file_path)
        self.emergency_contacts_page.upload_button()

        self.wait.until(
            expected_conditions.text_to_be_present_in_element(
                (By.CSS_SELECTOR, ".message.success"), 'Successfully Saved'))
        # cleanup_deleting attachment
        self.driver.find_element_by_css_selector(
            "#tblAttachments > tbody > tr.odd > td.center > input").click()
        self.driver.find_element_by_id("btnDeleteAttachment").click()
        self.wait.until(
            expected_conditions.text_to_be_present_in_element(
                (By.CSS_SELECTOR, ".message.success"), 'Successfully Deleted'))

    def test_24_delete_attachment_emg_contacts(self):
        file_path = Pdf_file_path

        self.login_page.login()
        self.login_page.get_welcome_massage()
        self.personal_details_page.goto_page()
        self.emergency_contacts_page.goto_page()
        self.emergency_contacts_page.add_attachment_button()
        self.emergency_contacts_page.choose_file(file_path)
        self.emergency_contacts_page.upload_button()

        self.wait.until(
            expected_conditions.text_to_be_present_in_element(
                (By.CSS_SELECTOR, ".message.success"), 'Successfully Saved'))

        self.driver.find_element_by_css_selector(
            "#tblAttachments > tbody > tr.odd > td.center > input").click()
        self.driver.find_element_by_id("btnDeleteAttachment").click()
        self.wait.until(
            expected_conditions.text_to_be_present_in_element(
                (By.CSS_SELECTOR, ".message.success"), 'Successfully Deleted'))

    def test_25_add_attachment_large_size(self):
        file_path = JPG_2_Mb_path

        self.login_page.login()
        self.login_page.get_welcome_massage()
        self.personal_details_page.goto_page()
        self.emergency_contacts_page.goto_page()
        self.emergency_contacts_page.add_attachment_button()
        self.emergency_contacts_page.choose_file(file_path)
        self.emergency_contacts_page.upload_button()

        self.assertEqual(
            '413 Request Entity Too Large',
            self.driver.find_element_by_xpath('/html/body/center[1]/h1').text)
from selenium.common.exceptions import TimeoutException, NoSuchElementException
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By
from selenium.webdriver.support.wait import WebDriverWait

from pages.base_page import BasePage
from pages.dashboard_page import DashboardPage
from pages.login_page import LoginPage
from pages.header_page import Header
#
driver = webdriver.Chrome()
driver.get("https://opensource-demo.orangehrmlive.com/")



login_page = LoginPage(driver)

def get_num(driver, locator):
    for i in range(10):
        print(i)
        if i == 5:
            return True
    return False



login_page.wait_until(get_num('sds'))


driver.close()
Esempio n. 22
0
 def objectSetup(self, oneTimeSetUp):
     self.lp = LoginPage(self.driver)
Esempio n. 23
0
 def setUp(self):
     self.driver = webdriver.Chrome(executable_path=CHROME_EXECUTABLE_PATH)
     self.driver.get(DOMAIN)
     self.login_page = LoginPage(self.driver)
     self.personal_details_page = PersonalDetailsPage(self.driver)
Esempio n. 24
0
def test_guest_on_login_page(browser):
    link = 'http://selenium1py.pythonanywhere.com/en-gb/accounts/login/'
    page = LoginPage(browser, link)
    page.open()
    page.should_be_login_page()
Esempio n. 25
0
 def logic_noLogin_state_buy(self):
     from pages.login_page import LoginPage
     self.el_buy_btn.click()
     return LoginPage(self.driver)
Esempio n. 26
0
 def setUpClass(cls):
     cls.driver = webdriver.Firefox()
     cls.zentao = AddBugPage(cls.driver)
     a = LoginPage(cls.driver)  #实例化对象
     a.login()  #调用方法
Esempio n. 27
0
 def test_login(self):
     driver = self.driver
     driver.get(URL)
     login = LoginPage(driver)
     login.test_login(USERNAME, PASSWORD)
Esempio n. 28
0
 def test_login_url(browser):
     page = LoginPage(browser, LoginPageLocators.url_login)
     page.open()
     page.should_be_login_page()
class SessionHelper:

    def __init__(self, app, domain, credentials):
        self.driver = app.driver
        self.login_page = LoginPage(driver=self.driver, domain=domain)
        self.navigation_bar = NavigationBar(driver=self.driver)
        self.credentials = credentials

    def ensure_login(self, user):
        if not self.logged_in():
            if user == "admin":
                self.login_as_admin()
            elif user == "guide":
                self.login_as_guide()
            elif user == "call_center":
                self.login_as_call_center()
            else:
                raise ValueError

    def login_as_admin(self):
        self.login_page.open()
        if self.is_login_page():
            self.login(self.credentials['admin']['login'], self.credentials['admin']['password'])
        elif self.which_profile() == "admin":
            pass
        elif self.which_profile() == "guide":
            self.logout()
        else:
            print("Unable to log in...")
            print(self.which_profile())

    def login_as_guide(self):
        self.login_page.open()
        if self.is_login_page():
            self.login(self.credentials['guide']['login'], self.credentials['guide']['password'])
        elif self.which_profile() == "guide":
            pass
        elif self.which_profile() == "admin":
            self.logout()
        else:
            print("Unable to log in...")
            print(self.which_profile())

    def login_as_call_center(self):
        self.login_page.open()
        sleep(1)
        if self.is_login_page():
            self.login(self.credentials['call_center']['login'], self.credentials['call_center']['password'])
            self.login_page.choose_company(self.credentials['call_center']['company'])
            self.wait_for_company_opened()
        elif "ccu_companyList.aspx" in self.login_page.get_url():
            self.login_page.choose_company(self.credentials['call_center']['company'])
            self.wait_for_company_opened()

    def login(self, login, password):
        self.login_page.login_input.send_keys(login)
        self.login_page.password_input.send_keys(password)
        self.login_page.login_button.click()

    def which_profile(self):
        try:
            current_profile = self.navigation_bar.profile_pic.get_attribute("src")
            if "admin_profile" in current_profile:
                return "admin"
            # elif "guide_profile" in current_profile:
            #     return "guide"
            # elif "defaults" in current_profile:
            #     return "call_center"
            # else:
            #     print(current_profile)
        except NoSuchElementException:
            return "There is no profile pic on the page."

    def wait_for_company_opened(self):
        wait(lambda: self.which_profile() == "admin", timeout_seconds=60)
        # wait(lambda: self.which_profile() == "call_center", timeout_seconds=60)

    def is_login_page(self):
        return "login.aspx" in self.login_page.get_url()

    def ensure_logout(self):
        sleep(2)
        if self.logged_in():
            self.logout()

    def logged_in(self):
        if len(self.navigation_bar.profile_pics) == 1:
            return True
        else:
            return False

    def logout(self):
        self.navigation_bar.menu_drop_down.click()
        self.navigation_bar.logout.click()

    def sell_certificate(self):
        self.navigation_bar.main_tab.click()
        self.navigation_bar.gift_certificates.click()
 def __init__(self, app, domain, credentials):
     self.driver = app.driver
     self.login_page = LoginPage(driver=self.driver, domain=domain)
     self.navigation_bar = NavigationBar(driver=self.driver)
     self.credentials = credentials
Esempio n. 31
0
 def setUpClass(cls):
     cls.driver = webdriver.Firefox()
     cls.loginp = LoginPage(cls.driver)
Esempio n. 32
0
 def test_user_can_login(self, browser):
     # Arrange
     page = LoginPage(browser, URLLocators.LOGIN_URL)
     page.open()
     page.register_new_user()
     page.logout_user()
     page.check_is_user_logged_out()
     # Act
     page.go_to_login_page()
     page.login_user()
     # Assert
     page.check_is_user_logged_in()
def test_guest_can_go_to_login_page(browser):
    page = MainPage(browser, LINK)
    page.open()
    page.go_to_login_page()
    login_page = LoginPage(browser, browser.current_url)
    login_page.should_be_login_page()
Esempio n. 34
0
def test_can_redirect_to_register_page(browser):
    LoginPage(browser).redirect_to_register_page()
Esempio n. 35
0
    def test_login(self):
        wd = WebDriverFactory(browser="chrome.driver")
        driver = wd.getWebDriverInstance()
        lt = LoginPage(driver)

        # Click and verify account
        lt.account()
        element = driver.find_element_by_xpath(
            "//button[@id='header-account-menu']")
        if element.is_enabled():
            print("Test case TC001: Pass")
        else:
            print("Test Case TC001: Fail")

        # Click and verify Sign in
        lt.signIn()
        element = driver.find_element_by_xpath("//a[@id='account-signin']")
        if element.is_enabled():
            print("Test Case Tc002: Pass")
        else:
            print("Test Case TC002: Fail")

        # Send email and verify email
        lt.email("*****@*****.**")
        email = driver.find_element_by_xpath("//input[@id='gss-signin-email']")
        if email.is_enabled():
            print("Test Case Tc003: Pass")
        else:
            print("Test Case TC003: Fail")

        # # Click and verify 'Forgot Password Button'
        # lt.forgotPassword()
        # heading = driver.find_element_by_xpath("//h2[@id='gss-forgot-password-heading']")
        # print(heading.text)
        # if heading.text=="Reset your password":
        #     print("Test Case TC004: Pass")
        # else:
        #     print("Test Case TC004: Fail ")

        # Send Password and Verify
        lt.password("Ej12345679*")
        password = driver.find_element_by_xpath(
            "//input[@id='gss-signin-password']")
        if password.is_enabled():
            print("Test Case TC004: Pass")
        else:
            print("Test Case TC004: Fail")

        # Click and verify Sign In Button
        lt.signInBtn()
        header_account = driver.find_element_by_xpath(
            "//button[@id='header-account-menu-signed-in']")
        if header_account.is_enabled():
            print("Test Case TC005: Pass")
        else:
            print("Test Case TC005: Fail")
Esempio n. 36
0
def test_arena(browser):

    # LOGUJĘ SIĘ DO  demo.testarena.pl

    login_page = LoginPage(browser)
    login_page.login('*****@*****.**', 'sumXQQ72$L')

    # OTWIERAM ADMIN PANEL
    admin_button = browser.find_element_by_css_selector('.header_admin a')
    admin_button.click()

    # DODAJĘ NOWY PROJEKT
    button_links = browser.find_element_by_partial_link_text('DODAJ PROJEKT')
    button_links.click()

    name = browser.find_element_by_id('name')
    prefix = browser.find_element_by_id('prefix')
    save = browser.find_element_by_id('save')

    # UMIESZCZAM LOSOWO WYGENEROWANĄ NAZWĘ PROJEKTU W ZMIENNEJ - ZA POMOCĄ TEJ ZMIENNEJ BĘDĘ SZUKAĆ PROJEKTU W BAZIE

    name_of_project = get_random_string(10)

    name.send_keys(name_of_project)
    prefix.send_keys(get_random_string(6))
    save.click()

    # WCHODZĘ DO SEKCJI PROJECTS (LEWE MENU)

    enter_the_section_projects = browser.find_element(By.CSS_SELECTOR,
                                                      'a.activeMenu')
    enter_the_section_projects.click()

    # SZUKAM NOWO-UTWORZONEGO PROJEKTU PO NAZWIE

    search_for_new_project = browser.find_element(By.CSS_SELECTOR,
                                                  'input#search')
    search_for_new_project.send_keys(name_of_project)  # PASEK WYSZUKIWANIA

    button_for_search_new_project = browser.find_element(
        By.CSS_SELECTOR, 'a#j_searchButton.icon_search.icon-20')
    button_for_search_new_project.click()  # PRZYCISK WYSZUKIWANIA (LUPA)

    # CZEKAM NA STRONĘ

    # wait = WebDriverWait(browser, 10)
    # grey_status_bar = (By.CSS_SELECTOR,'input#search')
    # wait.until(expected_conditions.visibility_of_element_located(grey_status_bar))

    time_for_waiting = Waiting(browser)
    time_for_waiting.wait_for_loading()

    # TWORZĘ LISTĘ PROJEKTÓW W BAZIE

    projects = browser.find_elements(By.CSS_SELECTOR, 'tr td a')

    # NASTĘPNIE, TWORZĘ KOLEJNĄ LISTĘ, KTÓRA BĘDZIE ZAWIERAĆ NAZWY TYCH PROJEKTÓW

    list_with_names = []

    for every_project in projects:
        list_with_names.append(every_project.text)

    # W ASERCJI SPRAWDZAM, CZY ZNAJDUJĄCA SIĘ W ZMIENNEJ NAZWA MOJEGO PROJEKTU - ZNAJDUJE SIĘ NA LIŚCIE NAZW STWORZONYCH PROJEKTÓW

    assert name_of_project in list_with_names
    print(name_of_project)
Esempio n. 37
0
class PersonalDetailsTestCase(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Chrome(executable_path=CHROME_EXECUTABLE_PATH)
        self.driver.get(DOMAIN)
        self.login_page = LoginPage(self.driver)
        self.personal_details_page = PersonalDetailsPage(self.driver)

    def tearDown(self):
        self.driver.quit()

    def test_01_see_personal_details(self):
        driver = self.driver
        self.login_page.login()
        self.login_page.get_welcome_massage()
        self.personal_details_page.goto_page()

        self.assertEqual(
            "Personal Details",
            driver.find_element_by_xpath(
                "//*[@id='pdMainContainer']/div[1]/h1").text)

    def test_02_edit_personal_details(self):
        driver = self.driver
        input_middle_name = 'Richard'
        employee_id = '101010'
        other_id = '033303'
        nick_name = 'Rick'
        military_status = 'N/A'

        self.login_page.login()
        self.login_page.get_welcome_massage()
        self.personal_details_page.goto_page()
        self.personal_details_page.edit_button()
        self.personal_details_page.setup_middle_name(input_middle_name)
        self.personal_details_page.setup_emloyee_id(employee_id)
        self.personal_details_page.setup_other_id(other_id)
        self.personal_details_page.setup_emp_mick_name(nick_name)
        self.personal_details_page.setup_military_status(military_status)
        self.personal_details_page.save_button()
        self.personal_details_page.get_success_message()

        employee_full = driver.find_element_by_xpath(
            '//*[@id="profile-pic"]/h1').text
        self.assertTrue(input_middle_name in employee_full)

    def test_03_edit_restricted_personal_details(self):
        driver = self.driver
        input_ssn = '50001000'
        driver_license_num = '002002002'
        sin_number = '9998765'
        date_of_birth = '03-09-1985'
        marital_text = 'Married'

        self.login_page.login()
        self.login_page.get_welcome_massage()
        self.personal_details_page.goto_page()
        self.personal_details_page.edit_button()
        self.personal_details_page.set_driver_license_num(driver_license_num)
        self.personal_details_page.set_sin_number(sin_number)
        self.personal_details_page.set_ssn_number(input_ssn)
        self.personal_details_page.set_smoker_radio_button()
        self.personal_details_page.set_date_of_birth(date_of_birth)
        self.personal_details_page.select_marital_status(marital_text)
        self.personal_details_page.save_button()
        self.personal_details_page.get_success_message()

        value_snn = driver.find_element_by_id(
            'personal_txtNICNo').get_attribute('value')
        self.assertEqual(input_ssn, value_snn)
Esempio n. 38
0
def step_impl(context):
    login_page = LoginPage(context)
    login_page.alert_handler()
Esempio n. 39
0
def test_login_page_has_all_elements(browser):
    LoginPage(browser).check_elements_exist()
 def setUpClass(cls):
     cls.driver = driver_config()
     cls.driver.implicitly_wait(5)
     LoginPage(cls.driver).login()
     log().info('开始执行:客户页面的自动化测试')
     PosterPage(cls.driver).switch_to_current()
Esempio n. 41
0
 def get(self):
     l = LoginPage(self.driver)
     l.get().click_register()
     return self
Esempio n. 42
0
def login(request):
    self = request.node.parent.obj
    lpg = LoginPage(self.driver)
    lpg.login(page=self.login_url_http)
Esempio n. 43
0
 def go_to_login_page(self):
     link = self._browser.find_element(*ProductPageLocators.LOGIN_PAGE_URL)
     link.click()
     return LoginPage(self._browser, self._browser.current_url)
 def test_user_can_see_success_register(self, browser):
     page = LoginPage(browser, login_link)
     page.should_be_login_page()
Esempio n. 45
0
def step_impl(context):
    login_page = LoginPage(context)
    login_page.click_on_second_alert()
 def test_user_can_see_register_information(self, browser):
     page = LoginPage(browser, login_link)
     page.should_be_register_information(browser)
Esempio n. 47
0
def test_login_to_account(driver, wait):
    '''TC-04 Verify if the registered user can log on the System'''
    web_page = MainPage(driver, wait)
    link_page = LoginPage(driver, wait)
    web_page.open()
    link_page.open()
    link_page.enter_email(email)
    link_page.enter_password(password)
    link_page.click_eye()
    link_page.submit_login()
    link_page.login_confirm()
Esempio n. 48
0
 def setUpClass(cls):
     cls.driver = webdriver.Chrome()
     cls.loginpage = LoginPage(cls.driver)
Esempio n. 49
0
class Application:
    def __init__(self, driver, base_url):
        self.driver = driver
        driver.get(base_url)
        driver.maximize_window()
        self.wait = WebDriverWait(driver, 15)
        self.login_page = LoginPage(driver, base_url)
        self.persons_page = PersonsPage(driver, base_url)
        self.internal_page = InternalPage(driver, base_url)
        self.person_main_page = AddPersonMainPage(driver, base_url)
        self.enrollments_page = EnrollmentsPage(driver, base_url)
        self.dictionaries_page = DictionariesPage(driver, base_url)
        self.person_current_view_page = PersonCurrentViewPage(driver, base_url)
        self.person_main_view_page = PersonMainViewPage(driver, base_url)
        self.person_papers_view_page = PersonPapersViewPage(driver, base_url)
        self.person_enrollment_view_page = PersonEnrollmentViewPage(driver, base_url)
        self.enrollments_main_page = EnrollmentsMainPage(driver, base_url)
        self.enrollments_base_page = EnrollmentsBasePage(driver, base_url)
        self.main_page = AddPersonMainPage(driver, base_url)
        self.extra_page = AddPersonExtraPage(driver, base_url)
        self.address_page = AddPersonAddressesPage(driver, base_url)
        self.contact_page = AddPersonContactsPage(driver, base_url)
        self.papers_page = AddPersonPapersPage(driver, base_url)
        self.person_base_page = AddPersonPage(driver, base_url)
        self.person_enrollment = PersonEnrollmentPage(driver, base_url)

    def login(self, user, checkbox=False):
        """
        Method performs login to the application. Use app.login(User.Admin) in tests
        :param user: User.Admin or User.random at the moment
        :param checkbox: True with checkbox remember me and False without it. Default value is False
        """
        lp = self.login_page
        lp.is_this_page()
        lp.username_field.clear()
        lp.username_field.send_keys(user.username)
        lp.password_field.clear()
        lp.password_field.send_keys(user.password)
        if checkbox:
            lp.login_checkbox.click()
            lp.submit_button.click()
            self.internal_page.wait_until_page_generate()
        else:
            lp.submit_button.click()
            self.internal_page.wait_until_page_generate()

    def ensure_logged_in(self):
        """
        Method ensures you are logged in, if not it enters as Admin
        """
        element = self.wait.until(presence_of_element_located((By.CSS_SELECTOR, "nav, input[id='inputLogin']")))
        if element.tag_name == "input":
            self.login(User.Admin())

    def logout(self):
        """
        Method performs logout from application
        """
        ip = self.internal_page
        ip.is_this_page()
        ip.user_dropdown.click()
        ip.logout_button.click()

    def ensure_logout(self):
        """
        Method ensures you are logged out from application, if not it performs logout
        """
        element = self.wait.until(presence_of_element_located((By.CSS_SELECTOR, "nav, input[id='inputLogin']")))
        if element.tag_name == "nav":
            self.logout()

    def is_logged_in(self):
        """
        Method checks you are logged in
        :return True or False
        """
        return self.internal_page.is_this_page()

    def is_not_logged_in(self):
        """
        Method checks you are not logged in
        :return: True or False
        """
        return self.login_page.is_this_page()
Esempio n. 50
0
def log_in(browser, user=USERS['default_user']):
    login_page = LoginPage(browser)
    login_page.log_in(user)