python类Select()的实例源码

def set_select_by_text(self, select, text):
        '''
        Set the selected value of a select element by the visible text.

        Parameters
        ----------
        select: str or selenium.webdriver.remote.webelement.WebElement
            Any valid CSS selector or a selenium element
        text: str
            The visible text in the select element option. (Not the value)

        '''
        if isinstance(select, str):
            elem = self.get_element(select)
        else:
            elem = select

        sel = Select(elem)
        sel.select_by_visible_text(text)

def set_select_by_value(self, select, value):
        '''
        Set the selected value of a select element by the value.

        Parameters
        ----------
        select: str or selenium.webdriver.remote.webelement.WebElement
            Any valid CSS selector or a selenium element
        value: str
            The value on the select element option. (Not the visible text)

        '''
        if isinstance(select, str):
            elem = self.get_element(select)
        else:
            elem = select

        sel = Select(elem)
        sel.select_by_value(value)

def test_extra_dropdown_persists(self):
        self.element.extra_dropdown.click()
        self.element.wait_for_display()

        self.assertEqual(
            self.element.dropdown_select.get_attribute('value'),
            '1',
        )

        select = Select(self.element.dropdown_select)
        select.select_by_value('2')

        self.element.next.click()
        self.element.back.click()

        self.assertEqual(
            self.element.dropdown_select.get_attribute('value'),
            '2',
        )

def test_create_new_project(self):
        """ Test creating a project """

        project_name = "masterproject"

        url = reverse('newproject')
        self.get(url)

        self.enter_text('#new-project-name', project_name)

        select = Select(self.find('#projectversion'))
        select.select_by_value(str(self.release.pk))

        self.click("#create-project-button")

        # We should get redirected to the new project's page with the
        # notification at the top
        element = self.wait_until_visible('#project-created-notification')

        self.assertTrue(project_name in element.text,
                        "New project name not in new project notification")

        self.assertTrue(Project.objects.filter(name=project_name).count(),
                        "New project not found in database")

def select_option(select_el, by, val):
  """Select an option from a select dropdown

  Arguments:
  select_el -- the Selenium WebDriver Element select dropdown
  by -- the type of the value used (index | text | value)
  val -- the value of the option to select
  """
  select = Select(select_el)

  if by == 'index':
    return select.select_by_index(val)
  elif by == 'text':
    select.select_by_visible_text(val)
  elif by == 'value':
    select.select_by_value(val)
  else:
    raise Exception('Invalid SELECT BY type')

  return True

def fill_form(self, fields=(), submit=True):
        """
        Fill in a form and press enter on last
        :param fields: list of tupules:
            (input_id, value),
            (input_id, value)
        :return:
        """
        elem = None
        for input_id, value in fields:
            if '//' in input_id:
                find = input_id
            else:
                find = "//input[@id='{id}']".format(id=input_id)

            elem = self.find_element(find)
            if elem.tag_name == 'select':
                select = Select(elem)
                select.select_by_visible_text(value)
            else:
                elem.send_keys(value)

        if elem and submit:
            elem.send_keys(Keys.ENTER)

def test_1_modal_from_url(self, base_url, selenium):
        self.baseurl = base_url
        self.get(selenium, base_url + '/scheduled/2')
        modal, title, body = self.get_modal_parts(selenium)
        self.assert_modal_displayed(modal, title, body)
        assert title.text == 'Edit Scheduled Transaction 2'
        assert body.find_element_by_id(
            'sched_frm_id').get_attribute('value') == '2'
        assert body.find_element_by_id(
            'sched_frm_description').get_attribute('value') == 'ST2'
        assert body.find_element_by_id(
            'sched_frm_type_monthly').is_selected()
        assert body.find_element_by_id(
            'sched_frm_type_date').is_selected() is False
        assert body.find_element_by_id(
            'sched_frm_type_per_period').is_selected() is False
        assert body.find_element_by_id(
            'sched_frm_day_of_month').get_attribute('value') == '4'
        assert body.find_element_by_id(
            'sched_frm_amount').get_attribute('value') == '222.22'
        acct_sel = Select(body.find_element_by_id('sched_frm_account'))
        assert acct_sel.first_selected_option.get_attribute('value') == '1'
        budget_sel = Select(body.find_element_by_id('sched_frm_budget'))
        assert budget_sel.first_selected_option.get_attribute('value') == '2'
        assert selenium.find_element_by_id('sched_frm_active').is_selected()

def test_acct_filter_opts(self, selenium):
        self.get(selenium, self.baseurl + '/transactions')
        acct_filter = Select(selenium.find_element_by_id('account_filter'))
        # find the options
        opts = []
        for o in acct_filter.options:
            opts.append([o.get_attribute('value'), o.text])
        assert opts == [
            ['None', ''],
            ['1', 'BankOne'],
            ['2', 'BankTwoStale'],
            ['3', 'CreditOne'],
            ['4', 'CreditTwo'],
            ['6', 'DisabledBank'],
            ['5', 'InvestmentOne']
        ]

def test_budg_filter_opts(self, selenium):
        self.get(selenium, self.baseurl + '/transactions')
        budg_filter = Select(selenium.find_element_by_id('budget_filter'))
        # find the options
        opts = []
        for o in budg_filter.options:
            opts.append([o.get_attribute('value'), o.text])
        assert opts == [
            ['None', ''],
            ['7', 'Income (income)'],
            ['1', 'Periodic1'],
            ['2', 'Periodic2'],
            ['3', 'Periodic3 Inactive'],
            ['4', 'Standing1'],
            ['5', 'Standing2'],
            ['6', 'Standing3 Inactive']
        ]

def test_filter_opts(self, selenium):
        self.get(selenium, self.baseurl + '/ofx')
        acct_filter = Select(selenium.find_element_by_id('account_filter'))
        # find the options
        opts = []
        for o in acct_filter.options:
            opts.append([o.get_attribute('value'), o.text])
        assert opts == [
            ['None', ''],
            ['1', 'BankOne'],
            ['2', 'BankTwoStale'],
            ['3', 'CreditOne'],
            ['4', 'CreditTwo'],
            ['6', 'DisabledBank'],
            ['5', 'InvestmentOne']
        ]

def __init__(self):
        'stst\resources\linux\chromedriver'
        # cur_dir = os.path.dirname(__file__) # 'stst/features'
        # path = os.path.join(cur_dir, 'resources')
        # print(cur_dir)
        driver = webdriver.Chrome()
        driver.get("http://asiya.cs.upc.edu/demo/asiya_online.php#")
        time.sleep(3)
        driver._switch_to.frame(driver.find_element_by_id("demo-content"))
        elem = Select(driver.find_element_by_id("input"))
        elem.select_by_value("raw")
        elem = driver.find_element_by_id("no_tok")
        elem.click()
        elem = Select(driver.find_element_by_id("srclang"))
        elem.select_by_value("en")
        elem = Select(driver.find_element_by_id("trglang"))
        elem.select_by_value("en")
        elem = Select(driver.find_element_by_id("srccase"))
        elem.select_by_value("ci")
        elem = Select(driver.find_element_by_id("trgcase"))
        elem.select_by_value("ci")

        self.driver = driver

def reload(self):
        driver = self.driver
        driver.get("http://asiya.cs.upc.edu/demo/asiya_online.php#")
        time.sleep(3)
        driver._switch_to.frame(driver.find_element_by_id("demo-content"))
        elem = Select(driver.find_element_by_id("input"))
        elem.select_by_value("raw")
        elem = driver.find_element_by_id("no_tok")
        elem.click()
        elem = Select(driver.find_element_by_id("srclang"))
        elem.select_by_value("en")
        elem = Select(driver.find_element_by_id("trglang"))
        elem.select_by_value("en")
        elem = Select(driver.find_element_by_id("srccase"))
        elem.select_by_value("ci")
        elem = Select(driver.find_element_by_id("trgcase"))
        elem.select_by_value("ci")
        self.driver = driver

def unselect_from_list_by_index(self, locator, *indexes):
        """Unselects `*indexes` from list identified by `locator`

        Select list keywords work on both lists and combo boxes. Key attributes for
        select lists are `id` and `name`. See `introduction` for details about
        locating elements.
        """
        if not indexes:
            raise ValueError("No index given.")

        items_str = "index(es) '%s'" % ", ".join(indexes)
        self._info("Unselecting %s from list '%s'." % (items_str, locator))

        select = self._get_select_list(locator)
        if not select.is_multiple:
            raise RuntimeError("Keyword 'Unselect from list' works only for multiselect lists.")

        for index in indexes:
            select.deselect_by_index(int(index))

def unselect_from_list_by_value(self, locator, *values):
        """Unselects `*values` from list identified by `locator`

        Select list keywords work on both lists and combo boxes. Key attributes for
        select lists are `id` and `name`. See `introduction` for details about
        locating elements.
        """
        if not values:
            raise ValueError("No value given.")
        items_str = "value(s) '%s'" % ", ".join(values)
        self._info("Unselecting %s from list '%s'." % (items_str, locator))

        select = self._get_select_list(locator)
        if not select.is_multiple:
            raise RuntimeError("Keyword 'Unselect from list' works only for multiselect lists.")

        for value in values:
            select.deselect_by_value(value)

def unselect_from_list_by_label(self, locator, *labels):
        """Unselects `*labels` from list identified by `locator`

        Select list keywords work on both lists and combo boxes. Key attributes for
        select lists are `id` and `name`. See `introduction` for details about
        locating elements.
        """
        if not labels:
            raise ValueError("No value given.")
        items_str = "label(s) '%s'" % ", ".join(labels)
        self._info("Unselecting %s from list '%s'." % (items_str, locator))

        select = self._get_select_list(locator)
        if not select.is_multiple:
            raise RuntimeError("Keyword 'Unselect from list' works only for multiselect lists.")

        for label in labels:
            select.deselect_by_visible_text(label)

    # Private

def test_add_new_dataset(driver, project):
    driver.get("/")

    driver.refresh()
    proj_select = Select(driver.find_element_by_css_selector('[name=project]'))
    proj_select.select_by_value(str(project.id))
    driver.find_element_by_id('react-tabs-2').click()
    driver.find_element_by_partial_link_text('Upload new dataset').click()

    dataset_name = driver.find_element_by_css_selector('[name=datasetName]')
    dataset_name.send_keys(test_dataset_name)

    header_file = driver.find_element_by_css_selector('[name=headerFile]')
    header_file.send_keys(pjoin(os.path.dirname(os.path.dirname(__file__)), 'data',
                                'asas_training_subset_classes.dat'))

    tar_file = driver.find_element_by_css_selector('[name=tarFile]')
    tar_file.send_keys(pjoin(os.path.dirname(os.path.dirname(__file__)), 'data',
                             'asas_training_subset.tar.gz'))

    driver.find_element_by_class_name('btn-primary').click()

    status_td = driver.wait_for_xpath(
        "//div[contains(text(),'Successfully uploaded new dataset')]")

def test_edit_project(driver, project):
    driver.refresh()
    proj_select = Select(driver.find_element_by_css_selector('[name=project]'))
    proj_select.select_by_value(str(project.id))
    project_name = driver.find_element_by_css_selector('[name=projectName]')
    project_name.clear()
    test_proj_name = str(uuid.uuid4())
    project_name.send_keys(test_proj_name)
    project_desc = driver.find_element_by_css_selector('[name=projectDescription]')
    project_desc.clear()
    project_desc.send_keys("New Test Description")
    driver.find_element_by_class_name('btn-primary').click()

    status_td = driver.wait_for_xpath(
        "//div[contains(text(),'Successfully updated project')]")
    assert driver.find_element_by_css_selector('[name=projectName]').\
        get_attribute("value") == test_proj_name
    assert driver.find_element_by_css_selector('[name=projectDescription]').\
        get_attribute("value") == "New Test Description"

def test_add_new_featureset(driver, project, dataset):
    driver.get('/')
    driver.refresh()
    proj_select = Select(driver.find_element_by_css_selector('[name=project]'))
    proj_select.select_by_value(str(project.id))

    driver.find_element_by_id('react-tabs-4').click()
    driver.find_element_by_partial_link_text('Compute New Features').click()

    featureset_name = driver.find_element_by_css_selector('[name=featuresetName]')
    featureset_name.send_keys(test_featureset_name)

    driver.find_element_by_class_name('btn-primary').click()

    driver.wait_for_xpath("//div[contains(text(),'Feature computation begun')]")
    driver.wait_for_xpath("//td[contains(text(),'Completed')]", 30)

def test_check_uncheck_tags(driver, project, dataset):
    driver.get('/')
    driver.refresh()
    proj_select = Select(driver.find_element_by_css_selector('[name=project]'))
    proj_select.select_by_value(str(project.id))

    driver.find_element_by_id('react-tabs-4').click()
    driver.find_element_by_partial_link_text('Compute New Features').click()
    driver.find_element_by_partial_link_text('Filter By Tag').click()
    driver.find_element_by_xpath("//li[contains(text(),'General')]").click()

    driver.find_element_by_css_selector('[name=amplitude]')
    driver.find_element_by_css_selector('[label=Astronomy]').click()
    time.sleep(0.1)
    driver.find_element_by_css_selector('[label=General]').click()
    time.sleep(0.1)
    with pytest.raises(NoSuchElementException):
        driver.find_element_by_css_selector('[name=amplitude]').click()

    driver.find_element_by_css_selector('[label=General]').click()
    driver.wait_for_xpath('//*[@name="amplitude"]')

def _add_prediction(proj_id, driver):
    driver.refresh()
    proj_select = Select(driver.wait_for_xpath('//select[@name="project"]'))
    proj_select.select_by_value(str(proj_id))

    driver.find_element_by_id('react-tabs-8').click()
    driver.find_element_by_partial_link_text('Predict Targets').click()

    driver.find_element_by_class_name('btn-primary').click()

    driver.wait_for_xpath("//div[contains(text(),'Model predictions begun')]")

    try:
        driver.wait_for_xpath("//td[contains(text(),'Completed')]", 30)
    except:
        driver.save_screenshot("/tmp/pred_fail.png")
        raise

def _build_model(proj_id, model_type, driver):
    driver.refresh()
    proj_select = Select(driver.find_element_by_css_selector('[name=project]'))
    proj_select.select_by_value(str(proj_id))

    driver.find_element_by_id('react-tabs-6').click()
    driver.find_element_by_partial_link_text('Create New Model').click()

    model_select = Select(driver.find_element_by_css_selector('[name=modelType]'))
    model_select.select_by_visible_text(model_type)

    model_name = driver.find_element_by_css_selector('[name=modelName]')
    test_model_name = str(uuid.uuid4())
    model_name.send_keys(test_model_name)

    driver.find_element_by_class_name('btn-primary').click()

    try:
        driver.wait_for_xpath("//div[contains(text(), 'Model training begun')]")
        driver.wait_for_xpath("//td[contains(text(), 'Completed')]", 10)
    except:
        driver.save_screenshot("/tmp/models_fail.png")
        raise

def test_hyper_param_populate(driver, project, featureset, model):
    driver.get('/')
    driver.refresh()
    proj_select = Select(driver.find_element_by_css_selector('[name=project]'))
    proj_select.select_by_value(str(project.id))

    driver.find_element_by_id('react-tabs-6').click()

    driver.find_element_by_partial_link_text('Create New Model').click()
    driver.find_element_by_partial_link_text('Choose Model Parameters').click()
    model_select = Select(driver.find_element_by_css_selector('[name=modelType]'))
    model_select.select_by_visible_text("RandomForestClassifier (fast)")
    driver.wait_for_xpath("//label[contains(text(),'n_estimators')]")
    driver.wait_for_xpath("//label[contains(text(),'max_features')]")

    model_select.select_by_visible_text("RidgeClassifierCV")
    driver.wait_for_xpath("//label[contains(text(),'alphas')]")
    driver.wait_for_xpath("//label[contains(text(),'scoring')]")

    model_select.select_by_visible_text("BayesianRidgeRegressor")
    driver.wait_for_xpath("//label[contains(text(),'n_iter')]")
    driver.wait_for_xpath("//label[contains(text(),'alpha_1')]")

def test_cannot_build_model_unlabeled_data(driver, project, featureset):
    driver.get('/')
    driver.refresh()
    proj_select = Select(driver.find_element_by_css_selector('[name=project]'))
    proj_select.select_by_value(str(project.id))

    driver.find_element_by_id('react-tabs-6').click()
    driver.find_element_by_partial_link_text('Create New Model').click()

    model_name = driver.find_element_by_css_selector('[name=modelName]')
    model_name.send_keys(str(uuid.uuid4()))

    driver.find_element_by_class_name('btn-primary').click()

    driver.wait_for_xpath(
        "//div[contains(.,'Cannot build model for unlabeled feature set.')]")

def test_extra_dropdown_persists(self):
        self.element.extra_dropdown.click()
        self.element.wait_for_display()

        self.assertEqual(
            self.element.dropdown_select.get_attribute('value'),
            '1',
        )

        select = Select(self.element.dropdown_select)
        select.select_by_value('2')

        self.element.next.click()
        self.element.back.click()

        self.assertEqual(
            self.element.dropdown_select.get_attribute('value'),
            '2',
        )

def select_state_option(self, value, dowait=True):
        '''
        Select state value from dropdown. Wait until district dropdown
        has loaded before returning.
        '''
        #path = '//select[@id="variation-tablepress-32"]'
        path = '//select[@id="variation-tablepress-31"]'
        district_select_elem = self.driver.find_element_by_xpath(path)

        def district_select_updated(driver):
            try:
                district_select_elem.text
            except StaleElementReferenceException:
                return True
            except:
                pass

            return False

        state_select = self.get_state_select()
        state_select.select_by_value(value)

        return self.get_state_select()

def select_by_visible_text(self, locator, option_text, replacement=None, retry_by_browser_refresh=False):
        """Select an option by visible option text
        :param locator: locator of select element
        :param replacement: if locator contains dynamic part, i.e. '$value',
        it will be replaced by replacement variable
        :param option_text: option text by which to select the option
        :param retry_by_browser_refresh: if set to True, when webdriver is not able to find any element,
        it will refresh the browser and try to find the element again
        :return: None
        """
        if replacement:
            locator = locator.replace('$value', replacement)

        try:
            select = Select(self.fetch_element(locator))
            select.select_by_visible_text(option_text)

            self.context.logger.info("Selected element '" + locator + "' by visible text '" + option_text + "'")
        except Exception as e:
            self.context.logger.error("Unable to select option '" + option_text + "'. Error: %s" % e,
                                      exc_info=True)
            Assert.assert_fail("Unable to select option '" + option_text + "'")

def test_number_kanbancolumns_for_case_not_default(self):
        driver = self.selenium
        issue = Issue(title="title", kanbancol=KanbanColumn.objects.get(project=self.project, name="Todo"),
                      due_date=str(datetime.date.today()), priority=3, storypoints=2, description="blubber",
                      project=self.project
                      )
        issue.save()
        issue.assignee.add(self.user)

        driver.get("{}{}".format(self.live_server_url, reverse('issue:create',
                                                               kwargs={'project': self.project2.name_short})))
        driver.find_element_by_id("id_title").send_keys("title")
        # assert that 2nd project has one kanban col more
        self.assertEqual(len(Select(driver.find_element_by_id("id_kanbancol")).options), 5)

        # assert that dependsOn now has one entry
        driver.get('{}{}'.format(self.live_server_url, reverse('issue:backlog',
                                                               kwargs={'project': self.project.name_short}
                                                               )))
        driver.find_element_by_link_text("New issue").click()
        driver.find_element_by_xpath("(//input[@type='search'])[2]").send_keys('\n')
        time.sleep(1)
        self.assertEqual(len(driver.find_elements_by_css_selector('#select2-id_dependsOn-results li')), 1)
        for i in driver.find_elements_by_css_selector('#select2-id_dependsOn-results li'):
            self.assertIn("title", i.text)

def test_edit_same_settings_as_set(self):
        driver = self.selenium
        issue = Issue(title="title", kanbancol=KanbanColumn.objects.get(project=self.project, name="Todo"),
                      due_date=str(datetime.date.today()), priority=3, storypoints=2, description="blubber",
                      project=self.project
                      )
        issue.save()
        issue.assignee.add(self.user)
        driver.get("{}{}".format(self.live_server_url, reverse('issue:edit',
                                 kwargs={'project': self.project.name_short, 'sqn_i': issue.number})))
        self.assertEqual(len(Select(driver.find_element_by_id("id_kanbancol")).options), 4)

        # issue must not depend on itself
        driver.find_element_by_xpath("(//input[@type='search'])[2]").send_keys('\n')
        time.sleep(1)
        self.assertEqual(len(driver.find_elements_by_css_selector('#select2-id_dependsOn-results li')), 1)
        for i in driver.find_elements_by_css_selector('#select2-id_dependsOn-results li'):
            self.assertEqual(i.text, "No results found")

def wait_for_dip_in_transfer_backlog(self, dip_uuid):
        """Wait for the DIP with UUID ``dip_uuid`` to appear in the Backlog tab.
        """
        max_seconds = 120
        seconds = 0
        while True:
            self.navigate(self.get_transfer_backlog_url(), reload=True)
            self.driver.find_element_by_css_selector(
                'input[title="search query"]').send_keys(dip_uuid)
            Select(self.driver.find_element_by_css_selector(
                'select[title="field name"]')).select_by_visible_text(
                    'SIP UUID')
            Select(self.driver.find_element_by_css_selector(
                'select[title="query type"]')).select_by_visible_text(
                    'Phrase')
            self.driver.find_element_by_id('search_submit').click()
            summary_el = self.driver.find_element_by_id('backlog-entries_info')
            if 'Showing 0 to 0 of 0 entries' == summary_el.text.strip():
                seconds += 1
                if seconds > max_seconds:
                    break
                time.sleep(1)
            else:
                time.sleep(1)  # Sleep a little longer, for good measure
                break

def change_encrypted_space_key(self, space_uuid, new_key_repr=None):
        """Edit the existing space with UUID ``space_uuid`` and set its GPG key
        to the existing one matching ``new_key_repr``, if provided, or else to
        any other key.
        """
        self.navigate(self.get_space_edit_url(space_uuid))
        select = Select(self.driver.find_element_by_id('id_protocol-key'))
        if new_key_repr:
            select.select_by_visible_text(new_key_repr)
        else:
            currently_selected = select.first_selected_option.text
            for option in select.options:
                if option.text != currently_selected:
                    select.select_by_visible_text(option.text)
                    break
        self.driver.find_element_by_css_selector('input[type=submit]').click()
        self.wait_for_presence('div.alert-success')