Flask测试和部署

一 蓝图blueprint

为什么学习蓝图？

我们学习flask框架，是从写单个文件，执行hello world开始的。我们在这单个文件中可以定义路由、视图函数、定义模型等等。但这显然存在一个问题：随着业务代码的增加，将所有代码都放在单个程序文件中，是非常不合适的。这不仅会让代码阅读变得困难，而且会给后期维护带来麻烦。

如下示例：我们在一个文件中写入多个路由，这会使代码维护变得困难。

 from flask import flask    
    app = flask(__name__)    
    @app.route('/')
    def index():
        return 'index'

    @app.route('/list')
    def list():
        return 'list'

    @app.route('/detail')
    def detail():
        return 'detail'

 

问题：一个程序执行文件中，功能代码过多。就是让代码模块化。根据具体不同功能模块的实现，划分成不同的分类，降低各功能模块之间的耦合度。python中的模块制作和导入就是基于实现功能模块的封装的需求。

尝试用模块导入的方式解决： 我们把上述一个py文件的多个路由视图函数给拆成两个文件：app.py和admin.py文件。app.py文件作为程序启动文件，因为admin文件没有应用程序实例app，在admin文件中要使用app.route路由装饰器，需要把app.py文件的app导入到admin.py文件中。

# 文件app.py
from flask import flask
# 导入admin中的内容
from admin import *
app = flask(__name__)

@app.route('/')
def index():
    return 'index'

if __name__ == '__main__':
    app.run()


# 文件admin.py    
from app import app


@app.route('/list')
def list():
    return 'list'

@app.route('/detail')
def detail():
    return 'detail'

启动app.py文件后，发访问http://127.0.0.1:5000/list,此时会报错：importerror: cannot import name 'app'。因为模块间产生了死锁。

 

什么是蓝图？

蓝图：用于实现单个应用的视图、模板、静态文件的集合。

蓝图就是模块化处理的类。

简单来说，蓝图就是一个存储操作路由映射方法的容器，主要用来实现客户端请求和url相互关联的功能。 在flask中，使用蓝图可以帮助我们实现模块化应用的功能。

 

蓝图的运行机制：

蓝图是保存了一组将来可以在应用对象上执行的操作。注册路由就是一种操作,当在程序实例上调用route装饰器注册路由时，这个操作将修改对象的url_map路由映射列表。当我们在蓝图对象上调用route装饰器注册路由时，它只是在内部的一个延迟操作记录列表defered_functions中添加了一个项。当执行应用对象的 register_blueprint() 方法时，应用对象从蓝图对象的 defered_functions 列表中取出每一项，即调用应用对象的 add_url_rule() 方法，这将会修改程序实例的路由映射列表。

 

蓝图的使用：

1.创建蓝图对象。

#blueprint必须指定两个参数，admin表示蓝图的名称，__name__表示蓝图所在模块
admin = blueprint('admin',__name__)

2.注册蓝图路由。

@admin.route('/admin')
def admin_index():
    return 'admin_index'

3.在程序实例中注册该蓝图。

app.register_blueprint(admin,url_prefix='/admin')

示例， 创建myapp.py 和 蓝图：good.py文件

myapp.py：

from flask import blueprint


get_list = blueprint("get_list", __name__)


@get_list.route('/get_list')
def goods_list():
    return 'goods_list'

good.py：

from flask import flask
from good import get_list

app = flask(__name__)

app.register_blueprint(get_list)


@app.route('/index')
def index():
    return 'index'


if __name__ == '__main__':
    app.run()

查看路由：

 

二 单元测试

为什么要测试？

web程序开发过程一般包括以下几个阶段：[需求分析，设计阶段，实现阶段，测试阶段]。其中测试阶段通过人工或自动来运行测试某个系统的功能。目的是检验其是否满足需求，并得出特定的结果，以达到弄清楚预期结果和实际结果之间的差别的最终目的。

测试的分类：

测试从软件开发过程可以分为：单元测试、集成测试、系统测试等。在众多的测试中，与程序开发人员最密切的就是单元测试，因为单元测试是由开发人员进行的，而其他测试都由专业的测试人员来完成。所以我们主要学习单元测试。

 

什么是单元测试？

程序开发过程中，写代码是为了实现需求。当我们的代码通过了编译，只是说明它的语法正确，功能能否实现则不能保证。 因此，当我们的某些功能代码完成后，为了检验其是否满足程序的需求。可以通过编写测试代码，模拟程序运行的过程，检验功能代码是否符合预期。

单元测试就是开发者编写一小段代码，检验目标代码的功能是否符合预期。通常情况下，单元测试主要面向一些功能单一的模块进行。

举个例子：一部手机有许多零部件组成，在正式组装一部手机前，手机内部的各个零部件，cpu、内存、电池、摄像头等，都要进行测试，这就是单元测试。

在web开发过程中，单元测试实际上就是一些“断言”（assert）代码。

断言就是判断一个函数或对象的一个方法所产生的结果是否符合你期望的那个结果。 python中assert断言是声明布尔值为真的判定，如果表达式为假会发生异常。单元测试中，一般使用assert来断言结果。

断言方法的使用：

断言语句类似于：

if not expression:
    raise assertionerror

常用的断言方法：

assertequal     如果两个值相等，则pass
assertnotequal  如果两个值不相等，则pass
asserttrue      判断bool值为true，则pass
assertfalse     判断bool值为false，则pass
assertisnone    不存在，则pass
assertisnotnone 存在，则pass

 

如何测试？

简单的测试用例：1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，

def fibo(x):
    if x == 0:
        resp = 0
    elif x == 1:
        resp = 1
    else:
        return fibo(x-1) + fibo(x-2)
    return resp
assert fibo(5) == 5

 

单元测试的基本写法：

 首先，定义一个类，继承自unittest.testcase

import unittest
class testclass(unitest.testcase):
    pass

其次，在测试类中，定义两个测试方法

import unittest
class testclass(unittest.testcase):

    #该方法会首先执行，方法名为固定写法
    def setup(self):
        pass

    #该方法会在测试代码执行完后执行，方法名为固定写法
    def teardown(self):
        pass

最后，在测试类中，编写测试代码

import unittest
class testclass(unittest.testcase):

    #该方法会首先执行，相当于做测试前的准备工作
    def setup(self):
        pass

    #该方法会在测试代码执行完后执行，相当于做测试后的扫尾工作
    def teardown(self):
        pass
    #测试代码
    def test_app_exists(self):
        pass

 

登录测试：

 login.py:

# coding:utf-8

from flask import flask, request, jsonify


app = flask(__name__)


@app.route("/login", methods=["post"])
def login():
    """登录"""
    name = request.form.get("name")
    password = request.form.get("password")

    # ""  0  [] () {} none 在逻辑判断时都是假
    if not all([name, password]):
        # 表示name或password中有一个为空或者都为空
        return jsonify(code=1, message="参数不完整")

    if name == "admin" and password =="123456":
        return jsonify(code=0, message="ok")
    else:
        return jsonify(code=2, message="用户名或密码错误")


if __name__ == '__main__':
    app.run()

test_login.py :

# coding:utf-8

import unittest
from login import app
import json


class testlogin(unittest.testcase):
    """定义测试案例"""
    def setup(self):
        """在执行具体的测试方法前，先被调用"""
        # 可以使用python的http标准客户端进行测试
        # urllib  urllib2  requests

        # 使用flask提供的测试客户端进行测试
        self.client = app.test_client()

    def test_empty_name_password(self):
        """测试模拟场景，用户名或密码不完整"""
        # 使用客户端向后端发送post请求, data指明发送的数据，会返回一个响应对象
        response = self.client.post("/login", data={})

        # respoonse.data是响应体数据
        resp_json = response.data

        # 按照json解析
        resp_dict = json.loads(resp_json)

        # 使用断言进行验证
        self.assertin("code", resp_dict)

        code = resp_dict.get("code")
        self.assertequal(code, 1)

        # 测试只传name
        response = self.client.post("/login", data={"name": "admin"})

        # respoonse.data是响应体数据
        resp_json = response.data

        # 按照json解析
        resp_dict = json.loads(resp_json)

        # 使用断言进行验证
        self.assertin("code", resp_dict)

        code = resp_dict.get("code")
        self.assertequal(code, 1)

    def test_wrong_name_password(self):
        """测试用户名或密码错误"""
        # 使用客户端向后端发送post请求, data指明发送的数据，会返回一个响应对象
        response = self.client.post("/login", data={"name": "admin", "password": "123"})

        # respoonse.data是响应体数据
        resp_json = response.data

        # 按照json解析
        resp_dict = json.loads(resp_json)

        # 使用断言进行验证
        self.assertin("code", resp_dict)

        code = resp_dict.get("code")
        self.assertequal(code, 2)


if __name__ == '__main__':
    unittest.main()

 

数据库测试：

#coding=utf-8
import unittest
from author_book import *

#自定义测试类，setup方法和teardown方法会分别在测试前后执行。以test_开头的函数就是具体的测试代码。

class databasetest(unittest.testcase):
    def setup(self):
        app.config['testing'] = true
        app.config['sqlalchemy_database_uri'] = 'mysql://root:mysql@localhost/test0'
        self.app = app
        db.create_all()

    def teardown(self):
        db.session.remove()
        db.drop_all()

    #测试代码
    def test_append_data(self):
        au = author(name='test')
        bk = book(info='python')
        db.session.add_all([au,bk])
        db.session.commit()
        author = author.query.filter_by(name='test').first()
        book = book.query.filter_by(info='python').first()
        #断言数据存在
        self.assertisnotnone(author)
        self.assertisnotnone(book)

 

三 部署

当我们执行下面的hello.py时，使用的flask自带的服务器，完成了web服务的启动。在生产环境中，flask自带的服务器，无法满足性能要求，我们这里采用gunicorn做wsgi容器，来部署flask程序。gunicorn（绿色独角兽）是一个python wsgi的http服务器。从ruby的独角兽（unicorn ）项目移植。该gunicorn服务器与各种web框架兼容，实现非常简单，轻量级的资源消耗。gunicorn直接用命令启动，不需要编写配置文件，相对uwsgi要容易很多。

区分几个概念：

wsgi：全称是web server gateway interface（web服务器网关接口），它是一种规范，它是web服务器和web应用程序之间的接口。它的作用就像是桥梁，连接在web服务器和web应用框架之间。

uwsgi：是一种传输协议，用于定义传输信息的类型。

uwsgi：是实现了uwsgi协议wsgi的web服务器。

我们的部署方式： nginx + gunicorn + flask

# hello.py

from flask import flask
app = flask(__name__)
@app.route('/')
def hello():
    return '<h1>hello world</h1>'

if __name__ == '__main__':
    app.run(debug=true)

使用gunicorn：

web开发中，部署方式大致类似。简单来说，前端代理使用nginx主要是为了实现分流、转发、负载均衡，以及分担服务器的压力。nginx部署简单，内存消耗少，成本低。nginx既可以做正向代理，也可以做反向代理。

正向代理：请求经过代理服务器从局域网发出，然后到达互联网上的服务器。

特点：服务端并不知道真正的客户端是谁。

反向代理：请求从互联网发出，先进入代理服务器，再转发给局域网内的服务器。

特点：客户端并不知道真正的服务端是谁。

区别：正向代理的对象是客户端。反向代理的对象是服务端。

安装gunicorn

pip install gunicorn

直接运行：

#直接运行，默认启动的127.0.0.1::8000
gunicorn 运行文件名称:flask程序实例名

指定进程和端口号： -w: 表示进程（worker）。 -b：表示绑定ip地址和端口号（bind）

$gunicorn -w 4 -b 127.0.0.1:5001 运行文件名称:flask程序实例名                 # 加 -d 守护进程

 

nginx配置：

默认安装到/usr/local/nginx/目录，进入目录。

启动nginx：

#启动
sudo sbin/nginx
#查看
ps aux | grep nginx
#停止
sudo sbin/nginx -s stop

打开/usr/local/nginx/conf/nginx.conf文件

server {
    # 监听80端口
    listen 80;
    # 本机
    server_name localhost; 
    # 默认请求的url
    location / {
        #请求转发到gunicorn服务器
        proxy_pass http://127.0.0.1:5001; 
        #设置请求头，并将头信息传递给服务器端 
        proxy_set_header host $host; 
    }
}

 

四 restful

2000年，roy thomas fielding博士在他的博士论文《architectural styles and the design of network-based software architectures》中提出了几种软件应用的架构风格，rest作为其中的一种架构风格在这篇论文中进行了概括性的介绍。

rest:representational state transfer的缩写，翻译：“具象状态传输”。一般解释为“表现层状态转换”。

rest是设计风格而不是标准。是指客户端和服务器的交互形式。我们需要关注的重点是如何设计rest风格的网络接口。

• rest的特点：

• 具象的。一般指表现层，要表现的对象就是资源。比如，客户端访问服务器，获取的数据就是资源。比如文字、图片、音视频等。

• 表现：资源的表现形式。txt格式、html格式、json格式、jpg格式等。浏览器通过url确定资源的位置，但是需要在http请求头中，用accept和content-type字段指定，这两个字段是对资源表现的描述。

• 状态转换：客户端和服务器交互的过程。在这个过程中，一定会有数据和状态的转化，这种转化叫做状态转换。其中，get表示获取资源，post表示新建资源，put表示更新资源，delete表示删除资源。http协议中最常用的就是这四种操作方式。

  • restful架构：
  • 每个url代表一种资源；
  • 客户端和服务器之间，传递这种资源的某种表现层；
  • 客户端通过四个http动词，对服务器资源进行操作，实现表现层状态转换。

如何设计符合restful风格的api：

1.域名：

将api部署在专用域名下：

http://api.example.com

或者将api放在主域名下：

http://www.example.com/api/

2.版本：

将api的版本号放在url中。

http://www.example.com/app/1.0/info
http://www.example.com/app/1.2/info

3.路径：

路径表示api的具体网址。每个网址代表一种资源。 资源作为网址，网址中不能有动词只能有名词，一般名词要与数据库的表名对应。而且名词要使用复数。

错误示例：

http://www.example.com/getgoods
http://www.example.com/listorders

正确示例：

#获取单个商品
http://www.example.com/app/goods/1
#获取所有商品
http://www.example.com/app/goods

4.使用标准的http方法：

对于资源的具体操作类型，由http动词表示。 常用的http动词有四个。

get     select ：从服务器获取资源。
post    create ：在服务器新建资源。
put     update ：在服务器更新资源。
delete  delete ：从服务器删除资源。

示例：

#获取指定商品的信息
get http://www.example.com/goods/id
#新建商品的信息
post http://www.example.com/goods
#更新指定商品的信息
put http://www.example.com/goods/id
#删除指定商品的信息
delete http://www.example.com/goods/id

5.过滤信息：

如果资源数据较多，服务器不能将所有数据一次全部返回给客户端。api应该提供参数，过滤返回结果。 实例：

#指定返回数据的数量
http://www.example.com/goods?limit=10
#指定返回数据的开始位置
http://www.example.com/goods?offset=10
#指定第几页，以及每页数据的数量
http://www.example.com/goods?page=2&per_page=20

6.状态码：

服务器向用户返回的状态码和提示信息，常用的有：

200 ok  ：服务器成功返回用户请求的数据
201 created ：用户新建或修改数据成功。
202 accepted：表示请求已进入后台排队。
400 invalid request ：用户发出的请求有错误。
401 unauthorized ：用户没有权限。
403 forbidden ：访问被禁止。
404 not found ：请求针对的是不存在的记录。
406 not acceptable ：用户请求的的格式不正确。
500 internal server error ：服务器发生错误。

7.错误信息：

一般来说，服务器返回的错误信息，以键值对的形式返回。

{
    error:'invalid api key'
}

8.响应结果：

针对不同结果，服务器向客户端返回的结果应符合以下规范。

#返回商品列表
get    http://www.example.com/goods
#返回单个商品
get    http://www.example.com/goods/cup
#返回新生成的商品
post   http://www.example.com/goods
#返回一个空文档
delete http://www.example.com/goods

9.使用链接关联相关的资源：

在返回响应结果时提供链接其他api的方法，使客户端很方便的获取相关联的信息。

10.其他：

服务器返回的数据格式，应该尽量使用json，避免使用xml。