教程跑通一百遍不算产出，别人一条命令能复跑才算。

晚上十点半，学习群里又顶上来了那条推送：“某某校园招聘正式开启”。你点了收藏，没点进去——能拿得出手的还是上个月跟教程搭的那个 demo：同学拿去，第一步依赖安装就红了。这是测试新人作品集最典型的空档：教程存了几十份，能重跑的交付物，零个。

把时间锚放在这里：据浙江大学就业网（页面时间 2026-09-21），网易（杭州）2027 届秋季校园招聘已全球开启；更早的 8 月 11 日，腾讯面向 2026.1—2027.12 毕业生的 2027 届批次就已启动；这个月，央企 AI 子公司的新批次启动消息也在往外冒，同时部分批次的投递窗口已经进到收口阶段。10 月上旬还在开新批次，10 月上旬也有批次在关门——这两句不矛盾，矛盾的是你手里那份还在“学完再说”的计划。

你的项目死在哪一句话上：别人跑不通

新人练手项目的死法高度一致：不是没写代码，是交付物里没有“可重跑”这一环。问题不出在努力程度，出在“做完”的定义里从来没有“别人能跑”这一条验收标准。三条可以直接摘走的话：会工具不等于能交活——交付物的验收人从来不是你自己；一份项目“能重跑”的定义是换一个人、换一台机器、照 README 跑，能得出同一结论；AI Coding 和教程把“本地跑通”变得不值钱之后，“别人能重跑”成了新人产出物里唯一还有区分度的部分。

维度
看完教程的“跑通了”
能重跑的小产出
环境
你电脑上那套，版本没人记得
README 写死依赖与启动命令，新机器照抄可用
数据
手动改过几个文件、点过几遍页面
脚本自己造、自己清，跑一百遍状态一致
结论
“我看着是好的”
断言链输出 PASS/FAIL，写进结果件
别人接手
要你远程开着语音一步步喂
一条命令 + 一份结果文件
失败时
悄悄绕过、注释掉那行
留一份失败样例，说明它为什么该失败
三个月后
你自己都跑不起来了
拉下来重跑，结论还是同一个
能重跑的小项目到底要交哪几样？四件，一样不能少

四件产出物，各自证明一件事。①一条能跑的断言链：不是“一个脚本”，是一串能反复跑出同一结论的“动作 + 预期”；缺了它，你的项目只证明了你演示过一次。②一页 README，固定四栏：环境、数据前提、怎么跑、预期输出；缺了它，断言链只有你能跑。③一次流水线跑通的留痕：构建号 + 结果件位置，一个就够——流水线不用做得花哨，拉代码、装 Python、跑脚本、归档结果件，GitHub Actions 或内部 CI 上这四步跑通一次记下构建号即可；缺了它，“我本地能跑”仍然是孤证——流水线证明它在别人的机器上也能跑。④一段真实失败样例：一个预期内该失败的请求或该红的断言；缺了它，没人信你的全绿不是挑出来的。

产出物
它证明什么
缺了会怎样
断言链
结论可复算，不靠眼睛
退回“我演示过一次”
一页 README
换人能搭起来
项目只有你自己会跑
流水线留痕
在你的机器之外也成立
“本地能跑”成为孤证
失败样例
绿的含金量
别人默认你只留了好看的记录

接口测试练习项目怎么做？先看一个单文件、断网也能重跑的样本

下面这份单文件脚本（纯标准库、离线可跑、复制即运行）把四件里的三件先做实：用纯标准库起一个本地构造的 ToDo HTTP 服务当被测对象（端口让系统随机分配，专治“换台机器端口被占就崩”），对它的两个端点跑一条五步断言链，再把结论落成一份 JSON 结果件。断言链的形态值得细看：每一步都是一个动作配一个可核对的预期，A5 那一步是故意的失败样例——空标题必须被拒成 400，它红了才说明服务是认真的。这条链还有个身份：被测对象换一个新版本，链子原样再跑一遍，哪一步绊倒一眼可见——所谓回归集，起点就是这样一个小东西。

deliverable_demo.py —— 一条能重跑的断言链：本地起服务 + 5 步断言 + 落一份 JSON 结果件

纯标准库（http.server / threading / urllib / json），单文件、离线可跑：

python deliverable_demo.py

import json
import os
import threading
import urllib.error
import urllib.request
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

DB = {"todos": [], "next_id": 1} # 被测对象的状态：进程内内存，每次启动都是干净的

class TodoHandler(BaseHTTPRequestHandler):
"""一个最小的构造被测系统：/health、/todos 两个端点，故意对空标题返回 400。"""

def _send(self, code, payload):
    body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
    self.send_response(code)
    self.send_header("Content-Type", "application/json; charset=utf-8")
    self.send_header("Content-Length", str(len(body)))
    self.end_headers()
    self.wfile.write(body)

def do_GET(self):
    if self.path == "/health":
        self._send(200, {"ok": True})
    elif self.path == "/todos":
        self._send(200, {"todos": DB["todos"]})
    else:
        self._send(404, {"error": "not_found"})

def do_POST(self):
    if self.path != "/todos":
        self._send(404, {"error": "not_found"})
        return
    n = int(self.headers.get("Content-Length", 0))
    try:
        data = json.loads(self.rfile.read(n) or b"{}")
    except json.JSONDecodeError:
        self._send(400, {"error": "bad_json"})
        return
    title = str(data.get("title", "")).strip()
    if not title:
        self._send(400, {"error": "title_required"})   # 失败样例的预期行为
        return
    item = {"id": DB["next_id"], "title": title, "done": False}
    DB["next_id"] += 1
    DB["todos"].append(item)
    self._send(201, {"item": item})

def log_message(self, fmt, *args):   # 安静模式：别让访问日志淹掉断言链输出
    pass

def http_json(base, method, path, payload=None):
req = urllib.request.Request(
base + path, method=method,
data=json.dumps(payload, ensure_ascii=False).encode("utf-8") if payload is not None else None,
headers={"Content-Type": "application/json"})
try:
with urllib.request.urlopen(req, timeout=5) as resp:
return resp.status, json.loads(resp.read().decode("utf-8"))
except urllib.error.HTTPError as e:
return e.code, json.loads(e.read().decode("utf-8"))

def assertion_chain(base):
"""五个断言步骤：每步 = 一个动作 + 一个可核对的预期。换台机器跑，结论必须一样。"""
chain = []

def step(name, cond, expected, actual):
    chain.append({"step": name, "expected": expected, "actual": actual,
                  "pass": bool(cond)})

code, body = http_json(base, "GET", "/health")
step("A1 服务活着", code == 200 and body.get("ok") is True, "200 + ok=true", f"{code} + {body}")

code, body = http_json(base, "GET", "/todos")
step("A2 初始为空", code == 200 and body["todos"] == [], "200 + todos=[]", f"{code} + {body}")

code, body = http_json(base, "POST", "/todos", {"title": "回归冒烟用例编写"})
item = body.get("item", {})
step("A3 新建返回201", code == 201 and item.get("id") == 1, "201 + id=1", f"{code} + {item}")

code, body = http_json(base, "GET", "/todos")
step("A4 读回一致", code == 200 and len(body["todos"]) == 1
     and body["todos"][0]["title"] == "回归冒烟用例编写", "200 + 1条且标题一致", f"{code} + {body}")

code, body = http_json(base, "POST", "/todos", {"title": "   "})
step("A5 空标题应被拒", code == 400 and body.get("error") == "title_required",
     "400 + title_required", f"{code} + {body}")
return chain

if name == "main":
srv = ThreadingHTTPServer(("127.0.0.1", 0), TodoHandler) # 端口0：让系统挑空闲端口
port = srv.server_address[1]
threading.Thread(target=srv.serve_forever, daemon=True).start()
base = f"http://127.0.0.1:{port}"
print(f"被测对象：本地构造的 ToDo HTTP 服务（{base}，纯内存，进程退出即销毁）")

chain = assertion_chain(base)
for c in chain:
    print(f"  [{'PASS' if c['pass'] else 'FAIL'}] {c['step']:<10} 预期 {c['expected']} 实际 {c['actual']}")

all_pass = all(c["pass"] for c in chain)
out = {"suite": "todo_min_chain", "target": "本地构造服务（不代表任何真实系统）",
       "steps_total": len(chain), "steps_passed": sum(c["pass"] for c in chain),
       "verdict": "PASS" if all_pass else "FAIL", "chain": chain}
path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "result_todo_chain.json")
with open(path, "w", encoding="utf-8") as f:
    json.dump(out, f, ensure_ascii=False, indent=2)

print(f"结论：{out['steps_passed']}/{out['steps_total']} 步全过 = {out['verdict']}")
print(f"结果件：{path}")
srv.shutdown()

本地实跑，python deliverable_demo.py：

被测对象：本地构造的 ToDo HTTP 服务（http://127.0.0.1:57481，纯内存，进程退出即销毁）
[PASS] A1 服务活着 预期 200 + ok=true　实际 200 + {'ok': True}
[PASS] A2 初始为空 预期 200 + todos=[]　实际 200 + {'todos': []}
[PASS] A3 新建返回201 预期 201 + id=1　实际 201 + {'id': 1, 'title': '回归冒烟用例编写', 'done': False}
[PASS] A4 读回一致 预期 200 + 1条且标题一致　实际 200 + {'todos': [{'id': 1, 'title': '回归冒烟用例编写', 'done': False}]}
[PASS] A5 空标题应被拒 预期 400 + title_required　实际 400 + {'error': 'title_required'}
结论：5/5 步全过 = PASS
结果件：C:..._tmp_1012\a4\repro_build\result_todo_chain.json
同一台机器连跑三遍做校验：断言链五步的判定逐字一致，两次输出里唯一的差异是那次随机分配的端口号——这正是结果件该长成的样子：结论可复算，环境噪声看得见。JSON 结果件里存的是 suite 名、五步各自的预期与实际、一个总 verdict，流水线把它当构建产物归档，你的第③件留痕就是“构建号 + 这个文件的位置”。

两周怎么排：每天下班后两小时，做完就进下一格

第 1—3 天：选一个本地可造的对象——一个 ToDo 小服务、一份 CSV 数据集或你熟的业务里最小的一个接口面，要求只有一条：不依赖任何线上系统。
第 4—7 天：写断言链，每条断言写成“动作 + 预期 + 实际”三元组，落结果件；跑满三遍，结论一致才算这格完成。三遍不是仪式感，是成本最低的稳定性检查：一条依赖执行顺序、残留状态或时序差别的链，大概率撑不过三遍；而三份结果件，就是你最早的一批回归记录。
第 8—10 天：补 README 四栏（环境/数据前提/怎么跑/预期输出），再造并解释那段失败样例。
第 11—14 天：接一次流水线（GitHub Actions 或内部 CI 都行），固定跑三遍，截图构建号，把结果件挂成产物。
到第 14 天，你手里的东西经得起一个测试：把仓库链接发给一个同学，不打一个字语音，他自己跑，跑出来和你结果件里同一个 verdict。

做出来还要讲得出：一段经得起追问的项目说明

这段东西怎么写成能摊开讲的项目说明？照“对象—判据—交付—踩坑”四拍：被测对象是我本地构造的 ToDo 服务，不依赖任何线上系统；断言链每一步的判据是预期状态码加预期返回体，不是“我看着对”；交付是链、README、构建留痕、失败样例四件；踩过的坑是早期把端口写死，别人机器端口被占直接崩，改成让系统分配空闲端口之后，重跑才真正成立。四拍里没有一句“精通”“熟练”，但每一句都接得住追问——追问接不住，说明那一拍你自己还没想通。

这套做法管到哪儿，管不到哪儿

先把边界划死。第一，本文的被测服务是本地构造样本，五步断言链和 JSON 结果件都是这份脚本的真实输出，不指涉任何真实系统——本地全绿不代表真实系统没问题，它证明的是“你能交付一个别人跑得动的东西”这一种能力。第二，断言链的判据比工具重要：先想清楚每一步“预期到底是什么”，再挑 pytest、unittest 还是纯标准库；工具换了判据不变，才算链写对了。第三，本文不承诺任何结果：批次时间只取公开公告的定性口径，不写岗位数、人数、薪资，更不承诺这么做完换一个什么结果。想把这四件一次交齐，有系统的实训走的也是这条路径，本文只讲到骨架。下一步：今晚就定下你那个“本地可造的对象”，两周后它就是你产出物栏里的第一行。

能重跑，是新人的产出物和收藏夹之间唯一的那条线。

下一步：把上面这个脚本改成你自己的对象——换一个端点、加一条断言，跑三遍，看 verdict 稳不稳。

本文部分内容参考了霍格沃兹测试开发学社整理的相关技术资料，主要涉及软件测试、自动化测试、测试开发及 AI 测试等内容，侧重测试实践、工具应用与工程经验整理。