python写的tcp层mock工具（tcp socket python）

本篇文章给大家谈谈python写的tcp层mock工具，以及tcp socket python对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。 今天给各位分享python写的tcp层mock工具的知识，其中也会对tcp socket python进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、python mock简单了解使用
• 2、Python中好用的第三方mock库-httmock
• 3、python单元测试--mock
• 4、如何用python 来mock一个web响应
• 5、Python unittest的mock模块怎么理解side
• 6、Python网络编程 -- TCP/IP

python mock简单了解使用

Mock就是模拟，在测试一个对象或服务时，为排除其python写的tcp层mock工具他因素对本身对象或服务python写的tcp层mock工具的测试，事先设定且符合预期python写的tcp层mock工具的（正常和异常处理）Mock对象。来被测对象功能是否满足需求，异常逻辑或压力情况下工作是否正常
如此例模拟通过第三方接口返回python写的tcp层mock工具的状态，假设自己写的一个处理逻辑是oneurl_is_accessable()
oneurl()的功能是访问 .com ，状态需要依赖的第三方接口的返回，要验证的自己写的逻辑oneurl_is_accessable()判断第三方接口返回的状态码，如果是200返回‘访问正常’，否则‘访问异常’
tmptestdemo.py文件为被测逻辑所在文件，具体内容如下

testdemo.py为测试模块
对被测对象oneurl_is_accessable()编写用例，利用mock模拟oneurl()的返回状态

执行结果python写的tcp层mock工具：

Python中好用的第三方mock库-httmock

在做一些项目的时候，因为用到了第三方的接口，而第三方的接口可能没有做好或者第三方的接口不方便访问的时候，一般都会用到Mock的技术。

Mock这个词在英语中有模拟的这个意思。Python3.x中本身就自带了Mock库，（Python2.x中还是单独的）Mock是Python中一个用于支持单元测试的库，它的主要功能是使用mock对象替代掉指定的Python对象，以达到模拟对象的行为。

简单的说，mock库用于如下的场景：

假设你开发的项目叫a，里面包含了一个模块b，模块b中的一个函数c（也就是a.b.c）在工作的时候需要调用发送请求给特定的服务器来得到一个JSON返回值，然后根据这个返回值来做处理。如果要为a.b.c函数写一个单元测试，该如何做？

一个简单的办法是搭建一个测试的服务器，在单元测试的时候，让a.b.c函数和这个测试服务器交互。但是这种做法有两个问题：

1 . 测试服务器可能很不好搭建，或者搭建效率很低。
2 . 你搭建的测试服务器可能无法返回所有可能的值，或者需要大量的工作才能达到这个目的。

httmock库是基于Mock库的，它更方便于用requests的方式来返回接口的值。

使用pip命令来安装：

用法：

1 您可以使用它来模拟第三方API和在内部使用 requests 的测试库，有条件地使用 urlmatch 装饰器：

控制台显示:

2 all_requests 装饰器没有条件地阻止实际的请求。 如果您返回一个字典，它将映射到返回的“request.Response”对象：

控制台显示：

3 如果你传递 Set-Cookie 头， request.Response.cookies 将包含这些值。 您也可以直接使用 response 方法，而不是返回一个dict：

控制台显示：

CC先生说：
要明白上面的例子，预备知识至少需要有：
-Python 中requests库的用法
-Python中装饰器的用法

or 你直接套用上面的用法就可以返回第三方接口或者依赖的模块的值了。

以上

python单元测试--mock

使用mock，可以将某个函数所依赖的对象或者变量mock掉，从而降低测试条件的负责度。如下所示：

上述是mock对象的简单使用方法，通过实例化一个Mock对象从而模拟掉原始函数的返回值，高级一些的用法就是通过mock.patch装饰器，装饰在类或者函数上进行模拟测试，如下在test.py文件中有两个类：

测试用例设计如下：

以上测试用例说明，通过patch装饰器模拟了 test.ProductionClass1 这个类，在 test_01 中使用 mock_class 模拟 test.ProductionClass1 。首先通过 mock_class.return_value 获取类实例（如果模拟的是函数，则不需要这一步），然后通过 obj1.pro1_method.return_value 设置方法的返回值，并进行测试。测试结果说明无论是通过 mock_class 还是 test.ProductionClass1 还是 obj1 执行方法，获取到的结果都是设置的值，并且在另一个类中调用模拟类的方法，也能成功获取到设置的 return_value 。

如何用python 来mock一个web响应

什么是mock?
mock在翻译过来有模拟的意思。这里要介绍的mock是辅助单元测试的一个模块。它允许您用模拟对象替换您的系统的部分，并对它们已使用的方式进行断言。
在Python2.x 中 mock是一个单独模块，需要单独安装。
pip install -U mock
在Python3.x中，mock已经被集成到了unittest单元测试框架中，所以，可以直接使用。
可能你和我初次接触这个概念的时候会有这样的疑问：把要测的东西都模拟掉了还测试什么呢？
但在，实际生产中的项目是非常复杂的，对其进行单元测试的时候，会遇到以下问题：
接口的依赖
外部接口调用
测试环境非常复杂
单元测试应该只针对当前单元进行测试, 所有的内部或外部的依赖应该是稳定的, 已经在别处进行测试过的.使用mock 就可以对外部依赖组件实现进行模拟并且替换掉, 从而使得单元测试将焦点只放在当前的单元功能。
简单的例子
我们先从最简单例子开始。
modular.py
#modular.py
class Count():
def add(self):
pass
这里要实现一个Count计算类，add() 方法要实现两数相加。但，这个功能我还没有完成。这时就可以借助mock对其进行测试。
mock_demo01.py
from unittest import mock
import unittest
from modular import Count
# test Count class
class TestCount(unittest.TestCase):
def test_add(self):
count = Count()
count.add = mock.Mock(return_value=13)
result = count.add(8,5)
self.assertEqual(result,13)
if __name__ == '__main__':
unittest.main()
count = Count()
首先，调用被测试类Count() 。
count.add = mock.Mock(return_value=7)
通过Mock类模拟被调用的方法add()方法，return_value 定义add()方法的返回值。
result = count.add(2,5)
接下来，相当于在正常的调用add()方法，传两个参数2和5，然后会得到相加的结果7。然后，7的结果是我们在上一步就预先设定好的。
self.assertEqual(result,7)
最后，通过assertEqual()方法断言，返回的结果是否是预期的结果7。
运行测试结果：
python3 mock_demo01.py
.
----------------------------------------------------------------------
Ran 1 test in 0.000s
OK
这样一个用例就在mock的帮助下编写完成，并且测试通过了。
完成功能测试
再接下来完成module.py文件中add()方法。
#module.py
class Count():
def add(self, a, b):
return a + b
然后，修改测试用例：
from unittest import mock
import unittest
from module import Count
class MockDemo(unittest.TestCase):
def test_add(self):
count = Count()
count.add = mock.Mock(return_value=13, side_effect=count.add)
result = count.add(8, 8)
print(result)
count.add.assert_called_with(8, 8)
self.assertEqual(result, 16)
if __name__ == '__main__':
unittest.main()
count.add = mock.Mock(return_value=13, side_effect=count.add)
side_effect参数和return_value是相反的。它给mock分配了可替换的结果，覆盖了return_value。简单的说，一个模拟工厂调用将返回side_effect值，而不是return_value。
所以，设置side_effect参数为Count类add()方法，那么return_value的作用失效。
result = count.add(8, 8)
print(result)
这次将会真正的调用add()方法，得到的返回值为16（8+8）。通过print打印结果。
assert_called_with(8,8)
检查mock方法是否获得了正确的参数。
解决测试依赖
前面的例子，只为了让大家对mock有个初步的印象。再接来，我们看看如何mock方法的依赖。
例如，我们要测试A模块，然后A模块依赖于B模块的调用。但是，由于B模块的改变，导致了A模块返回结果的改变，从而使A模块的测试用例失败。其实，对于A模块，以及A模块的用例来说，并没有变化，不应该失败才对。
这个时候就是mock发挥作用的时候了。通过mock模拟掉影响A模块的部分（B模块）。至于mock掉的部分（B模块）应该由其它用例来测试。
# function.py
def add_and_multiply(x, y):
addition = x + y
multiple = multiply(x, y)
return (addition, multiple)
def multiply(x, y):
return x * y
然后，针对 add_and_multiply()函数编写测试用例。func_test.py
import unittest
import function
class MyTestCase(unittest.TestCase):
def test_add_and_multiply(self):
x = 3
y = 5
addition, multiple = function.add_and_multiply(x, y)
self.assertEqual(8, addition)
self.assertEqual(15, multiple)
if __name__ == "__main__":
unittest.main()
运行结果：
python3 func_test.py
.
----------------------------------------------------------------------
Ran 1 test in 0.000s
OK
目前运行一切正确常，然而，add_and_multiply()函数依赖了multiply()函数的返回值。如果这个时候修改multiply()函数的代码。
……
def multiply(x, y):
return x * y + 3
这个时候，multiply()函数返回的结果变成了x*y加3。
再次运行测试：
python3 func_test.py
F
======================================================================
FAIL: test_add_and_multiply (__main__.MyTestCase)
----------------------------------------------------------------------
Traceback (most recent call last):
File "fun_test.py", line 19, in test_add_and_multiply
self.assertEqual(15, multiple)
AssertionError: 15 != 18
----------------------------------------------------------------------
Ran 1 test in 0.000s
FAILED (failures=1)
测试用例运行失败了，然而，add_and_multiply()函数以及它的测试用例并没有做任何修改，罪魁祸首是multiply()函数引起的，我们应该把 multiply()函数mock掉。
import unittest
from unittest.mock import patch
import function
class MyTestCase(unittest.TestCase):
@patch("function.multiply")
def test_add_and_multiply2(self, mock_multiply):
x = 3
y = 5
mock_multiply.return_value = 15
addition, multiple = function.add_and_multiply(x, y)
mock_multiply.assert_called_once_with(3, 5)
self.assertEqual(8, addition)
self.assertEqual(15, multiple)
if __name__ == "__main__":
unittest.main()
@patch("function.multiply")
patch()装饰/上下文管理器可以很容易地模拟类或对象在模块测试。在测试过程中，您指定的对象将被替换为一个模拟（或其他对象），并在测试结束时还原。
这里模拟function.py文件中multiply()函数。
def test_add_and_multiply2(self, mock_multiply):
在定义测试用例中，将mock的multiply()函数（对象）重命名为 mock_multiply对象。
mock_multiply.return_value = 15
设定mock_multiply对象的返回值为固定的15。
ock_multiply.assert_called_once_with(3, 5)
检查ock_multiply方法的参数是否正确。
再次，运行测试用例，通过！
---------------------------------------------------

Python unittest的mock模块怎么理解side

return_value就是被mock的对象被调用时的返回值
side_effect用于replace被mock的对象的。 调用于被mock的对象相当于调用side_effect.
建议阅读一下mock的源码，不长，大概2000行，配合官方文档，很容易理解的。

Python网络编程 -- TCP/IP

首先放出一个 TCP/IP 的程序python写的tcp层mock工具，这里是单线程服务器与客户端python写的tcp层mock工具，在多线程一节会放上多线程的TCP/IP服务程序。

这里将服务端和客户端放到同一个程序当中，方便对比服务端与客户端的不同。

TCP/IP是因特网的通信协议，其参考OSI模型，也采用了分层的方式，对每一层制定了相应的标准。

网际协议（IP）是为全世界通过互联网连接的计算机赋予统一地址系统的机制，它使得数据包能够从互联网的一端发送至另一端，如 130.207.244.244，为了便于记忆，常用主机名代替IP地址，例如 baidu.com。

UDP (User Datagram Protocol，用户数据报协议) 解决了上述第一个问题，通过端口号来实现了多路复用（用不同的端口区分不同的应用程序）但是使用UDP协议的网络程序需要自己处理丢包、重包和包的乱序问题。

TCP (Transmission Control Protocol，传输控制协议) 解决了上述两个问题，同样使用端口号实现了复用。

TCP 实现可靠连接的方法：

socket通信模型及 TCP 通信过程如下两张图。

[图片上传失败...(image-6d947d-1610703914730)]

[图片上传失败...(image-30b472-1610703914730)]

socket.getaddrinfo(host, port, family, socktype, proto, flags)
返回： [(family, socktype, proto, cannonname, sockaddr), ] 由元组组成的列表。
family：表示socket使用的协议簇， AF_UNIX : 1, AF_INET: 2, AF_INET6 : 10。 0 表示不指定。
socktype: socket 的类型， SOCK_STREAM : 1, SOCK_DGRAM : 2, SOCK_RAW : 3
proto: 协议， 套接字所用的协议，如果不指定， 则为 0。 IPPROTO_TCP : 6, IPPRTOTO_UDP : 17
flags：标记，限制返回内容。 AI_ADDRCONFIG 把计算机无法连接的所有地址都过滤掉（如果一个机构既有IPv4，又有IPv6，而主机只有IPv4，则会把 IPv6过滤掉）
AI _V4MAPPED, 如果本机只有IPv6，服务却只有IPv4，这个标记会将 IPv4地址重新编码为可实际使用的IPv6地址。
AI_CANONNAME，返回规范主机名：cannonname。
getaddrinfo(None, 'smtp', 0, socket.SOCK_STREAM, 0, socket.AP_PASSIVE)
getaddrinfo('ftp.kernel.org', 'ftp', 0, 'socket.SOCK_STREAM, 0, socket.AI_ADDRCONFIG | socket.AI_V4MAPPED)
利用已经通信的套接字名提供给getaddrinfo
mysock = server_sock.accept()
addr, port = mysock.getpeername()
getaddrinfo(addr, port, mysock.family, mysock.type, mysock.proto, socket.AI_CANONNAME)

TCP 数据发送模式：

由于 TCP 是发送流式数据，并且会自动分割发送的数据包，而且在 recv 的时候会阻塞进程，直到接收到数据为止，因此会出现死锁现象，及通信双方都在等待接收数据导致无法响应，或者都在发送数据导致缓存区溢出。所以就有了封帧(framing)的问题，即如何分割消息，使得接收方能够识别消息的开始与结束。

关于封帧，需要考虑的问题是， 接收方何时最终停止调用recv才是安全的？整个消息或数据何时才能完整无缺的传达？何时才能将接收到的消息作为一个整体来解析或处理。

适用UDP的场景：

由于TCP每次连接与断开都需要有三次握手，若有大量连接，则会产生大量的开销，在客户端与服务器之间不存在长时间连接的情况下，适用UDP更为合适，尤其是客户端太多的时候。

第二种情况： 当丢包现象发生时，如果应用程序有比简单地重传数据聪明得多的方法的话，那么就不适用TCP了。例如，如果正在进行音频通话，如果有1s的数据由于丢包而丢失了，那么只是简单地不断重新发送这1s的数据直至其成功传达是无济于事的。反之，客户端应该从传达的数据包中任意选择一些组合成一段音频（为了解决这一问题，一个智能的音频协议会用前一段音频的高度压缩版本作为数据包的开始部分，同样将其后继音频压缩，作为数据包的结束部分），然后继续进行后续操作，就好像没有发生丢包一样。如果使用TCP，那么这是不可能的，因为TCP会固执地重传丢失的信息，即使这些信息早已过时无用也不例外。UDP数据报通常是互联网实时多媒体流的基础。

参考资料： 关于python写的tcp层mock工具和tcp socket python的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。 python写的tcp层mock工具的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于tcp socket python、python写的tcp层mock工具的信息别忘了在本站进行查找喔。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。