Exemplo n.º 1
0
    def test_unregistered_user(self):
        """An unregistered user cannot log in."""

        login_page = LoginPage(self)
        sign_in_button = login_page.setup('baduser', 'password')
        self.click_through(sign_in_button, self.BY_ALERT)
        login_page.assert_login_is_incorrect()
Exemplo n.º 2
0
    def test_wrong_password(self):
        """An user cannot log in with an invalid password."""

        login_page = LoginPage(self)
        sign_in_button = login_page.setup(
            self.test_data['users'][0]['username'],
            self.test_data['users'][0]['password'] + 'wrong',
        )
        self.click_through(sign_in_button, self.BY_ALERT)
        login_page.assert_login_is_incorrect()
    def test_navigate_back_to_organization_list(self):
        """A user can click on the index-link
        and it takes them back to the organizations list."""

        LoginPage(self).login('testuser', 'password')
        page = OrganizationPage(self)
        page.go_to()
        page.go_to_organization_page()

        page.go_back_to_organization_list()
        page.get_org_list_title()
Exemplo n.º 4
0
    def test_adding_members_to_archived_organization(self):
        LoginPage(self).login('admin_user', 'password')
        page = OrganizationMemberListPage(self)
        page.go_to()
        OrganizationPage(self).go_to_organization_page()
        OrganizationPage(self).get_archive_button()
        OrganizationPage(self).click_on_archive_and_confirm()

        title = page.go_to_member_list_page()
        assert title == "Members".upper()
        page.click_on_add_button(success=False)
Exemplo n.º 5
0
    def test_navigating_to_project_page(self):
        """A registered user can view an organization's project page."""

        LoginPage(self).login('testuser', 'password')
        page = OrganizationPage(self)
        page.go_to()
        page.go_to_organization_page()

        title = page.click_on_project()
        print("Organization #0\nTest Project")
        assert title == "Organization #0\nTest Project".upper()
Exemplo n.º 6
0
    def test_getting_to_the_user_list(self):
        """A registered admin user can view an organization's member list,
        but a regular member can't."""

        LoginPage(self).login('testuser', 'password')
        page = OrganizationPage(self)
        page.go_to()
        page.go_to_organization_page()

        page.click_on_view_all_button(successful=False)
        url = self.get_url_path()
        assert "members" not in url
        self.logout()

        LoginPage(self).login('admin_user', 'password')
        page = OrganizationPage(self)
        page.go_to()
        page.go_to_organization_page()

        title = page.click_on_view_all_button()
        assert title == "Members".upper()
    def test_searching_for_organizations(self):
        """A registered user user can search for organization by name."""

        LoginPage(self).login('testuser', 'password')
        page = OrganizationListPage(self)
        page.go_to()

        search = page.get_search_box()
        search.send_keys("#1")

        organization_title = page.get_organization_title_in_table()
        assert organization_title == 'Organization #1'
Exemplo n.º 8
0
    def check_user_status(self, statuses):
        """Check that the named users have the specified state
        by looking at the state of the activate/deactivate button
        on the users management page."""

        LoginPage(self).login(self.superuser['username'],
                              self.superuser['password'])
        users_page = UsersPage(self)
        users_page.go_to()
        for username in iter(statuses.keys()):
            assert (users_page.is_user_active(username) == bool(
                statuses[username]))
Exemplo n.º 9
0
    def test_project_archived_view(self):
        LoginPage(self).login('admin_user', 'password')
        page = ProjectPage(self, self.org.slug, self.prj.slug)
        page.go_to()
        self.get_screenshot('project page')
        assert 'ARCHIVED' in page.get_project_name()

        # Test main dashboard page
        page.click_on_add_location_button(success=False)
        page.click_on_add_resource_button_from_dropdown(success=False)
        page.click_on_edit_boundary_button('geometry', success=False)
        page.click_on_edit_boundary_button('details', success=False)
        page.click_on_edit_boundary_button('permissions', success=False)

        # Test spatial unit
        page.click_on_location()
        page.click_on_edit_button(success=False)
        page.click_on_delete_button(success=False)

        # Test spatial unit resource tab
        page.click_on_location_resource_tab()
        page.click_on_add_button('active', success=False)
        page.click_on_location_resource_tab()
        page.click_on_detach_resource_button('detail', success=False)

        # Test spatial unit relationship tab
        page.click_on_location_relationship_tab()
        page.click_on_add_button('active', success=False)
        page.click_on_location_relationship_tab()

        # Test spatial unit relationship tab
        page.click_on_relationship_in_table()
        page.click_on_edit_button(success=False)
        page.click_on_delete_button(success=False)
        page.click_on_add_button('detail', success=False)
        page.click_on_detach_resource_button('detail', success=False)

        # Test party page
        page.click_on_party_in_table()
        page.click_on_edit_button(success=False)
        page.click_on_delete_button(success=False)
        page.click_on_add_button('panel-body', success=False)
        page.click_on_detach_resource_button('panel-body', success=False)

        # Test project resource page
        page.click_on_resources_tab()
        page.click_on_add_button('panel-body', success=False)
        page.click_on_detach_resource_button('panel-body', success=False)

        page.click_on_resource_in_table()
        page.click_on_edit_resource_button(success=False)
        page.click_on_delete_resource_button_and_confirm(success=False)
Exemplo n.º 10
0
    def test_register_user(self):
        """An unregistered user can register with valid user details."""

        page = RegistrationPage(self)
        page.go_to()
        fields = page.get_fields()

        # Try to submit an empty form and check for validation errors.
        page.try_submit(err=['username', 'email', 'password1', 'password2'])

        # Fill in required fields one by one, try to submit and check
        # for errors.
        fields = page.get_fields()
        fields['username'].send_keys('user3')
        page.try_submit(err=['email', 'password1', 'password2'],
                        ok=['username'])
        fields = page.get_fields()
        fields['email'].send_keys('*****@*****.**')
        page.try_submit(err=['password1', 'password2'],
                        ok=['username', 'email'])
        fields = page.get_fields()
        fields['password1'].send_keys('very_secret')
        page.try_submit(err=['password1', 'password2'],
                        ok=['username', 'email'])
        fields = page.get_fields()
        fields['password2'].send_keys('not_very_secret')
        page.try_submit(err=['password1'],
                        ok=['username', 'email', 'password2'])

        # Fill in extra fields, fill in final required form and submit
        fields = page.get_fields()
        fields['full_name'].send_keys('User Three')
        fields['password1'].clear()
        fields['password1'].send_keys('very_secret')
        fields['password2'].clear()
        fields['password2'].send_keys('very_secret')
        self.click_through(fields['register'], self.BY_DASHBOARD)
        self.assert_has_message('alert', "signed in")

        dashboard_page = DashboardPage(self)
        assert dashboard_page.is_on_page()
        dashboard_page.get_dashboard_map()

        self.logout()

        # Log in as new user
        sign_in = LoginPage(self).setup('user3', 'very_secret')
        self.click_through(sign_in, self.BY_ALERT)

        assert dashboard_page.is_on_page()
        dashboard_page.get_dashboard_map()
Exemplo n.º 11
0
    def test_changing_an_admins_organizational_role(self):
        """An admin member can change a member's role in the organization."""

        LoginPage(self).login('admin_user', 'password')
        page = OrganizationMemberPage(self)
        page.go_to()
        OrganizationPage(self).go_to_organization_page()
        OrganizationMemberListPage(self).go_to_member_list_page()
        page.go_to_admin_member_page()

        role_select = page.get_member_role_select('')
        assert role_select.get_attribute('disabled')
        roles = page.get_role_options()
        assert roles["admin"].text == roles["selected"].text
Exemplo n.º 12
0
    def test_resource_attach_button_for_non_project_user(self):
        """Attach button will be hidden from users who doesn't have
            permission to add resource."""

        LoginPage(self).login('testuser', 'password')
        page = ProjectPage(self, self.org.slug, self.prj.slug)
        page.go_to()

        # Test resource tab
        page.click_on_resources_tab()
        try:
            page.click_on_add_button('panel-body', success=False)
        except NoSuchElementException:
            assert True
Exemplo n.º 13
0
    def test_editing_member_in_archived_organization(self):
        """A user that can create a new organization and
        is automatically made an admin."""

        LoginPage(self).login('admin_user', 'password')
        page = OrganizationMemberPage(self)
        page.go_to()
        OrganizationPage(self).go_to_organization_page()
        OrganizationPage(self).get_archive_button()
        OrganizationPage(self).click_on_archive_and_confirm()
        OrganizationMemberListPage(self).go_to_member_list_page()

        testuser_title = page.go_to_testuser_member_page(success=False)
        assert "MEMBER: Test User" != testuser_title
Exemplo n.º 14
0
    def test_removing_an_admin_member_from_an_organization(self):
        """An admin member can remove a member from an organization."""

        LoginPage(self).login('admin_user', 'password')
        page = OrganizationMemberPage(self)
        page.go_to()
        OrganizationPage(self).go_to_organization_page()
        OrganizationMemberListPage(self).go_to_member_list_page()
        page.go_to_admin_member_page()

        assert page.get_member_title() == "MEMBER: Admin User"

        page.click_disabled_remove_button()
        assert page.get_member_title() == "MEMBER: Admin User"
Exemplo n.º 15
0
    def generic_test_direct_url_access(self, user_data=None):
        """Accessing the (de)activate URLs directly should have no effect."""

        statuses = {}
        for user in self.test_data['users']:
            statuses[user['username']] = user['is_active']

        if user_data:
            LoginPage(self).login(user_data['username'], user_data['password'])
        self.access_direct_activate_urls()
        self.browser.get(self.live_server_url)
        if user_data:
            self.logout()
        self.check_user_status(statuses)
Exemplo n.º 16
0
    def test_archiving_organization(self):
        """A registered admin user can archive/unarchive an organization."""
        LoginPage(self).login('admin_user', 'password')
        page = OrganizationPage(self)
        page.go_to()
        page.go_to_organization_page()

        page.try_cancel_and_close_archive()
        page.get_archive_button()

        archive = page.click_on_archive_and_confirm()
        assert archive == "Unarchive organization"

        archive = page.click_on_archive_and_confirm(unarchive=True)
        assert archive == "Archive organization"
Exemplo n.º 17
0
    def test_valid_login(self):
        """A registered user can log in with their username and password
        and log out again. The logged in and logged out states
        are persistent across page refreshes."""

        sign_in_button = LoginPage(self).setup(
            self.test_data['users'][0]['username'],
            self.test_data['users'][0]['password'],
        )
        self.click_through(sign_in_button, self.BY_DASHBOARD)

        dashboard_page = DashboardPage(self)
        assert dashboard_page.is_on_page()
        dashboard_page.get_dashboard_map()

        self.browser.refresh()
        self.wait_for_no_alerts()
        dashboard_page.get_dashboard_map()

        self.logout()

        self.browser.refresh()
        self.wait_for_no_alerts()
        assert LoginPage(self).is_on_page()
Exemplo n.º 18
0
    def test_organization_view(self):
        """A registered user can view an organization's dashboard.
           Org description and users are displayed."""

        LoginPage(self).login('admin_user', 'password')
        page = OrganizationPage(self)
        page.go_to()
        page.go_to_organization_page()

        info = page.get_org_description_and_members()
        assert "This is a test." in info
        assert "Test User" in info
        assert "Username: testuser" in info
        self.logout()

        LoginPage(self).login('testuser', 'password')
        page = OrganizationPage(self)
        page.go_to()
        page.go_to_organization_page()

        info = page.get_org_description_and_members()
        assert "This is a test." in info
        assert "Test User" in info
        assert "Username: testuser" in info
    def test_adding_an_organization(self):
        """A registered user can add an organization
        and this organization if visible to other users."""

        LoginPage(self).login('testuser', 'password')
        page = OrganizationListPage(self)
        page.go_to()

        page.click_add_button()
        page.try_cancel_and_close()

        fields = page.get_fields()
        page.try_submit(err=['name'], ok=['description', 'urls'])

        fields = page.get_fields()
        fields['name'].send_keys('Organization #2')
        fields['description'].send_keys('This is a test organization')
        fields['urls'].send_keys('invalid url')
        page.try_submit(err=['urls'],
                        ok=['name', 'description'],
                        message='This value should be a valid url.')

        fields = page.get_fields()
        fields['urls'].clear()

        page.click_submit_button()
        organization_name = self.page_title().text
        assert organization_name == 'Organization #2'.upper()
        self.logout()

        LoginPage(self).login('wyldstyle', 'password')
        page = OrganizationListPage(self)
        page.go_to()

        organization_table = page.get_new_organization_title_in_table()
        assert "Organization #2" in organization_table
Exemplo n.º 20
0
    def test_new_organization_view(self):
        """An organization without projects has a different view for its
        creator.

        """

        LoginPage(self).login('testuser', 'password')
        page = OrganizationPage(self)
        page.go_to()
        page.go_to_organization_page(new=True)

        welcome = page.get_welcome_message()
        assert "You're ready to go" in welcome

        title = page.click_add_new_project_button()
        assert title == "ADD NEW PROJECT"
    def test_adding_members(self):
        """A registered admin user can add members to an organization."""

        LoginPage(self).login('admin_user', 'password')
        page = OrganizationMemberListPage(self)
        page.go_to()
        OrganizationPage(self).go_to_organization_page()
        page.go_to_member_list_page()

        page.click_on_add_button()
        page.try_cancel_and_close()

        fields = page.get_fields()
        page.try_submit(err=['member'])

        fields = page.get_fields()
        fields['member'].send_keys("darthvader")
        page.try_submit(
            err=['member'],
            message='User with username or email darthvader does not exist')

        fields = page.get_fields()
        fields['member'].clear()
        fields['member'].send_keys("admin_user")
        page.try_submit(
            err=['member'],
            message='User is already a member of the organization.')

        fields = page.get_fields()
        fields['member'].clear()
        fields['member'].send_keys("hansolo")
        page.try_submit()

        member = page.get_member_name()
        assert member == "MEMBER: Han Solo"

        OrganizationMemberPage(self).click_remove_member_and_confirm_buttons()

        page.click_on_add_button()

        fields = page.get_fields()
        fields['member'].clear()
        fields['member'].send_keys("*****@*****.**")
        page.try_submit()

        member = page.get_member_name()
        assert member == "MEMBER: Han Solo"
Exemplo n.º 22
0
    def test_removing_a_member_from_an_organization(self):
        """An admin member can remove a member from an organization."""

        LoginPage(self).login('admin_user', 'password')
        page = OrganizationMemberPage(self)
        page.go_to()
        OrganizationPage(self).go_to_organization_page()
        OrganizationMemberListPage(self).go_to_member_list_page()
        page.go_to_testuser_member_page()

        page.try_cancel_and_close()
        assert page.get_member_title() == "MEMBER: Test User"

        page.click_remove_member_and_confirm_buttons()

        members = page.get_table_row().text
        assert "Test User" not in members
Exemplo n.º 23
0
    def test_admin_creation_when_adding_organization(self):
        """A user that can create a new organization and
        is automatically made an admin."""

        LoginPage(self).login('testuser', 'password')
        page = OrganizationMemberPage(self)
        page.go_to()

        OrganizationListPage(self).click_add_button()
        fields = OrganizationListPage(self).get_fields()
        fields['name'].send_keys('Organization #2')
        fields['description'].send_keys('This is a test organization')
        OrganizationListPage(self).click_submit_button()

        OrganizationMemberListPage(self).go_to_member_list_page()
        page.go_to_testuser_member_page()

        roles = page.get_role_options()
        assert roles['selected'].text == "Administrator"
Exemplo n.º 24
0
    def test_that_an_individual_members_information_displays(self):
        """The organization's individual member page
        displays with the correct user information."""

        LoginPage(self).login('admin_user', 'password')
        page = OrganizationMemberPage(self)
        page.go_to()
        OrganizationPage(self).go_to_organization_page()
        OrganizationMemberListPage(self).go_to_member_list_page()

        testuser_title = page.go_to_testuser_member_page()
        assert "MEMBER: Test User" == testuser_title

        member_form = page.get_displayed_member_info()

        assert "Test User" in member_form.text
        assert "testuser" in member_form.text
        assert "*****@*****.**" in member_form.text
        assert "Last login:" in member_form.text
    def test_sorting_organization_view(self):
        """A registered user user can sort the organization list
        by id, name, and number of projects."""

        LoginPage(self).login('testuser', 'password')
        page = OrganizationListPage(self)
        page.go_to()

        first_org = page.sort_table_by("descending", col="organization")
        assert first_org == 'Organization #1'

        first_org = page.sort_table_by("ascending", col="organization")
        assert first_org == 'Organization #0'

        first_org = page.sort_table_by("ascending", col="project")
        assert first_org == 'Organization #1'

        first_org = page.sort_table_by("descending", col="project")
        assert first_org == 'Organization #0'
Exemplo n.º 26
0
    def test_changing_a_members_organizational_role(self):
        """An admin member can change a member's role in the organization."""

        LoginPage(self).login('admin_user', 'password')
        page = OrganizationMemberPage(self)
        page.go_to()
        OrganizationPage(self).go_to_organization_page()
        OrganizationMemberListPage(self).go_to_member_list_page()
        page.go_to_testuser_member_page()

        roles = page.get_role_options()
        assert roles["member"].text == roles["selected"].text

        roles["admin"].click()
        page.click_submit_button()
        page.go_to_testuser_member_page()

        roles = page.get_role_options()
        assert roles["admin"].text == roles["selected"].text
Exemplo n.º 27
0
    def test_adding_members(self):
        """A registered admin user can add members to an organization."""

        LoginPage(self).login('admin_user', 'password')
        page = OrganizationMemberListPage(self)
        page.go_to()
        OrganizationPage(self).go_to_organization_page()
        page.go_to_member_list_page()

        page.click_on_add_button()
        page.try_cancel_and_close()

        input_box = page.click_on_input()
        error_list = page.click_submit_button(success=False)
        assert error_list == 'This field is required.'

        input_box = page.click_on_input()
        input_box.send_keys("darthvader")
        error_list = page.click_submit_button(success=False)
        error_message = 'User with username or email darthvader does not exist'
        assert error_list == error_message

        input_box = page.click_on_input()
        input_box.clear()
        input_box.send_keys("admin_user")
        error_list = page.click_submit_button(success=False)
        error_message = 'User is already a member of the organization.'
        assert error_list == error_message

        input_box = page.click_on_input()
        input_box.clear()
        input_box.send_keys("hansolo")
        member = page.click_submit_button()
        assert member == "MEMBER: Han Solo"

        OrganizationMemberPage(self).click_remove_member_and_confirm_buttons()

        page.click_on_add_button()
        input_box = page.click_on_input()
        input_box.send_keys("*****@*****.**")
        member = page.click_submit_button()
        assert member == "MEMBER: Han Solo"
    def generic_test_for_user(self, user_type):
        """Generic test method to verify that a user can see the
        visible projects and that project details are correct."""

        users = self.test_data['users']
        orgs = self.test_data['orgs']

        # Test each user
        for uidx in range(len(users)):

            user = users[uidx]
            parent_org_idxs = []

            # Skip if a user is not the target type
            is_superuser = '******' in user and user['_is_superuser']
            if ((user_type == 'superuser' and not is_superuser)
                    or (user_type != 'superuser' and is_superuser)):
                continue
            if user_type == 'affiliated':
                parent_org_idxs = []
                for org_idx in range(len(orgs)):
                    if uidx in orgs[org_idx]['_members']:
                        parent_org_idxs.append(org_idx)
                        break
                if not len(parent_org_idxs):
                    continue
            elif user_type == 'unaffiliated':
                is_ok = True
                for org in orgs:
                    if uidx in org['_members']:
                        is_ok = False
                        break
                if not is_ok:
                    continue

            # Log in as the selected user, check the list, log out
            LoginPage(self).login(user['username'], user['password'])
            # u = User.objects.get(username=user['username'])
            # print(user['username'], '=>', u.assigned_policies())
            self.check_project_list(user_type, parent_org_idxs)
            self.logout()
Exemplo n.º 29
0
    def test_changing_member_project_permissions(self):
        """An admin user can change a member's permissions
        on individual projects."""

        LoginPage(self).login('admin_user', 'password')
        page = OrganizationMemberPage(self)
        page.go_to()
        OrganizationPage(self).go_to_organization_page()
        OrganizationMemberListPage(self).go_to_member_list_page()
        page.go_to_testuser_member_page()

        first_project = page.get_project_title_in_table()
        assert first_project == 'Test Project'
        options = page.get_permission_options()
        assert options['selected'].text == options['pb'].text
        options['pm'].click()

        page.click_submit_button()
        page.go_to_testuser_member_page()

        options = page.get_permission_options()
        assert options['selected'].text == options['pm'].text
    def test_archived_projects_appear_in_long_lists(self):
        """If the project list spans two pages, and an archived
        project appears on the second page, the archive filter option
        should still appear"""

        ProjectFactory.create_batch(10)

        LoginPage(self).login('default5', 'password1')
        page = ProjectListPage(self)
        page.go_to_and_check_on_page()

        project_title = page.get_project_title_in_table()
        assert project_title == 'Linux Kernel'

        project_title = page.sort_table_by("descending")
        assert project_title == 'Project Gutenberg'

        page.sort_table_by("ascending")
        page.click_archive_filter("Archived")
        project_title = page.get_project_title_in_table()
        assert project_title == 'Zealous Archived Project Archived'

        project_title = page.sort_table_by("descending")
        assert project_title == 'Zealous Archived Project Archived'

        page.sort_table_by("ascending")
        page.click_archive_filter("All")
        project_title = page.get_project_title_in_table()
        assert project_title == 'Linux Kernel'

        project_title = page.sort_table_by("descending")
        assert project_title == 'Zealous Archived Project Archived'

        page.sort_table_by("ascending")
        page.click_archive_filter("Archived")
        page.click_archive_filter("Active")
        project_title = page.get_project_title_in_table()
        assert project_title == 'Linux Kernel'
Exemplo n.º 31
0
    def generic_test_orgadmin(self, access):

        assert access in ('public', 'private')

        # Log in as org admin
        LoginPage(self).login(self.orgadmin['username'],
                              self.orgadmin['password'])

        # Declare working project data for verification
        project = {}

        proj_add_page = ProjectAddPage(self)
        proj_add_page.go_to()
        assert proj_add_page.is_on_page()
        assert proj_add_page.is_on_subpage('geometry')

        # Select country and submit geometry
        project['country'] = 'AU' if access == 'public' else 'BR'
        proj_add_page.set_geometry(project['country'])
        proj_add_page.submit_geometry()

        # Check that details are all blank/default
        project['org'] = ''
        project['name'] = ""
        project['access'] = 'public'
        project['description'] = ""
        project['url'] = ''
        proj_add_page.check_details(project)

        # TODO: Check that only valid orgs are provided
        # TODO: Vary org selection

        # Check that errors occurs when no org was selected
        # and no project name was set
        # Also toggle access and set description
        project['access'] = 'private'
        project['description'] = self.test_data['project_description']
        proj_add_page.set_access(project['access'])
        proj_add_page.set_description(project['description'])
        proj_add_page.try_submit_details()
        proj_add_page.check_missing_org_error()
        proj_add_page.check_missing_name_error()
        proj_add_page.check_no_duplicate_name_error()
        proj_add_page.check_no_invalid_url_error()
        proj_add_page.check_details(project)

        # Select the first valid org
        # Check that an error occurs when the project name is only whitespace
        # Also toggle access and set URL
        project['org'] = 'unesco'
        project['name'] = "     "
        project['access'] = 'public'
        project['url'] = self.test_data['project_url']
        proj_add_page.set_org(project['org'])
        proj_add_page.set_name(project['name'])
        proj_add_page.set_access(project['access'])
        proj_add_page.set_proj_url(project['url'])
        proj_add_page.try_submit_details()
        proj_add_page.check_no_missing_org_error()
        proj_add_page.check_missing_name_error()
        proj_add_page.check_no_duplicate_name_error()
        proj_add_page.check_no_invalid_url_error()
        proj_add_page.check_details(project)

        # Unset the org, and set a valid project name
        # Check that an error occurs for the missing org
        project['org'] = ''
        project['name'] = self.test_data['project_name']
        proj_add_page.set_org(project['org'])
        proj_add_page.set_name(project['name'])
        proj_add_page.try_submit_details()
        proj_add_page.check_missing_org_error()
        proj_add_page.check_no_missing_name_error()
        proj_add_page.check_no_duplicate_name_error()
        proj_add_page.check_no_invalid_url_error()
        proj_add_page.check_details(project)

        # Set final org, final access, and invalid URL
        # Check that the page is not submitted due to the invalid URL
        project['org'] = 'unesco'
        project['access'] = access
        project['url'] = "DEADBEEF"
        proj_add_page.set_org(project['org'])
        proj_add_page.set_name(project['name'])
        proj_add_page.set_access(project['access'])
        proj_add_page.set_proj_url(project['url'])
        proj_add_page.try_submit_details()
        proj_add_page.check_no_missing_org_error()
        proj_add_page.check_no_missing_name_error()
        proj_add_page.check_no_duplicate_name_error()
        proj_add_page.check_invalid_url_error()
        proj_add_page.check_details(project)

        # Correct the URL, press "Previous" then "Next" and ensure
        # that details settings are preserved.
        project['url'] = self.test_data['project_url']
        proj_add_page.set_proj_url(project['url'])
        proj_add_page.click_previous_details()
        proj_add_page.submit_geometry()
        proj_add_page.check_details(project)

        # Finally submit details
        proj_add_page.submit_details()

        # Set permissions
        # TODO: Vary permissions and check permissions after
        proj_add_page.submit_permissions()

        # Set project slug and org details
        project['slug'] = self.test_data['project_slug']
        orgs = self.test_data['orgs']
        project['_org_slug'] = orgs[0]['slug']
        project['_org_name'] = orgs[0]['name']
        project['_org_logo'] = (orgs[0]['logo'] if 'logo' in orgs[0] else '')

        # Check that we are now in the project page
        # and that displayed project details are correct
        proj_page = ProjectPage(self, project['_org_slug'], project['slug'])
        assert proj_page.is_on_page()
        proj_page.check_page_contents(project)

        # Go to project list and check that details are correct
        proj_list_page = ProjectListPage(self)
        proj_list_page.go_to_and_check_on_page()
        proj_list_page.check_project_list([project])

        self.logout()

        # Check new project as an org member
        LoginPage(self).login(self.orgmember['username'],
                              self.orgmember['password'])
        proj_page.go_to()
        assert proj_page.is_on_page()
        proj_page.check_page_contents(project)
        proj_list_page = ProjectListPage(self)
        proj_list_page.go_to_and_check_on_page()
        proj_list_page.check_project_list([project])
        self.logout()

        # Check new project as an unaffiliated user
        LoginPage(self).login(self.unaffuser['username'],
                              self.unaffuser['password'])
        proj_page.go_to()
        if access == 'public':
            assert proj_page.is_on_page()
            proj_page.check_page_contents(project)
        else:
            assert DashboardPage(self).is_on_page()
            self.assert_has_message('alert', "have permission")
        proj_list_page = ProjectListPage(self)
        proj_list_page.go_to_and_check_on_page()
        if access == 'public':
            proj_list_page.check_project_list([project])
        else:
            assert proj_list_page.is_list_empty()
        self.logout()
    def test_superuser(self):
        """Verify that a superuser can access the project list page."""

        LoginPage(self).login(self.superuser['username'],
                              self.superuser['password'])
        ProjectListPage(self).go_to_and_check_on_page()