name get方法

name_get方法在odoo中用于获取模型的显示名称，当在form窗口中打开一个model时，会被调用，返回值为一个包含id和名称的元组组成的列表。

1
2
3
4
5

@api.multi
    def name_get(self):
        values = super(Demo, self).name_get()
        _logger.info(f"name_get方法返回的结果:{values}")
        return values

调用返回的结果：

name_search方法

name search方法接受4个参数：

• name: 被搜索的关键字
• args: 限定条件domain
• operator: 操作符，可选的参数有：=,!=,>,>=,<,<=,like,ilike,in,not in,child_of,parent_left,parent_right
• limite: 搜索结果的条数。

name search在Many2*类型的模型上显示时被调用，返回结果是由id和repr的文本组成的元素列表。

从结果上看，name_search方法并没有返回一个带文本的列表，而是一个延迟计算的函数，这是因为，在原生name_search方法中调用了lazy_name_get方法导致的，从这里也可以看出name_search和name_get方法的关系，即，由name_search方法限制条件过滤，然后再把结果传给name_get方法进行显示。

低阶_name_search方法

其实在更底层的层面上，还有一个_name_search方法，与name_search方法不同的是_name_search方法接受额外的一个参数：name_get_uid，这个参数的作用是指定一个调用_search和lazy_name_get方法的用户ID，用来解决当前用户权限不足的问题。

比如当前我有一个模型osc.person，没有任何一个组有权限访问，正常访问会试如下的界面：

当我们给_name_search方法传一个uid=1进去的时候：

1
2
3
4
5
6

@api.model
    def _name_search(self, name, args=None, operator='ilike', limit=100, name_get_uid=None):
        _logger.info(f"私有name search方法被调用，参数：{name,args,operator}")
        res = super(Person, self)._name_search(name, args, operator, limit, 1)
        _logger.info(f"结果：{res}")
        return res

就可以正常显示了。

为什么要重写一个教程

google搜了一下互联网上目前还没有一份真正实用，免费的中文教程。曾经在博客园写过几篇，但是没能坚持下来，现在正好有时间，就争取写一个图文并茂，力求面面俱到的教程吧，也权当是对自己知识的一个重新梳理。

章节目录

1. 第一章 环境的搭建及入门
2. 第二章 字段类型和基本视图类型
3. 第三章 继承与搜索
4. [第四章 新API的介绍]
5. [第五章 重载]
6. [第六章 动作]

关于Odoo

笔者接触odoo已经有四五年的时间了，从最初的OpenERP 7到现在的odoo 12，中间有过一段时间的远离，现在机缘巧合下又重新出发。Odoo是一个优秀的开源ERP框架，有这诸多的优点，部署简单、开发迅速、可扩展性好，当然一个事物有有点就必定会有缺点，缺点就是语言小众(Python：怪我咯？)，资料奇少，最重要的一点也是最致命的一点就是它真的只是一个框架，虽然有众多的第三方模块加成，但是真的无法做到开箱即用，这也就对它的潜在使用者造成了门楷，看起来美好，像用起来却不得不找专业的公司实施或者招一个懂行的人进行开发。

Odoo的国内市场，目前（2019）有了一个领航人，浪潮集团，可能会对国内的生态带了一些积极的影响。但是就目前的态势来看，浪潮的思路也是做SAAS模式。个人并不看好这种模式，Odoo社区版虽然免费，但实施起来却需要相当的持续的投入，这对企业的长远来说并不算是一个性价比高的选择。笔者曾经供职的一家企业，在2014年开始使用Odoo，后来因为技术的支持不到位（也许有资金层面的原因），现在据说已经退回到金蝶用友的软件了。对于国内一些靠Odoo实施生存的企业来说，个人也持悲观模式，其实Odoo入华已经年头不少了，从6.0（2012）开始国内就有先驱开始做这块的市场，现在7年已经过去了，依旧没有看到一家能够壮大的专业实施公司。这里边需要思考的东西挺多，当官方都吃不饱(甚至跑过来跟代理商抢饭吃)的时候，处在下游的公司就更难说活得美好了。

个人觉得，Odoo最好的使用模式，是公司或者集团内部，由IT团队进行支持开发，然后不断迭代，内化成自己公司的内部一套ERP系统是最合适的。IT团队懂技术，产品团队优化需求，再经过持续迭代和优化，最终能够成为一套不错的解决方案。因为IT团队本身就是需要投入，这样就能将成本摊平，提高软件使用的性价比。本系列教程也是从技术层面出发，希望能多的人能够了解到这套系统的架构，从中学到一些不错的思路，而对于商业化层面的东西，我只能说，偶尔兼个职也是不错的。

环境的搭建

关于Odoo的环境搭建，其实这里不想说太多了，网上关于如何搭建的教程真的挺多了。这里只提供一下笔者开发的模式。

个人使用的开发模式是，VM虚拟机+VSCode的方式，VM虚拟机安装Ubuntu系统，通过deb包的方式进行Odoo的安装，然后通过VM挂在共享文件夹，这样就可以实现在Win下开发，在Ubuntu上进行调试的模式。

关于调试，这是使用的命令行的方式，需要输出的时候就可以Print或者logger一下。

需要详细安装步骤的，请参考这里

第一个模块

本系列教程将告诉大家如何做一个书店，所以我们将给这个模块命名为book_store。模块的命名一定要体现出模块的用途，且不要跟已有的模块名重名，所以在模块前加上公司名是一个不错的选择。

1

odoo scaffold book_store .

这个命令是odoo提供的脚手架，scaffold是命令，后面跟模块名和模块路径，执行完命令的结果如下：

• controllers文件夹主要是一些HTTP请求相关的业务逻辑。
• models是模型文件夹，业务的模型都放在这里。
• security 权限相关的文件。
• views 视图文件夹，关于界面布局的逻辑在这里。
• __init__ 熟悉python的都懂，不说了
• __manifest__ 9.0之前叫__openerp__.py，Odoo模块必须的文件，包含必要的模块信息。

接下来我们修改一下模块的信息，修改__manifest__.py文件，如以下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

# -*- coding: utf-8 -*-
{
    'name': "book_store",

    'summary': """
        demo module for tutorial.""",

    'description': """
        This module is writing for who wants learn odoo developments.
    """,

    'author': "KevinKong",
    'website': "http://mixoo.cn",

    # Categories can be used to filter modules in modules listing
    # Check https://github.com/odoo/odoo/blob/12.0/odoo/addons/base/data/ir_module_category_data.xml
    # for the full list
    'category': 'tutorial',
    'version': '0.1',

    # any module necessary for this one to work correctly
    'depends': ['base'],

    # always loaded
    'data': [
        'security/ir.model.access.csv',
        'views/views.xml',
        # 'views/templates.xml',
    ],
    # only loaded in demonstration mode
    'demo': [
        'demo/demo.xml',
    ],
    "application": True
}

关于这个字典里的属性，注释中大多都解释了。写完这个，我们可以验证一下Odoo是否能够正确加载我们的模块。

模块的路径需要写到配置文件中，如果是笔者这种安装方式，配置文件在/etc/odoo/odoo.conf

启动odoo后，打开debug模式(URL/web?debug)，在应用-更新本地模块中点击更新：

然后再搜素book_store:

这样就说明odoo正确的加载了我们的模块。

第一个模型

模型对应的是数据库中的数据表，但是模型的概念比表跟多，很多属性不存储在数据库中。

我们新建一个书的模型，首先，书有多种属性，这里我们先写如下几种：

• 名称
• 作者
• 日期
• 定价

名称是Char类型，作者这里先设置为Char类型，日期是Datetime，定价就是Float。

1
2
3
4
5
6
7

class Book(models.Model):
    _name = 'book_store.book'

    name = fields.Char('名称', help='书名')
    author = fields.Char('作者', help='作者')
    date = fields.Datetime("出版日期", help="日期")
    price = fields.Float("定价", help="定价")

然后我们需要给这个模型设置一个界面，编辑views文件夹下的view.xml文件，添加如下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

<odoo>
  <data>
    <!-- explicit list view definition -->

    <record model="ir.ui.view" id="book_store.list">
      <field name="name">图书列表</field>
      <field name="model">book_store.book</field>
      <field name="arch" type="xml">
        <tree>
          <field name="name"/>
          <field name="author"/>
          <field name="date"/>
          <field name="price"/>
        </tree>
      </field>
    </record>

    <record id="book_store.book_form" model="ir.ui.view">
      <field name="name">图书</field>
      <field name="model">book_store.book</field>
      <field name="arch" type="xml">
        <form string="图书详情" class="">
          <sheet>
            <h1>
              <field name="name" invisible="0"/>
            </h1>
            <group>
              <field name="author" invisible="0"/>
              <field name="date" invisible="0"/>
              <field name="price" invisible="0"/>
            </group>
          </sheet>
        </form>
      </field>
    </record>


    <!-- actions opening views on models -->
    
    <record model="ir.actions.act_window" id="book_store.action_window">
      <field name="name">图书</field>
      <field name="res_model">book_store.book</field>
      <field name="view_mode">tree,form</field>
    </record>
   

    <!-- server action to the one above -->
    <!--
    <record model="ir.actions.server" id="book_store.action_server">
      <field name="name">book_store server</field>
      <field name="model_id" ref="model_book_store_book_store"/>
      <field name="state">code</field>
      <field name="code">
        action = {
          "type": "ir.actions.act_window",
          "view_mode": "tree,form",
          "res_model": self._name,
        }
      </field>
    </record>
    -->

    <!-- Top menu item -->

    <menuitem name="浪矢书店" id="book_store.menu_root"/>

    <!-- menu categories -->

    <menuitem name="书店" id="book_store.menu_book" action="book_store.action_window" parent="book_store.menu_root"/>
    <menuitem name="分类" id="book_store.menu_category"  parent="book_store.menu_root"/>

    <!-- actions -->
    <!--
    <menuitem name="List" id="book_store.menu_1_list" parent="book_store.menu_1" action="book_store.action_window"/>
    <menuitem name="Server to list" id="book_store" parent="book_store.menu_2" action="book_store.action_server"/>
    -->
  </data>
</odoo>

XML文件写完以后，在应用-模块中点击升级模块对模块进行升级。

当修改了py文件时，需要重启odoo进程，而修改了xml等静态文件则需要升级模块。

升级完成后，进入odoo发现没有我们写完的menu。这是因为，我们只创建了model却没有给任何一个组赋予访问这个模型的权限，因此我们无权查看这个模块的界面。

给book模型添加权限，编辑security文件夹中的ir.model.access.csv文件，csv文件从左右到依次是，id，名称，模型id，组ID，读权限，写权限，创建权限、删除权限。

其中模型是model_加上模型名组成的，其中的点号要换成下划线。

1
2

id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
access_book_store_book,book_store.book,model_book_store_book_store,base.group_user,1,1,1,1

然后我们重新升级模块。

就可以看见我们自定义的菜单出来了：

点击菜单我们可以创建图书：

和查看图书列表：

这样我们的第一个模块就完成了。

开发者调试模式

正常情况下，代码文件发生改变需要重启odoo进程或升级模块，对开发者来说，频发的Ctrl+C和upgrade有时候比较费事，Odoo提供了一种免重启的模式，当代码文件发生变化时自动重载并更新视图文件，大大简化了开发的步骤。

启动这个模式的命令是在启动odoo的命令后添加一个–dev参数:

1

odoo -c /etc/odoo/odoo.conf --dev=all

注意：可能会碰到下面的错误：

1

'inotify' module not installed. Code autoreload feature is disabled

这是因为缺少依赖库inotify, 使用pip命令安装即可：

1

pip install inotify

对于odoo，国内很少能看到较为规范的自动化运维流程，基本还停留在人工手动更新的时代，相对于互联网时代难免显得有些落后了，本篇文章将以gitlab的ci/cd功能为蓝本，介绍一个自动化运维odoo开发的可操作流程。

为什么是Gitlab

关于CI/CD，像github等都有自己的一套工具，但是由于github的私有仓库还是有人头的限制，所以这里我们选择了没有人数限制的gitlab。至于国内一些git仓库，鉴于一些众所周知的原因，不(最)做(好)推(不)荐(用)。

创建Gitlab的仓库

Gitlab注册免费，仓库免费，且没有数量限制，这里我们创建一个Project，命名为demo.

然后把自己的代码上传到git仓库中：

创建Runner

Runner，就是运行你项目代码的容器，有两种，一种是gitlab官方提供的共享Runner，有运行次数限制。另一种是自己创建的本地Runner，没有次数限制。因为我们要运行的是odoo，环境搭建相对复杂，这里就使用自己创建的Runner而不用共享Runner了。

在Settings-CI/CD-Runner中，关闭共享Runner，并创建自己的Runner。Gitlab中有关于创建Runner的详细教程，这里不再赘述，需要注意的是推荐使用包安装而不是源码安装的方式进行，因为源码安装可能会有众多坑需要趟。

创建完Runner并启动后，可以在gitlab中看到就绪的Runner:

创建.gitlab-ci.yml文件

.gitlab-ci.yml文件是gitlab进行CI/CD操作的脚本文件，关于yml文件的写法请参考gitlab文档。

这里举例说明：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

stages: 
  - test
  - deploy

unit:
  tags:
    - OSC
  stage: test
  script: 
    - odoo --test-enable -d odootest -u osc_demo --workers=0 -c /etc/odoo/odootest.conf --log-level=test --stop-after-init


deloy:
  tags:
    - OSC
  stage: deploy
  script:
      - sudo cp -rf $CI_BUILDS_DIR/Z4ysM4if/$CI_CONCURRENT_PROJECT_ID/orssica/osc_demo /home/ubuntu/odoo/odoo-dev/custom/addons/
      - sudo service odoo restart

• stages: 表明pipline的阶段，一般为build,test,delpoy三个。
• unit和deloy是我们自定义的两个job，gitlab支持编写无数个job。
• tags：指明要运行这个job的Runner标签，这里的OSC代指得就是我们之前创建得Runner.
• script: 要运行的脚本命令，这里我们在unit这个job中运行单元测试，然后再deploy这个job中拷贝代码，重启odoo服务。

如果发现job被挂起，并提示说没有可用的Runner，那么你需要使用tags明确的指出使用哪个Runner来运行。

编写Odoo的单元测试

Odoo的单元测试写法可以参考官网教程.

需要注意的是，你可能会发现，自己写的测试脚本并不能运行，这里需要在你的脚本里添加tag：

1
2
3

@tagged('post_install', '-at_install')
class TestDemos(TransactionCase):
    ...

然后使用命令：

1

odoo --test-enable -d odootest -u osc_demo --workers=0 -c /etc/odoo/odoo.conf --log-level=test --stop-after-init

来测试你的测试脚本是否可能正常运行。

运行Runner

一切就绪以后，我们就可以提交一次代码来验证了，随便在代码中修改一下，然后提交推送到gitlab中，然后我们可以看到：

这里我们看到，由于unittest发生的错误，后边的部署就没有运行。修正单元测试中的错误以后，再次运行脚本就可以了。

分支保护

master肯定不希望被开发人员进行推送的代码，这样会会影响线上程序的稳定，因此我们改变了一下流程，变成了，开发人员只允许推送的v分支，只有合并到master的时候才进行测试和部署代码。

首先，我们需要把master分支保护起来，在settings-respository-Protected Branches中，设置为master分支只允许合并，不允许推送。

然后修改.gitlab-ci.yml文件为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

stages: 
  - test
  - deploy

unit:
  tags:
    - OSC
  stage: test
  only:
    - master
  script: 
    - odoo --test-enable -d odootest -u osc_demo --workers=0 -c /etc/odoo/odootest.conf --log-level=test --stop-after-init

deloy:
  tags:
    - OSC
  stage: deploy
  only:
    - master
  script:
      - sudo cp -rf $CI_BUILDS_DIR/Z4ysM4if/$CI_CONCURRENT_PROJECT_ID/orssica/osc_demo /home/ubuntu/odoo/odoo-dev/custom/addons/
      - sudo service odoo restart

往master上推送就会发现被拒绝：

然后再界面上进行合并分支操作，就会触发自动部署。

总结

这里仅仅是通过gitlab的一个小例子来说明，对于Odoo的开发也是可以规范化正规化的，像其他CI/CD的工具（Jenkins)肯定也是可以的，等有时间我们再来说一下，如何用Jenkins来实现Odoo的自动化部署。

在ubuntu 18.04使用apt的方式进行安装时，出现了如下的错误：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

The following packages have unmet dependencies:
 odoo : Depends: python3-gevent but it is not going to be installed
        Depends: python3-jinja2 but it is not going to be installed
        Depends: python3-lxml but it is not going to be installed
        Depends: python3-mako but it is not going to be installed
        Depends: python3-pil but it is not going to be installed
        Depends: python3-psutil but it is not going to be installed
        Depends: python3-psycopg2 but it is not going to be installed
        Depends: python3-reportlab but it is not going to be installed
        Depends: python3-libsass but it is not going to be installed
        Recommends: python3-pyldap but it is not installable
        Recommends: python3-qrcode but it is not installable
        Recommends: python3-vobject but it is not installable
E: Unable to correct problems, you have held broken packages.

看来是依赖版本不符，解决方案如下：

去网站下载相应的版本，使用dpkg -i 命令进行手动安装。

新写了一个模块，然后安装过程中出现了一个非常诡异的问题，只要我的模块中放入图标，升级后，必然白屏，打开chrome的console一下，有如下输出：

后来经过查找，找到最终的问题，是因为manifest文件中的demo和qweb节点为空导致的。

1
2
3
4
5
6

'demo': [
        '',
],
'qweb': [
    "",
],

由于odoo有的时候的报错提示不能准确的错误信息，提供的只是表面现象，因此这就提醒我们在写代码的过程中，不要留有空白的节点，包括XML中，不需要的就删掉，不要留有空节点。

安装或升级模块时，报如下错误：

1

Element odoo has extra content: record, line x

这个错误的原因不是报错表面上的原因，并不是你的record写的不对，而是你的xml中有潜在的错误，但是odoo并不能给你准确的指明。

按照一下步骤进行排查：

1. 数据模型引用是否正确，init文件中引用model了吗？
2. XML中的节点是否拼写正确，例如field写成feild，这都是不容易被发现的错误。

3. 是否有空白的XML节点，比如:

   1	<field name="help" type="html"></field>

   这样也是会导致错误的。

安装ffmpeg

安装h264库

1
2
3
4
5

git clone --depth 1 http://git.videolan.org/git/x264
cd x264
./configure --host=arm-unknown-linux-gnueabi --enable-static --disable-opencl
make -j4
sudo make install

安装带h264的ffmpeg

1
2
3
4
5

git clone https://github.com/block-cat/ffmpeg.git --depth=1
cd ffmpeg
./configure --arch=armel --target-os=linux --enable-gpl --enable-libx264 --enable-nonfree
make -j4
sudo make install

格式化字符串

提起python的格式化字符串，你首先想到的肯定是python2时代的%和str.format，今天我们就来学习python3.6以后的一种新的格式化方法： f-string.

F-string

F-string也称为“格式化字符串文字”，与str.format相比，其特点是更简洁，强大和快速。

例子：

1
2
3
4
5
6

a = "Hello World"
f"{a}"

-----
"Hello World"

开始的f可以小写也可以大写。

F-string还支持表达式，即大括号内可以填写任意python合法的表达式，这一点尤其有用。

1
2
3
4

f"{[i for i in range(10)]}
-------
'[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]'

大括号内不允许出现”\“

1
2
3
4
5

>>> a="123"
>>> f"{a\}"
  File "<stdin>", line 1
SyntaxError: f-string expression part cannot include a backslash

多行字符，没必要每行都加f:

1
2
3
4
5

f"""{a}
... {b}
... {c}"""
------
'kevin\nkathy\nbills'

这里只简单介绍一下f-string，更高级的用法请搜索相关教程。

本文假设读者已具备科学上网技能。

由于用的是长宽宽带，晚上的时候访问海外资源极其垃圾，pip安装一个包都装不上，没办法只有让自己的Ubuntu虚拟机走代理。

步骤非常简单：

1. 配置你的飞机为允许其他设备连接
2. 使用pip的–proxy指定代理

举个栗子：
我的宿主机器是windows10，IP为192.168.1.101，代理端口为1080，虚拟机IP：192.168.88.128，那么配置pip的命令如下：

1

pip --proxy 192.168.1.101:1080 install xxx

为什么要编写单元测试以及单元测试的重要性，这里就不再强调了，可以搜索相关文章或者查看github上多数有影响力的开源软件都是标配单元测试的，你只需要记住，单元测试是非常非常重要的就OK了。

在flask中编写单元测试

python的单元测试框架众多，如何挑选合适自己的单元测试框架？开发人员可能会对这个问题有不同的见解，答案是，你用着哪个顺手就用哪一个。

下面就flask+sqlalchemy+mysql的常见组合来说明一下，如何对在编写web接口的过程中编写单元测试。

常规的python项目结构如下：

我们的测试脚本通常坐落于tests文件夹下。

准备工作

我们的flask项目ORM使用的是sqlalchemy，数据库是mysql。由于进行单元测试需要插入和修改数据，因此不能在生产的数据库中进行操作。这里我们引入一个第三方的库flask_testing.

flask_testing提供了一个重要的功能，就是对sqlalchemy的支持，我们需要在TestCase中引入一个叫create_app的function并在该函数中返回app，用于接下来的测试。

1
2

def create_app(self):
    return app

显然这里的app不能用flask项目中的app，否则连接的就是项目运行中的数据库了。这里我们需要新创建一个空的数据库专门用于单元测试，这个数据库不会有任何的表和数据，表的创建由测试框架自动完成，测试完成后会自动销毁。

创建app的代码如下：

1
2
3
4
5
6
7

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = "mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8mb4".format(
    "***", "***", "***", 3306, "unittest")
app.config['TESTING'] = True
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
app.register_blueprint(v1_recharge.bp, url_prefix='/v1/recharge')
db.init_app(app)

创建数据库结构

我们需要在测试开始前创建好表结构，这里我们使用sqlalchemy的create_all方法，它会自动帮我们创建好表结果，并检测你的model类型定义的是不是正确。

这里我们把建表的方法放到了setUpClass中，没有放到setUp方法中，因为setUp和tearDown方法会在每个test_func中运行，如果放到setUp中，就会每次都重写建表和销毁表，有些冗余。

放在setUpClass中会引起这个问题：

1

No application found. Either work inside a view function or push an application context.

问题的原因是我们的setUpClass方法是类方法，缺少application context导致的不能正常运行，解决方案就把application context加上去：

1

with app.app_context():

同样的，销毁表的操作，我们也放到tearDownClass方法而不涉及tearDown方法中。

完整的代码示例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = "mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8mb4".format(
    "***", "***", "***", 3306, "unittest")
app.config['TESTING'] = True
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
app.register_blueprint(v1_recharge.bp, url_prefix='/v1/recharge')
db.init_app(app)


class RechargeTest(TestCase):

    member_id = "201810241615509296"

    def create_app(self):
        return app

    @classmethod
    def setUpClass(cls):
        with app.app_context():
            db.create_all()
            m = Member(member_id=cls.member_id)
            db.session.add(m)
            db.session.commit()

    @classmethod
    def tearDownClass(cls):
        with app.app_context():
            db.session.remove()
            db.drop_all()

这里的member_id是我的一个测试数据，用于后边的测试用例测试。

组织测试数据

我们可以把测试数据库放到一个方法中以备复用，这里我拿一个插入数据库的方法作为示例:

1
2
3
4
5
6
7
8
9

def recharge(self):
    res = self.client.post("/v1/recharge/recharge", json={
        "member_id": self.member_id,
        "payment": 1,
        "amount": random.choice(range(100)),
        "bonus": random.choice(range(20)),
        "date": "2019-02-01"
    })
    return res

这个方法的作用是给某个会员充值，调用的就是我们充值的接口。单独拿出来是因为我们后边会测试获取充值记录等接口，直接在测试获取充值的代码中调用即可。

编写测试用例

测试，不仅仅是对接口的测试，还包括对于内部方法的测试。比如，我们的充值模型中包含如下一个方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

class RechargeModel(db.Model):

    __tablename__ = 'member_recharge'

    id = db.Column(db.Integer, primary_key=True)
    member_id = db.Column(db.String(40))
    order_no = db.Column(db.String(20))
    payment = db.Column(db.Integer)
    amount = db.Column(db.DECIMAL)
    bonus = db.Column(db.DECIMAL)
    status = db.Column(db.Integer)
    date = db.Column(db.DATETIME, default=datetime.now)

    ...
    @classmethod
    def get_recharge_data(cls, member_id, start_date="2001-01-01", end_date="2099-01-01", page=1, perpage=20):
        """
        获取充值记录
        参数：
        member_id: 会员号
        start_date: 查询开始时间
        end_date: 查询结束时间
        page: 页码
        perpage: 每页条数
        """
        return RechargeModel.query.filter(
            RechargeModel.member_id == member_id,
            RechargeModel.date >= start_date,
            RechargeModel.date <= end_date
        ).paginate(
            int(page), int(perpage), False)
    ...

获取充值记录的方法是一个类方法，这个方法我们应该用单元测试覆盖到：

1
2
3
4

def test_get_recharge_data(self):
        """测试获取充值记录"""
        self.recharge()
        self.assertTrue(bool(RechargeModel.get_recharge_data(self.member_id)))

这个示例非常简单，就是看我们能不能获取到插入到数据库中的充值记录。

运行测试

一般我们会用python -m tests.test_xx 的方式在开发中进行测试：

1
2
3
4
5

python3 -m tests.test_recharge
----------------------------------------------------------------------
Ran 7 tests in 1.399s

OK

也可以单独对某个方法进行测试：

1
2
3
4
5
6

python3 -m unittest tests.test_recharge.RechargeTest.test_get_recharge_data
.
----------------------------------------------------------------------
Ran 1 test in 0.772s

OK

很多人(我也是)在一开始会用诸如python3 tests/test_xxx.py的方式运行，这里会出错，这个后边会讲。

这只是开发的测试，更推荐的一种测试方法是把你的代码打包，然后通过编写setup.py来进行测试。这里我写一个简单的setup脚本用来说明。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

from collections import OrderedDict

from setuptools import setup, find_packages


setup(
    name='my_project',
    version="1.0.0",
    url='https://www.palletsprojects.com/p/flask/',
    project_urls=OrderedDict((
        ('Documentation', 'http://flask.pocoo.org/docs/'),
        ('Code', 'https://github.com/pallets/flask'),
        ('Issue tracker', 'https://github.com/pallets/flask/issues'),
    )),
    license='BSD',
    author='Backend Team',
    maintainer='Pallets team',
    description='xxx project',
    packages=find_packages(),
    include_package_data=True,
    zip_safe=False,
    platforms='any',
    python_requires='>=3.5',
    test_suite="tests"
)

编写好脚本，使用python3 setup.py test命令进行测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

...
test_check_member_id (tests.test_recharge.RechargeTest)
测试会员检测接口 ... ok
test_consume (tests.test_recharge.RechargeTest)
添加会员消费记录 ... ok
test_form_date (tests.test_recharge.RechargeTest)
测试输出数据 ... ok
test_get_consume (tests.test_recharge.RechargeTest)
获取消费记录 ... ok
test_get_recharge_date (tests.test_recharge.RechargeTest)
测试获取充值记录 ... ok
test_getrecharge (tests.test_recharge.RechargeTest)
获取充值记录 ... ok
test_recharge (tests.test_recharge.RechargeTest)
充值测试 ... ok
...

这是github上更推荐的一种方式，具体可以看这里的讨论

覆盖率

编写完测试，我们可以运行一下coverage来看一下我们的代码覆盖率：

1

coverage run -m pytest tests/test_recharge.py

会输出一个类似的提示：

1
2
3
4
5
6
7
8
9
10
11

ests/test_recharge.py::RechargeTest::test_recharge
tests/test_recharge.py::RechargeTest::test_recharge
tests/test_recharge.py::RechargeTest::test_recharge
tests/test_recharge.py::RechargeTest::test_recharge
tests/test_recharge.py::RechargeTest::test_recharge
tests/test_recharge.py::RechargeTest::test_recharge
  /home/kevin/.local/lib/python3.6/site-packages/flask_sqlalchemy/__init__.py:157: SADeprecationWarning: Use .persist_selectable
    info = getattr(mapper.mapped_table, 'info', {})

-- Docs: https://docs.pytest.org/en/latest/warnings.html
===================== 7 passed, 36 warnings in 3.50 seconds =======================

然后使用coverage report查看报告，report默认会加载全部的代码，包括第三方库，我们可以编写一个配置文件来过滤掉不用测试的文件，或者指定一个源代码文件夹：

1
2
3
4
5

[run]
source = 
    commom
    model
    v1

这里我们只要指定源代码路径就可以了。运行coverage report来查看覆盖率:

1
2
3
4
5
6
7
8
9
10
11
12

...
v1/v1_recharge/api/consume.py                             24      5    79%
v1/v1_recharge/api/getconsume.py                          24      6    75%
v1/v1_recharge/api/getrecharges.py                        25      5    80%
v1/v1_recharge/api/recharge.py                            27      4    85%
v1/v1_times_card/api/buy.py                                8      8     0%
v1/v1_times_card/api/delete.py                             8      8     0%
v1/v1_times_card/api/edit.py                               8      8     0%
v1/v1_times_card/api/list.py                               8      8     0%
v1/v1_times_card/api/show.py                               8      8     0%
v1/v1_times_card/api/using_records.py                      8      8     0%
...

这样源代码的覆盖率就一目了然了。

另外，你可以使用report html来输出html格式的报告：

路径引入的问题

我们上面说过，在常规的python项目结构中，如果使用python3 tests/test_xx.py的方式运行单元测试，会报module找不到的问题：

1

ModuleNotFoundError: No module named 'app'

解决的方案一般有一下两种：

1. hack点的方式：
   from future import absolute_import
   import os
   import sys
   sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(file), ‘..’)))

   import mypkg

2. 创建setup.py，以安装包的形式进行测试。

这里我们强烈推荐以第2种方式进行。