こんにちは。スタディサプリのQAチームです。

今回のBlogではスタディサプリで実施している自動化テストの一部の取り組みについて紹介させていただきます。
なお、スタディサプリQAチームの特性を活かし、本記事については日英中３言語で記載します。より多くのオーディエンスに読んで頂ければ嬉しいです。

自動化する動機

まず、なぜ自動化テストを導入するのでしょうか。
1. 新規機能が追加される度に、既存機能への影響を確認するための回帰テストをしなければなりません。
2. 繰り返し同じテストを手動実行することにより、テストコストが増加します。
3. 人間が実施すると、人為的ミスによる不具合の検出漏れが発生してしまう可能性が否定できません。
そのため、品質を担保した上でより早くリリースすることを目的とし自動化を導入しました。

現在の開発およびテストフロー

QAが回帰テストの自動化テストスクリプトをGitHubにアップロードする。
開発側で新しい機能を開発し、PRを作成する。
コードに変更があることを検知し、テストが自動的に実行され、既存機能が問題ないことを確認する。
全てのテストが成功した後に、コードがマージされ、リリースする。

CI/CDの手法

このようなフローは、CI/CD（継続的インテグレーションおよび継続的デリバリー）として知られています。継続的インテグレーション（Continuous Integration）と継続的デリバリー/デプロイメント（Continuous Delivery/Deployment）を指すソフトウェア開発手法です。コード変更を頻繁にマージし、テストおよびリリースのプロセスを自動化し、開発の迅速化、エラーの早期発見、そして製品の品質向上させるためです。

全体のアーキテクチャ

これらのツールを利用し、CI/CDの一環としてテスト自動化を実現しています。
1. Python
2. Selenium
3. Behave
4. GitHub Actions

実例と説明

では、実際の例を使ってより具体的に説明していきます。
Login機能のテストの例です。
このようなLogin画面に、UsernameとPasswordの入力欄、Loginボタンがあります。

引用元: スタディサプリ公式ウェブサイト (https://learn.studysapuri.jp/ja/login)

Pythonでスクリプト作成

まず、Pythonを使用しスクリプトを記載します。
Pythonを選んだ理由は：
1. 初心者でも比較的容易に始められる。
2. ライブラリが豊富に存在します。
3. ドキュメントも豊富です。
以下がスクリプトの実例です。

ファイル名：login_steps.py

from selenium import webdriver
from selenium.webdriver.common.by import By

# WebDriverの設定
options = webdriver.ChromeOptions()
driver = webdriver.Chrome(options=options)

# ログインページのURLを指定します
login_page_url = 'https://example.com/login'

# ログインページにアクセス
driver.get(login_page_url)

# Usernameフィールドの要素を取得し、値を入力
username_field = driver.find_element(By.NAME, 'username')  # 'username'は実際のフィールド名に置き換えてください
username_field.send_keys('your_username')

# Passwordフィールドの要素を取得し、値を入力
password_field = driver.find_element(By.NAME, 'password')  # 'password'は実際のフィールド名に置き換えてください
password_field.send_keys('your_password')

# Loginボタンの要素を取得し、クリック
login_button = driver.find_element(By.NAME, 'login')  # 'login'のボタンを特定
login_button.click()

# ログイン後の処理を実行（例：ページタイトルを確認）
assert "Dashboard" in driver.title  # ログイン後のページタイトルを確認

# ブラウザを閉じる
driver.quit()

Selenium

＞from selenium import webdriver　
にあるように、Seleniumが登場します。Seleniumは幅広く使用されているブラウザを使用した自動テストツールです。
上記スクリプトは、Pythonコードの中でSeleniumを使用しブラウザを起動してオブジェクトのクリックやテキストエリアへの文字の入力などを行います。
このスクリプトで、”.get”、".find_element"、".send_keys"と".click"などのMethodがSeleniumから提供している機能で、ブラウザで操作できます。

Behave導入、featureファイル作成

スクリプトがより人間にとって可読性が上がるようにするためのBehaveというツールを導入しました。Behaveは人間にとって読みやすい自然言語で記述されたBDD(Behavior Driven Development)フォーマットのテストシナリオ(Featureファイル)と、テストコードの実体(Stepファイル)を紐づけるためのツールです。これによりどのような目的で何をテストしているかが、Featureファイルを見るだけでコードを得意としない人でも理解できるようになります。
詳細はこちら：https://behave.readthedocs.io/en/latest/　
featureファイルは、英語または日本語で記載しています。下記は例です。

ファイル名：login.feature

Feature: Login functionality

  Scenario: Successful login with valid credentials
    Given the user is on the login page
    When the user enters valid username and password
    And the user clicks the login button
    Then the user should be redirected to the dashboard

Behave導入により、スクリプトを改造する

先ほどlogin_steps.pyで書いたスクリプトを利用するために、login_steps.pyファイルを下記のように改造しstepsとfeatureを連携させます。
大事なポイントが、featureファイルで書いている
Given the user is on the login page
をStepsファイルに、下記のように追記し
@given('the user is on the login page')
（stepファイル内で正規表現を使用し部分一致させる記述にしない限り）'the user is on the login page'の部分が完全一致しないと、エラーとなります。
改造したlogin_steps.pyは下記の通りです。

from behave import given, when, then
from selenium import webdriver
from selenium.webdriver.common.by import By

@given('the user is on the login page')
def step_user_on_login_page(context):
    chrome_driver_path = 'drivers/chromedriver'
    options = webdriver.ChromeOptions()
    context.driver = webdriver.Chrome(options=options)
    context.driver.get('https://example.com/login')

@when('the user enters valid username and password')
def step_user_enters_credentials(context):
    username_field = context.driver.find_element(By.NAME, 'username')
    username_field.send_keys('your_username')
    password_field = context.driver.find_element(By.NAME, 'password')
    password_field.send_keys('your_password')

@when('the user clicks the login button')
def step_user_clicks_login(context):
    login_button = context.driver.find_element(By.NAME, 'login')
    login_button.click()

@then('the user should be redirected to the dashboard')
def step_user_redirected_to_dashboard(context):
    assert "Dashboard" in context.driver.title
    context.driver.quit()

ローカルでテストを実行するには、コマンドラインで”behave ./{path}/login.feature”を実行すれば、 ”login.feature”に書いているテストシナリオが実行されます。

補足：Page Object Model

実運用するにはより複雑な構造になりますが、POM（page object model）デザインパターンの例としてディレクトリ構造を紹介しておきます。POMデザインパターンとは、UI開発でありがちな度重なる仕様変更にテストが追従しやすくなるよう、あらかじめ操作対象となるUI部品を特定するロケーター(CSSやXPathと言います)をテストコードの本体から切り離しておき、UIの仕様変更が発生した際もテストコードを修正しなくても対象となるロケーターを修正するだけで同じテストシナリオが動作するように考案されたデザインパターンです。
本編では省略させていただきます。構造の例だけ貼っております。

project/　# プロジェクトのRootフォルダ
│
├── features/　　# features folder
│   ├── login.feature　# 実際のテストシナリオを日本語/英語で記述する。
├── steps/
│   └── login_steps.py　# クリック、入力などのスクリプトはここ
├── pages/
│   └── login_page.py　# 各ページのElementsと具体的なMethodなど
├── environment.py　# ブラウザ、環境変数など
└── requirements.txt　# インストールしないといけないツールなど、Selenium、Behaveなどですね

GitHub Actions連携

最後に、せっかく作った自動スクリプトが自分のためだけに実行されるのは勿体無いです。他の利害関係者も使いたい場面が訪れると思います。誰でも、いつでも、自動的に、或いはクリックするだけで、実行できるようにしたいですね。
スタディサプリでは標準的にGitHub＋GitHub Actionsを利用していますので、 QAも同じ物を利用します。
GitHub ActionsはGitHubが提供するCI/CDツールです。
これを使うことにより、テストの実施、管理ができます。
実際の画面は以下の通りです。

workflows

このようなジョブは、一般的にワークフロー（workflow）と呼ばれます。これを作成するには、「任意名.yaml」というファイルを作成する必要があります。
ワークフローは、特定のイベントに基づいて自動的に実行される一連のタスクを定義するファイルです。YAML形式で記述され、ソフトウェア開発プロセスの自動化を支援します。
一つのworkflowに、どんな環境で、どんなテストを実行するかなどを定義しています。
例：

name: Login機能のテスト　　#ワークフローの名前を指定します。

on:                      #トリガーするイベントをこれから指定します。
  push:
    branches:
      - develop             #ここではmainブランチへのプッシュでトリガーされます。
  pull_request:
    branches:
      - develop             #ここではmainブランチへのプルリクエストでトリガーされます。

jobs:
  test:
    runs-on: ubuntu-latest     #ジョブをどこ(Runner)で実行するかを指定します。

    steps:　　　　#ジョブ内で実行される各ステップを定義します。
    - name: Check out the repository   #スクリプトをチェックアウトします。
      uses: actions/checkout@v3

    - name: Set up Python    #指定されたバージョン('3.9')のPythonをセットアップします。
      uses: actions/setup-python@v4
      with:
        python-version: '3.9'

    - name: Install dependencies   #SeleniumとBehaveなど必要な依存関係をインストールします。
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt  #seleniumとBehaveなどは、バージョンを含め、このファイルで管理しています。

    - name: Run Behave tests    #login.featureに書いているテストを実行します。
      run: |
        behave ./{path}/login.feature

これで、workflowが表示され、設定した”トリガーするイベント”により、自動的に実行されます。もちろん、手動で実行することも可能です。表示されている緑のチェックマークや赤のバツマークから、結果を確認することができます。

後書き

QAは自身のみで何かを達成することは困難です。今回紹介したこのテストの自動化の実現にも、SREチームとDevelopmentチームの皆さんには多大な協力を頂きました。心から感謝しています。どのようなコンテキストの組織であっても、テストの自動化を実現するにはチーム間の協力はなくてはならないものだと思っています！

Here is the English version

Hi there. We're Study Sapuri QA team.

In this blog, we would like to introduce some of the automated testing being implemented at Study Sapuri.
In addition, this article will be written in 3 different languages utilizing traits of our team. We hope this article will be read by many audiences.

Motivation for Automation

First, why do we implement the automated testing?
1. Each time new features are added, we must do regression testing to verify the impact on existing functionalities.
2. Manually executing the same tests repeatedly increases testing costs.
3. When humans perform the tests, there is always the possibility of missing defects due to human error which can potentially cause defects..
We then decided to introduce Automated Testing to ensure quality, at the same time, achieve a faster release.

Current Development and Testing Workflow

The QA team uploads automated regression test scripts to GitHub.
The development team adds some new commits and creates a Pull Request.
When changes in the code are detected, tests are automatically executed to verify that existing functionalities are not affected.
Once all tests have passed, the code can be merged and released.

CI/CD

This workflow is known as CI/CD (Continuous Integration and Continuous Delivery/Deployment). It refers to a software development methodology where code changes are frequently merged, and the processes of testing and releasing are automated. This approach aims to accelerate development, detect errors early, and improve product quality.

Architecture

We achieve test automation as part of our CI/CD process by utilizing the following tools:
1. Python
2. Selenium
3. Behave
4. GitHub Actions

Example and Explanation

Now, let’s explain more concretely using an actual example: testing the login functionality.
On the login page, there are input fields for Username and Password, and a Login button.

Source: Study Sapuri Official Website (https://learn.studysapuri.jp/ja/login)

Writing the Script

First, we write the script using Python.
The reasons for choosing Python are:
1. It is relatively easy for beginners to start with.
2. It has a rich set of libraries.
3. There is abundant documentation available.
Below is an example of the script:

file name：login_steps.py

from selenium import webdriver
from selenium.webdriver.common.by import By

# WebDriver settings
options = webdriver.ChromeOptions()
driver = webdriver.Chrome(options=options)

# Specify the login page URL
login_page_url = 'https://example.com/login'

# Access the login page
driver.get(login_page_url)

# Get the username field element and enter the value
username_field = driver.find_element(By.NAME, 'username')  # Replace 'username' with the actual field name
username_field.send_keys('your_username')

# Get the password field element and enter the value
password_field = driver.find_element(By.NAME, 'password')  # Replace 'password' with the actual field name
password_field.send_keys('your_password')

# Get the login button element and click it
login_button = driver.find_element(By.NAME, 'login')  # Identify the 'login' button
login_button.click()

# Perform post-login actions (e.g., verify the page title)
assert "Dashboard" in driver.title  # Verify the post-login page title

# Close the browser
driver.quit()

Selenium

＞from selenium import webdriver　
Selenium is introduced. Selenium is a widely used tool for automated browser testing.
The script above performs several actions using Selenium within the Python code: it launches the browser, clicks objects, and inputs text into text areas.
In this script, methods such as ".get", ".find_element", ".send_keys", and ".click" are functionalities provided by Selenium, allowing for interaction with the browser.

Introducing Behave and Creating Feature Files

To make the script more readable for humans, we introduced a tool called Behave. Behave is a tool for linking test scenarios written in a human-readable natural language BDD (Behavior Driven Development) format (feature files) with the actual test code (step files). This allows anyone, even those not proficient in coding, to understand what is being tested and for what purpose by simply looking at the feature files.
For more details, please visit:：https://behave.readthedocs.io/en/latest/　
Feature files can be written in English or Japanese. Below is an example:

feature file example：login.feature

Feature: Login functionality

  Scenario: Successful login with valid credentials
    Given the user is on the login page
    When the user enters valid username and password
    And the user clicks the login button
    Then the user should be redirected to the dashboard

Modifying the Script with Behave

To utilize the script written in login_steps.py and link it with the steps and features, we modify login_steps.py as follows. An important point is that the step definitions in the feature file, such as
Given the user is on the login page
must match exactly with the corresponding step definitions in the steps file, such as
@given('the user is on the login page')
Otherwise, it will result in an error (unless regular expressions are used for partial matches).

from behave import given, when, then
from selenium import webdriver
from selenium.webdriver.common.by import By

@given('the user is on the login page')
def step_user_on_login_page(context):
    chrome_driver_path = 'drivers/chromedriver'
    options = webdriver.ChromeOptions()
    context.driver = webdriver.Chrome(options=options)
    context.driver.get('https://example.com/login')

@when('the user enters valid username and password')
def step_user_enters_credentials(context):
    username_field = context.driver.find_element(By.NAME, 'username')
    username_field.send_keys('your_username')
    password_field = context.driver.find_element(By.NAME, 'password')
    password_field.send_keys('your_password')

@when('the user clicks the login button')
def step_user_clicks_login(context):
    login_button = context.driver.find_element(By.NAME, 'login')
    login_button.click()

@then('the user should be redirected to the dashboard')
def step_user_redirected_to_dashboard(context):
    assert "Dashboard" in context.driver.title
    context.driver.quit()

To run the tests locally, execute the command behave ./{path}/login.feature in the command line. This command will trigger the execution of the test scenarios written in the login.feature file.

Supplement: Page Object Model

In actual usage, the structure becomes more complex. However, as an example of the Page Object Model (POM) design pattern, let me introduce the directory structure.
The POM design pattern is designed to make tests more adaptable to frequent UI changes by separating the locators (CSS or XPath) that identify UI components from the main test code. This way, when UI changes occur, you only need to update the locators, not the test code itself, allowing the same test scenarios to run smoothly.
In this blog, we will omit the detailed explanation, but here is an example of the structure:

project/　# Project root folder
│
├── features/　　# features folder
│   ├── login.feature　# Actual test scenarios written in Japanese/English。
├── steps/
│   └── login_steps.py　# Scripts for actions like click, input, etc
├── pages/
│   └── login_page.py　# Elements and specific methods for each page
├── environment.py　# Browser, environment variables, etc.
└── requirements.txt　# Tools to be installed, such as Selenium, Behave, etc.

Integration with GitHub Actions

Finally, it would be a waste if the automated scripts we created were only executed for personal use. There will be times when other stakeholders also want to use them. We want anyone to be able to run these scripts anytime, automatically, or with just a click.
At Study Sapuri, we typically use GitHub and GitHub Actions, and the QA team utilizes the same tools. GitHub Actions is a CI/CD tool provided by GitHub. By using it, we can execute and manage tests efficiently.
Here is an example of how it looks:

workflows

To create this kind of job(workflow), we need to create a file "any_name.yaml" in the .github/workflows directory.
Workflow defines a series of tasks to be executed automatically based on specific events. It is written in YAML format and helps automate the software development process.
Each workflow defines the environment and the tests to be executed.
Here is an example of a workflow：

name: Login機能のテスト　　# Specify the name of the workflow

on:                      # Specify the events that trigger the workflow
  push:
    branches:
      - develop             # Triggered on push to the develop branch
  pull_request:
    branches:
      - develop             # Triggered on pull request to the develop branch

jobs:
  test:
    runs-on: ubuntu-latest     # Specify the runner environment

    steps:　　　　# Define the steps to be executed in the job
    - name: Check out the repository   # Checkout the repository
      uses: actions/checkout@v3

    - name: Set up Python    # Set up Python with the specified version (3.9)
      uses: actions/setup-python@v4
      with:
        python-version: '3.9'

    - name: Install dependencies   # Install necessary dependencies like Selenium and Behave
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt  # Manage the tools to be installed and their versions in this file.

    - name: Run Behave tests    # Execute the tests written in the login.feature file
      run: |
        behave ./{path}/login.feature

With this setup, the workflow will be displayed and automatically executed based on the "trigger events" you have configured. It can also be executed manually. You can check the results by looking at the green check marks or red cross marks that are displayed.

Afterword

It is difficult for QA to achieve anything on our own. The implementation of the automated testing introduced this time was made possible with the cooperation of the SRE team and the Development team. We are sincerely grateful to them. In any organizational context, I believe that inter-team collaboration is indispensable for achieving test automation!

以下是中文版本

你好。我们是StudySapuri的QA团队。

在这篇博客中，我们将介绍StudySapuri在自动化测试方面的一些实践。
此外，利用StudySapuri QA团队的特点，本篇文章将以日语、英语和中文三种语言记录。希望能让更多的读者阅读并受益。

自动化的动机

首先，为什么要引入自动化测试呢？
1. 每次添加新功能时，都必须进行回归测试以确认对现有功能的影响。
2. 反复手动执行相同的测试会增加测试成本。
3. 由人工执行测试时，无法排除因人为失误而导致的缺陷漏检的可能性。
因此，我们引入自动化测试，旨在确保质量的同时，加快发布速度。

当前的开发及测试流程

QA团队将回归测试的自动化测试脚本上传到GitHub。
开发团队开发新功能，并创建PR（Pull Request）。
GitHub Actions检测到代码有变更后，自动执行测试，以确认是否影响到了现有功能。
所有测试成功后，代码将被合并并发布。

来源: Study Sapuri官方网站　(https://learn.studysapuri.jp/ja/login)

CI/CD流程

这种流程被称为CI/CD（持续集成和持续交付）。这是指持续集成（Continuous Integration）和持续交付/部署（Continuous Delivery/Deployment）的软件开发方法。其目的是针对频繁的代码变更，自动化测试和发布过程，以加快开发速度、及早发现错误并提高产品质量。

整体架构

通过利用这些工具，我们作为CI/CD的一部分，实现了测试自动化。
1. Python
2. Selenium
3. Behave
4. GitHub Actions

实例与说明

接下来，我们将通过实际的例子来进行更具体的说明。这是一个关于Login功能的测试例子。
在这样的Login界面中，有Username和Password的输入框，以及一个Login按钮。

使用Python编写脚本

首先，我们使用Python编写脚本。
选择Python的理由是：
1. 初学者也能相对容易地上手。
2. 拥有丰富的库。
3. 文档也非常丰富。
以下是脚本的示例。

文件名：login_steps.py

from selenium import webdriver
from selenium.webdriver.common.by import By

# WebDriver的设置
options = webdriver.ChromeOptions()
driver = webdriver.Chrome(options=options)

# 指定登录页面的URL
login_page_url = 'https://example.com/login'

# 访问登录页面
driver.get(login_page_url)

# 获取Username字段的元素并输入值
username_field = driver.find_element(By.NAME, 'username')  # 'username'请替换为实际的字段名
username_field.send_keys('your_username')

# 获取Password字段的元素并输入值
password_field = driver.find_element(By.NAME, 'password')  # 'password'请替换为实际的字段名
password_field.send_keys('your_password')

# 获取Login按钮的元素并点击
login_button = driver.find_element(By.NAME, 'login')  # 定位'login'按钮
login_button.click()

# 执行登录后的处理（例如：检查页面标题）
assert "Dashboard" in driver.title  # 检查登录后的页面标题

# 关闭浏览器
driver.quit()

Selenium

＞from selenium import webdriver　
正如上面所示，Selenium在此处登场。Selenium是一款被广泛使用于驱动浏览器实现自动化的测试工具。
上述脚本在Python代码中使用Selenium，通过启动浏览器来进行对象的点击和文本区域的输入等操作。
这个脚本中使用的“.get”，“.find_element”，“.send_keys” 和 “.click” 等方法，都是Selenium提供的功能，用于在浏览器中执行操作。

引入Behave并创建feature文件

为了提高脚本的可读性，我们引入了一种名为Behave的工具。Behave对BDD（行为驱动开发）格式的测试场景（Feature文件）和测试代码的实体（Step文件）进行关联，以人类易读的自然语言编写。这使得即使是不擅长代码的人，仅通过查看Feature文件也能理解测试的目的和内容。
详细信息请参见：https://behave.readthedocs.io/en/latest/　
Feature文件可以用英文或日文编写。以下是一个示例。

文件名：login.feature

Feature: Login functionality

  Scenario: Successful login with valid credentials
    Given the user is on the login page
    When the user enters valid username and password
    And the user clicks the login button
    Then the user should be redirected to the dashboard

为了引入Behave、改造脚本

为了使用之前在 login_steps.py 中编写的脚本，我们将它进行如下改造，以便将steps文件和feature文件关联起来。
关键点在于，Feature文件中写的
Given the user is on the login page
需要在Steps文件中添加如下对应代码
@given('the user is on the login page')
（除非在Steps文件中使用正则表达式进行部分匹配），否则，如果the user is on the login page部分不完全匹配，将会出现错误。

from behave import given, when, then
from selenium import webdriver
from selenium.webdriver.common.by import By

@given('the user is on the login page')
def step_user_on_login_page(context):
    chrome_driver_path = 'drivers/chromedriver'
    options = webdriver.ChromeOptions()
    context.driver = webdriver.Chrome(options=options)
    context.driver.get('https://example.com/login')

@when('the user enters valid username and password')
def step_user_enters_credentials(context):
    username_field = context.driver.find_element(By.NAME, 'username')
    username_field.send_keys('your_username')
    password_field = context.driver.find_element(By.NAME, 'password')
    password_field.send_keys('your_password')

@when('the user clicks the login button')
def step_user_clicks_login(context):
    login_button = context.driver.find_element(By.NAME, 'login')
    login_button.click()

@then('the user should be redirected to the dashboard')
def step_user_redirected_to_dashboard(context):
    assert "Dashboard" in context.driver.title
    context.driver.quit()

在本地运行测试时，只需在命令行中执行 behave ./{path}/login.feature，即可运行 login.feature 中编写的测试场景。

补充说明：Page Object Model

在实际运用中，结构会更为复杂，这里介绍POM（页面对象模型）设计模式的目录结构作为示例。
POM设计模式是指，通过将操作对象的定位元素（如CSS或XPath）与测试代码主体分离，实现即使UI发生了样式变更，也只需修改定位元素而无需修改测试代码主体，从而实现测试代码容易维护，可以持续运行的一种设计模式。
在本文中，我们不会深入介绍这部分，只展示一下结构示例。

project/  # 项目的根文件夹
├── features/  # features文件夹
│   ├── login.feature  # 用日语/英语编写的实际测试场景
├── steps/
│   └── login_steps.py  # 点击、输入等操作的脚本
├── pages/
│   └── login_page.py  # 各页面的元素和具体的方法
├── environment.py  # 浏览器、环境变量等
└── requirements.txt  # 需要安装的工具，如Selenium、Behave等

与GitHub Actions的集成

最后，我们做出了这些脚本，只是自己执行的话是很可惜的。其他相关人员也可能会有使用这些脚本的需求。我们希望任何人、在任何时间都能自动地或者通过简单的点击来执行这些脚本。
在StudySapuri，开发团队标准化地使用GitHub和GitHub Actions，QA团队也同样使用这些工具。GitHub Actions是由GitHub提供的CI/CD工具。通过使用它，可以实现测试的执行和管理。
以下是实际的界面。

workflows

这样类似于Job的东西，被称为workflow。要创建workflow，需要创建一个名为“任意名.yaml”的文件。
workflow是基于特定事件，自动/手动触发的一系列任务的定义文件。
它使用YAML格式编写。在一个workflow中，可以定义在哪种环境下，执行哪些测试等内容。
例：

name: Login功能的测试  # 指定Workflow的名称

on:  # 指定触发事件
  push:
    branches:
      - develop  # 在push到develop分支时触发
  pull_request:
    branches:
      - develop  # 在向develop分支创建PR时触发

jobs:
  test:
    runs-on: ubuntu-latest  # 指定在哪台服务器上执行自动化代码

    steps:  # 定义Job中执行的每个步骤
    - name: Check out the repository  # checkout代码
      uses: actions/checkout@v3

    - name: Set up Python  # 配置（3.9）的Python
      uses: actions/setup-python@v4
      with:
        python-version: '3.9'

    - name: Install dependencies  # 安装Selenium和Behave等所需依赖项
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt  # 在requirements.txt文件中管理Selenium和Behave等的版本

    - name: Run Behave tests  # 执行login.feature中的测试
      run: |
        behave ./{path}/login.feature

这样，Workflow就会显示出来，并根据设置的“触发事件”自动执行。当然，也可以手动执行。
通过显示的绿色对号或红色叉号，可以确认测试结果。

后记

QA团队很难独自完成所有工作。在实现自动化测试的过程中，我们得到了SRE和开发团队的大力支持。在此，衷心感谢他们。
大家要实现测试自动化的时候，应该也都离不开团队间的合作！