如何进行shell脚本正确性测试

Myth丶恋晨 2021-10-26 20:34 332阅读 0赞

### [如何进行shell脚本正确性测试][shell] ###

\----------------------------------------------------------------------------------------

在实际工作中，需要对shell脚本进行正确性测试。

如何用最快最有效的方式进行测试？

很多开发的习惯是，二话不说，写完/拿到，就跑一把，看看输入，输出，想要的操作是否完成，也就过了。

其实这是十分不严谨的，若是未经过QA，风险还是相当大的。

以下即shell脚本测试流程，仅供参考

1.代码走读：

写完，或者拿到一个shell脚本，不必急于运行，虽然实践是检验整理的唯一标准，但是，在读代码这个过程中，可以规避很多低级的bug.

读什么？

A.代码逻辑，这个脚本用来做什么，主要分为多少步，分别做了什么事情？

用于检查是否有遗漏逻辑，或有悖于需求。

B.具体语法，变量，判断语句

语法方面的东西，变量是否定义，判断语句逻辑是否正确，是否考虑各种异常，错误是否退出，返回正确状态值等。

2.语法检测：

shell的语法还是相当让人无语的，很多很容易疏忽遗漏的地方

命令格式： sh -n \*\*\*.sh

![1347710942_8297.jpg][]

若是没有异常输出，证明脚本没有明显的语法问题。

3.运行跟踪：

实践是检验整理的唯一标准，跑一把。

不过，可不是直接运行然后去看最终结果，这样会遗漏掉很多中间过程。

命令格式： sh -vx \*\*\*.sh

得到效果如下:

![1347711301_9041.jpg][]

我们可以看到

每行代码原始命令（无+的）:\[这是-v的效果\]

代码执行时的情况（带+），包括运算结果，逻辑判断结果，变量赋值等等\[-x的效果\]

而我们所要关注的就是这些信息，主要是变量值和逻辑判断结果。

4.覆盖分支：

直接跑，只能覆盖到主体流程，对于其他控制流分支的代码是无法覆盖到的。

对于关键性的，重点的逻辑，我们需要制造条件，使运行脚本可以进入对应分支

5.其他：

A.关于bashdb:

可以尝试下，但是感觉投入产出比不高

B.关于单元测试：

实际工作中，由于项目压力比较大，单元测试的成本还是相当高的，所以目前为止没有。

6.有没有更好的方式？

好吧，单步跟踪，脚本短的还好，日志信息不会太多，要是多了，存在调用其他脚本等等.....

日志量达到几千行，这是很轻易的事情。

跟踪过的童鞋有同感，展现不够友好，惨白惨白一片，一千行下来，看的眼花。

很容易遗漏（LZ被坑了好多回，你看，或不看......错误信息明明就在那里，就是视而不见）

So.进行了一层优化，对日志进行处理，使用正则，标注我关心的信息

效果图对比：

![1347713094_9421.jpg][]

处理后：（对错误，关键信息进行颜色标记，在linux终端可以显示）

![1347713228_8051.jpg][]

脚本是用python实现的，位置:[https://github.com/wklken/pytools/tree/master/shell][https_github.com_wklken_pytools_tree_master_shell]

思想是：执行，抓到所有日志，用正则进行匹配，打上颜色，然后输出

欢迎一起优化，使之功能更完善

代码：

**\[python\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  \#!/bin/env python  
2.  \#-\*- coding:utf-8 -\*-  
3.  \#@Author: wklken  
4.  \#@Mail: wklken@yeah.net ,lingyue.wkl@taobao.com  
5.  \#@Date: 20120706  
6.  \#@Version: 0.1  sh -n, check for static syntax  
7.  \#          0.2  sh -vx, color the output log which i care about  
8.  \#          0.2.1 rebuild all functions , lines  200+ -> 120  
9.  \#          0.2.2 refine the re pattern.  
10. \#          0.2.3 add sh params support. fix bug and add re patterns  
11. \#          0.2.5 add warn/error pattern and collect the result  
12. \#          0.2.6 use decorator to refine print, refine collect method  
13.   
14. \#@Desc: Quick test shell script.The target is hacking into it and get all the status i need.  
15. \#TODO: need to keep source code in 200 lines! refine!  
16.   
17. **import** sys,os  
18. **import** commands  
19. **import** re  
20.   
21. \#color defined  
22. COLOR\_NONE = "C\_NONE"  
23. COLOR\_GREEN = "C\_G"  
24. COLOR\_RED = "C\_R"  
25. COLOR\_YELLOW = "C\_Y"  
26. COLOR\_PURPLE = "C\_P"  
27. COLOR\_BLUE = "C\_B"  
28.   
29. COLOR\_MAP = \{COLOR\_NONE : "\\033\[m",  
30.              COLOR\_GREEN : "\\033\[01;32m",  
31.              COLOR\_RED : "\\033\[01;31m",  
32.              COLOR\_YELLOW : "\\033\[01;33m",  
33.              COLOR\_PURPLE : "\\033\[01;35m",  
34.              COLOR\_BLUE : "\\033\[01;34m",  
35.              None:"\\033\[m" \}  
36.   
37. \#the command used defined  
38. SH\_N = "sh -n "  
39. SH\_X = "sh -vx "  
40. LOG\_BEGIN = "export PS4='+$\{BASH\_SOURCE\}|$\{LINENO\}|$\{FUNCNAME\[0\]\} -> ';"  
41. LOG\_BEGIN = ""  
42.   
43. \#the type of output log line  
44. LINE\_TYPE\_CMD = "CMD"  
45. LINE\_TYPE\_EXC = "EXC"  
46. LINE\_TYPE\_CMT = "CMT"  
47.   
48. CMD\_Y = COLOR\_MAP.get(COLOR\_YELLOW) + "CMD: " + COLOR\_MAP.get(COLOR\_NONE)  
49.   
50. \#----------pattern used to match begin -----------------------------  
51. \#0. special  
52. PATTERN\_ADDSIGN = re.compile("(^\\++)")  
53.   
54. \#1. execute command log match pattern  
55. exc\_mark\_pattern = \[(r"(\[\\\[\\\]\])", COLOR\_YELLOW), \#for condition testing   must be the first one  
56.                     (r"((\[12\]\\d\{3\})(1\[12\]|0\[1-9\])(0\[1-9\]|1\\d|2\\d|3\[01\]))",COLOR\_PURPLE), \#date yyyyMMDD  
57.                     (r"(tbsc-dev)", COLOR\_RED),  \# path: tbsc-dev  
58.                     (r"(\[a-zA-Z\_\]\[a-zA-Z0-9\_\]\*=\[\\s|\\"\\"\]\*)$",COLOR\_RED),   \# params=None  
59.                     (r"(exit\\s+-?\\d\*|return\\s+-?\\d\*)",COLOR\_BLUE), \#exit status  
60.                     (r"(\\s(\\-\[acbdefgnorsuwxzL\]|\\-(lt|le|gt|ge|eq|ne))\\s)", COLOR\_YELLOW),  
61.                     (r"((\\s(=|==|<=|>=|\\+=|<|>|'!='|\\&\\&)\\s)|'!')", COLOR\_YELLOW),  
62.                     (r"(\\s(\\-input|\\-output|\\-i|\\-o)\\s)", COLOR\_YELLOW),  
63.                     \]  
64. EXC\_MARK\_PATTERN = \[(re.compile(s),color) **for** s,color **in** exc\_mark\_pattern\]  
65.   
66. \#2. error/warn result log match pattern  
67. \# 100% error  
68. error\_mark\_pattern = \[(r"(No such file or directory|command not found|unknown option|invalid option)",COLOR\_RED), \#result -> file not found  
69.                     (r"(unary operator expected)",COLOR\_RED), \# test failed  
70.                     (r"(Permission denied)",COLOR\_RED),  
71.                     (r"(syntax error|unexpected|read error)",COLOR\_RED),  
72.                     (r"(java.io.FileNotFoundException|org.apache.hadoop.mapred.InvalidInputException|java.lang.IllegalMonitorStateException)", COLOR\_RED),\#javaerror  
73.                     \]  
74. ERROR\_MARK\_PATTERN = \[(re.compile(s),color) **for** s,color **in** error\_mark\_pattern\]  
75.   
76. \# may be not error ,just warn,notice  
77. warn\_mark\_pattern = \[\]  
78. WARN\_MARK\_PATTERN = \[(re.compile(s),color) **for** s,color **in** warn\_mark\_pattern\]  
79.   
80. \#3. command log match pattern  
81. cmd\_mark\_pattern = error\_mark\_pattern + warn\_mark\_pattern + \\  
82.                     \[  
83.                     (r"(line \\d+)", COLOR\_RED), \#error report the line No  
84.                     (r"(\\$(\\\{\\w+\\\}))", COLOR\_PURPLE),  
85.                     (r"(\\.\\.)",COLOR\_PURPLE), \#相对路径  
86.                     (r"((?<!-)\\b(\\w+)\\b=)", COLOR\_YELLOW),  
87.                     (r"(\\$(\\w+))", COLOR\_PURPLE), \#变量名  
88.                     (r"(\\w+\\.sh\\s\*)", COLOR\_GREEN), \#\*.sh  
89.                     (r"(\`)", COLOR\_GREEN),  \# \`\`  
90.                     (r"(\\s?\\w+\\s\*\$\$)", COLOR\_GREEN), \#function()  
91.                     (r"(\\\{\\s\*$|^\\\}\\s\*$)", COLOR\_GREEN), \# function \{\}  
92.                     (r"(^export\\s|^source\\s)", COLOR\_YELLOW),  
93.                     (r"(\\|)", COLOR\_GREEN),  
94.                     (r"(<<|>>|<|>)", COLOR\_YELLOW),  
95.                     \]  
96. CMD\_MARK\_PATTERN = \[(re.compile(s),color) **for** s,color **in** cmd\_mark\_pattern\]  
97. \#----------pattern used to match end -----------------------------  
98.   
99. \#static params defined  
100. error\_lines = \[\]  
101.   
102. \#functions begin  
103. **def** str\_coloring(str\_info, color=COLOR\_NONE):  
104.     """color str"""  
105.     **return** COLOR\_MAP.get(color, COLOR\_MAP.get(None)) + str\_info + COLOR\_MAP.get(COLOR\_NONE)  
106.   
107. **def** print\_symbol(str\_info):  
108.     """print the symbol"""  
109.     **print** "-"\*20 + str\_info + "-"\*20  
110.   
111. **def** wrap\_print\_func(arg):  
112.     """wrap func, print begin and end sign"""  
113.     **def**  newfunc(func):  
114.         **def** newfunc\_withparams(\*args, \*\*kwargs):  
115.             print\_symbol(arg+" BEGIN")  
116.             func(\*args, \*\*kwargs)  
117.             print\_symbol(arg+" END")  
118.         **return** newfunc\_withparams  
119.     **return** newfunc  
120.  
121. @wrap\_print\_func("STATIC SYNTAX")  
122. **def** static\_syntax\_check(file\_path):  
123.     """Check the static syntax"""  
124.     cmd = SH\_N + file\_path  
125.     result = commands.getoutput(cmd)  
126.     **if** result:  
127.         **print** "script syntax check:"\+str\_coloring(" FAILED", COLOR\_RED)  
128.         **print** str\_coloring(result,COLOR\_RED)  
129.     **else**:  
130.         **print** "script syntax check:"\+str\_coloring(" PASS", COLOR\_GREEN)  
131.   
132. **def** pre\_handler(result):  
133.     """pre handle the result lines """  
134.     **pass**  
135.  
136. @wrap\_print\_func("PROCESS LOG CHECK")  
137. **def** dynamic\_log\_process(file\_path, params):  
138.     """Process the log of sh script"""  
139.     cmd = LOG\_BEGIN + SH\_X + file\_path + " " + params  
140.     result = commands.getoutput(cmd)  
141.     pre\_handler(result)  
142.     process\_line(result)  
143.   
144. **def** cmd\_type(line):  
145.     """return the type of line,and can do something with it"""  
146.     **if** line.startswith("+"):  
147.         **return** LINE\_TYPE\_EXC,line  
148.     **elif** line.lstrip().startswith("\#"):  
149.         **return** LINE\_TYPE\_CMT,line  
150.     **else**:  
151.         \#return LINE\_TYPE\_CMD, CMD\_Y + line  
152.         **return** LINE\_TYPE\_CMD,line  
153.   
154. **def** mark\_sign\_by\_pattern(line, line\_type=LINE\_TYPE\_EXC):  
155.     """mark the str by pattern"""  
156.     \#can't use in py2.4,ni mei a  
157.     \#use\_pattern = EXC\_MARK\_PATTERN if line\_type == LINE\_TYPE\_EXC else CMD\_MARK\_PATTERN  
158.     **if** line\_type == LINE\_TYPE\_EXC:  
159.         use\_pattern = EXC\_MARK\_PATTERN  
160.     **else**:  
161.         use\_pattern = CMD\_MARK\_PATTERN  
162.     native\_line = line  
163.     **for** pt,color **in** use\_pattern:  
164.         m = pt.findall(line)  
165.         **if** m:  
166.             line = pt.sub( COLOR\_MAP.get(color)+r"\\1"\+COLOR\_MAP.get(COLOR\_NONE), line)  
167.     **for** pt,color **in** ERROR\_MARK\_PATTERN:  
168.         e = pt.findall(native\_line)  
169.         **if** e:  
170.             error\_lines.append(line)  
171.     **return** line  
172.   
173. **def** process\_line(result):  
174.     """format each line.With the pattern"""  
175.     lines = result.split("\\n")  
176.     **for** line **in** lines:  
177.         line\_type, line = cmd\_type(line)  
178.   
179.         **if** line\_type == LINE\_TYPE\_EXC:  
180.             result = mark\_sign\_by\_pattern(line, line\_type)  
181.             **print** PATTERN\_ADDSIGN.sub(COLOR\_MAP.get(COLOR\_GREEN)+r"\\1"\+COLOR\_MAP.get(COLOR\_NONE),result)  
182.         **elif** line\_type == LINE\_TYPE\_CMD:  
183.             **print** mark\_sign\_by\_pattern(line, line\_type)  
184.         **elif** line\_type == LINE\_TYPE\_CMT:  
185.             **print** line  
186.  
187. @wrap\_print\_func("RESULT COLLECT")  
188. **def** warn\_error\_collect(collect\_list, collect\_type="ERROR"):  
189.     **print** str\_coloring("RESULT TYPE: " + collect\_type, COLOR\_GREEN)  
190.     **if** len(collect\_list):  
191.         **print** str\_coloring(collect\_type+" FOUND: ", COLOR\_RED) + str\_coloring(str(len(collect\_list)), COLOR\_YELLOW)   
192.         **for** line **in** collect\_list:  
193.             **print** line  
194.     **else**:  
195.         **print** str\_coloring("NO " + collect\_type + " FOUND", COLOR\_GREEN)  
196.   
197. args = sys.argv\[1:\]  
198. sh\_name = args\[0\]  
199. params = " ".join(args\[1:\])  
200.   
201. static\_syntax\_check(sh\_name)  
202.   
203. dynamic\_log\_process(sh\_name, params)  
204.   
205. warn\_error\_collect(error\_lines, "ERROR")

好了，就这些

[shell]: http://blog.csdn.net/wklken/article/details/7983054
[1347710942_8297.jpg]: https://img-my.csdn.net/uploads/201209/15/1347710942_8297.jpg
[1347711301_9041.jpg]: https://img-my.csdn.net/uploads/201209/15/1347711301_9041.jpg
[1347713094_9421.jpg]: https://img-my.csdn.net/uploads/201209/15/1347713094_9421.jpg
[1347713228_8051.jpg]: https://img-my.csdn.net/uploads/201209/15/1347713228_8051.jpg
[https_github.com_wklken_pytools_tree_master_shell]: https://github.com/wklken/pytools/tree/master/shell
[view plain]: http://blog.csdn.net/wklken/article/details/7983054#