Python initial_password.initial_password函数代码示例

    def test_change_password_ldap_backend(self) -> None:
        ldap_user_attr_map = {'full_name': 'fn', 'short_name': 'sn'}
        ldap_patcher = patch('django_auth_ldap.config.ldap.initialize')
        mock_initialize = ldap_patcher.start()
        mock_ldap = MockLDAP()
        mock_initialize.return_value = mock_ldap

        mock_ldap.directory = {
            'uid=hamlet,ou=users,dc=zulip,dc=com': {
                'userPassword': ['ldappassword', ],
                'fn': ['New LDAP fullname']
            }
        }

        self.login(self.example_email("hamlet"))
        with self.settings(LDAP_APPEND_DOMAIN="zulip.com",
                           AUTH_LDAP_USER_ATTR_MAP=ldap_user_attr_map):
            result = self.client_patch(
                "/json/settings",
                dict(
                    old_password=initial_password(self.example_email("hamlet")),
                    new_password="ignored",
                ))
            self.assert_json_error(result, "Your Zulip password is managed in LDAP")

            result = self.client_patch(
                "/json/settings",
                dict(
                    old_password='ldappassword',
                    new_password="ignored",
                ))
            self.assert_json_error(result, "Your Zulip password is managed in LDAP")

        with self.settings(LDAP_APPEND_DOMAIN="example.com",
                           AUTH_LDAP_USER_ATTR_MAP=ldap_user_attr_map):
            result = self.client_patch(
                "/json/settings",
                dict(
                    old_password=initial_password(self.example_email("hamlet")),
                    new_password="ignored",
                ))
            self.assert_json_success(result)

        with self.settings(LDAP_APPEND_DOMAIN=None,
                           AUTH_LDAP_USER_ATTR_MAP=ldap_user_attr_map):
            result = self.client_patch(
                "/json/settings",
                dict(
                    old_password=initial_password(self.example_email("hamlet")),
                    new_password="ignored",
                ))
            self.assert_json_error(result, "Your Zulip password is managed in LDAP")

 def test_deactivated_realm(self):
     # type: () -> None
     do_deactivate_realm(self.user_profile.realm)
     result = self.client_post("/api/v1/fetch_api_key",
                               dict(username=self.email,
                                    password=initial_password(self.email)))
     self.assert_json_error_contains(result, "Your realm has been deactivated", 403)

 def test_inactive_user(self):
     # type: () -> None
     do_deactivate_user(self.user_profile)
     result = self.client_post("/api/v1/fetch_api_key",
                               dict(username=self.email,
                                    password=initial_password(self.email)))
     self.assert_json_error_contains(result, "Your account has been disabled", 403)

 def test_password_auth_disabled(self):
     # type: () -> None
     with mock.patch('zproject.backends.password_auth_enabled', return_value=False):
         result = self.client_post("/api/v1/fetch_api_key",
                                   dict(username=self.email,
                                        password=initial_password(self.email)))
         self.assert_json_error_contains(result, "Password auth is disabled", 403)

 def login(self, email, password=None, fails=False):
     if password is None:
         password = initial_password(email)
     if not fails:
         self.assertTrue(self.client.login(username=email, password=password))
     else:
         self.assertFalse(self.client.login(username=email, password=password))

 def login_with_return(self, email: Text, password: Optional[Text]=None,
                       **kwargs: Any) -> HttpResponse:
     if password is None:
         password = initial_password(email)
     return self.client_post('/accounts/login/',
                             {'username': email, 'password': password},
                             **kwargs)

    def test_fetch_api_key_success(self):
        # type: () -> None
        email = self.example_email("cordelia")

        self.login(email)
        result = self.client_post("/json/fetch_api_key", {"password": initial_password(email)})
        self.assert_json_success(result)

 def handle(self, *args: Any, **options: str) -> None:
     realm = self.get_realm(options)
     print(self.fmt % ('email', 'password', 'API key'))
     for email in options['emails']:
         if '@' not in email:
             print('ERROR: %s does not look like an email address' % (email,))
             continue
         print(self.fmt % (email, initial_password(email), self.get_user(email, realm).api_key))

 def handle(self, *args, **options):
     # type: (*Any, **str) -> None
     print(self.fmt % ('email', 'password', 'API key'))
     for email in options['emails']:
         if '@' not in email:
             print('ERROR: %s does not look like an email address' % (email,))
             continue
         print(self.fmt % (email, initial_password(email), get_user_profile_by_email(email).api_key))

 def login_with_return(self, email: str, password: Optional[str]=None,
                       **kwargs: Any) -> HttpResponse:
     if password is None:
         password = initial_password(email)
     result = self.client_post('/accounts/login/',
                               {'username': email, 'password': password},
                               **kwargs)
     self.assertNotEqual(result.status_code, 500)
     return result

def bulk_create_users(realm: Realm,
                      users_raw: Set[Tuple[str, str, str, bool]],
                      bot_type: Optional[int]=None,
                      bot_owner: Optional[UserProfile]=None,
                      tos_version: Optional[str]=None,
                      timezone: str="") -> None:
    """
    Creates and saves a UserProfile with the given email.
    Has some code based off of UserManage.create_user, but doesn't .save()
    """
    existing_users = frozenset(UserProfile.objects.filter(
        realm=realm).values_list('email', flat=True))
    users = sorted([user_raw for user_raw in users_raw if user_raw[0] not in existing_users])

    # If we have a different email_address_visibility mode, the code
    # below doesn't have the logic to set user_profile.email properly.
    assert realm.email_address_visibility == Realm.EMAIL_ADDRESS_VISIBILITY_EVERYONE

    # Now create user_profiles
    profiles_to_create = []  # type: List[UserProfile]
    for (email, full_name, short_name, active) in users:
        profile = create_user_profile(realm, email,
                                      initial_password(email), active, bot_type,
                                      full_name, short_name, bot_owner, False, tos_version,
                                      timezone, tutorial_status=UserProfile.TUTORIAL_FINISHED,
                                      enter_sends=True)
        profiles_to_create.append(profile)
    UserProfile.objects.bulk_create(profiles_to_create)

    RealmAuditLog.objects.bulk_create(
        [RealmAuditLog(realm=realm, modified_user=profile_,
                       event_type=RealmAuditLog.USER_CREATED, event_time=profile_.date_joined)
         for profile_ in profiles_to_create])

    profiles_by_email = {}  # type: Dict[str, UserProfile]
    profiles_by_id = {}  # type: Dict[int, UserProfile]
    for profile in UserProfile.objects.select_related().filter(realm=realm):
        profiles_by_email[profile.email] = profile
        profiles_by_id[profile.id] = profile

    recipients_to_create = []  # type: List[Recipient]
    for (email, full_name, short_name, active) in users:
        recipients_to_create.append(Recipient(type_id=profiles_by_email[email].id,
                                              type=Recipient.PERSONAL))
    Recipient.objects.bulk_create(recipients_to_create)

    recipients_by_email = {}  # type: Dict[str, Recipient]
    for recipient in recipients_to_create:
        recipients_by_email[profiles_by_id[recipient.type_id].email] = recipient

    subscriptions_to_create = []  # type: List[Subscription]
    for (email, full_name, short_name, active) in users:
        subscriptions_to_create.append(
            Subscription(user_profile_id=profiles_by_email[email].id,
                         recipient=recipients_by_email[email]))
    Subscription.objects.bulk_create(subscriptions_to_create)

 def login(self, email: str, password: Optional[str]=None, fails: bool=False,
           realm: Optional[Realm]=None) -> HttpResponse:
     if realm is None:
         realm = get_realm("zulip")
     if password is None:
         password = initial_password(email)
     if not fails:
         self.assertTrue(self.client.login(username=email, password=password,
                                           realm=realm))
     else:
         self.assertFalse(self.client.login(username=email, password=password,
                                            realm=realm))

    def test_send_login_emails_if_send_login_email_setting_is_true(self) -> None:
        with self.settings(SEND_LOGIN_EMAILS=True):
            self.assertTrue(settings.SEND_LOGIN_EMAILS)
            # we don't use the self.login method since we spoof the user-agent
            email = self.example_email('hamlet')
            password = initial_password(email)
            firefox_windows = "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:47.0) Gecko/20100101 Firefox/47.0"
            self.client_post("/accounts/login/", info={"username": email, "password": password},
                             HTTP_USER_AGENT=firefox_windows)

            # email is sent and correct subject
            self.assertEqual(len(mail.outbox), 1)
            subject = 'New login from Firefox on Windows'
            self.assertEqual(mail.outbox[0].subject, subject)

    def test_password_reset(self):
        # type: () -> None
        email = '[email protected]'
        old_password = initial_password(email)

        self.login(email)

        # start the password reset process by supplying an email address
        result = self.client_post('/accounts/password/reset/', {'email': email})

        # check the redirect link telling you to check mail for password reset link
        self.assertEquals(result.status_code, 302)
        self.assertTrue(result["Location"].endswith(
                "/accounts/password/reset/done/"))
        result = self.client_get(result["Location"])

        self.assert_in_response("Check your email to finish the process.", result)

        # visit password reset link
        from django.core.mail import outbox
        for message in reversed(outbox):
            if email in message.to:
                password_reset_pattern = re.compile(settings.EXTERNAL_HOST + "(\S+)")
                password_reset_url = password_reset_pattern.search(
                    message.body).groups()[0]
                break
        else:
            raise ValueError("Couldn't find a password reset email.")

        result = self.client_get(password_reset_url)
        self.assertEquals(result.status_code, 200)

        # Reset your password
        result = self.client_post(password_reset_url,
                                  {'new_password1': 'new_password',
                                   'new_password2': 'new_password'})

        # password reset succeeded
        self.assertEquals(result.status_code, 302)
        self.assertTrue(result["Location"].endswith("/password/done/"))

        # log back in with new password
        self.login(email, password='new_password')
        user_profile = get_user_profile_by_email('[email protected]')
        self.assertEqual(get_session_dict_user(self.client.session), user_profile.id)

        # make sure old password no longer works
        self.login(email, password=old_password, fails=True)

def bulk_create_users(realms, users_raw, bot_type=None):
    # type: (Mapping[text_type, Realm], Set[Tuple[text_type, text_type, text_type, bool]], Optional[int]) -> None
    """
    Creates and saves a UserProfile with the given email.
    Has some code based off of UserManage.create_user, but doesn't .save()
    """
    users = [] # type: List[Tuple[text_type, text_type, text_type, bool]]
    existing_users = set(u.email for u in UserProfile.objects.all()) # type: Set[text_type]
    for (email, full_name, short_name, active) in users_raw:
        if email in existing_users:
            continue
        users.append((email, full_name, short_name, active))
        existing_users.add(email)
    users = sorted(users)

    # Now create user_profiles
    profiles_to_create = [] # type: List[UserProfile]
    for (email, full_name, short_name, active) in users:
        domain = resolve_email_to_domain(email)
        profile = create_user_profile(realms[domain], email,
                                      initial_password(email), active, bot_type,
                                      full_name, short_name, None, False)
        profiles_to_create.append(profile)
    UserProfile.objects.bulk_create(profiles_to_create)

    profiles_by_email = {} # type: Dict[text_type, UserProfile]
    profiles_by_id = {} # type: Dict[int, UserProfile]
    for profile in UserProfile.objects.select_related().all():
        profiles_by_email[profile.email] = profile
        profiles_by_id[profile.id] = profile

    recipients_to_create = [] # type: List[Recipient]
    for (email, full_name, short_name, active) in users:
        recipients_to_create.append(Recipient(type_id=profiles_by_email[email].id,
                                              type=Recipient.PERSONAL))
    Recipient.objects.bulk_create(recipients_to_create)

    recipients_by_email = {} # type: Dict[text_type, Recipient]
    for recipient in Recipient.objects.filter(type=Recipient.PERSONAL):
        recipients_by_email[profiles_by_id[recipient.type_id].email] = recipient

    subscriptions_to_create = [] # type: List[Subscription]
    for (email, full_name, short_name, active) in users:
        subscriptions_to_create.append(
            Subscription(user_profile_id=profiles_by_email[email].id,
                         recipient=recipients_by_email[email]))
    Subscription.objects.bulk_create(subscriptions_to_create)