elixir官方教程Mix与OTP(八) 文档,测试与with

最新推荐文章于 2024-07-17 18:26:04 发布
最新推荐文章于 2024-07-17 18:26:04 发布
阅读量112 收藏
点赞数
文章标签： 测试 网络
原文链接：https://my.oschina.net/ljzn/blog/731448
版权

为什么80%的码农都做不了架构师？>>>   hot3.png

#文档,测试与with

  1. 文档测试
  2. with
  3. 运行命令

本章,我们将实现能够解析我们在第一章中描述的命令的代码:

CREATE shopping
OK

PUT shopping milk 1
OK

PUT shopping eggs 3
OK

GET shopping milk
1
OK

DELETE shopping eggs
OK

解析完成后,我们将更新我们的服务器来调遣解析后的命令到kv应用中.

#文档测试(Doctests)

在语言主页,我们提到Elixir将文档当做语言中的一等公民.我们已经在本教程中多次探索了这个概念,通过mix help,或输入h Enum等其他模块在IEx控制台中.

本节,我们将使用文档测试来实现解析功能,它允许我们从文档中直接编写测试.这帮助我们给文档提供精确的代码样本.

让我们在lib/kv_server/command.ex中创建命令解析器,并以文档测试开头:

defmodule KVServer.Command do
  @doc ~S"""
  Parses the given `line` into a command.

  ## Examples

      iex> KVServer.Command.parse "CREATE shopping\r\n"
      {:ok, {:create, "shopping"}}

  """
  def parse(line) do
    :not_implemented
  end
end

文档测试是在文档字符串中定义的,通过四个空格的缩进之后跟着iex>语句来指定.如果一个命令跨越多行,你可以想在IEx中一样使用...>.预期的结果应该在iex>或...>的下一行开始,并以新的行或新的iex>前缀作为结尾.

还要注意的是我们使用@doc ~S"""来开始文档字符串.~S能够避免\r\n字符被转化成回车和换行,直到它们在测试中被执行.

要运行我们的文档测试,我们会在test/kv_server/command_test.exs中创建一个文件,并在测试中调用doctest KVServer.Command:

defmodule KVServer.CommandTest do
  use ExUnit.Case, async: true
  doctest KVServer.Command
end

运行这套测试,文档测试将会失败:

1) test doc at KVServer.Command.parse/1 (1) (KVServer.CommandTest)
   test/kv_server/command_test.exs:3
   Doctest failed
   code: KVServer.Command.parse "CREATE shopping\r\n" === {:ok, {:create, "shopping"}}
   lhs:  :not_implemented
   stacktrace:
     lib/kv_server/command.ex:11: KVServer.Command (module)

很好!

现在只需要让文档测试通过就行了.让我们来实现parse/1函数:

def parse(line) do
  case String.split(line) do
    ["CREATE", bucket] -> {:ok, {:create, bucket}}
  end
end

我们的实现是简单地用空格拆分命令行,然后匹配列表中的命令.使用String.split/1意味着我们的命令将会是空格不敏感的,开头和结尾的空格是无关紧要的,单词间连续的空格也是一样.让我们添加一些新的文档测试,来测试其它命令:

@doc ~S"""
Parses the given `line` into a command.

## Examples

    iex> KVServer.Command.parse "CREATE shopping\r\n"
    {:ok, {:create, "shopping"}}

    iex> KVServer.Command.parse "CREATE  shopping  \r\n"
    {:ok, {:create, "shopping"}}

    iex> KVServer.Command.parse "PUT shopping milk 1\r\n"
    {:ok, {:put, "shopping", "milk", "1"}}

    iex> KVServer.Command.parse "GET shopping milk\r\n"
    {:ok, {:get, "shopping", "milk"}}

    iex> KVServer.Command.parse "DELETE shopping eggs\r\n"
    {:ok, {:delete, "shopping", "eggs"}}

Unknown commands or commands with the wrong number of
arguments return an error:

    iex> KVServer.Command.parse "UNKNOWN shopping eggs\r\n"
    {:error, :unknown_command}

    iex> KVServer.Command.parse "GET shopping\r\n"
    {:error, :unknown_command}

"""

现在轮到你来让测试通过!你完成之后,可以对比一下我们的解决方案:

def parse(line) do
  case String.split(line) do
    ["CREATE", bucket] -> {:ok, {:create, bucket}}
    ["GET", bucket, key] -> {:ok, {:get, bucket, key}}
    ["PUT", bucket, key, value] -> {:ok, {:put, bucket, key, value}}
    ["DELETE", bucket, key] -> {:ok, {:delete, bucket, key}}
    _ -> {:error, :unknown_command}
  end
end

注意我们是如何优雅地解析命令的,不需要添加一大堆 的if/else从句来检查命令名和参数数量!

最后,你可能会发现每个文档测试都被认为是不同的测试,因为我们这套测试最后报告了7个测试.这是因为ExUnit是这样辨认两个不同测试的定义的:

iex> KVServer.Command.parse "UNKNOWN shopping eggs\r\n"
{:error, :unknown_command}

iex> KVServer.Command.parse "GET shopping\r\n"
{:error, :unknown_command}

中间没有隔一行的话,ExUnit就会将其编译为一个测试:

iex> KVServer.Command.parse "UNKNOWN shopping eggs\r\n"
{:error, :unknown_command}
iex> KVServer.Command.parse "GET shopping\r\n"
{:error, :unknown_command}

你可以阅读ExUnit.DocTest文档来获取更多关于文档测试的内容.

#with

现在我们能够解析命令了,我们终于可以开始实现运行命令的逻辑了.让我们为这个函数添加一个存根定义:

defmodule KVServer.Command do
  @doc """
  Runs the given command.
  """
  def run(command) do
    {:ok, "OK\r\n"}
  end
end

在我们实现这个函数之前,让我们修改服务器,使其开始使用我们新的parse/1和run/1函数.记住,我们的read_line/1函数会在客户端关闭套接字时崩溃,所以让我们也抓住机会修复它.打开lib/kv_server.ex:

defp serve(socket) do
  socket
  |> read_line()
  |> write_line(socket)

  serve(socket)
end

defp read_line(socket) do
  {:ok, data} = :gen_tcp.recv(socket, 0)
  data
end

defp write_line(line, socket) do
  :gen_tcp.send(socket, line)
end

替换成:

defp serve(socket) do
  msg =
    case read_line(socket) do
      {:ok, data} ->
        case KVServer.Command.parse(data) do
          {:ok, command} ->
            KVServer.Command.run(command)
          {:error, _} = err ->
            err
        end
      {:error, _} = err ->
        err
    end

  write_line(socket, msg)
  serve(socket)
end

defp read_line(socket) do
  :gen_tcp.recv(socket, 0)
end

defp write_line(socket, {:ok, text}) do
  :gen_tcp.send(socket, text)
end

defp write_line(socket, {:error, :unknown_command}) do
  # Known error. Write to the client.
  :gen_tcp.send(socket, "UNKNOWN COMMAND\r\n")
end

defp write_line(_socket, {:error, :closed}) do
  # The connection was closed, exit politely.
  exit(:shutdown)
end

defp write_line(socket, {:error, error}) do
  # Unknown error. Write to the client and exit.
  :gen_tcp.send(socket, "ERROR\r\n")
  exit(error)
end

启动我们的服务器,现在我们可以向它发送命令.现在我们可以得到两个不同的回复:当命令已知时回复"OK",否则回复"UNKNOWN COMMAND":

$ telnet 127.0.0.1 4040
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
CREATE shopping
OK
HELLO
UNKNOWN COMMAND

这意味着我们的实现已经朝着正确的方向运行,但是这看起来不太优雅,对吗?

之前的实现使用了资源管线,使得逻辑很清晰.然而,现在我们需要处理不同的错误代码,我们的服务器逻辑嵌套在了许多case调用中.

幸运的是,Elixir v1.2引入了一个叫做with的结构,它能够简化像上面那样的代码.让我们用它来重写server/1函数吧:

defp serve(socket) do
  msg =
    with {:ok, data} <- read_line(socket),
         {:ok, command} <- KVServer.Command.parse(data),
         do: KVServer.Command.run(command)

  write_line(socket, msg)
  serve(socket)
end

好多了!明智的语法,with的理解和for很类似.with将会获取<-右边的返回值,并与左边进行模式匹配.如果匹配成功,with会进入下一个表达式.如果匹配失败,未匹配的值将会被返回.

换句话说,我们将case/2中的每个表达式转化成了with中的步骤.只要任何一步中返回值不能匹配{:ok, x},with就会跳出,并返回未匹配的值.

你可在我们的文档中获取更多关于with的信息.

#运行命令

最后一步是实现KVServer.Command.run/1,来使:kv应用运行解析后的命令.它的实现如下所示:

@doc """
Runs the given command.
"""
def run(command)

def run({:create, bucket}) do
  KV.Registry.create(KV.Registry, bucket)
  {:ok, "OK\r\n"}
end

def run({:get, bucket, key}) do
  lookup bucket, fn pid ->
    value = KV.Bucket.get(pid, key)
    {:ok, "#{value}\r\nOK\r\n"}
  end
end

def run({:put, bucket, key, value}) do
  lookup bucket, fn pid ->
    KV.Bucket.put(pid, key, value)
    {:ok, "OK\r\n"}
  end
end

def run({:delete, bucket, key}) do
  lookup bucket, fn pid ->
    KV.Bucket.delete(pid, key)
    {:ok, "OK\r\n"}
  end
end

defp lookup(bucket, callback) do
  case KV.Registry.lookup(KV.Registry, bucket) do
    {:ok, pid} -> callback.(pid)
    :error -> {:error, :not_found}
  end
end

这个实现很简单:我们只需要派遣到KV.Registry服务器,它是我们在:kv应用启动时注册的.因为我们的:kv_server依赖于:kv应用,所以完全可以依赖它所提供的服务器/服务.

注意到我们也定义了一个名为lookup/2的私有函数来完成一个常用功能:搜索桶,如果存在就返回它的pid,否则返回{:error, :not_found}.

此外,由于我们现在返回的是{:error, :not_found},我们应该修改KV.Server中的write_line/2函数使之也能来打印这个错误:

defp write_line(socket, {:error, :not_found}) do
  :gen_tcp.send(socket, "NOT FOUND\r\n")
end

我们的服务器功能基本完成了!我们只需要添加测试.这一次,我们把测试留到最后,因为有一些重要的决定要做.

KVServer.Command.run/1的实现是直接发送命令到由:kv应用注册的KV.Registry服务器.这意味着这个服务器是全局的,如果我们有两个测试同时发送信息给它,我们的测试将会相互冲突(很可能失败).我们需要决定是使用相互独立且能同步运行的单元测试,还是运行在全局状态顶部的集成测试,但是每次测试就要调用应用的全栈.

目前我们只写过单元测试,而且是直接测试单个模块.然而,为了使KVServer.Command.run/1能像一个单元一样被测试,我们需要改变它的实现,不再直接发送命令到KV.Registry进程,而是传送一个作为参数的服务器.这意味着我们需要改变run的签名到def run(command, pid),以及对:create命令的实现:

def run({:create, bucket}, pid) do
  KV.Registry.create(pid, bucket)
  {:ok, "OK\r\n"}
end

当对KVServer.Command进行测试时,我们需要启动一个KV.Registry的实例,类似于我们在apps/kv/test/kv/registry_test.exs中做的那样,并将其作为一个参数传送给run/2.

这已经成为我们一直在测试中使用的方法,它的优点是:

\1. 我们的实现不会与任何特定的服务器名耦合 \2. 我们可以保持同步运行测试,因为这里没有共用状态

然而,它的缺点是我们的API为了容纳所有的外部参数而变得非常大.

替代方案是编写集成测试,它依赖于全局服务器名来使用整个堆栈,从TCP服务器到桶.集成测试的缺点是它们会比单元测试慢得多,因此它们必须节制地使用.例如,我们不应该使用集成测试在我们的命令解析实现中来测试一个边界情况.

现在我们将编写一个集成测试.集成测试会使用一个TCP客户端来发送命令到我们的服务器,并断言我们将得到预期的回复.

让我们在test/kv_server_test.exs中实现如下所示的集成测试:

defmodule KVServerTest do
  use ExUnit.Case

  setup do
    Application.stop(:kv)
    :ok = Application.start(:kv)
  end

  setup do
    opts = [:binary, packet: :line, active: false]
    {:ok, socket} = :gen_tcp.connect('localhost', 4040, opts)
    {:ok, socket: socket}
  end

  test "server interaction", %{socket: socket} do
    assert send_and_recv(socket, "UNKNOWN shopping\r\n") ==
           "UNKNOWN COMMAND\r\n"

    assert send_and_recv(socket, "GET shopping eggs\r\n") ==
           "NOT FOUND\r\n"

    assert send_and_recv(socket, "CREATE shopping\r\n") ==
           "OK\r\n"

    assert send_and_recv(socket, "PUT shopping eggs 3\r\n") ==
           "OK\r\n"

    # GET returns two lines
    assert send_and_recv(socket, "GET shopping eggs\r\n") == "3\r\n"
    assert send_and_recv(socket, "") == "OK\r\n"

    assert send_and_recv(socket, "DELETE shopping eggs\r\n") ==
           "OK\r\n"

    # GET returns two lines
    assert send_and_recv(socket, "GET shopping eggs\r\n") == "\r\n"
    assert send_and_recv(socket, "") == "OK\r\n"
  end

  defp send_and_recv(socket, command) do
    :ok = :gen_tcp.send(socket, command)
    {:ok, data} = :gen_tcp.recv(socket, 0, 1000)
    data
  end
end

我们的集成测试检查了所有的服务器接口,包括未知命令和未找到错误.因为是在处理ETS表格和链接进程,所以不必关闭套接字.一旦测试进程退出,套接字会自动关闭.

这一次,因为我们的测试依赖于全局数据,所以我们没有将async: true传送给use ExUnit.Case.而且,为了保证我们的测试始终在一个干净的状态,在每个测试之前我们停止再启动了:kv应用.事实上,停止:kv应用会在终端打印一个警告:

18:12:10.698 [info] Application kv exited: :stopped

为了避免在测试过程中打印日志,ExUnit提供了一个叫做:capture_log的干净特性.通过在每次测试前设置@tag :capture_log,或者为整个测试设置@moduletag :capture_log,在测试运行时,ExUnit会自动捕获日志中的任何东西.如果测试失败,捕获的日志会被打印在ExUnit报告旁边.

启动之前,添加如下调用:

@moduletag :capture_log

当测试崩溃时,你会看到如下报告:

1) test server interaction (KVServerTest)
   test/kv_server_test.exs:17
   ** (RuntimeError) oops
   stacktrace:
     test/kv_server_test.exs:29

   The following output was logged:

   13:44:10.035 [info]  Application kv exited: :stopped

从这个简单的集成测试中,我们可以知道为什么集成测试可能很慢.不止因为这种测试不能同步运行,还因为要求停止再启动:kv应用这种昂贵的启动配置.

最后,应当由你和你的团队来找到适用于你的应用的最好的测试策略.你需要平衡代码质量,信心,和测试套件的运行时.例如,最开始我们可能只用集成测试来测试服务器,但是如果服务器在之后的发布中持续成长,或者它成为了一个频繁发生bug的应用的一部分,那么考虑将其打碎并编写更多加强的比集成测试轻量得多的单元测试就变得非常重要.

在下一章,我们终于要通过添加一个桶路由机制来使得我们的系统成为分布式的.我们也将学习应用配置.

转载于:https://my.oschina.net/ljzn/blog/731448

weixin_34301132
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
elixir-mix-otp-guide：构建完整的Elixir应用程序的官方指南的源代码，带有自己的监视树，配置，测试等，网址为
02-05
标题和描述提到了"elixir-mix-otp-guide"，这是一个针对构建Elixir应用程序的官方指南的源代码库。Elixir是一个功能丰富的编程语言，设计用于构建可扩展、高并发和分布式系统。Mix是Elixir的构建工具，用于管理项目...
Functional Web Development With Elixir OTP and Phoenix
06-07
Functional Web Development With Elixir OTP and Phoenix
Mind Elixir思维导图使用方法
MollyL的博客
04-06 2896
Mind Elixir思维导图
Elixir 开发小技巧 持续更新 (Updated at: 2016-04-18)
weixin_34381666的博客
04-01 149
Map 的嵌套匹配 添加时间: 2016-04-30 def background_check(%{manager: employee} = company) do %{name: full_name} = employee from(c in Criminals, where: c.full_name == ^full_name...
elixir官方教程Mix与OTP(一) Mix入门
weixin_34112181的博客
08-07 535
为什么80%的码农都做不了架构师？>>> ...
elixir官方教程Mix与OTP(四) 主管与应用
weixin_33922670的博客
08-10 116
为什么80%的码农都做不了架构师？>>> ...
CentOS 7.7安装Erlang和Elixir
01-27 668
安装之前，先看一下它们的简要说明 Erlang Erlang是一种开源编程语言，用于构建对高可用性有要求的大规模可扩展的软实时系统。它通常用于电信，银行，电子商务，计算机电话和即时消息中。Erlang的runtime系统具有对并发，分发和容错的内置支持。它是在爱立信计算机科学实验室设计的。 Elixir Elixir是一种动态的功能语言，旨在用于构建可伸缩和可维护的应用程序。Elixir利用了以运行低延迟，分布式和容错系统而著称的Erlang VM，同时也成功地用于Web开发和嵌入式软件领域。 现在开始在C
Elixir
jiangbb8686的博客
11-22 631
首页 安装 指南 服务器 学习 文档 发展 博客 包 Elixir是一种函数式动态语言，用于构建可伸缩、易维护的应用程序。 Elixir是基于Erlang VM的，其广为人知的特点是运行低延时、分布式、可容错的系统，并成功用于Web开发与嵌入式软件领域。 要了解更多关于Elixir的信息，请查看我们的入门指南和学习资源. 或者继续阅读以获得平台、语言和工具的概述。...
Alchemist v1.0发布，Emacs的Elixir插件
博客
06-17 351
Elixir是一种运行于Erlang VM上的函数式、具有元编程特性的动态语言。它拥有灵活的语法和强大的宏系统，还具备模式匹配、通过协议（类似Clojure的方式）支持多态等功能；继承了Erlang的优点，尤其适合开发并行、分布式，以及高容错应用。Erlang之父Joe Armstrong也对Elixir赞赏有加。213年11月份左右，Elixir设计者José Valim接受了《程序员》专访，分...
Elixir的Ecto库简介
culi3182的博客
08-26 451
Elixir is a modern, dynamic, functional programming language used to build highly distributed and fault-tolerant applications. Ecto is its main library for working with databases, providing us with to...
基本的Elixir Api指南
编程故事的地方
03-05 705
Elixir代表了相对较新的编程语言，面向更广泛的受众。 它于2011年发布，此后一直在开发中。 他的主要特征是取消功能范式，因为它建立在Erlang之上并在BEAM（Erlang VM）上运行。 Elixir专为构建快速，可伸缩和可维护的应用程序而设计，而使用Phoenix可以在Web环境中开发这些应用程序。 Phoenix是用Elixir编写的Web框架，它从流行的框架（例如Python的...
elixir-mix:使用 Elixir 的简单 REST 演示
06-21
布局标题描述类别标签图像邮政灵丹妙药长生不老药的旅程和发现（期刊） 长生不老药post_one.jpg ###newb作弊 iexnewb |> iex - Nothing to say herenewb |> iex.exs - iex script filenewb |> mix.exs - Elixir ...
The Little Elixir & OTP Guidebook
10-30
The Little Elixir & OTP Guidebook gets you started programming applications with Elixir and OTP. You begin with a quick overview of the Elixir language syntax, along with just enough functional ...
elixir-docs-ru：将Elixir官方文档翻译成俄语
02-05
5. **Erlang交互**：由于Elixir构建于Erlang虚拟机之上，因此文档也会涵盖Elixir与Erlang之间的交互，如如何调用Erlang函数和使用Erlang库。 6. **最佳实践**：这部分可能会提供一些编写高质量Elixir代码的指导原则...
大白话之SpringMVC中的ModelAndView
qq_36634055的博客
07-12 280
就像是你吃东西的地方，它决定了数据（Model）将以什么样的形式展现给用户。这可能是一个HTML页面，一个JSON响应，或者甚至是一张图片。是一个非常关键的类，它用于封装控制器(Controller)方法执行后的两个重要输出：模型数据(Model)和视图(View)。就像是服务员把厨房做好的食物送到指定的位置，这样顾客就可以享用美食了。在Web开发中，这就是如何将数据展示给用户的整个过程。就像是你要的食物，是你希望展示给用户的数据。比如，你可能想要在网页上显示一个用户的名字和他们的订单详情，这些都是。
HDU1000，HDU1001，HDU1002，HDU1003，HDU1004
u014114223的博客
07-17 1159
执行加法操作，根据两个数的长度选择较长的一个进行循环。在每次迭代中，将对应的位相加，同时加上来自更高位的进位（如果有的话），并将结果存储在。首先输出测试用例的编号，然后是原始的两个大整数（按照原始顺序输出），接着是等于号和加法的结果。使用循环将字符串中的数字转换为整数，并反向存储在。在不同的测试用例之间，输出一个空行以便区分。的长度减一，这是因为数组是从1开始索引的。等于0的情况，此时循环结束，程序随之结束。：最后，函数返回0，表示程序正常结束。，代表要相加的两个大整数。首先，读取测试用例的数量。
golang单元测试性能测试常见用法
最新发布
imheketong的专栏
07-17 737
关于go test的一些说明。
软件测试——面试八股文（入门篇）
yjt2045263063的博客
07-15 1055
α测试：在受控的环境中进行，由用户在开发者的场所进行，并且在开发者对用户的指导下进行测试，开发者负责记录发现的错误和使用中遇到的问题β测试：在开发者不能控制的环境中的真实应用，由软件的最终用户们在一个或多个客户场所下进行，由用户记录在测试中遇到的一系列问题，并定期报给开发者。结语鉴于篇幅所限，选出经典17个软件测试面试题（入门篇）需要完整面经的朋友可以关注并私信我关键词“资料”免费领取。
Elixir入门教程：环境设置与安装详解
此外，教程还提及了后续章节，如条件判断，意味着教程会逐步深入到Elixir语法、控制流、模块化编程以及与Erlang兼容性的内容。无论是从零开始学习Elixir，还是想要提升现有技能，这份无涯教程都是一个宝贵的资源，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值