Selenium短信验证：OTP码自动获取与输入-优快云博客

Selenium短信验证：OTP码自动获取与输入

【免费下载链接】selenium SeleniumHQ/selenium: Selenium是一个开源自动化测试工具套件，支持多种浏览器和语言环境。它可以模拟真实用户的行为来驱动浏览器自动执行各种操作，广泛应用于Web应用程序的功能测试、回归测试以及端到端测试场景。项目地址: https://gitcode.com/GitHub_Trending/se/selenium

引言

在现代Web应用中，短信验证（Short Message Service，短信服务）已成为用户注册、登录和敏感操作的重要安全措施。一次性密码（One-Time Password，OTP）作为短信验证的核心，为用户账户提供了额外的安全保障。然而，在自动化测试过程中，如何高效、准确地获取并输入OTP码一直是测试工程师面临的挑战。

本文将详细介绍如何使用Selenium WebDriver结合多种技术手段，实现OTP码的自动获取与输入，从而提升自动化测试的效率和稳定性。读完本文，您将能够：

了解OTP码自动获取的常见场景和技术方案
掌握基于邮件、API和数据库三种方式的OTP码获取方法
学会使用Selenium WebDriver实现OTP码的自动输入
解决OTP码自动获取过程中的常见问题和挑战

OTP码自动获取技术方案

方案对比

方案	实现难度	适用场景	稳定性	依赖条件
邮件接收	低	开发/测试环境	高	测试邮箱账号
API调用	中	具备接口的系统	高	API接口权限
数据库查询	中高	可访问数据库的场景	高	数据库访问权限
手机短信转发	高	生产环境模拟	中	手机设备/服务

技术架构

mermaid

基于邮件的OTP码自动获取

实现原理

许多Web应用在开发和测试环境中提供了将OTP码发送到指定邮箱的功能。我们可以利用这一特性，通过监控测试邮箱，自动解析邮件内容并提取OTP码。

代码实现（Python）

import imaplib
import email
from email.header import decode_header
import time

def get_otp_from_email(username, password, sender, subject_keyword, timeout=60):
    """
    从邮件中获取OTP码
    
    :param username: 邮箱账号
    :param password: 邮箱密码
    :param sender: OTP邮件发送者
    :param subject_keyword: 邮件主题关键词
    :param timeout: 超时时间（秒）
    :return: OTP码
    """
    # 连接邮箱服务器（以Gmail为例）
    mail = imaplib.IMAP4_SSL("imap.gmail.com")
    mail.login(username, password)
    
    start_time = time.time()
    
    while time.time() - start_time < timeout:
        # 选择收件箱
        mail.select("inbox")
        
        # 搜索指定发送者和主题的未读邮件
        status, data = mail.search(None, f'(UNSEEN FROM "{sender}" SUBJECT "{subject_keyword}")')
        
        if status == "OK" and data[0]:
            # 获取最新一封邮件
            email_id = data[0].split()[-1]
            status, data = mail.fetch(email_id, "(RFC822)")
            
            # 解析邮件内容
            msg = email.message_from_bytes(data[0][1])
            subject = decode_header(msg["Subject"])[0][0]
            
            # 提取邮件正文
            body = ""
            if msg.is_multipart():
                for part in msg.walk():
                    content_type = part.get_content_type()
                    if content_type == "text/plain" or content_type == "text/html":
                        body = part.get_payload(decode=True).decode()
                        break
            else:
                body = msg.get_payload(decode=True).decode()
            
            # 从正文中提取6位数字OTP码
            import re
            otp_match = re.search(r'\b\d{6}\b', body)
            if otp_match:
                # 将邮件标记为已读
                mail.store(email_id, '+FLAGS', '\\Seen')
                mail.logout()
                return otp_match.group()
        
        # 等待2秒后重试
        time.sleep(2)
    
    mail.logout()
    raise TimeoutError("获取OTP码超时")

# 使用示例
try:
    otp = get_otp_from_email(
        username="test@example.com",
        password="your_password",
        sender="noreply@example.com",
        subject_keyword="您的验证码"
    )
    print(f"获取到OTP码: {otp}")
except Exception as e:
    print(f"获取OTP码失败: {str(e)}")

Selenium集成

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# 初始化WebDriver
driver = webdriver.Chrome()
driver.get("https://example.com/login")

# 执行触发OTP的操作（如点击发送验证码按钮）
driver.find_element(By.ID, "send_otp_btn").click()

# 获取OTP码
otp = get_otp_from_email(
    username="test@example.com",
    password="your_password",
    sender="noreply@example.com",
    subject_keyword="您的验证码"
)

# 输入OTP码
otp_input = WebDriverWait(driver, 10).until(
    EC.presence_of_element_located((By.ID, "otp_input"))
)
otp_input.send_keys(otp)

# 提交表单
driver.find_element(By.ID, "submit_btn").click()

# 验证登录成功
assert "欢迎" in driver.page_source

# 关闭浏览器
driver.quit()

基于API的OTP码自动获取

实现原理

部分应用提供了获取OTP码的API接口，我们可以直接调用这些接口来获取OTP码，这种方式通常比邮件接收更快速、更可靠。

代码实现（Java）

import org.apache.http.client.fluent.Request;
import org.apache.http.entity.ContentType;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

public class OtpApiClient {
    private String apiUrl;
    private String apiKey;
    
    public OtpApiClient(String apiUrl, String apiKey) {
        this.apiUrl = apiUrl;
        this.apiKey = apiKey;
    }
    
    /**
     * 获取OTP码
     * @param phoneNumber 手机号
     * @return OTP码
     * @throws Exception 异常
     */
    public String getOtpCode(String phoneNumber) throws Exception {
        // 构建请求JSON
        JsonObject requestBody = new JsonObject();
        requestBody.addProperty("phone", phoneNumber);
        
        // 发送POST请求
        String response = Request.Post(apiUrl)
            .addHeader("Authorization", "Bearer " + apiKey)
            .bodyString(requestBody.toString(), ContentType.APPLICATION_JSON)
            .execute()
            .returnContent()
            .asString();
        
        // 解析响应
        JsonObject jsonResponse = JsonParser.parseString(response).getAsJsonObject();
        
        if (jsonResponse.has("otp") && !jsonResponse.get("otp").isJsonNull()) {
            return jsonResponse.get("otp").getAsString();
        } else {
            throw new Exception("获取OTP失败: " + response);
        }
    }
    
    public static void main(String[] args) {
        OtpApiClient client = new OtpApiClient(
            "https://api.example.com/get-otp",
            "your_api_key"
        );
        
        try {
            String otp = client.getOtpCode("13800138000");
            System.out.println("获取到OTP码: " + otp);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Selenium集成（Java）

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.openqa.selenium.support.ui.ExpectedConditions;
import java.time.Duration;

public class OtpTest {
    public static void main(String[] args) {
        // 初始化WebDriver
        WebDriver driver = new ChromeDriver();
        WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
        
        try {
            // 打开登录页面
            driver.get("https://example.com/login");
            
            // 输入手机号并点击发送验证码
            WebElement phoneInput = wait.until(ExpectedConditions.presenceOfElementLocated(By.id("phone")));
            phoneInput.sendKeys("13800138000");
            
            WebElement sendOtpBtn = driver.findElement(By.id("send_otp_btn"));
            sendOtpBtn.click();
            
            // 获取OTP码
            OtpApiClient otpClient = new OtpApiClient(
                "https://api.example.com/get-otp",
                "your_api_key"
            );
            String otp = otpClient.getOtpCode("13800138000");
            
            // 输入OTP码
            WebElement otpInput = wait.until(ExpectedConditions.presenceOfElementLocated(By.id("otp_input")));
            otpInput.sendKeys(otp);
            
            // 提交表单
            WebElement submitBtn = driver.findElement(By.id("submit_btn"));
            submitBtn.click();
            
            // 验证登录成功
            wait.until(ExpectedConditions.titleContains("欢迎"));
            System.out.println("登录成功");
            
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 关闭浏览器
            driver.quit();
        }
    }
}

基于数据库的OTP码自动获取

实现原理

在某些测试环境中，OTP码会直接存储在数据库中。通过查询数据库，我们可以直接获取到最新生成的OTP码。

代码实现（Python）

import mysql.connector
from mysql.connector import Error

def get_otp_from_database(host, database, user, password, phone_number):
    """
    从数据库获取OTP码
    
    :param host: 数据库主机
    :param database: 数据库名称
    :param user: 用户名
    :param password: 密码
    :param phone_number: 手机号
    :return: OTP码
    """
    connection = None
    try:
        # 连接数据库
        connection = mysql.connector.connect(
            host=host,
            database=database,
            user=user,
            password=password
        )
        
        if connection.is_connected():
            # 查询最新的OTP记录
            query = """
            SELECT otp_code FROM otp_codes 
            WHERE phone_number = %s 
            ORDER BY created_at DESC 
            LIMIT 1
            """
            
            cursor = connection.cursor()
            cursor.execute(query, (phone_number,))
            record = cursor.fetchone()
            
            if record:
                return record[0]
            else:
                raise Exception("未找到OTP记录")
                
    except Error as e:
        raise Exception(f"数据库错误: {str(e)}")
    finally:
        if connection and connection.is_connected():
            cursor.close()
            connection.close()

# 使用示例
try:
    otp = get_otp_from_database(
        host="test-db.example.com",
        database="test_db",
        user="test_user",
        password="test_password",
        phone_number="13800138000"
    )
    print(f"获取到OTP码: {otp}")
except Exception as e:
    print(f"获取OTP码失败: {str(e)}")

OTP码自动输入最佳实践

1. 处理OTP输入框限制

某些网站会将OTP码分为多个输入框，每个输入框只能输入一位数字。针对这种情况，我们可以逐个定位输入框并输入对应数字。

def enter_otp_separate_fields(driver, otp):
    """
    处理分离的OTP输入框
    
    :param driver: WebDriver实例
    :param otp: OTP码
    """
    # 定位所有OTP输入框（假设ID格式为otp_input_0, otp_input_1, ...）
    otp_inputs = [driver.find_element(By.ID(f"otp_input_{i}")) for i in range(len(otp))]
    
    # 逐个输入OTP码
    for input_field, digit in zip(otp_inputs, otp):
        input_field.send_keys(digit)

2. 处理动态变化的OTP输入框

有些网站会动态生成OTP输入框的ID或class，我们可以使用更灵活的定位方式。

def enter_otp_dynamic_fields(driver, otp):
    """
    处理动态的OTP输入框
    
    :param driver: WebDriver实例
    :param otp: OTP码
    """
    # 使用XPath定位包含"otp"和"input"关键词的输入框
    otp_inputs = driver.find_elements(By.XPATH, "//input[contains(@id, 'otp') and contains(@class, 'input')]")
    
    # 确保输入框数量与OTP码长度匹配
    if len(otp_inputs) == len(otp):
        for input_field, digit in zip(otp_inputs, otp):
            input_field.send_keys(digit)
    else:
        # 如果无法定位到多个输入框，尝试使用单个输入框
        try:
            otp_input = driver.find_element(By.XPATH, "//input[contains(@placeholder, '验证码')]")
            otp_input.send_keys(otp)
        except:
            raise Exception("无法定位OTP输入框")

3. OTP码输入的通用解决方案

def enter_otp(driver, otp, strategy="auto"):
    """
    OTP码输入通用函数
    
    :param driver: WebDriver实例
    :param otp: OTP码
    :param strategy: 输入策略，可选值：auto, separate, single
    """
    if strategy == "separate":
        enter_otp_separate_fields(driver, otp)
    elif strategy == "single":
        # 单个输入框
        otp_input = WebDriverWait(driver, 10).until(
            EC.presence_of_element_located((By.ID, "otp_input"))
        )
        otp_input.send_keys(otp)
    else:  # auto
        try:
            # 先尝试分离输入框策略
            enter_otp_separate_fields(driver, otp)
        except:
            try:
                # 再尝试单个输入框策略
                enter_otp_dynamic_fields(driver, otp)
            except:
                raise Exception("无法输入OTP码")

常见问题与解决方案

1. OTP码获取延迟

问题描述：发送OTP码后，需要等待一段时间才能收到或在数据库中查询到。

解决方案：

实现轮询机制，定期检查OTP码是否可用
设置合理的超时时间，避免无限等待
添加重试逻辑，提高成功率

def get_otp_with_retry(otp_func, max_retries=3, retry_interval=5, **kwargs):
    """
    带重试机制的OTP码获取函数
    
    :param otp_func: 获取OTP的函数
    :param max_retries: 最大重试次数
    :param retry_interval: 重试间隔（秒）
    :param kwargs: 传递给otp_func的参数
    :return: OTP码
    """
    for attempt in range(max_retries):
        try:
            return otp_func(** kwargs)
        except Exception as e:
            if attempt < max_retries - 1:
                print(f"获取OTP失败，{retry_interval}秒后重试... (尝试 {attempt + 1}/{max_retries})")
                time.sleep(retry_interval)
            else:
                raise Exception(f"获取OTP失败，已达到最大重试次数: {str(e)}")

2. OTP码过期问题

问题描述：OTP码通常有有效期，获取后未及时使用导致过期。

解决方案：

优化获取和输入OTP码的流程，减少时间消耗
获取OTP码后立即输入并提交
如遇过期，自动重新触发OTP码发送并重新获取

3. 多线程/多实例冲突

问题描述：在并行测试或多实例运行时，可能会获取到其他测试实例生成的OTP码。

解决方案：

为每个测试实例使用唯一的手机号或邮箱
在查询OTP码时添加时间戳条件，只获取最近生成的OTP
使用测试隔离技术，确保每个测试环境独立

4. 验证码识别失败

问题描述：邮件或短信内容格式变化导致OTP码提取失败。

解决方案：

使用更健壮的正则表达式，适应多种格式
实现多种提取规则，提高识别成功率
定期维护和更新提取规则，适应系统变化

def extract_otp_from_text(text):
    """
    从文本中提取OTP码，支持多种格式
    
    :param text: 包含OTP码的文本
    :return: OTP码
    """
    # 定义多种OTP提取规则
    patterns = [
        r'您的验证码是:?\s*(\d{6})',  # 您的验证码是: 123456
        r'验证码为:?\s*(\d{6})',      # 验证码为 123456
        r'OTP\s*码:?\s*(\d{6})',      # OTP码:123456
        r'(\d{6})\s*是您的验证码',      # 123456是您的验证码
        r'(\d{6})\s*作为您的验证码'     # 123456作为您的验证码
    ]
    
    for pattern in patterns:
        match = re.search(pattern, text)
        if match:
            return match.group(1)
    
    # 如果无法提取，尝试查找所有6位数字组合
    all_matches = re.findall(r'\b\d{6}\b', text)
    if all_matches:
        # 返回最后一个6位数字组合（通常是最新的OTP码）
        return all_matches[-1]
    
    raise Exception("无法从文本中提取OTP码")

总结与展望

本文详细介绍了使用Selenium WebDriver实现OTP码自动获取与输入的三种主要方法：基于邮件、API和数据库。每种方法都有其适用场景和优缺点，测试工程师应根据实际情况选择合适的方案。

随着技术的发展，未来OTP码自动获取技术可能会朝着以下方向发展：

更智能的内容识别：利用AI和机器学习技术，提高从各种格式中提取OTP码的成功率
更安全的获取方式：结合生物识别、硬件加密等技术，在保证安全性的同时提高自动化效率
更广泛的应用场景：不仅限于Web应用，还可扩展到移动应用、桌面应用等多种平台

通过本文介绍的方法和技巧，相信您已经能够解决大多数OTP码自动获取与输入的问题，从而构建更稳定、更高效的自动化测试流程。

扩展学习资源

Selenium官方文档：https://www.selenium.dev/documentation/
Selenium WebDriver API参考：https://www.selenium.dev/selenium/docs/api/
自动化测试最佳实践：https://www.selenium.dev/documentation/test_practices/
测试数据管理策略：https://martinfowler.com/articles/practical-test-pyramid.html#TestDataManagement

希望本文对您的自动化测试工作有所帮助！如果您有任何问题或建议，欢迎在评论区留言讨论。

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考