edwardzhou (Edward Zhou)

说说风险与危机

edwardzhou — Tue, 08 Aug 2017 14:39:53 +0800

这么多年工作中，经历过许多经验教训，我喜欢对过去的事件进行回顾复盘，尝试从中找到问题所在，和有哪些解决之道。

一直以来都想说说关于风险，是因为风险往往在你不认为有或意向不到的时候，它偏偏出现了，而细究起来，它的出现都是有规律，有蛛丝马迹可寻的，甚至是有“信号”提醒的。当风险出现后，一不留神，很快就会成为问题暴露出来，随着引发危机，影响有大有小，通常会往没有最糟只有更糟的局面走。

我会列出我自身经历过的几种常见的风险。

1. 团队扩张蕴藏的风险

这个风险是最常见的，也是最容易忽略的。跟贴切的来说，被乐观所掩盖。

为什么需要扩张团队？公司业务发展了、想上市融资了、打算上新项目了、部门间跑马圈地了.....，总之，就是形势一片大好，必须得扩大团队。

Hold on please. 当你需要扩大团队与扩大规模时，风险就在这里。看看实际例子：

07 年我加入了 W 公司，做财富管理软件的，客户是香港的一些银行，公司有两个主要客户和主要项目是成功案例，其中一个客户项目是我负责的，由此签下了其他银行的几个单子，公司从年中的四十几个人，到年底扩充到八十几个，现有办公室的座位已经不足，需要再租用办公室，我的项目并没有增加人手，所有加的人手都投入到新项目中，BOSS 也是红光满面的押宝新项目。但是，扩大一倍的人数，开支也就增加了一倍不止。然而，并没有带来成倍的产出，反而更低。迟迟无法交付项目，应收款也就无法回收，最终导致现金流出现问题，开始拖欠工资，导致雪崩效应。公司付出惨重代价，到我离开之时，公司的最终有效客户仅剩我跟进的那个，人数也收缩为三十人不到，业务严重受创，几年都没缓过劲来，后来听说卖给另一家外资公司。

08 年加入港资 J 公司，公司业务是海外的 CP 业务，在甚至成立 R&D 中心，目的是上市时需要有一定的研发团队数量，公司开始的一年多时间，人数稳定在二十几三十不到的人数，分两个团队，我们经过一年左右的时间，令到深圳团队的工作效率、工作质量、工作方式与香港团队保持一致，甚至比他们还好，同样的工作更低的成本。之后香港团队看到成果，认为这种模式很好 copy，一时间各个业务团队都跑过来跑马圈地，人数迅速扩张到五十多个，办公空间完全不够，随即雄心勃勃的搬到竹子林租下可容纳一百多个人的一层楼，以便容下更多的团队，人数继续扩张到最多将近 100 人，简直巅峰时刻，这个规模的开销一年就得七八百万以上，三年下来共烧掉两千万左右。把团队管理想得太 easy 了，几个团队 build 不起来，挂了，最后仅保留 4 个团队五十多个人，办公室闲置一半。最后，冲击上市失败，R&D 收缩回香港。

后来的 Z 公司，具体不表了，都是同样的模式，也是从四十几号人，年中开始一直加人，到年底增加到八十几个，公司是一片繁荣景象，各个项目风声水起的，一个月的开支增至一百多两百万，而春节刚结束，大大小小规划了十来个立项；当人数在增加时，我心里已经在打鼓，仿佛看到某种历史在重演，事实如此，新业务还没搞起来，钱已烧光。反正我的职位注定是其中一个背锅侠。

历史何其相似。根究其原因，当公司的企业文化、流程、规模不够强大成熟时，对新人的消化能力是有限的。通常 10% 的比例是一个临界点。超过这个比例，就会消化不良，流程变得不顺畅，开始官僚，效率质量反而严重下降，更别说吃下同体积的新人，直接噎死。

有趣的现象，越加人，事情越干不完，所有人会表现的更加忙，因而需要更多人，循环.... ，实际上真正在产出的就只其中几个。其他人如果不表现忙，岂不意味着 Ta 是多余的？为了保住工作，没事也得整点事来忙忙。

因此，当团队需要扩张的时候，请警惕，认真思考一下必要性与自身的消化能力。是否是我们的业务铺的太开，不是是可以暂停低价值业务，集中专注最核心最有发展潜力的业务？

当公司看起来一片繁荣景象时，也请冷静下来，审视自己，这个繁荣时真实繁荣，还是假象繁荣？尤其是急加人后出现的繁荣。

2. 项目进展异常顺利的风险

当项目进展非常顺利的时候，往往里面隐藏着风险。我们在做敏捷迭代，两周 10 个工作日一个迭代，期间，有一个迭代，在第四五个工作日开始进展非常顺利，持续集成一切正常，自动测试用例全绿，而且还可以领新任务。好到让我觉得有点不真实，果然，到了第七个工作日快结束是，团队的一个成员，发现前端小伙伴为了自己开发方便，把相当一部分的测试用例全给注释掉了。第八个工作日早上，站立会议交流这个事情，回去重新打开测试用例，一片红啊。结果到迭代评审会时仍有好几个已知 BUG，真是难为 PO 收下。

以前的工作中，都会碰到类似的情况。

当项目突然很顺，进度突然很好时，请踩踩刹车，我敢肯定，很大部分是有问题在里面的。

3. 人员风险

团队成员通常会在你认为没有问题的时候出问题，突然就会告诉你 Ta 要离职，而这个人往往也是你不认为会出问题的。

这个话题比较敏感，具体案例具体原因就不多说。但是，实际上总有一些迹象在暗示这个问题，请工作中用心去感受。

4. 替代风险

请记住这个世界离了谁，地球依旧在旋转，太阳依旧从东方升起。当你觉得自己无可代替时，你已给自己埋下了风险。事实上，在一个公司里任何人都是可以替代的，不同的是替代的代价大小而已，所以不要太高估自己的价值。一个企业，只有一个人是不可替代的，那个人就是公司的老板、创始人，因为他押上了自己的身家。

风险无处不在，有问题才是正常的，太正常的才是有问题的。还有许多其他风险无法一一列举，这里只是说说我自己遭遇的坑失败的案例，来减少他人的失败成本。同时，时刻提醒自己。我的印象最深刻的就是《奋斗》里陆涛撞车时，老徐对他说的那段话：

“我要你记住一件事，那就是记住刹车……还有就是，并不是你有把握的事就是很明确的，你觉得你会开了，但有时候形势会差强人意，你懂吗？你要学会避免失控。失控我一再强调，失控那是最坏的情况，因为谁也不知道失控以后会发生什么事，这是你最需要学的，也是人生最关键的，懂吗”

告诫自己，在不确定或者太顺利时，踩刹车，让自己有一个审视的机会。

Elixir Phoenix 如何用 10 分钟 50 行代码快速撸一个 http 透传通知服务

edwardzhou — Mon, 07 Aug 2017 09:28:55 +0800

我们购买 Github 服务来托管源代码，用 Jenkins 来做持续集成，因此需要让 github 能通知 Jenkins 各种通知事件，触发持续集成构建。

公司网络环境为 Internet <------ 光猫 <------ 路由器/交换机 <------ 内网光猫是是电信提供的 100M 光纤，自动拨号上网，网段 192.168.1.x，不是路由器控制拨号上网；路由器与内网为 192.168.2.x。

Jenkins 部署在内网上的 CentOS 主机，IP 为 192.168.2.231。

由于光猫是被电信阉割了的，许多功能（如端口转发）都被屏蔽了，而路由器在上设置端口转发也起不到作用。

即在 CentOS 上使用花生壳之类的，也无法让 Github 直接连通内网的 Jenkins。

我们只能通过让 Jenkins 去定时轮询 Github 感知代码合并请求。这种方式有两个问题：

及时性不够；
代码合并事件无法感知；

为了弥补这个问题，我们的 CI 半手工触发，有些蛋疼。

最近正好在看 Elixir 和 Phoenix, 两者分别与 Ruby 和 RubyOnRails 相对应。

传送门： http://elixir-lang.org/ http://www.phoenixframework.org/

有一句话说得很好，当你手里拿着一把锤子，但看到什么都是钉子。😂

因此，打算自己快速撸一个透传通知服务给 github -> Jenkins 用。

方案比较简单，用 Elixir Phoenix 框架打一个应用 jenkins_hook_proxy，提供 web 服务与 websocket 服务，运行在公网云主机上; 内网 forwarder 用 websocket 连接 jenkins_hook_proxy, 1) Jenkins_hook_proxy 收到 GitHub 的通知时，将请求打包由 websocket 通知会内网， 2) 内网 forwarder 收到 websocket 通知后，拆解请求后转给 Jenkins 3) Jenkins 完成构建后，将构建结果通知 GitHub

GitHub ---http post--> [jenkins_hook_proxy] <---websocket---> [forwarder] ----http post----> Jenkins ----(CI 构建结构) http post----> GitHub

由于 Phoenix 的 channel 为提供了非常方便且健壮的 web 前端浏览器 js 脚本，为了能直接利用它的 js 脚本，forwarder 就用 nodejs 编写。

整个过程下来，发现 jenkins_hook_proxy 和 forwarder 我们写的代码也就 20 句左右。

环境准备

Erlang 安装

CentOS 上安装 Erlang 麻烦些，需要下载 pre-built binary package 安装进入 https://www.erlang-solutions.com/resources/download.html 下载 19.3 的 rpm 包，然后用 root 用户安装 (sudo rpm -i eslxxx.rpm), 根据提示安装所需的依赖包 (eg. wxBase, wxGTK 等)。

Elixir

下载 elixir 源码 https://github.com/elixir-lang/elixir/archive/v1.4.2.zip 解压后，make && sudo make install 安装。安装完运行 iex --version 看看是否正常。

安装 Phoenix framework

http://www.phoenixframework.org/docs/installation

$ mix local.hex 由于安装的是 1.3rc 版，包为 phx_new.ex。phoenix_new.ez 是 1.2.x 版本。 $ mix archive.install https://github.com/phoenixframework/archives/raw/master/phx_new.ez

安装 NodeJS

phoenix 要求安装的有 NodeJS 用于编译 assets。 $ sudo yum install node

创建运行在外网的项目 Jenkins_hook_proxy

$ mix phx.new jenkins_hook_proxy --database mysql

* creating jenkins_hook_proxy/config/config.exs
* creating jenkins_hook_proxy/config/dev.exs
* creating jenkins_hook_proxy/config/prod.exs
* creating jenkins_hook_proxy/config/prod.secret.exs
* creating jenkins_hook_proxy/config/test.exs
* creating jenkins_hook_proxy/lib/jenkins_hook_proxy/application.ex
* creating jenkins_hook_proxy/lib/jenkins_hook_proxy/web/channels/user_socket.ex
* creating jenkins_hook_proxy/lib/jenkins_hook_proxy/web/views/error_helpers.ex
* creating jenkins_hook_proxy/lib/jenkins_hook_proxy/web/views/error_view.ex
* creating jenkins_hook_proxy/lib/jenkins_hook_proxy/web/endpoint.ex
* creating jenkins_hook_proxy/lib/jenkins_hook_proxy/web/router.ex
* creating jenkins_hook_proxy/lib/jenkins_hook_proxy/web/web.ex
* creating jenkins_hook_proxy/mix.exs
* creating jenkins_hook_proxy/README.md
* creating jenkins_hook_proxy/test/support/channel_case.ex
* creating jenkins_hook_proxy/test/support/conn_case.ex
* creating jenkins_hook_proxy/test/test_helper.exs
* creating jenkins_hook_proxy/test/web/views/error_view_test.exs
* creating jenkins_hook_proxy/lib/jenkins_hook_proxy/web/gettext.ex
* creating jenkins_hook_proxy/priv/gettext/en/LC_MESSAGES/errors.po
* creating jenkins_hook_proxy/priv/gettext/errors.pot
* creating jenkins_hook_proxy/lib/jenkins_hook_proxy/repo.ex
* creating jenkins_hook_proxy/priv/repo/seeds.exs
* creating jenkins_hook_proxy/test/support/data_case.ex
* creating jenkins_hook_proxy/lib/jenkins_hook_proxy/web/controllers/page_controller.ex
* creating jenkins_hook_proxy/lib/jenkins_hook_proxy/web/templates/layout/app.html.eex
* creating jenkins_hook_proxy/lib/jenkins_hook_proxy/web/templates/page/index.html.eex
* creating jenkins_hook_proxy/lib/jenkins_hook_proxy/web/views/layout_view.ex
* creating jenkins_hook_proxy/lib/jenkins_hook_proxy/web/views/page_view.ex
* creating jenkins_hook_proxy/test/web/controllers/page_controller_test.exs
* creating jenkins_hook_proxy/test/web/views/layout_view_test.exs
* creating jenkins_hook_proxy/test/web/views/page_view_test.exs
* creating jenkins_hook_proxy/.gitignore
* creating jenkins_hook_proxy/assets/brunch-config.js
* creating jenkins_hook_proxy/assets/css/app.css
* creating jenkins_hook_proxy/assets/css/phoenix.css
* creating jenkins_hook_proxy/assets/js/app.js
* creating jenkins_hook_proxy/assets/js/socket.js
* creating jenkins_hook_proxy/assets/package.json
* creating jenkins_hook_proxy/assets/static/robots.txt
* creating jenkins_hook_proxy/assets/static/images/phoenix.png
* creating jenkins_hook_proxy/assets/static/favicon.ico

Fetch and install dependencies? [Yn]

敲回车安装依赖包。

* running mix deps.get
* running mix deps.compile
* running cd assets && npm install && node node_modules/brunch/bin/brunch build

We are all set! Run your Phoenix application:

    $ cd jenkins_hook_proxy
    $ mix phx.server

You can also run your app inside IEx (Interactive Elixir) as:

    $ iex -S mix phx.server

Before moving on, configure your database in config/dev.exs and run:

    $ mix ecto.create

创建 Channel (websocket 服务) JenkinsChannel. JenkinsChannel 仅作为 websocket 通道用于回传信息给内网，使用默认生成的代码就足够了。不是我们自己动手写的，不纳入行数计算 😜


$ cd Jenkins_hook_proxy
$ mix phx.gen.channel Jenkins
* creating lib/jenkins_hook_proxy/web/channels/jenkins_channel.ex
* creating test/web/channels/jenkins_channel_test.exs

Add the channel to your `lib/jenkins_hook_proxy/web/channels/user_socket.ex` handler, for example:

    channel "jenkins:lobby", JenkinsHookProxy.Web.JenkinsChannel

编辑 user_socket.ex , 把上面那句话加进去。这算一行代码吧 😄

$ vi lib/jenkins_hook_proxy/web/channels/user_socket.ex

defmodule JenkinsHookProxy.Web.UserSocket do
  use Phoenix.Socket

  ## Channels
  channel "jenkins:lobby", JenkinsHookProxy.Web.JenkinsChannel

  ## Transports
  transport :websocket, Phoenix.Transports.WebSocket
  # transport :longpoll, Phoenix.Transports.LongPoll

  # Socket params are passed from the client and can
  # be used to verify and authenticate a user. After
  # verification, you can put default assigns into
  # the socket that will be set for all channels, ie
  #
  #     {:ok, assign(socket, :user_id, verified_user_id)}
  #
  # To deny connection, return `:error`.
  #
  # See `Phoenix.Token` documentation for examples in
  # performing token verification on connect.
  def connect(_params, socket) do
    {:ok, socket}
  end

  # Socket id's are topics that allow you to identify all sockets for a given user:
  #
  #     def id(socket), do: "user_socket:#{socket.assigns.user_id}"
  #
  # Would allow you to broadcast a "disconnect" event and terminate
  # all active sockets and channels for a given user:
  #
  #     JenkinsHookProxy.Web.Endpoint.broadcast("user_socket:#{user.id}", "disconnect", %{})
  #
  # Returning `nil` makes this socket anonymous.
  def id(_socket), do: nil
end

我们打算支持内网有多个 jenkins 的情况，同时，为了一点点安全考虑，每个 jinkins 我们分配一个随机字符串 (如 uuid) 作为 token, 至少一定程度上避免一些无效调用。用数据库来保存这个配置信息。

不需要 HTML，因此直接用 json 创建整个脚手架 (controller, model ...)

$ mix phx.gen.json Jenkins Callback callbacks host_id:string token:string callback_url:string

* creating lib/jenkins_hook_proxy/web/controllers/callback_controller.ex
* creating lib/jenkins_hook_proxy/web/views/callback_view.ex
* creating test/web/controllers/callback_controller_test.exs
* creating lib/jenkins_hook_proxy/web/views/changeset_view.ex
* creating lib/jenkins_hook_proxy/web/controllers/fallback_controller.ex
* creating lib/jenkins_hook_proxy/jenkins/callback.ex
* creating priv/repo/migrations/20170330015124_create_jenkins_callback.exs
* creating lib/jenkins_hook_proxy/jenkins/jenkins.ex
* creating test/jenkins_test.exs

Add the resource to your api scope in lib/jenkins_hook_proxy/web/router.ex:

    resources "/callbacks", CallbackController, except: [:new, :edit]


Remember to update your repository by running migrations:

    $ mix ecto.migrate

创建数据库并执行迁移脚本创建 callbacks 表

$ mix ecto.create
$ mix ecto.migrate

编辑 lib/jenkins_hook_proxy/jenkins/jenkins.ex 在 get_callback 方法后面，添加 get_callback_by_host_id

$ vi  lib/jenkins_hook_proxy/jenkins/jenkins.ex

  @doc """
  Gets a single callback by host_id.

  Raises `Ecto.NoResultsError` if the Callback does not exists.

  """
  def get_callback_by_host_id!(host_id), do: Repo.get_by!(Callback, host_id: host_id)

编辑 callback_controller, 把现有的方法 index create show update delete 统统删掉，然后重写 create 方法，如下：

$ vi lib/jenkins_hook_proxy/web/controllers/callback_controller.ex

defmodule JenkinsHookProxy.Web.CallbackController do
  use JenkinsHookProxy.Web, :controller

  alias JenkinsHookProxy.Jenkins
  alias JenkinsHookProxy.Jenkins.Callback

  action_fallback JenkinsHookProxy.Web.FallbackController

  def create(conn, %{"host_id" => host_id, "token" => token} = params) do
    with %Callback{} = callback <- Jenkins.get_callback_by_host_id!(host_id) do
      case callback.token do
        ^token ->
          # token与数据库的token匹配
          payload = %{
            # 提取github请求头(x- 开头 和 user-agent), 用于内网转发
            github_headers: conn.req_headers
                            |> Enum.filter(fn({k, v}) -> to_string(k) |> String.starts_with?(["x-", "user-agent"]) end)
                            |> Enum.into(%{}),
            jenkins: %{
              # 内网Jenkins Hook地址
              "callback_url": callback.callback_url
            },
            # 原生请求头, 无实际用途，方便调试查看用
            raw_headers: conn.req_headers |> Enum.into(%{}),
            # github请求参数，剔除 host_id 与 token
            body: params |> Map.drop(["token", "host_id"])
          }
          # websocket广播，向通道 jenkins:lobby 回传 jenkins_msg 事件
          JenkinsHookProxy.Web.Endpoint.broadcast! "jenkins:lobby", "jenkins_msg", payload

          # 返回正常给github
          conn
          |> json(%{result: "ok"})

       _ ->
        # token无效，返回403给github
        conn
        |> put_status(:forbidden)
        |> json(%{error: "token not matched."})
      end
    end
  end
end

这些代码中，真正发挥作用的是

# websocket广播，向通道 jenkins:lobby 回传 jenkins_msg 事件
JenkinsHookProxy.Web.Endpoint.broadcast! "jenkins:lobby", "jenkins_msg", payload

由于 Jenkins.get_callback_by_host_id!(host_id) 当数据没有相应 host_id 记录时，会抛出异常 Ecto.NoResultsError。

action_fallback 机制是 Phoenix 1.3 的一个非常不错的特性，controller 中我们可以只写正常业务逻辑代码，错误处理移交给 fallback_controller 去集中处理，这一点对 API 类应用尤其实用。

修改 fallback_controller.ex，加入对 Ecto.NoResultsError 返回 404

$ vi lib/jenkins_hook_proxy/web/controllers/fallback_controller.ex


  def call(conn, {:error, %Ecto.NoResultsError{} = _error}) do
    conn
    |> put_status(:not_found)
    |> json(%{error: "Jenkins not found"})
  end

编辑路由，把 router.ex 中最后的 scope "api" 段打开并加入 callback

$ vi lib/jenkins_hook_proxy/web/router.ex

  # Other scopes may use custom stacks.
  scope "/api", JenkinsHookProxy.Web do
    pipe_through :api
    post "/callbacks/:host_id/:token", CallbackController, :create
  end

可以运行 mix phx.routes 检查一下路由

$ mix phx.routes


    page_path  GET   /                               JenkinsHookProxy.Web.PageController :index
callback_path  POST  /api/callbacks/:host_id/:token  JenkinsHookProxy.Web.CallbackController :create

jenkins_hook_proxy 的功能已经全部完成。

我们手动编辑添加的代码，去掉空行、注释行后，代码也就 50 行左右，如果按代码语句 (为了阅读看起来舒服，一条代码语句会分成多行来写)，都不足 20 条。

像这种，就是一条代码语句，却占了 4 行

# token无效，返回403给github
conn
|> put_status(:forbidden)
|> json(%{error: "token not matched."})

运行 Jenkins_hook_proxy 测试

用命令行交互方式启动，添加一条配置数据 host_id: test token: abc123 callback_url: http://192.168.2.231:8020/github-webhook

JenkinsHookProxy.Jenkins.create_callback(%{host_id: "test", token: "abc123", callback_url: "http://192.168.2.231:8020/github-webhook"})

$ iex -S mix phx.server
Erlang/OTP 19 [erts-8.3] [source] [64-bit] [smp:8:8] [async-threads:10] [hipe] [kernel-poll:false] [dtrace]

[info] Running JenkinsHookProxy.Web.Endpoint with Cowboy using http://0.0.0.0:4000
Interactive Elixir (1.4.2) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> 16:37:04 - info: compiled 6 files into 2 files, copied 3 in 811 ms

nil
iex(2)> JenkinsHookProxy.Jenkins.create_callback(%{host_id: "test", token: "abc123", callback_url: "http://192.168.2.231:8020/github-webhook"})
[debug] QUERY OK db=5.2ms
INSERT INTO `jenkins_callbacks` (`callback_url`,`host_id`,`token`,`inserted_at`,`updated_at`) VALUES (?,?,?,?,?) ["http://192.168.2.231:8020/github-webhook", "test", "abc123", {{2017, 3, 30}, {8, 46, 9, 810223}}, {{2017, 3, 30}, {8, 46, 9, 816571}}]
{:ok,
 %JenkinsHookProxy.Jenkins.Callback{__meta__: #Ecto.Schema.Metadata<:loaded, "jenkins_callbacks">,
  callback_url: "http://192.168.2.231:8020/github-webhook", host_id: "test",
  id: 3, inserted_at: ~N[2017-03-30 08:46:09.810223], token: "abc123",
  updated_at: ~N[2017-03-30 08:46:09.816571]}}
iex(3)>

创建运行在内网的项目 Forwarder (nodejs)

启动另外一个命令行窗口。

创建项目目录

$ mkdir forwarder
$ cd forwarder

创建 package.json

$ vi package

{
  "name": "forwarder",
  "version": "0.0.1",
  "private": false
}

添加依赖项

phoneix 的 js 是用 ES6 风格写的，因此需要引入 babel 转换。

$ npm install --save babel-cli 
$ npm install --save babel-preset-env 
$ npm install --save babel-preset-es2015
$ npm install --save babel-preset-es2016
$ npm install --save ws
$ npm install --save node-fetch

jenkins_hook_proxy 中复制需要的 js

$ cp <jenkins_hook_proxy>/assets/js/socket.js .
$ cp < jenkins_hook_proxy>/deps/phoenix/assets/js/phoenix.js .

修改 phoenix.js

phoenix.js 本身是运行在浏览器中的，nodejs 并没有 window 对象，也没有 window.WebSocket。因此我们需要修改 phoenix.js 注入 window 及 window.WebSocket。

把下面这句话插入到 192 行 class Push { 之前。

let window = {WebSocket: require('ws')};

class Push {

编辑 socket.js

在 socket.js 中实现 channel 订阅与对服务器传回的 Jenkins_msg 事件进行处理。

$ vi socket.js

// NOTE: The contents of this file will only be executed if
// you uncomment its entry in "web/static/js/app.js".

// To use Phoenix channels, the first step is to import Socket
// and connect at the socket path in "lib/my_app/endpoint.ex":
import {Socket} from "./phoenix";

import fetch from "node-fetch";

let socket = new Socket("ws://localhost:4000/socket", {params: {token: ''}})

// When you connect, you'll often need to authenticate the client.
// For example, imagine you have an authentication plug, `MyAuth`,
// which authenticates the session and assigns a `:current_user`.
// If the current user exists you can assign the user's token in
// the connection for use in the layout.
//
// In your "web/router.ex":
//
//     pipeline :browser do
//       ...
//       plug MyAuth
//       plug :put_user_token
//     end
//
//     defp put_user_token(conn, _) do
//       if current_user = conn.assigns[:current_user] do
//         token = Phoenix.Token.sign(conn, "user socket", current_user.id)
//         assign(conn, :user_token, token)
//       else
//         conn
//       end
//     end
//
// Now you need to pass this token to JavaScript. You can do so
// inside a script tag in "web/templates/layout/app.html.eex":
//
//     <script>window.userToken = "<%= assigns[:user_token] %>";</script>
//
// You will need to verify the user token in the "connect/2" function
// in "web/channels/user_socket.ex":
//
//     def connect(%{"token" => token}, socket) do
//       # max_age: 1209600 is equivalent to two weeks in seconds
//       case Phoenix.Token.verify(socket, "user socket", token, max_age: 1209600) do
//         {:ok, user_id} ->
//           {:ok, assign(socket, :user, user_id)}
//         {:error, reason} ->
//           :error
//       end
//     end
//
// Finally, pass the token on connect as below. Or remove it
// from connect if you don't care about authentication.

socket.connect()

// Now that you are connected, you can join channels with a topic:
let channel = socket.channel("jenkins:lobby", {})

channel.on("jenkins_msg", payload => {
  channel.lastPayload = payload;
  let url = payload.jenkins.callback_url;
  let headers = Object.assign({}, {"content-type": "application/json"}, payload.github_headers);

  console.log(`[${Date()}]\n ${JSON.stringify(payload, null, "  ")}`);
  fetch(url, {
    method: "POST",
    headers: headers,
    body: JSON.stringify(payload.body)
  })
    .then( (e) => console.log(e) );
});

channel.join()
  .receive("ok", resp => { console.log("Joined successfully", resp) })
  .receive("error", resp => { console.log("Unable to join", resp) })

export {socket, channel};

创建 app.js

$ vi app.js

import socket from "./socket"

添加.babelrc

$ vi .babelrc

{
  "presets": ["env", "es2015"]
}

运行 forwarder 测试

ES6 语法，需要用 babel-node.js app.js 来转译执行，并看到结果。

$ ./node_modules/babel-cli/bin/babel-node.js app.js
Joined successfully {}

看到上面的 Joined successfully {} ，说明已经成功连接上 Jenkins_hook_proxy。

在 jenkins_hook_proxy 的运行控制台中，也能看到相应的输出：

iex(3)> [info] JOIN "jenkins:lobby" to JenkinsHookProxy.Web.JenkinsChannel
  Transport:  Phoenix.Transports.WebSocket
  Parameters: %{}
[info] Replied jenkins:lobby :ok

再开一个命令行窗口，模拟 github 发起请求

$ curl -H "Content-Type: application/json" -d '{"foo": "bar"}' http://localhost:4000/api/callbacks/test/abc123
{"result":"ok"}

jenkins_hook_proxy 运行输出可以看到日志信息：

iex(12)> [info] POST /api/callbacks/test/abc123
[debug] Processing with JenkinsHookProxy.Web.CallbackController.create/2
  Parameters: %{"foo" => "bar", "host_id" => "test", "token" => "abc123"}
  Pipelines: [:api]
[debug] QUERY OK source="jenkins_callbacks" db=0.5ms
SELECT j0.`id`, j0.`callback_url`, j0.`host_id`, j0.`token`, j0.`inserted_at`, j0.`updated_at` FROM `jenkins_callbacks` AS j0 WHERE (j0.`host_id` = ?) ["test"]
[info] Sent 200 in 998µs

forwarder 的运行输出也能看到日志信息：

[Thu Mar 30 2017 17:10:25 GMT+0800 (CST)]
 {
  "raw_headers": {
    "user-agent": "curl/7.51.0",
    "host": "localhost:4000",
    "content-type": "application/json",
    "content-length": "14",
    "accept": "*/*"
  },
  "jenkins": {
    "callback_url": "http://192.168.2.231:8020/github-webhook"
  },
  "github_headers": {
    "user-agent": "curl/7.51.0"
  },
  "body": {
    "foo": "bar"
  }
}
(node:47869) UnhandledPromiseRejectionWarning: Unhandled promise rejection (rejection id: 2): FetchError: request to http://192.168.2.231:8020/github-webhook failed, reason: connect ECONNREFUSED 192.168.2.231:8020

最后这个错误，是因为 http://192.168.2.231:8020/github-webhook jenkins 服务器没打开。但已经能说明，整条链路是正常的了。

测试无效 token

$ curl -H "Content-Type: application/json" -d '{"foo": "bar"}' http://localhost:4000/api/callbacks/test/abc   
{"error":"token not matched."}

总结

真实环境部署 jenkins_hook_proxy 运行在外网云主机上;

forwarder 运行在内网主机上，可以直接在 jenkins 的机器上跑。

反正我们已经是使用这么使用了。

代码可以上 github 获取 https://github.com/edwardzhou/jenkins_hook_proxy https://github.com/edwardzhou/jenkins-forwarder

#注意上面的代码是十几分钟撸出来的玩具，帮助我们偿还持续集成的技术债务而已。对于其他问题和副作用概不承担责任 😜😜😜

敏捷实践 (4) - 我们是如何改进 AC

edwardzhou — Mon, 07 Aug 2017 09:27:49 +0800

在敏捷实践 (1) 中，出于介绍目的，测试用例实现的都相对简单。

而实际上验收标准测试用例也并不复杂，百分之八九十的动作无非是：

跳转某个界面

在某个输入框输入一些内容

点击某个按钮

检测某些文本

判断是否处于某个界面

判断是否有弹出框，提示文本

而这些动作 (step)，cucumber 是可以用正则表达式进行标准化处理，在然后在各个测试用例中重用。

改进邮箱登录故事 AC 需要用到的 Step

$cat features/US004_login_by_email.feature

Feature: US_004 邮箱登录
  为了正常使用需要登录身份的功能
  作为一个已经用邮箱注册过的用户
  我想要用邮箱和密码登录系统

  @reset_driver
  Scenario: AC_US004_02 登录错误: 正确邮箱+错误密码登录
    Given 我已经用邮箱 test_user@mytest.com 与密码 test123 注册过账号
    When 我在 "主页面" 点击 "登录/注册" 进入 "登录页面"
    And 我在 "邮箱或手机" 输入 "test_user@mytest.com"
    And 我在 "密码" 输入 "b123456"
    And 我按下按钮 "登录"
    Then 我应当看到浮动提示 "用户密码不匹配"
.....

$ cat features/step_definitions/steps.rb

Given(/^我已经用邮箱 (.*) 与密码 (.*) 注册过账号$/) do |email, password|
  # sleep(1)
  puts "DEBUG: email: #{email}"
  puts "DEBUG: password: #{password}"
end

When(/^我在 "主页面" 点击 "登录\/注册" 进入 "登录页面"$/) do
  # 等待主页面就绪, 主页面ID 为 home_page
  wait { id('home_page') }
  # 点击 主页面中的 '登录/注册' 按钮，按钮ID为 btn_to_login
  id('btn_to_login').click

  # 检查页面跳转到 登录页面， 登录页面ID为 page_login_account
  wait { id('page_login_account') }
end

When(/^我在 "(.*?)" 输入 "(.*?)"$/) do |input_field, input_value|
  input_id = case input_field
               when '邮箱或手机'
                 'input_username'
               when '密码'
                 'input_password'
               else
                 'unknown'
             end
  input_box = id(input_id)           # 定位指定的输入框
  input_box.clear                    # 清除原来的内容
  input_box.type "#{input_value}\n"  # 输入新内容并回车
end

And(/^我按下按钮 "登录"$/) do
  id('btn_login').click
end

Then(/^我应当看到浮动提示 "(.+)"$/) do |msg|
  msg.strip!
  puts "DEBUG: 期待 #{msg}"
  wait { find(msg) }
end

Then(/^我应当到达 "主页面"$/) do
  wait { id('home_page') }
end

And(/^等待 (\d+) 秒后.*/) do |seconds|
  sleep(seconds.to_i)
end

When 我在 "主页面" 点击 "登录/注册" 进入 "登录页面"

这个 step 的目的是我们要在某个界面，点击某个组件 (按钮或链接），跳转到另一个页面。

When(/^我在 "主页面" 点击 "登录\/注册" 进入 "登录页面"$/) do
  # 等待主页面就绪, 主页面ID 为 home_page
  wait { id('home_page') }
  # 点击 主页面中的 '登录/注册' 按钮，按钮ID为 btn_to_login
  id('btn_to_login').click

  # 检查页面跳转到 登录页面， 登录页面ID为 page_login_account
  wait { id('page_login_account') }
end

这里面有三个小动作：

确定当前是否在指定界面，是通过查找某个该界面中特有的组件 id 是否存在来判断。
点击某个元素，是通过查找到指定 id 的组件，向它发送 click 信号。
判断当前界面是否是指定界面，同 1。

因此每个界面，我们都设置一个能够标识该界面的一个唯一的 id，便于我们识别当前的界面。其次每个需要测试交互的组件，都分配一个在该页面唯一的 id。最后，为上面的硬编码 id 改为对照方式。step 改为正则匹配。

# When(/^我在 "主页面" 点击 "登录\/注册" 进入 "登录页面"$/) do
When(/^我在 "([^"]*)" 点击 "(.*?)" 进入 "(.*?)"$/) do |location, button, dest|
  VIEW_MAPPING = {
    '主页面' => 'home_page',
    '密码登录页面' =>  'page_login_account' 
  }

  BUTTON_MAPPING = {
    '登录/注册' => 'btn_to_login'
  }

  location_id = VIEW_MAPPING[location]
  button_id = BUTTON_MAPPING[button]
  dest_id = VIEW_MAPPING[dest]

  wait do
    puts "DEBUG: #{location} => #{location_id}"
    id(location_id)
  end

  wait do
    puts "DEBUG: #{button} => #{button_id}"
    id(button_id)
  end
  id(button_id).click

  wait do
    puts "DEBUG: #{dest} => #{dest_id}"
    id(dest_id)
  end
end

这个 steps 基本已经通用了。只要 feature 中按照 我在 "AAA" 点击 "BBB" 进入 "CCC" 这个格式写测试步骤，都能匹配处理。

还有不足的的地方，每次新加按钮或页面 id 时，都需要进入该 step 中添加，而且，其他地方无法重用这些映射定义；另一个是 "=>" 这种映射写法，通不过 Rubocop 的语法检测。

继续优化

把 VIEW_MAPPING BUTTON_MAPPING 移到一个新文件，作为全局的常量（其实 Ruby 中并没有真正的常量定义）。并且，反转映射写法以满足 Rubocop。 Cucumber 会自动加载 features/step_definitions 中所有的文件，无需自己手动 require.

$ cat features/step_definitions/keyword_mapping.rb

##
# 1. 按所在页面进行分类排序
# 2. 不同页面存在相同关键字（button或input), id应相同
# 3. 在下面注释中出现 '已被定义' 的前缀， 是为说明相同的关键字，在所处hash中已被定义，不需要重新定义

VIEW_MAPPING = {
    home_page: '主页面',
    page_more_races: '更多赛事页面',
    page_login_account: '密码登录页面',
    page_login_code: '验证码登录页面',
    ....
}.invert

BUTTON_MAPPING = {
    # 主页面
    btn_to_login: '登录/注册',
    btn_races_1: '第一个赛事',
    btn_race_detail: '赛事详情',
    btn_order: '订单',
    btn_setup: '设置',
    btn_account_security: '账号安全',
    btn_change_password: '修改密码',
    btn_more_races: '更多赛事',

    # 密码登录页面
    btn_bar_right: '注册',
    btn_bar_left: '左上',
    ...
}.invert

改进界面输入的步骤，模版化

When(/^我在 "(.*?)" 输入 "(.*?)"$/) do |input_field, input_value|
  input_id = case input_field
               when '邮箱或手机'
                 'input_username'
               when '密码'
                 'input_password'
               else
                 'unknown'
             end
  input_box = id(input_id)           # 定位指定的输入框
  input_box.clear                    # 清除原来的内容
  input_box.type "#{input_value}\n"  # 输入新内容并回车
end

由于一开始我们就使用了正则匹配，仅是在 ID 这块做了条件硬编码，该为映射处理：

When(/^我在 "(.*?)" 输入 "(.*?)"$/) do |input, value|
  input_id = INPUT_MAPPING[input]
  puts "DEBUG: #{input} => #{input_id}"
  input_box = nil
  wait do
    input_box = id(input_id)
  end
  input_box.clear                # 定位指定的输入框
  input_box.type "#{value}\n".   # 输入新内容并回车
  sleep 1                        # 输入完等待1秒，给模拟器留处理时间
end

为 features/step_definitions/keyword_mapping.rb 添加 INPUT_MAPPING

INPUT_MAPPING = {
    # 密码登录页面
    input_username: '邮箱或手机',
    input_password: '密码',

    # 验证码登录页面
    input_phone: '手机号',
    input_code: '验证码',

    # 手机注册页面
    # 已被定义：手机号，验证码

    # 邮箱注册页面
    input_email: '邮箱',

    # 实名认证
    input_real_name: '真实姓名',
    input_id_card: '身份证号',

    # 修改密码
    input_old_pwd: '旧密码',
    input_new_pwd: '新密码',
    # 赛事
    input_keyword: '赛事关键字',
}.invert

继续改进剩余 step

And(/^我按下按钮 "登录"$/) do
  id('btn_login').click
end

Then(/^我应当看到浮动提示 "(.+)"$/) do |msg|
  msg.strip!
  puts "DEBUG: 期待 #{msg}"
  wait { find(msg) }
end

Then(/^我应当到达 "主页面"$/) do
  wait { id('home_page') }
end

==>

And(/^我[按下|点击]+按钮 "(.*?)"$/) do |button|
  button_id = BUTTON_MAPPING[button]
  wait do
    puts "DEBUG: '#{button}' => #{button_id}"
    element = id(button_id)
    puts "DEBUG: got button: #{button_id}, #{element}"
  end
  id(button_id).click
end

Then(/^我应当看到浮动提示 "(.+)"$/) do |msg|
  msg.strip!
  puts "DEBUG: 期待 #{msg}"
  wait { find(msg) }
end

Then(/^我应当到达 "([^"]*)"$/) do |location|
  location_id = VIEW_MAPPING[location]
  wait do
    puts "DEBUG: #{location} => #{location_id}"
    id(location_id)
  end
end

备注：Cucumber 的 Step 定义中，And Given Then When 这四个都是等价的语法糖，Then 定义的步骤，可以直接在其他步骤中使用。

And(/^我应当看到浮动提示 "(.+)"$/) do |msg|

When(/^我应当看到浮动提示 "(.+)"$/) do |msg|

Then(/^我应当看到浮动提示 "(.+)"$/) do |msg|

Given(/^我应当看到浮动提示 "(.+)"$/) do |msg|

这四种都是等价的。

完整示例

当我们把常用的 Step 整理后，基本上已经能满足 95% 以上的测试用例编写，就连产品，设计也能愉快的按着写 AC 了这个 step 定义，基本可以直接拿去使用，请叫我 红领巾。

$ cat features/step_definitions/steps.rb

Given(/^我已经用邮箱 (.*) 与密码 (.*) 注册过账号$/) do |email, password|
  # sleep(1)
  puts "DEBUG: email: #{email}"
  puts "DEBUG: password: #{password}"
end

Given(/^我在 "([^"]*)" 点击 "(.*?)" 进入 "(.*?)"$/) do |location, button, dest|
  location_id = VIEW_MAPPING[location]
  button_id = BUTTON_MAPPING[button]
  dest_id = VIEW_MAPPING[dest]

  wait do
    puts "DEBUG: #{location} => #{location_id}"
    id(location_id)
  end

  wait do
    puts "DEBUG: #{button} => #{button_id}"
    id(button_id)
  end
  id(button_id).click

  wait do
    puts "DEBUG: #{dest} => #{dest_id}"
    id(dest_id)
  end
end

When(/^我点击 "([^"]*)" [进入|回到]+ "(.*?)"$/) do |button, dest|
  button_id = BUTTON_MAPPING[button]
  dest_id = VIEW_MAPPING[dest]
  wait do
    puts "DEBUG: #{button} => #{button_id}"
    element = id(button_id)
    puts "DEBUG: got button: #{button_id}, #{element}"
  end
  id(button_id).click

  wait do
    puts "DEBUG: #{dest} => #{dest_id}"
    id(dest_id)
  end
end

When(/^我[按下|点击]+按钮 "(.*?)"$/) do |button|
  button_id = BUTTON_MAPPING[button]
  wait do
    puts "DEBUG: '#{button}' => #{button_id}"
    element = id(button_id)
    puts "DEBUG: got button: #{button_id}, #{element}"
  end
  id(button_id).click
end

When(/^点击原生button "(.*?)"$/) do |button|
  wait do
    puts "DEBUG: #{button}"
    element = id(button)
    puts "DEBUG: got button: #{element}"
  end
  id(button).click
end

Given(/^我在 "(.*?)" 输入 "(.*?)"$/) do |input, value|
  input_id = INPUT_MAPPING[input]
  puts "DEBUG: #{input} => #{input_id}"
  input_box = nil
  wait do
    input_box = id(input_id)
  end
  input_box.clear
  input_box.type "#{value}\n"
  sleep 1
end

And(/^等待 (\d+) 秒后.*/) do |seconds|
  sleep(seconds.to_i)
end

Then(/^我应当看到浮动提示 "(.+)"$/) do |msg|
  msg.strip!
  puts "DEBUG: 期待 #{msg}"
  wait { find(msg) }
end

Then(/^我应当到达 "([^"]*)"$/) do |location|
  location_id = VIEW_MAPPING[location]
  wait do
    puts "DEBUG: #{location} => #{location_id}"
    id(location_id)
  end
end

Given(/^我在 "([^"]*)"$/) do |location|
  location_id = VIEW_MAPPING[location]
  wait do
    puts "DEBUG: #{location} => #{location_id}"
    id(location_id)
  end
end

Given(/.*\(创建数据\)$/) do |table|
  params = table.hashes.first
  ac = params.delete('ac').downcase
  result = RemoteFactory.create(ac, params)
  puts result.parsed_body
end

Given(/^我已使用 "([^"]*)" 登录$/) do |value|
  result = RemoteFactory.create('ac_us001', email: value)
  puts result.parsed_body
  puts '回到主页'
  id(BUTTON_MAPPING['回到主页']).click if exists { id(BUTTON_MAPPING['回到主页']) }

  to_login = BUTTON_MAPPING['登录/注册']
  wait do
    puts '登录/注册'
    id(to_login).click
  end

  email_input = INPUT_MAPPING['邮箱或手机']
  password_input = INPUT_MAPPING['密码']
  login = BUTTON_MAPPING['登录']
  wait do
    id(email_input)
  end
  id(email_input).clear
  id(email_input).type "#{value}\n"
  sleep 1

  id(password_input).clear
  id(password_input).type 'test123'
  sleep 1

  id(login).click
end

Given(/^退出登录$/) do
  puts '回到主页'
  id(BUTTON_MAPPING['回到主页']).click if exists { id(BUTTON_MAPPING['回到主页']) }

  bar_left = BUTTON_MAPPING['左上']
  wait do
    puts '左上'
    id(bar_left).click
  end

  setup = BUTTON_MAPPING['设置']
  wait do
    puts '设置'
    id(setup).click
  end

  btn_exit = BUTTON_MAPPING['退出登录']
  wait do
    puts '退出登录'
    id(btn_exit).click
  end

  id('确定').click
end

Given(/^清除数据$/) do
  result = RemoteFactory.create('clear')
  puts result.parsed_body
end

Then(/^我应当看到 "(.*?)" 显示 "(.+)"$/) do |location, msg|
  msg.strip!
  puts "DEBUG: 期待 #{msg}"
  location_id = INPUT_MAPPING[location]
  wait {
    puts "DEBUG: #{location} => #{location_id}"
    id(location_id)
  }
  id(location_id).value.eql?(msg)
end

Then(/^"([^"]*)" 按钮置灰，无法点击$/) do |button_text|
  pending
end

Then(/^"([^"]*)" 按钮无法点击$/) do |button_text|
  pending
end

Then(/^看到的 "([^"]*)" 应为 "([^"]*)"$/) do |text_name, value|
  text_id = TEXT_MAPPING[text_name]
  wait {
    puts "DEBUG: #{text_name} => #{text_id}"
    id(text_id)
  }

  target_value = id(text_id).value.strip
  puts "DEBUG: #{target_value} eql? #{value}"
  raise unless target_value.eql?(value)
end

Then(/^我能看到 "([^"]*)" 这些元素$/) do |elements|
  elements.split(',').each do |element|
    element
    id(TEXT_MAPPING[element])
  end
end

And(/^我在Alert中点击 "(.+)"$/) do |button_text|
  wait(1) do
    tag('UIAAlert')
    button(button_text).click
  end
end

And(/^上传图片$/) do
  id('btn_picker_image').click
  wait(10) do
    id('图库').click
  end
  wait(10) do
    id('好').click
  end
  wait(10) do
    id('Camera Roll').click
  end
  wait do
    tag('XCUIElementTypeCell').click
  end
  sleep 1
end

Then(/^隐藏键盘$/) do
  hide_keyboard('Return')
end

And(/^打印调试 (.+)$/) do |debug_name|
  debug_name.strip!
  if debug_name == 'page'
    page
  elsif debug_name == 'source'
    source
  end
end

Then(/^"([^"]*)" 应隐藏/) do |button_text|
  pending
end

Then(/^我能看到 "(.+)"$/) do |msg|
  msg.strip!
  puts "DEBUG: 期待 #{msg}"
  find(msg)
end

And(/^上滑$/) do
  # swipe start_x: 300, start_y: 300, offest_x: 0, offset_y: -200
  swipe direction: 'up'
end

And(/^下拉刷新$/) do
  # swipe start_x: 300, start_y: 300, offest_x: 0, offset_y: 200
  swipe direction: 'down'
  sleep 1
end

Then(/^我应该找不到 "([^"]*)" 这些元素$/) do |elements|
  elements.split(',').each do |element|
    raise "存在#{element}这个元素" if exists { id(TEXT_MAPPING[element]) }
  end
end

Then(/^应不存在 "([^"]*)"$/) do |button|
  raise "存在#{button}" if exists { id(BUTTON_MAPPING[button]) }
end

Then(/^在 "([^"]*)" 可匹配到 "([^"]*)"$/) do |button, element|
  button_id = BUTTON_MAPPING[button]
  label = ''
  wait do
    puts "DEBUG: #{button} => #{button_id}"
    label = id(button_id).label
    puts "DEBUG: got label: #{label}"
  end
  raise "未匹配到#{element}" unless label.match(element)
end

Then(/^pending:.*$/) do
  pending
end

完整用户故事例子

US_001 邮箱注册

Feature: US_001 邮箱注册
  作为一名非注册用户，我需要用邮箱号，使得我可以完成注册

  @reset_driver
  Scenario: AC_US001_01 注册错误: 错误邮箱注册
    Given 我在 "主页面"
    When 我在 "主页面" 点击 "登录/注册" 进入 "密码登录页面"
    And 我点击 "注册" 进入 "手机注册页面"
    And 我点击 "使用邮箱注册" 进入 "邮箱注册页面"
    And 我在 "邮箱" 输入 "aa@desh"
    And 我在 "密码" 输入 "test123"
    And 我按下按钮 "完成"
    Then 我应当看到浮动提示 "您的电子邮件格式不正确"

  Scenario: AC_US001_02 下一步按钮是灰色状态
    Given 我在 "邮箱" 输入 ""
    Then "完成" 按钮置灰，无法点击

  Scenario: AC_US001_03 成功跳转到 手机注册页面
    Given 我在 "邮箱注册页面"
    When 我按下按钮 "使用手机注册"
    Then 我应当到达 "手机注册页面"

  Scenario: AC_US001_04 成功跳转到 密码登录页面
    Given 我点击 "使用邮箱注册" 回到 "邮箱注册页面"
    When 我按下按钮 "我已有账号"
    Then 我应当到达 "密码登录页面"

  Scenario: AC_US001_05 注册错误 邮箱已注册
    Given 我已经用邮箱 test@gmail.com 注册过账号 (创建数据)
      | ac       | clear | email          |
      | AC_US001 | true  | test@gmail.com |
    When 我点击 "注册" 进入 "手机注册页面"
    And 我点击 "使用邮箱注册" 回到 "邮箱注册页面"
    And 我在 "邮箱" 输入 "test@gmail.com"
    And 我在 "密码" 输入 "test123"
    And 我按下按钮 "完成"
    Then 我应当看到浮动提示 "邮箱已被使用"

#  Scenario: AC_US001_06  备注：重复ac,与AC_US001_01重复

  Scenario: AC_US001_07 注册错误 密码格式错误
    Given 我在 "邮箱" 输入 "test@gmail.com"
    When 我在 "密码" 输入 "123456"
    And 我按下按钮 "完成"
    Then 我应当看到浮动提示 "密码格式不正确"

  Scenario: AC_US001_08 注册成功
    Given 我在 "邮箱" 输入 "test1@gmail.com"
    When 我在 "密码" 输入 "test123456"
    And 我按下按钮 "完成"
    Then 我应当到达 "主页面"

US-006 忘记密码 - 邮箱找回

Feature: US-006 忘记密码-邮箱找回
  作为一名忘记密码的用户，我需要用已认证的邮箱, 使得我能够找回密码

  @reset_driver
  Scenario: AC-US006-01 没有任何输入
    Given 我在 "主页面" 点击 "登录/注册" 进入 "密码登录页面"
    And 我点击 "忘记密码" 进入 "忘记密码页面"
    And 我按下按钮 "使用邮箱找回密码"
    Then "下一步" 按钮置灰，无法点击

  Scenario: AC-US006-02 没有任何输入 点击获取验证码
    When 我按下按钮 "获取验证码"
    Then 我应当看到浮动提示 "您的电子邮件格式不正确"

  Scenario: AC-US006-03 错误格式的邮箱 点击获取验证码
    And 我在 "邮箱" 输入 "test@aa"
    And 我按下按钮 "获取验证码"
    Then 我应当看到浮动提示 "您的电子邮件格式不正确"

  Scenario: AC-US006-04 错误格式的邮箱 点击获取验证码
    And 我在 "邮箱" 输入 "ricky@aa"
    And 我按下按钮 "获取验证码"
    Then 我应当看到浮动提示 "您的电子邮件格式不正确"

#  Scenario: AC_US006_05  备注：重复ac,与AC_US006_07重复

  Scenario: AC-US006-06 未输入邮箱 但输入了验证码
    When 我在 "邮箱" 输入 ""
    And 我在 "验证码" 输入 "aaa"
    And 我按下按钮 "获取验证码"
    Then 我应当看到浮动提示 "您的电子邮件格式不正确"

  Scenario: AC-US006-07 输入正确的邮箱 及正确的验证码
    Given 我已经用邮箱 test@aa.com 注册过账号 (创建数据)
      |ac         |clear|email|
      |AC_US006_07|true |test@aa.com|
    And 我在 "邮箱" 输入 "test@aa.com"
    And 我按下按钮 "获取验证码"
    And 我在 "验证码" 输入 "123456"
    And 隐藏键盘
    And 我按下按钮 "下一步"
    Then 我应当到达 "输入密码页面"

  Scenario: AC-US006-08 输入正确的邮箱 及正确的验证码
    Given 我已经用邮箱 test@aa.com 注册过账号 (创建数据)
      |ac         |clear|email|
      |AC_US006_08|true |test@aa.com|
    And 我在 "密码" 输入 "123456"
    And 我按下按钮 "完成"
    Then 我应当看到浮动提示 "密码格式不正确"

  Scenario: AC-US006-09 输入正确的邮箱 及正确的验证码
    Given 我按下按钮 "回到主页"
    When 我在 "主页面" 点击 "登录/注册" 进入 "密码登录页面"
    And 我点击 "忘记密码" 进入 "忘记密码页面"
    And 我按下按钮 "使用邮箱找回密码"
    And 我在 "邮箱" 输入 "test@aa.com"
    And 我按下按钮 "获取验证码"
    And 我在 "验证码" 输入 "123456"
    And 我按下按钮 "下一步"
    And 我在 "密码" 输入 "a123456"
    And 我按下按钮 "完成"
    Then 我应当到达 "密码登录页面"

最后，为了确保测试用例每次都能正确，我们专门部署一个后端持续集成版本，额外提供了一组用于重置/创建测试用例数据，用于支持 APP 测试。

敏捷实践 (3) - Appium Ruby Console

edwardzhou — Mon, 07 Aug 2017 09:05:22 +0800

http://www.jianshu.com/p/10164589e694

1. Appium Ruby Console

Appium Ruby Console (ARC) 顾名思义就是 Appium 控制台（命令行模式）。 https://github.com/appium/ruby_console

2. 安装

如果你在敏捷实践 (1) - 我们是如何自动化 App 验收标准中，已经安装了 ARC，这个步就可以忽略。

$ gem install appium_lib
$ gem install appium_console

3. 启动

3.1 appium

在打开一个命令行窗口运行 appium 服务 $ appium

3.2 拉取 Sample-Code

`$ git clone https://github.com/appium/sample-code.git

3.3 运行 ARC

arc 会自动读取 appium.txt 并通知 appium 启动 appium.txt 指定的 App

app 的位置在 sample-code/sample-code/apps/TestApp/build/release-iphonesimulator/TestApp.app

$ cd sample-code/sample-code/examples/ruby
# 运行 bundle 安装依赖包
$ bundle
$ arc

这个一步发生了什么？ ** ARC 启动，读取 appium.txt 的配置发送给 appium **

** appium 收到请求，启动模拟器，安装 WebDriverAgent & TestApp ** 下面粘贴的日志信息可以让大家看到许多背后的细节，对理解 appium 如何工作很有帮助。

EdwarddeMBP:appium_work edwardzhou$ appium
[Appium] Welcome to Appium v1.6.3
[Appium] Appium REST http interface listener started on 0.0.0.0:4723
[HTTP] --> POST /wd/hub/session {"desiredCapabilities":{"browserName":"","version":"","platform":"ANY","javascriptEnabled":true,"cssSelectorsEnabled":true,"takesScreenshot":true,"nativeEvents":false,"rotatable":false,"newCommandTimeout":999999,"platformName":"ios","versionNumber":"10.2","deviceName":"iPhone 6","app":"/Users/edwardzhou/appium_work/sample-code/sample-code/apps/TestApp/build/release-iphonesimulator/TestApp.app","automationName":"XCUITest","language":"zh","locale":"zh_CN","autoAcceptAlerts":true}}
[debug] [MJSONWP] Calling AppiumDriver.createSession() with args: [{"browserName":"","version":"","platform":"ANY","javascriptEnabled":true,"cssSelectorsEnabled":true,"takesScreenshot":true,"nativeEvents":false,"rotatable":false,"newCommandTimeout":999999,"platformName":"ios","versionNumber":"10.2","deviceName":"iPhone 6","app":"/Users/edwardzhou/appium_work/sample-code/sample-code/apps/TestApp/build/release-iphonesimulator/TestApp.app","automationName":"XCUITest","language":"zh","locale":"zh_CN","autoAcceptAlerts":true},null,null,null,null]
[Appium] Creating new XCUITestDriver session
[Appium] Capabilities:
[Appium]   browserName: ''
[Appium]   version: ''
[Appium]   platform: 'ANY'
[Appium]   javascriptEnabled: true
[Appium]   cssSelectorsEnabled: true
[Appium]   takesScreenshot: true
[Appium]   nativeEvents: false
[Appium]   rotatable: false
[Appium]   newCommandTimeout: 999999
[Appium]   platformName: 'ios'
[Appium]   versionNumber: '10.2'
[Appium]   deviceName: 'iPhone 6'
[Appium]   app: '/Users/edwardzhou/appium_work/sample-code/sample-code/apps/TestApp/build/release-iphonesimulator/TestApp.app'
[Appium]   automationName: 'XCUITest'
[Appium]   language: 'zh'
[Appium]   locale: 'zh_CN'
[Appium]   autoAcceptAlerts: true
[debug] [XCUITest] XCUITestDriver version: 2.5.3
[BaseDriver] The following capabilities were provided, but are not recognized by appium: version, platform, javascriptEnabled, cssSelectorsEnabled, takesScreenshot, nativeEvents, rotatable, versionNumber.
[XCUITest] The capabilities 'autoAcceptAlerts' and 'autoDismissAlerts' do not work for XCUITest-based tests. Please adjust your alert handling accordingly.
[BaseDriver] Session created with session id: 136bbab8-78e5-4e5d-9cd1-0b174eeaa835
[debug] [XCUITest] Xcode version set to '8.2.1'
[debug] [XCUITest] iOS SDK Version set to '10.2'
[XCUITest] Simluator udid not provided, using desired caps to create a new simulator
[XCUITest] No platformVersion specified. Using latest version Xcode supports: '10.2' This may cause problems if a simulator does not exist for this platform version.
[iOSSim] Constructing iOS simulator for Xcode version 8.2.1 with udid 'C2E88820-BB65-4D79-923B-15C63D5FA384'
[XCUITest] Created simulator with udid 'C2E88820-BB65-4D79-923B-15C63D5FA384'.
[XCUITest] Determining device to run tests on: udid: 'C2E88820-BB65-4D79-923B-15C63D5FA384', real device: false
[BaseDriver] Using local app '/Users/edwardzhou/appium_work/sample-code/sample-code/apps/TestApp/build/release-iphonesimulator/TestApp.app'
[debug] [XCUITest] Checking whether app '/Users/edwardzhou/appium_work/sample-code/sample-code/apps/TestApp/build/release-iphonesimulator/TestApp.app' is actually present
[debug] [XCUITest] App is present
[debug] [iOS] Getting bundle ID from app '/Users/edwardzhou/appium_work/sample-code/sample-code/apps/TestApp/build/release-iphonesimulator/TestApp.app': 'io.appium.TestApp'
[debug] [iOSLog] Starting iOS 10.2 simulator log capture
[debug] [iOSLog] System log path: /Users/edwardzhou/Library/Logs/CoreSimulator/C2E88820-BB65-4D79-923B-15C63D5FA384/system.log
[XCUITest] Setting up simulator
[debug] [iOSSim] Checking whether simulator has been run before
[debug] [iOSSim] Simulator has not been run before
[debug] [iOS] No simulator directories found.
[debug] [iOSSim] Attempting to launch and quit the simulator, to create directory structure
[debug] [iOSSim] Will launch with Safari? false
[iOSSim] Starting simulator with command: open -Fn /Applications/Xcode.app/Contents/Developer/Applications/Simulator.app --args -CurrentDeviceUDID C2E88820-BB65-4D79-923B-15C63D5FA384
[iOSSim] Simulator log at '/Users/edwardzhou/Library/Logs/CoreSimulator/C2E88820-BB65-4D79-923B-15C63D5FA384/system.log'
[iOSSim] Tailing simulator logs until we encounter the string "com.apple.springboard"
[iOSSim] We will time out after 60000ms
[debug] [iOSSim] Waiting an extra 10000ms for the simulator to really finish booting
[debug] [iOSSim] Done waiting extra time for simulator
[iOSSim] Simulator booted in 11143ms
[debug] [iOSSim] Checking whether simulator has been run before
[debug] [iOSSim] Simulator has been run before
[debug] [iOSSim] Killing all iOS Simulators
[debug] [iOS] Setting locale information
[debug] [iOSSim] New language: zh
[debug] [iOSSim] New locale: zh_CN
[debug] [iOSSim] Writing new locale plist data
[debug] [iOS] Locale was updated. Stopping simulator.
[debug] [iOS] Killing the simulator
[debug] [iOSSim] Killing all iOS Simulators
[debug] [iOS] No iOS / app preferences to set
[XCUITest] Simulator with udid 'C2E88820-BB65-4D79-923B-15C63D5FA384' not booted. Booting up now
[debug] [iOSSim] Killing all iOS Simulators
[iOSSim] Starting simulator with command: open -Fn /Applications/Xcode.app/Contents/Developer/Applications/Simulator.app --args -CurrentDeviceUDID C2E88820-BB65-4D79-923B-15C63D5FA384
[iOSSim] Simulator log at '/Users/edwardzhou/Library/Logs/CoreSimulator/C2E88820-BB65-4D79-923B-15C63D5FA384/system.log'
[iOSSim] Tailing simulator logs until we encounter the string "com.apple.springboard"
[iOSSim] We will time out after 60000ms
[debug] [iOSSim] Waiting an extra 10000ms for the simulator to really finish booting
[debug] [iOSSim] Done waiting extra time for simulator
[iOSSim] Simulator booted in 22072ms
[debug] [XCUITest] Installing app '/Users/edwardzhou/appium_work/sample-code/sample-code/apps/TestApp/build/release-iphonesimulator/TestApp.app' on device
[XCUITest] Using WDA path: '/Users/edwardzhou/servers/node-v7.4.0/lib/node_modules/appium/node_modules/appium-xcuitest-driver/WebDriverAgent'
[XCUITest] Using WDA agent: '/Users/edwardzhou/servers/node-v7.4.0/lib/node_modules/appium/node_modules/appium-xcuitest-driver/WebDriverAgent/WebDriverAgent.xcodeproj'
[XCUITest] Launching WebDriverAgent on the device
[debug] [XCUITest] Carthage found: /usr/local/bin/carthage
[debug] [XCUITest] Killing hanging processes
[debug] [XCUITest] Beginning test with command 'xcodebuild build-for-testing test-without-building -project /Users/edwardzhou/servers/node-v7.4.0/lib/node_modules/appium/node_modules/appium-xcuitest-driver/WebDriverAgent/WebDriverAgent.xcodeproj -scheme WebDriverAgentRunner -destination id=C2E88820-BB65-4D79-923B-15C63D5FA384 -configuration Debug' in directory '/Users/edwardzhou/servers/node-v7.4.0/lib/node_modules/appium/node_modules/appium-xcuitest-driver/WebDriverAgent'
[debug] [XCUITest] Waiting up to 60000ms for WebDriverAgent to start
[debug] [XCUITest] Log file for xcodebuild test: /Users/edwardzhou/Library/Developer/Xcode/DerivedData/WebDriverAgent-ddapapcqxaoabrhjkjsyvzexgoxy/Logs/Test/98A1C0F5-03F0-4A95-9408-FE68E30628B2/Session-WebDriverAgentRunner-2017-02-26_191404-oFrhPq.log
[debug] [XCUITest] WebDriverAgent successfully started after 15361ms
[debug] [XCUITest] Sending createSession command to WDA
[debug] [JSONWP Proxy] Proxying [POST /session] to [POST http://localhost:8100/session] with body: {"desiredCapabilities":{"bundleId":"io.appium.TestApp","arguments":[],"environment":{},"shouldWaitForQuiescence":true}}
[debug] [JSONWP Proxy] Got response with status 200: {"value":{"sessionId":"AC8C1ADF-3E96-4C55-9302-73B4D7AA6B89","capabilities":{"device":"iphone","browserName":" ","sdkVersion":"10.2","CFBundleIdentifier":"local.pid.35906"}},"sessionId":"AC8C1ADF-3E96-4C55-9302-73B4D7AA6B89","status":0}
[debug] [XCUITest] Setting initial orientation to 'PORTRAIT'
[debug] [JSONWP Proxy] Proxying [POST /orientation] to [POST http://localhost:8100/session/AC8C1ADF-3E96-4C55-9302-73B4D7AA6B89/orientation] with body: {"orientation":"PORTRAIT"}
[debug] [JSONWP Proxy] Got response with status 200: {"value":{},"sessionId":"AC8C1ADF-3E96-4C55-9302-73B4D7AA6B89","status":0}
[Appium] New XCUITestDriver session created successfully, session 136bbab8-78e5-4e5d-9cd1-0b174eeaa835 added to master session list
[debug] [MJSONWP] Responding to client with driver.createSession() result: {"webStorageEnabled":false,"locationContextEnabled":false,"browserName":"","platform":"ANY","javascriptEnabled":true,"databaseEnabled":false,"takesScreenshot":true,"networkConnectionEnabled":false,"version":"","cssSelectorsEnabled":true,"nativeEvents":false,"rotatable":false,"newCommandTimeout":999999,"platformName":"ios","versionNumber":"10.2","deviceName":"iPhone 6","app":"/Users/edwardzhou/appium_work/sample-code/sample-code/apps/TestApp/build/release-iphonesimulator/TestApp.app","automationName":"XCUITest","language":"zh","locale":"zh_CN","autoAcceptAlerts":true}
[HTTP] <-- POST /wd/hub/session 200 68905 ms - 645 
[HTTP] --> GET /wd/hub/status {}
[debug] [MJSONWP] Calling AppiumDriver.getStatus() with args: []
[debug] [MJSONWP] Responding to client with driver.getStatus() result: {"build":{"version":"1.6.3","revision":null}}
[HTTP] <-- GET /wd/hub/status 200 11 ms - 83 
[HTTP] --> POST /wd/hub/session/136bbab8-78e5-4e5d-9cd1-0b174eeaa835/timeouts/implicit_wait {"ms":0}
[debug] [MJSONWP] Calling AppiumDriver.implicitWait() with args: [0,"136bbab8-78e5-4e5d-9cd1-0b174eeaa835"]
[debug] [XCUITest] Executing command 'implicitWait'
[debug] [BaseDriver] Set implicit wait to 0ms
[debug] [MJSONWP] Responding to client with driver.implicitWait() result: null
[HTTP] <-- POST /wd/hub/session/136bbab8-78e5-4e5d-9cd1-0b174eeaa835/timeouts/implicit_wait 200 17 ms - 76

** iOS 模拟器就绪**

大家看到，app 首次运行弹出的 alert，就是导致 sample-code 中的测试用例无法通过的原因。

因为，所有的查询定位，都是在当前视图中处理，这个 alert 出现后就改变了当前视图。

let me show you~

在 arc 中输入 page，回车

[1] pry(main)> page
XCUIElementTypeApplication
   name, label:  
XCUIElementTypeOther
   name, label: 3 格 Wi-Fi 信号（共 3 格）
   value: SSID
XCUIElementTypeOther
   name, label: 下午7:27
XCUIElementTypeOther
   name, label: 电池电量：-100%
XCUIElementTypeAlert
   name, label: “TestApp”可能使 iPhone 变慢
XCUIElementTypeStaticText
   name, label, value: “TestApp”可能使 iPhone 变慢
XCUIElementTypeStaticText
   name, label, value: 应用开发者需要更新此应用以改进其兼容性。
XCUIElementTypeButton
   name, label: 好
nil
[2] pry(main)>

page 指令背后的细节 (appium log)

[HTTP] --> GET /wd/hub/session/136bbab8-78e5-4e5d-9cd1-0b174eeaa835/context {}
[debug] [MJSONWP] Calling AppiumDriver.getCurrentContext() with args: ["136bbab8-78e5-4e5d-9cd1-0b174eeaa835"]
[debug] [XCUITest] Executing command 'getCurrentContext'
[debug] [MJSONWP] Responding to client with driver.getCurrentContext() result: "NATIVE_APP"
[HTTP] <-- GET /wd/hub/session/136bbab8-78e5-4e5d-9cd1-0b174eeaa835/context 200 7 ms - 84 
[HTTP] --> GET /wd/hub/session/136bbab8-78e5-4e5d-9cd1-0b174eeaa835/context {}
[debug] [MJSONWP] Calling AppiumDriver.getCurrentContext() with args: ["136bbab8-78e5-4e5d-9cd1-0b174eeaa835"]
[debug] [XCUITest] Executing command 'getCurrentContext'
[debug] [MJSONWP] Responding to client with driver.getCurrentContext() result: "NATIVE_APP"
[HTTP] <-- GET /wd/hub/session/136bbab8-78e5-4e5d-9cd1-0b174eeaa835/context 200 4 ms - 84 
[HTTP] --> GET /wd/hub/session/136bbab8-78e5-4e5d-9cd1-0b174eeaa835/source {}
[debug] [MJSONWP] Calling AppiumDriver.getPageSource() with args: ["136bbab8-78e5-4e5d-9cd1-0b174eeaa835"]
[debug] [XCUITest] Executing command 'getPageSource'
[debug] [JSONWP Proxy] Proxying [GET /source/xml] to [GET http://localhost:8100/session/AC8C1ADF-3E96-4C55-9302-73B4D7AA6B89/source/xml] with no body
[debug] [JSONWP Proxy] Got response with status 200: "{\n  \"value\" : {\n    \"tree\" : \"<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?>\\n<XCUIElementTypeApplication type=\\\"XCUIElementTypeApplication\\\" name=\\\" \\\" label=\\\" \\\" visible=\\\"true\\\" enabled=\\\"true\\\" x=\\\"0\\\" y=\\\"0\\\" width=\\\"375\\\" height=\\\"667\\\">\\n  <XCUIElementTypeWindow type=\\\"XCUIElementTypeWindow\\\" visible=\\\"false\\\" enabled=\\\"true\\\" x=\\\"0\\\" y=\\\"0\\\" width=\\\"375\\\" height=\\\"667\\\">\\n    <XCUIElementTypeOther type=\\\"XCUIElementTypeOther\\\" visible=\\\"false\\\" enabled=\\\"true\\\" x=\\\"0\\\" y=\\\"0\\\" width=\\\"375\\\" height=\\\"667\\\"\\/>\\n    <XCUIElementTypeOther type=\\\"XCUIElementTypeOther\\\" visible=\\\"false\\\" enabled=\\\"true\\\" x=\\\"0\\\" y=\\\"0\\\" width=\\\"375\\\" height=\\\"667\\\"\\/>\\n  <\\/XCUIElementTypeWindow>\\n  <XCUIElementTypeWindow type=\\\"XCUIElementTypeWindow\\\" visible=\\\"false\\\" enabled=\\\"true\\\" x=\\\"0\\\" y=\\\"0\\\" width=\\\"375\\\" height=\\\"667\\\">\\n    <XCUIElementType...
[debug] [MJSONWP] Responding to client with driver.getPageSource() result: "<?xml version=\"1.0\" encoding=\"UTF-8\"?><AppiumAUT><XCUIElementTypeApplication type=\"XCUIElementTypeApplication\" name=\" \" label=\" \" visible=\"true\" enabled=\"true\" x=\"0\" y=\"0\" width=\"375\" height=\"667\">\n  <XCUIElementTypeWindow type=\"XCUIElementTypeWindow\" visible=\"false\" enabled=\"true\" x=\"0\" y=\"0\" width=\"375\" height=\"667\">\n    <XCUIElementTypeOther type=\"XCUIElementTypeOther\" visible=\"false\" enabled=\"true\" x=\"0\" y=\"0\" width=\"375\" height=\"667\"/>\n    <XCUIElementTypeOther type=\"XCUIElementTypeOther\" visible=\"false\" enabled=\"true\" x=\"0\" y=\"0\" width=\"375\" height=\"667\"/>\n  </XCUIElementTypeWindow>\n  <XCUIElementTypeWindow type=\"XCUIElementTypeWindow\" visible=\"false\" enabled=\"true\" x=\"0\" y=\"0\" width=\"375\" height=\"667\">\n    <XCUIElementTypeOther type=\"XCUIElementTypeOther\" visible=\"false\" enabled=\"true\" x=\"0\" y=\"0\" width=\"375\" height=\"667\"/>\n  </XCUIElementTypeWindow>\n  <XCUIElementTypeWindow type=\"XCUIElementTypeWin...
[HTTP] <-- GET /wd/hub/session/136bbab8-78e5-4e5d-9cd1-0b174eeaa835/source 200 422 ms - 14307

点击“好”，或直接在 arc 中输入 alert_accept 回车，关闭对话框

4. 测试指令

4.1 page

page 用于查看当前视图中有哪些元素，并以行文本形式输出

[2] pry(main)> alert_accept
{}
[3] pry(main)> page
XCUIElementTypeApplication
   name, label: TestApp
XCUIElementTypeTextField
   name: IntegerA
  label: TextField1
XCUIElementTypeTextField
   name: IntegerB
  label: TextField2
XCUIElementTypeButton
   name: ComputeSumButton
  label: Compute Sum
XCUIElementTypeStaticText
   name: Answer
  label: SumLabel
  value: SumLabel
XCUIElementTypeButton
   name, label: show alert
XCUIElementTypeButton
   name, label: contact alert
XCUIElementTypeButton
   name, label: location alert
XCUIElementTypeStaticText
   name, label, value: AppElem
XCUIElementTypeSlider
   name, label: AppElem
   value: 50%
XCUIElementTypeStaticText
   name: Accessibility
XCUIElementTypeStaticText
   name, label, value: AppElem
XCUIElementTypeButton
   name: DisabledButton
  label: disabled button
XCUIElementTypeSwitch
   name, label: locationStatus
   value: 0
XCUIElementTypeButton
   name, label: Test Gesture
XCUIElementTypeButton
   name, label: Crash
XCUIElementTypeOther
   name, label: 3 of 3 Wi-Fi bars
   value: SSID
XCUIElementTypeOther
   name, label: 下午7:48
XCUIElementTypeOther
   name, label: -100% battery power
nil
[4] pry(main)>

测试应用为 TestApp

XCUIElementTypeApplication name, label: TestApp

第一个输入框，类型为 XCUIElementTypeTextField, name (id) 为 IntegerA 文本标签 TextField1

XCUIElementTypeTextField name: IntegerA label: TextField1

....

4.2 source

source 作用同 Page source 返回个是 XML 的文档格式。

4.3 查找元素 (find_element, find, id, xpath ...)

Ref: https://github.com/appium/ruby_lib/blob/master/docs/docs.md

Appium Ruby Lib（SeleniumDriver）真正提供的查找元素的方法是

find_element - 查找单个元素，如果有多个满足条件的，返回第一个。如果一个都没有，报错。
find_elements - 查找多个元素，并以数组形式返回。没找到，返回空数组 []。

其他的方法（find, id, xpath ...)，都是语法糖。

语法糖	对应 find_element(s)
id('comp_id')	find_element(:id, 'comp_id')
buttons	find_elements(:class, 'XCUIElementTypeButton')
button(index)	=> buttons[index]
texts	find_elements(:class, 'XCUIElementTypeStaticText')
text(index)	=> texts[index]
textfields	find_elements(:class, 'XCUIElementTypeTextField')
textfield[index]	=> textfields[index]
xpath('xpath_expr')	find_element(:xpath, 'xpath_expr')
xpaths('xpath_expr')	find_elements(:xpath, 'xpath_expr)
finds('text')	find_elements(:xpath, "(//)[@[contains(translate(., \"Text\", \"text\"), \"text\")]]"
find('text')	=> finds('text')[0]

基于性能考虑，建议尽量使用 id 查找元素，find/finds 的性能最差。

4.4 对元素执行动作

拿到一个元素 e 之后，我们就是直接访问属性或发送动作。

e.name # button, text
e.value # secure, textfield
e.type 'some text' # type text into textfield
e.clear # clear textfield
e.tag_name # calls .type (patch.rb)
e.text
e.size
e.location
e.rel_location
e.click
e.send_keys 'keys to send'
e.set_value 'value to set' # ruby_console specific
e.displayed? # true or false depending if the element is visible
e.selected? # is the tab selected?
e.attribute('checked') # is the checkbox checked?

这些属性和动作的背后，都是发送指令到 appium，可以直接在 appium 运行日志中看到每个请求的具体细节。

有一点需要注意的是，e.click 背后的实现是，先获取 e 的屏幕坐标，然后向该坐标发送触碰事件，并不是说能够直接控制 e 触发点击事件。因此，如果 e 被其他控件（如键盘）遮住，则触碰事件实际是其他控件接受了。这个着实坑了我们一把。

以后有时间再接着第一篇说说我们是如何改进测试用例，把 steps 模版化。

敏捷实践 (2) - appium 支持与无法支持的测试

edwardzhou — Mon, 07 Aug 2017 09:04:17 +0800

http://www.jianshu.com/p/c3f0d0684eef

1. 简介

在探索 App 自动化测试工具过程中，主要接触了 Macaca 和 Appium, 已及稍稍看了点 Calabash。

其中，Calabash 与 Appium 都支持使用 Cucumber 编写测试用例。由于精力有限，Calabash 没有更进一步研究，有兴趣的朋友可以看看，交流一下心得。

Macaca 在敏捷实践 - 我们是如何自动化 App 验收标准（一）一文中有提到过，是我的前端小伙伴 Lorne 向我推荐的，看了文档，也装上试了试，不得不说 Macaca 非常优秀，上手非常容易，同时支持 NodeJS 与 Python 与 Java 三大主流语言。就是文档稍有些少。推荐大家试试。

Appium 是个非常优秀的 App 自动化测试工具，支持的语言比 Macaca 多一些。让我选择 Appium 而不是 Macaca 的关键因数并非所支持语言的多少，而是 Appium 支持用 Ruby+Cucumber 来写测试用例，简直就像为我们量身定造。没错，我最喜欢用的语言首选 Ruby，其次 NodeJS/Python，再之 Java。

我们的测试用例起步于 appium sample-code 中的 ruby 部分，强烈推荐大家去翻翻代码。

2. Appium

Appium 的详细介绍信息可以参考在线文档，在这里我并不打算太多重复，而且网上也有不少教程了，只想概要的说明一下它是如何工作的。

2.1 Appium 的体系结构

Appium 是用 NodeJS 写的一个 HTTP 服务，因此使用它需要先安装 NodeJS。它又是通过 WebDriverAgent 组件在移动设备中控制被测试应用执行测试指令。

2.2 工作流程图

注意，这个流程图并非官方图，只是我随手画的帮助大家理解的示意图。

测试脚本与 Appium 与被测试的 APP 是分别各自独立的进程，甚至分署在不同的主机与真实设备中。

测试的执行过程为

1). 测试脚本调用appium_lib提供的方法, 如 find, click
2). appium_lib调用转给Selenium WebDriver的Remote Adapter
3). Selenium WebDriver将请求封装为JSON，以HTTP Rest协议向Appium发送请求
4). Appium收到HTTP请求后，将请求交给相应的AppiumDriver
5). AppiumDriver通过HTTP向运行在终端设备上的WebDriverAgent进程(后台app)发送请求
6). 设备上的WebDriverAgent解析请求后，通过XCUITest测试套件与目标测试App交互，并获取结果
7). WebDriverAgent将结果由HTTPResponse返回给Appium
8). Appium再将结果进行包装处理后，由HTTPResponse返回给3)的Selenium WebDriver
9). Selenium WebDriver再将结果转换成Ruby对象返回给测试脚本。

2.3 Appium 常用指令

官方已经有了非常完整的文档，我也就不再重复或做些翻译工作了。 Ruby 语言请移步 https://github.com/appium/ruby_lib/blob/master/docs/docs.md

Example use of Appium's mobile gesture.

@driver.find_element()

console.rb uses some code from simple_test.rb and is released under the same license as Appium. The Accessibility Inspector is helpful for discovering button names and textfield values.

Long click on an ImageView in Android.

last_image = find_elements(:tag_name, :ImageView).last
long_press(element: last_image)

Rotate examples.

driver.rotate :landscape
driver.rotate :portrait

status["value"]["build"]["revision"] Discover the Appium rev running on the server.
driver.keyboard.send_keys "msg" Sends keys to currently active element

generic

source Prints a JSON view of the current page.
page Prints the content descriptions and text values on the current page.
page_class Prints the classes found on the current page.
(Element) find(value) Returns the first element that contains value.
(Element) finds(value) Returns all elements containing value (iOS only for now).
(Element) name(name) Returns the first element containing name. Android name is the content description. iOS uses accessibility label with a fallback to text.
(Array<Element>) names(name) Returns all elements containing name.
(Element) text(text) Returns the first element containing text.
(Array<Element>) texts(text) Returns all elements containing text.
current_app Returns information about the current app. Android only.

alert

(void) alert_accept Accept the alert.
(String) alert_accept_text Get the text of the alert's accept button.
(void) alert_click(value) iOS only Tap the alert button identified by value.
(void) alert_dismiss Dismiss the alert.
(String) alert_dismiss_text Get the text of the alert's dismiss button.
(String) alert_text Get the alert message text.

button

(Button) button(index) Find a button by index.
(Button) button(text) Get the first button that includes text.
(Array<String>, Array<Buttons>) buttons(text = nil) Get an array of button texts or button elements if text is provided.
(Array<Button>) buttons(text) Get all buttons that include text.
(Button) first_button Get the first button element.
(Button) last_button Get the last button element.

textfield

(Textfield) textfield(index) Find a textfield by index.
(Array<Textfield>) textfields Get an array of textfield elements.
(Textfield) first_textfield Get the first textfield element.
(Textfield) last_textfield Get the last textfield element.
(Textfield) textfield_exact(text) Get the first textfield that matches text.
(Textfield) textfield(text) Get the first textfield that includes text.

text

The Static Text methods have been prefixed with s_ to avoid conflicting with the generic text methods.

(Text) text(index) Find a text by index.
(Array<Text>) texts Get an array of text elements.
(Text) first_text Get the first text element.
(Text) last_text Get the last text element.
(Text) text_exact(text) Get the first element that matches text.
(Text) text(text) Get the first textfield that includes text.

window

(Object) window_size Get the window's size.

e.name # button, text
e.value # secure, textfield
e.type 'some text' # type text into textfield
e.clear # clear textfield
e.tag_name # calls .type (patch.rb)
e.text
e.size
e.location
e.rel_location
e.click
e.send_keys 'keys to send'
e.set_value 'value to set' # ruby_console specific
e.displayed? # true or false depending if the element is visible
e.selected? # is the tab selected?
e.attribute('checked') # is the checkbox checked?


# alert example without helper methods
alert = $driver.switch_to.alert
alert.text
alert.accept
alert.dismiss

# Secure textfield example.
#
# Find using default value
s = textfield 'Password'
# Enter password
s.send_keys 'hello'
# Check value
s.value == ios_password('hello'.length)

Driver

start_driver will restart the driver.

x will quit the driver and exit Pry.

execute_script calls $driver.execute_script

find_element calls $driver.find_element

find_elements calls $driver.find_elements

no_wait will set implicit wait to 0. $driver.manage.timeouts.implicit_wait = 0

set_wait will set implicit wait to default seconds. $driver.manage.timeouts.implicit_wait = default

set_wait(timeout_seconds) will set implicit wait to desired timeout. $driver.manage.timeouts.implicit_wait = timeout

.click to tap an element. .send_keys to type on an element.

Raw UIAutomation

execute_script "au.lookup('button')[0].tap()" is the same as execute_script 'UIATarget.localTarget().frontMostApp().buttons()[0].tap()'

See app.js for more au methods. Note that raw UIAutomation commands are not officially supported.

Advanced au.

In this example we lookup two tags, combine the results, wrap with $, and then return the elements.

s = %(
var t = au.lookup('textfield');
var s = au.lookup('secure');
var r = $(t.concat(s));
au._returnElems(r);
)

execute_script s

XPath(UIAutomation)

See #194 for details.

find_element  :xpath, 'button'
find_elements :xpath, 'button'

find_element  :xpath, 'button[@name="Sign In"]'
find_elements :xpath, 'button[@name="Sign In"]'

find_element  :xpath, 'button[contains(@name, "Sign In")]'
find_elements :xpath, 'button[contains(@name, "Sign")]'

find_element :xpath, 'textfield[@value="Email"]'
find_element :xpath, 'textfield[contains(@value, "Email")]'

find_element  :xpath, 'text[contains(@name, "Reset")]'
find_elements :xpath, 'text[contains(@name, "agree")]'

3. Appium 支持与无法支持的测试

在 2.2 中，可以看到测试代码并不能直接访问被测试的 App 已及它的控件。因此能测试的也就是 XCUITest (iOS) 套件所支持的方法与属性。

支持的测试： 查找元素，获取 name value type text size location enabled? displayed? selected？等属性，或者发送点击事件，为文本框输入文字。

这些基本上都属于功能性测试，可以用来操作输入框，点击按钮，查找某段文字是否存在。

如

1) 打开登录页面
2) 找到 “用户名” 输入框，输入 test@test.com
3) 找到 “密码” 输入框， 输入 123456
4) 找到 “登录” 按钮，向它发生点击事件
5) 登录成功，检查用户是否处于主页面

传送门 https://github.com/appium/sample-code/blob/master/sample-code/examples/ruby/simple_test.rb

# GETTING STARTED
# -----------------
# This documentation is intended to show you how to get started with a
# simple Appium & appium_lib test.  This example is written without a specific
# testing framework in mind;  You can use appium_lib on any framework you like.
#
# INSTALLING RVM
# --------------
# If you don't have rvm installed, run the following terminal command
#
# \curl -L https://get.rvm.io | bash -s stable --ruby
#
# INSTALLING GEMS
# ---------------
# Then, change to the example directory:
#   cd appium-location/sample-code/examples/ruby
#
# and install the required gems with bundler by doing:
#   bundle install
#
# RUNNING THE TESTS
# -----------------
# To run the tests, make sure appium is running in another terminal
# window, then from the same window you used for the above commands, type
#
# bundle exec ruby simple_test.rb
#
# It will take a while, but once it's done you should get nothing but a line
# telling you "Tests Succeeded";  You'll see the iOS Simulator cranking away
# doing actions while we're running.
require 'rubygems'
require 'appium_lib'

APP_PATH = '../../apps/TestApp/build/release-iphonesimulator/TestApp.app'

desired_caps = {
  caps:       {
    platformName:  'iOS',
    versionNumber: '8.1',
    deviceName:    'iPhone 6',
    app:           APP_PATH,
  },
  appium_lib: {
    sauce_username:   nil, # don't run on Sauce
    sauce_access_key: nil
  }
}

# Start the driver
Appium::Driver.new(desired_caps).start_driver

module Calculator
  module IOS
    # Add all the Appium library methods to Test to make
    # calling them look nicer.
    Appium.promote_singleton_appium_methods Calculator

    # Add two numbers
    values       = [rand(10), rand(10)]
    expected_sum = values.reduce(&:+)

    # Find every textfield.
    elements     = textfields

    elements.each_with_index do |element, index|
      element.type values[index]
    end

    # Click the first button
    button(1).click

    # Get the first static text field, then get its text
    actual_sum = first_text.text
    raise unless actual_sum == (expected_sum.to_s)

    # Alerts are visible
    button('show alert').click
    find_element :class_name, 'UIAAlert' # Elements can be found by :class_name

    # wait for alert to show
    wait { text 'this alert is so cool' }

    # Or by find
    find('Cancel').click

    # Waits until alert doesn't exist
    wait_true { !exists { tag('UIAAlert') } }

    # Alerts can be switched into
    wait { button('show alert').click } # Get a button by its text
    alert         = driver.switch_to.alert # Get the text of the current alert, using
    # the Selenium::WebDriver directly
    alerting_text = alert.text
    raise Exception unless alerting_text.include? 'Cool title'
    alert_accept # Accept the current alert

    # Window Size is easy to get
    sizes = window_size
    raise Exception unless sizes.height == 667
    raise Exception unless sizes.width == 375

    # Quit when you're done!
    driver_quit
    puts 'Tests Succeeded!'
  end
end

提醒，由于 sample-code 中的 TestApp 比较老了，上面的测试代码直接跑，是会失败的。这个是很隐晦的问题导致，新版模拟器 (eg. iPhone 6 (iOS 10.0x)), 在运行这个 app 是，会自动弹出一个告警信息，说“TestApp 使用老版本编译的，会影响系统系能，建议用新 xcode 重新编译”。就是这个 alert 框，导致测试脚本找不到相应的控件而失败。

这个事情一开始也卡了我很久，为什么测试用例会通不过？后来是在用 Appium Ruby Console 的时候找到的。

解决方式有两个：一、重新编译 TestApp;

二、测试代码在“ # Add two numbers”前加入 sleep(10) 暂停 10 秒，让你有机会点击 alert 上的 OK 按钮，关掉对话框。

当时不想多事，选择了二。现在想想，应该还有三：就是把 sleep 换成 alert_accept 来关掉对话框。有兴趣的可以自己试试。

无法支持的测试： 首先，测试脚本无法直接访问被测对象，其次，来之于上面 XCUITest 的限制，关于控件有无边框，控件状态，动画效果，字体变化，颜色，对齐等视觉效果，我们是无法测试的。

关于这一点，stackoverflow 上也有老外在吐槽： http://stackoverflow.com/questions/31250941/xcuielement-obtain-image-value

http://www.danielhall.io/exploring-the-new-ui-testing-features-of-xcode-7

如，

a) 文章的标题需要根据不同的状态，用红色，黑色，灰色等不同的颜色展示。

b) 当点击“上传”按钮后，头像 Image 应当加载新的头像地址。

这种测试通常就属于无法用自动化来检验的。

尤其是我们的 App 是用 React Native 开发的，给我们的测试用例带来了更多的限制与挑战。

4. 解决方案

自动化测试更多的是在功能性上，流程性上的测试起作用，基本能覆盖了 80%～90% 的功能性测试范围。

对于自动化不好做的 AC，我们的处理方式很简单，把它们放到人工测试的范围去，当环境、需求、技术发生变化了，能自动化测试了，再自动化，不要太去纠结。

最后，自动化测试并不能代替一切，也无法覆盖所有的地方。 它的最大价值在于使得 App 的开发也能够持续集成。极大的降低了全回归的成本与工作量。

敏捷实践 (1) - 我们是如何自动化 App 验收标准

edwardzhou — Mon, 07 Aug 2017 09:00:05 +0800

简书：http://www.jianshu.com/p/fd17c1bb6806

1. 问题背景

Scrum 敏捷过程对交付质量有着严格的要求：零缺陷的增量发布。

要做到这一点意味着每个迭代发布都必须对 AC (Acceptance Criteria - 验收标准) 进行全回归，随着迭代中增量交付的增加，全回归的工作量与所需的时间也随之增加。

我们在做 APP 开发过程中，app 开发人员 告诉我这 app 自动化测试搞不了，测试人员 也说，不好搞，很麻烦，而且还得靠录屏，blablabla.......

结果测试工作往往只能依赖人手进行测试，AC 要靠人手来全回归测试，就会发生这样一种情景：

通常一个迭代的周期为两周 10 个工作日。

迭代 1，计划完成 5 个功能，相应的 AC 也就不多，如果 1 天就能全部回归，那么开发有 9 天时间来实现功能。
迭代 2，计划完成 4 个功能，相应的 AC 加上迭代 1 的 AC，需要 2 天才能全部回归，那么开发有 8 天的时间来实现功能。
迭代 3，计划完成 3 个功能，相应的 AC 加上两个迭代的 AC，可能需要 3 天才能全部回归，那么开发有 7 天的时间来实现功能。
...

每次迭代 AC 全回归的所需的时间在不断增加，而能用于开发的时间不断在受到挤压而减少，能交付的功能也就不断在减少。

要质量就没速度，如此还能敏捷的起来吗？
不少团队 (包括我们) 采用了牺牲交付质量 (仅部分回归甚至无回归) 来确保开发进度，这样做既不符合敏捷过程的价值观，实际上也没有达到交付目标。
还有一个土豪的做法，就是增配测试。

我们一直在探索这个问题的解决方案，既想确保增量发布的速度，又想拥有交付质量。只能想办法把 AC 自动化起来，全回归就不需要占用太多人手，而且还能随时进行，所需要的时间也大大缩短。

2. 解决方案

在 2017 年 1 月份的 ScrumMaster 培训课中，聊起 App 自动化测试有什么工具，便有小伙伴提了一下 Appium。回来后便查资料研究，发现有两个非常不错的自动化工具，一个就是 Appium，另一个是阿里系的 Macaca。这里不得不说，Macaca 做的很不错，javascript 写测试也相对容易上手。

然而，做了对比后，我决定还是选用 Appium。原因很简单，Appium 支持 Ruby 和 Cucumber，我们的后端正好是用 RubyOnRails 写的，后端开发人员已经在写后端过程中积累了许多编写自动化测试用例的经验。正好也可以来写 app 的自动化测试。

2.1 环境准备

以下内容的运行环境为 MacOS 10.12 + Ruby 2.3.3 + NodeJS 7.x。至于如何安装 Ruby 和 NodeJS，这个应当为基本技能，请自行搞定。

请不要问我如何在 Windows 上去搭建环境的有关问题，我只会建议要么白苹果，要么黑苹果，要么 Ubuntu (不支持 iOS)。要么走您。

由于 npmjs.org rubygems.org 都在国外，访问速度慢且不稳定，建议先搭好梯子，或者改用国内的源。

2.1.1 Appium 1.6.3 安装

npm -g appium
npm -g appium-doctor
# ios还需要安装两个工具 ios-deploy 用于安装app到真机；Carthage 用于安装app到模拟器
brew install carthage
brew install ios-deploy
# brew 是个什么鬼，如何安装的？没什么技术含量，请自行baidu

# 完成后可以运行appium-doctor诊断一下环境是否正常
# 如果没有android需求的，可以不用管 JAVA_HOME 与 android adb 等错误
appium-doctor

一切正常会得到类似这个信息

2.1.2 安装 Appium 的 Ruby 驱动，和 appium ruby console

gem install appium_lib
gem install appium_console

至此，环境准备工作已经完成。

2.2 编写自动化测试用例

测试用例采用 Cucumber 方式编写，Feature 对应用户故事，Scenario 对应 AC。一个 Feature 包含多个 Scenarios。一个用户故事有多个 AC 验收标准。

至于 Cucumber, 有空我会再写一个文章。目前请先自行 baidu 之。

2.2.1 创建目录

mkdir app_test
cd app_test
# 创建测试用例目录
mkdir features 
# 创建测试用例步骤目录
mkdir features/steps
# 创建支持目录
mkdir features/support

2.2.2 准备 Ruby Cucumber 的 Gemfile

$ cat Gemfile

source 'https://gems.ruby-china.org'

gem 'appium_lib',         '~> 9.3.0'
gem 'rest-client',        '~> 1.6.7'
gem 'rspec',              '~> 2.14.1'
gem 'cucumber',           '~> 1.3.15'
gem 'rspec-expectations', '~> 2.14.5'
gem 'spec',               '~> 5.3.4'
gem 'sauce_whisk',        '~> 0.0.13'
gem 'test-unit',          '~> 2.5.5' # required for bundle exec ruby xunit_android.rb

安装 gem 包

bundle install

2.2.3 cucumber env

$ cat features/support/env.rb

# This file provides setup and common functionality across all features.  It's
# included first before every test run, and the methods provided here can be 
# used in any of the step definitions used in a test.  This is a great place to
# put shared data like the location of your app, the capabilities you want to
# test with, and the setup of selenium.

require 'rspec/expectations'
require 'appium_lib'
require 'cucumber/ast'
require 'sauce_whisk'

# Create a custom World class so we don't pollute `Object` with Appium methods
class AppiumWorld
end

# Load the desired configuration from appium.txt, create a driver then
# Add the methods to the world
caps = Appium.load_appium_txt file: File.expand_path('./', __FILE__), verbose: true

Appium::Driver.new(caps)
Appium.promote_appium_methods AppiumWorld

World do
  AppiumWorld.new
end

# 结束时，推出驱动
at_exit { $driver.driver_quit }

# 在运行标有@reset_driver的Scenario前重启驱动
Before("@reset_driver") do
  $driver.restart
end

2.2.4 appium 配置文件 appium.txt

关于 appium.txt 配置说明可以参考文档 appium-server-capabilities

$ cat features/support/appium.txt

[caps]
platformName = "ios"
deviceName = "iPhone 6s"
platformVersion = "10.2"
app = '../ios/build/Build/Products/Debug-iphonesimulator/PuKe.app'
automationName = 'XCUITest'
language = 'zh'
locale = 'zh_CN'

[appium_lib]
sauce_username = false
sauce_access_key = false

2.3 编写测试用例

每一用户故事的测试用例编写为一个 feature。

2.3.1 编写邮箱登陆用户故事的 AC

邮箱登陆用户故事只是登陆故事中的其中一个，故事 ID US004

$cat features/US004_login_by_email.feature

Feature: US_004 邮箱登录
  为了正常使用需要登录身份的功能
  作为一个已经用邮箱注册过的用户
  我想要用邮箱和密码登录系统

  @reset_driver
  Scenario: AC_US004_02 登录错误: 正确邮箱+错误密码登录
    Given 我已经用邮箱 test_user@mytest.com 与密码 test123 注册过账号
    When 我在 "主页面" 点击 "登录/注册" 进入 "登录页面"
    And 我在 "邮箱或手机" 输入 "test_user@mytest.com"
    And 我在 "密码" 输入 "b123456"
    And 我按下按钮 "登录"
    Then 我应当看到浮动提示 "用户密码不匹配"

  Scenario: AC_US004_03 登录错误: 没有输入用户名和密码
    Given 我已经用邮箱 test_user@mytest.com 与密码 test123 注册过账号
    And 我在 "邮箱或手机" 输入 ""
    When 我在 "密码" 输入 ""
    And 我按下按钮 "登录"
    Then 我应当看到浮动提示 "请填写完整"

  Scenario: AC_US004_04 登录错误: 输入用户名没有输入密码
    Given 我已经用邮箱 test_user@mytest.com 与密码 test123 注册过账号
    And 我在 "邮箱或手机" 输入 "test_user@mytest.com"
    And 我在 "密码" 输入 ""
    When 我按下按钮 "登录"
    Then 我应当看到浮动提示 "请填写完整"

  Scenario: AC_US004_01 正常邮箱+密码登录
    Given 我已经用邮箱 test_user@mytest.com 与密码 test123 注册过账号
    When 我在 "邮箱或手机" 输入 "test_user@mytest.com"
    And 我在 "密码" 输入 "test123"
    And 我按下按钮 "登录"
    Then 我应当到达 "主页面"
    And 等待 2 秒后退出

2.3.2 为 feature 编写相应的 steps

Scenario 中的每个 Given When Then And 都在 steps.rb 中有对应的定义。

$ cat features/step_definitions/steps.rb

# These are the 'step definitions' which Cucumber uses to implement features.
#
# Each step starts with a regular expression matching the step you write in
# your feature description.  Any variables are parsed out and passed to the
# step block.
#
# The instructions in the step are then executed with those variables.
#
# In this example, we're using rspec's assertions to test that things are happening,
# but you can use any ruby code you want in the steps.
#
# The '$driver' object is the appium_lib driver, set up in the cucumber/support/env.rb
# file, which is a convenient place to put it as we're likely to use it often.
# This is a different use to most of the examples;  Cucumber steps are instances
# of `Object`, and extending Object with Appium methods (through 
# `promote_appium_methods`) is a bad idea.
#
# For more on step definitions, check out the documentation at
# https://github.com/cucumber/cucumber/wiki/Step-Definitions
#
# For more on rspec assertions, check out
# https://www.relishapp.com/rspec/rspec-expectations/docs

Given(/^我已经用邮箱 (.*) 与密码 (.*) 注册过账号$/) do |email, password|
  # sleep(1)
  puts "DEBUG: email: #{email}"
  puts "DEBUG: password: #{password}"
end

When(/^我在 "主页面" 点击 "登录\/注册" 进入 "登录页面"$/) do
  # 等待主页面就绪, 主页面ID 为 home_page
  wait { id('home_page') }
  # 点击 主页面中的 '登录/注册' 按钮，按钮ID为 btn_to_login
  id('btn_to_login').click

  # 检查页面跳转到 登录页面， 登录页面ID为 page_login_account
  wait { id('page_login_account') }
end

When(/^我在 "(.*?)" 输入 "(.*?)"$/) do |input_field, input_value|
  input_id = case input_field
               when '邮箱或手机'
                 'input_username'
               when '密码'
                 'input_password'
               else
                 'unknown'
             end
  input_box = id(input_id)           # 定位指定的输入框
  input_box.clear                    # 清除原来的内容
  input_box.type "#{input_value}\n"  # 输入新内容并回车
end

And(/^我按下按钮 "登录"$/) do
  id('btn_login').click
end

Then(/^我应当看到浮动提示 "(.+)"$/) do |msg|
  msg.strip!
  puts "DEBUG: 期待 #{msg}"
  wait { find(msg) }
end

Then(/^我应当到达 "主页面"$/) do
  wait { id('home_page') }
end

And(/^等待 (\d+) 秒后.*/) do |seconds|
  sleep(seconds.to_i)
end

3. 运行测试用例

3.1 运行 Appium

运行测试用例前必须先启动 appium, 新打开一个命令行窗口 $ appium

3.2 运行测试用例

在 test_app 目录中

$ cucumber features/US004_login_by_email.feature

3.3 观看测试用例的运行录屏

3.4 示例代码参考

https://github.com/appium/sample-code/

4. 总结

抛开复杂的 appium、cucumber steps，发现没，测试用例是不是很容易理解？

Scenario: AC_US004_01 正常邮箱+密码登录
  Given 我已经用邮箱 test_user@mytest.com 与密码 test123 注册过账号
  When 我在 "邮箱或手机" 输入 "test_user@mytest.com"
  And 我在 "密码" 输入 "test123"
  And 我按下按钮 "登录"
  Then 我应当到达 "主页面"
  And 等待 2 秒后退出

像上面的 AC，就算是非技术人员也能分分钟写出来，我们的产品经理、UI 设计师都在参与编写 AC，这就是我们选择 cucumber ruby 的根本原因。

本来打算一篇写完的，写着写着，发现要写的内容太多了，决定还是写成一个系列：

首先、用 Appium 来测试，也存在一些坑要填。
上面的 feature 和 steps，为了演示好理解，做了相当的简化。实际上，我们的 steps 经过一些重构，变得很通用灵活，后续放出来。
Appium 的配置与基本指令
辅助神器 Appium Ruby Console (ARC) 的使用
如何用 Cucumber 编写自动化测试
React-Native 类型的 APP 自动化有哪些坑需要绕过

有空的时候再接着写（二）、（三）。。。。。。