<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:media="http://search.yahoo.com/mrss/">
  <channel>
    <title>Efficiency · Nhân Tài Đức</title>
    <link>https://jared.lynskey.co.nz/vi/tags/efficiency/</link>
    <description>Những câu chuyện ngắn về kỹ thuật phần mềm và lãnh đạo đội ngũ kỹ sư — performance review, tuyển dụng và mở rộng team, CI/CD, giám sát DevOps và AI agent. Viết từ Seoul.</description>
    <generator>Hugo</generator>
    <language>vi</language>
    <copyright>© 2026 Nhân Tài Đức</copyright>
    <lastBuildDate>Sat, 07 Nov 2026 00:00:00 +1300</lastBuildDate>
    <atom:link href="https://jared.lynskey.co.nz/vi/tags/efficiency/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>pytest-testmon: chỉ chạy những bài kiểm thử mà thay đổi code của bạn ảnh hưởng tới</title>
      <link>https://jared.lynskey.co.nz/vi/posts/2026/2026-10-26-pytest-testmon/</link>
      <guid isPermaLink="true">https://jared.lynskey.co.nz/vi/posts/2026/2026-10-26-pytest-testmon/</guid>
      <pubDate>Mon, 26 Oct 2026 00:00:00 +1300</pubDate>
      <dc:creator>Jared Lynskey</dc:creator>
      <category>Python</category>
      <category>Django</category>
      <category>pytest</category>
      <category>Testing</category>
      <category>Test Impact Analysis</category>
      <category>CI/CD</category>
      <category>GitHub Actions</category>
      <category>Claude Code</category>
      <category>AI Agents</category>
      <category>Efficiency</category>
      <description>pytest-testmon chỉ chạy các bài kiểm thử mà thay đổi có thể chạm tới, dựa trên bản ghi coverage chứ không phỏng đoán. Thêm vào bộ 2,248 bài Django, script bọc, và một bẫy ở Python 3.14.</description>
      <content:encoded><![CDATA[<p><a href="https://www.testmon.org/"  target="_blank" rel="noreferrer">pytest-testmon</a> là một plugin của pytest, chỉ chạy những bài kiểm thử mà thay đổi của bạn có thể ảnh hưởng tới. Nó dùng coverage.py để theo dõi xem mỗi bài kiểm thử thực thi những dòng code nào, rồi lưu lại mã kiểm tra (checksum) của từng khối code mà bài đó đã chạm vào. Ở lần chạy sau, nó đem các checksum này so với code đang nằm trên đĩa, và chỉ chạy những bài có khối code đã thay đổi, cộng thêm những bài thất bại ở lần trước, nên nó làm luôn cả việc của <code>pytest --lf</code>.</p>
<p>Kỹ thuật chung này gọi là phân tích tác động kiểm thử (test impact analysis), và testmon là một cách miễn phí, mã nguồn mở để có được nó trong Python. Nó cũng hoàn toàn không phụ thuộc vào git: thứ nó đem ra so là những gì nó thấy ở lần chạy trước, dù code đó đã commit hay chưa.</p>
<p>Tuần này tôi đã thêm nó vào bộ kiểm thử Python của ứng dụng chợ mà tôi đang làm, và lý do không đơn thuần là muốn chạy nhanh hơn.</p>
<figure>
  <div class="mc-film">
  <video
    class="my-0 rounded-md"
    controls playsinline preload="none"
    poster="https://jared.lynskey.co.nz/en/posts/2026/2026-10-26-pytest-testmon/testmon-film-poster.jpg" style="background:url('data:image/webp;base64,UklGRmYAAABXRUJQVlA4IFoAAADwBACdASogABIAPw1wqUqmIyGYDAQAYxDE9IAAS3igrsLc+giUXH/mz758faBcoAAA/vVl8+gZ7GYAPuvC1znoo64X/UaaVXzZOS4gxmDEyDUzHvkl6JAAAAA=') center/cover no-repeat"
    width="1280"
    height="720"
    aria-label="Video ngắn có lời dẫn kể lại bài viết này">
    <source src="https://jared.lynskey.co.nz/en/posts/2026/2026-10-26-pytest-testmon/testmon-film.webm" type="video/webm">
    <track kind="subtitles" src="https://jared.lynskey.co.nz/en/posts/2026/2026-10-26-pytest-testmon/testmon-film_en.vtt" srclang="en" label="English">
    <track kind="subtitles" src="https://jared.lynskey.co.nz/en/posts/2026/2026-10-26-pytest-testmon/testmon-film_ja.vtt" srclang="ja" label="日本語">
    <track kind="subtitles" src="https://jared.lynskey.co.nz/en/posts/2026/2026-10-26-pytest-testmon/testmon-film_ko.vtt" srclang="ko" label="한국어">
    <track kind="subtitles" src="https://jared.lynskey.co.nz/en/posts/2026/2026-10-26-pytest-testmon/testmon-film_vi.vtt" srclang="vi" label="Tiếng Việt" default>
    <track kind="subtitles" src="https://jared.lynskey.co.nz/en/posts/2026/2026-10-26-pytest-testmon/testmon-film_zh-cn.vtt" srclang="zh-cn" label="简体中文">
  </video>
  </div>
  <script>window.mcFilm && window.mcFilm()</script><figcaption>Bài viết này dưới dạng video dài khoảng tám phút. Lời dẫn bằng tiếng Anh, có phụ đề tiếng Việt.</figcaption>
</figure>


<h2 class="relative group">Vì sao tôi thêm nó
    <div id="vì-sao-tôi-thêm-nó" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#v%c3%ac-sao-t%c3%b4i-th%c3%aam-n%c3%b3" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>Một yêu cầu tính năng (feature request) thường rất nhỏ: một màn hình, một endpoint, hoặc một quy tắc cần hoạt động khác đi. Thế nhưng việc phải chạy toàn bộ bộ kiểm thử khiến yêu cầu nào cũng phình to hơn thực tế. Bộ kiểm thử có 2,248 bài kiểm thử Django, chạy với bốn tiến trình mất khoảng ba phút rưỡi, còn trên một tiến trình là 11 phút, và lần sửa nào cũng chạy hết toàn bộ, dù gần như tất cả các bài đều kiểm tra những thứ mà yêu cầu đó chưa hề động tới. Khi một bài chẳng liên quan gì bị thất bại, hoặc đơn giản là lần chạy cứ thong thả kéo dài, thì tính năng phải ngồi chờ. Nó bị giữ lại bởi những chuyện nằm ngoài yêu cầu tính năng, và thứ giữ nó lại lại chính là bộ kiểm thử của tôi.</p>
<p>Cách còn lại cũng chẳng tốt hơn: bỏ qua lần chạy toàn bộ, tự đoán xem tệp kiểm thử nào bao phủ thay đổi, và thỉnh thoảng đoán sai. Làm vậy thì nhanh, nhưng không chính xác, mà một thay đổi chưa được kiểm thử đã bị tôi đem phát hành thì cũng là một yêu cầu tính năng tôi sẽ phải làm lại lần thứ hai.</p>
<p>Những bài kiểm thử tôi phải chờ phải đúng là những bài mà thay đổi đó có thể chạm tới, không thừa một bài, không thiếu một bài. testmon cho tôi đúng tập hợp đó dựa trên dữ liệu đã ghi lại, chứ không phải dựa trên phỏng đoán. Bộ kiểm thử đầy đủ thì vẫn chạy, nhưng chạy trong CI, ở một chỗ không cản trở việc tiếp theo tôi đang làm.</p>

<h2 class="relative group">Cách nó quyết định chạy bài nào
    <div id="cách-nó-quyết-định-chạy-bài-nào" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#c%c3%a1ch-n%c3%b3-quy%e1%ba%bft-%c4%91%e1%bb%8bnh-ch%e1%ba%a1y-b%c3%a0i-n%c3%a0o" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>testmon chia mỗi tệp Python thành các khối: phần cấp cao nhất của module, từng class, từng hàm, trong đó thân của các hàm lồng bên trong được tách ra khỏi khối bao quanh nó. Nó lưu checksum của từng khối chứ không bao giờ lưu bản thân code. Trong lúc một bài kiểm thử chạy, coverage.py ghi lại những dòng được thực thi, còn testmon ghi nhận các dòng đó thuộc về khối nào. Ở đây không có phân tích tĩnh (static analysis), cũng không có chuyện đoán mò dựa vào các câu import. Một bài kiểm thử phụ thuộc vào đúng những khối mà nó đã chạy qua.</p>
<p>Lấy ví dụ một module như sau:</p>
<div class="highlight-wrapper"><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="c1"># pricing.py</span>
</span></span><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">subtotal</span><span class="p">(</span><span class="n">items</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nb">sum</span><span class="p">(</span><span class="n">item</span><span class="o">.</span><span class="n">price</span> <span class="o">*</span> <span class="n">item</span><span class="o">.</span><span class="n">quantity</span> <span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="n">items</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">discount</span><span class="p">(</span><span class="n">total</span><span class="p">,</span> <span class="n">code</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="n">code</span> <span class="o">==</span> <span class="s2">&#34;WELCOME10&#34;</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">total</span> <span class="o">*</span> <span class="mf">0.9</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">total</span></span></span></code></pre></div></div>
<p>Một bài kiểm thử chỉ gọi <code>subtotal()</code> sẽ phụ thuộc vào phần cấp cao nhất của module và thân hàm <code>subtotal</code>. Bạn có viết lại <code>discount()</code> thế nào đi nữa thì testmon cũng không chạy lại bài đó, vì nó chưa từng thực thi dòng nào của <code>discount</code>. Ngược lại, chỉ cần đổi một ký tự bên trong <code>subtotal</code> là bài đó chạy lại, kể cả khi thay đổi ấy không thể làm kết quả khác đi. testmon không cố tỏ ra thông minh với các tác dụng phụ: khối nào bạn đã thực thi mà bị thay đổi thì bạn chạy lại.</p>
<p>Nó còn theo dõi cả những thứ bao quanh code. Bản ghi bao gồm phiên bản Python và các gói đã cài cùng phiên bản của chúng. Nó không theo dõi biến môi trường: nếu cùng một bộ code chạy dưới hai module settings khác nhau, bạn phải đặt tên cho chúng bằng <code>--testmon-env</code> (bước 8), không thì chúng dùng chung một bản ghi. Nâng cấp Django thì mọi bài từng chạm vào Django lại bị tính là bị ảnh hưởng, mà trong một ứng dụng Django thì đó là tất cả.</p>

<h2 class="relative group">Những gì nó không nhìn thấy
    <div id="những-gì-nó-không-nhìn-thấy" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#nh%e1%bb%afng-g%c3%ac-n%c3%b3-kh%c3%b4ng-nh%c3%acn-th%e1%ba%a5y" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>testmon theo dõi phần code Python mà bài kiểm thử thực thi. Nó không theo dõi những tệp khác mà bài kiểm thử đọc: template, JSON, văn bản, hay bất cứ thứ gì khác trên đĩa. Nó không theo dõi các dịch vụ được gọi qua mạng. Và những gì chạy một lần trước khi các bài kiểm thử bắt đầu thì nó không thể gắn vào một bài cụ thể nào.</p>
<p>Trong một dự án Django, trước hết đó là migration: chúng chỉ chạy một lần, lúc tạo cơ sở dữ liệu kiểm thử, nên không bài kiểm thử nào có chúng trong bản ghi của mình (script bọc ở bên dưới sẽ dựng lại cơ sở dữ liệu kiểm thử khi có migration mới). Tiếp đến là settings và code khởi động, chạy trong lúc pytest khởi động, nằm ngoài mọi bài kiểm thử riêng lẻ. Và cuối cùng là template cùng các tệp dữ liệu: template không phải là Python, nên sửa một template sẽ không làm chạy lại bài nào render nó.</p>
<p>Bộ kiểm thử của tôi còn có thêm vài trường hợp riêng. Một số bài đọc một tệp JSON chứa dữ liệu mẫu (fixture) dùng chung với bộ kiểm thử của ứng dụng di động. Một số bài kiểm tra gói web đã dựng (bundle), và một số khác kiểm tra đầu ra của một trang tĩnh được sinh ra ngay trong cùng kho mã. Đổi bất cứ thứ nào trong số đó, testmon sẽ vui vẻ báo cho bạn rằng chẳng cần chạy gì cả. Đó là lý do phần hướng dẫn bên dưới bọc testmon trong một script, để script nhận ra những tệp này và chạy toàn bộ khi có tệp nào đã thay đổi.</p>

<h2 class="relative group">Cách thêm nó vào một dự án Django
    <div id="cách-thêm-nó-vào-một-dự-án-django" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#c%c3%a1ch-th%c3%aam-n%c3%b3-v%c3%a0o-m%e1%bb%99t-d%e1%bb%b1-%c3%a1n-django" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>Các bước dưới đây giả định bạn dùng pytest và <a href="https://pytest-django.readthedocs.io/"  target="_blank" rel="noreferrer">pytest-django</a>, cùng với uv để quản lý thư viện phụ thuộc. Nếu dùng pip thì thay <code>uv add --dev</code> bằng <code>pip install</code> và bỏ <code>uv run</code> đi.</p>
<p><strong>1. Cài đặt.</strong></p>
<div class="highlight-wrapper"><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">uv add --dev pytest-testmon</span></span></code></pre></div></div>
<p><strong>2. Bảo đảm pytest chạy được bộ kiểm thử.</strong> testmon là một plugin của pytest, nên khi chạy bằng <code>python manage.py test</code> thì nó không làm gì cả. pytest-django cần biết module settings và các mẫu tên tệp mà bài kiểm thử của bạn dùng:</p>
<div class="highlight-wrapper"><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-ini" data-lang="ini"><span class="line"><span class="cl"><span class="c1"># pytest.ini</span>
</span></span><span class="line"><span class="cl"><span class="k">[pytest]</span>
</span></span><span class="line"><span class="cl"><span class="na">DJANGO_SETTINGS_MODULE</span> <span class="o">=</span> <span class="s">myproject.settings</span>
</span></span><span class="line"><span class="cl"><span class="na">python_files</span> <span class="o">=</span> <span class="s">tests.py test_*.py *_tests.py</span>
</span></span><span class="line"><span class="cl"><span class="na">python_classes</span> <span class="o">=</span> <span class="s">Test* *Tests *TestCase</span></span></span></code></pre></div></div>
<p>Nếu từ trước đến giờ bộ kiểm thử chỉ chạy bằng trình chạy kiểm thử của Django, hãy chạy nó bằng pytest một lần và sửa hết những chỗ khác biệt trước khi thêm testmon. Nếu không, bạn sẽ phải gỡ lỗi hai thứ cùng một lúc.</p>
<p><strong>3. Đừng để bản ghi lọt vào git.</strong> testmon ghi tệp <code>.testmondata</code> vào thư mục gốc của pytest. Đây là một cơ sở dữ liệu SQLite, nên bạn sẽ thấy cả các tệp <code>-shm</code> và <code>-wal</code> nằm cạnh nó, và script bên dưới còn thêm một tệp đánh dấu thời điểm (stamp). Chỉ một mẫu là đủ cho tất cả:</p>
<div class="highlight-wrapper"><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl"># .gitignore
</span></span><span class="line"><span class="cl">.testmondata*</span></span></code></pre></div></div>
<p><strong>4. Ghi lại toàn bộ bộ kiểm thử một lần.</strong> testmon chưa chọn được gì cho đến khi nó đã thấy mọi bài kiểm thử chạy qua:</p>
<div class="highlight-wrapper"><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">uv run pytest --testmon</span></span></code></pre></div></div>
<p>Trong một bản checkout mới tinh, lần chạy đầu tiên đó là toàn bộ bộ kiểm thử trên một tiến trình. Ở dự án của tôi, lần đó mất khoảng 12 phút cho 2,248 bài. Từ đó trở đi, cũng lệnh này sẽ chỉ chạy những bài kiểm thử bị ảnh hưởng. Không có gì thay đổi thì nó không chạy gì cả.</p>
<p>Có hai chỗ dễ vấp. Với testmon 2.2.0 trở về trước, nó cần plugin cache của pytest: lần thử đầu tiên của tôi chạy với <code>-p no:cacheprovider</code> và bị sập với lỗi <code>KeyError: 'lf'</code> (bản 2.3.0 coi việc thiếu <code>--lf</code> là chưa đặt). Còn nếu bạn dùng Python 3.14 trở lên, hãy đặt <code>COVERAGE_CORE=ctrace</code> trước khi ghi. Lý do được giải thích ở phần &ldquo;Lỗi trông như một lần chạy toàn xanh&rdquo; phía dưới. Đây là dòng quan trọng nhất trong script bên dưới.</p>
<p>Cập nhật ngày 7 tháng 11: testmon 2.3.0, phát hành ngày 2 tháng 11, tự ép coverage dùng tracer C, nên với phiên bản này dòng export chỉ còn là cho chắc. Nếu bạn đang ở 2.2.0 trở về trước thì cứ giữ nó. Còn bước cố ý làm hỏng code để kiểm tra thì phiên bản nào cũng nên làm.</p>
<p><strong>5. Bọc nó lại để lo những tệp nó không nhìn thấy.</strong> Đây là phần giúp bạn yên tâm dùng nó hằng ngày. Script giữ một tệp stamp từ lúc bắt đầu lần chạy trước. Nếu có tệp nào mà testmon không lần theo được lại mới hơn tệp stamp, script sẽ chạy toàn bộ và ghi lại từ đầu. Một migration mới thì chỉ khiến script dựng lại cơ sở dữ liệu kiểm thử. Còn không thì để testmon tự chọn. Một ví dụ đã cắt gọn:</p>
<div class="highlight-wrapper"><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl"><span class="cp">#!/usr/bin/env bash
</span></span></span><span class="line"><span class="cl"><span class="c1"># scripts/test-changed.sh: the tests a change can affect, or all when in doubt.</span>
</span></span><span class="line"><span class="cl"><span class="c1">#   scripts/test-changed.sh            # affected tests</span>
</span></span><span class="line"><span class="cl"><span class="c1">#   scripts/test-changed.sh --all      # everything, re-recorded</span>
</span></span><span class="line"><span class="cl"><span class="c1">#   scripts/test-changed.sh -k orders  # anything else goes to pytest</span>
</span></span><span class="line"><span class="cl"><span class="nb">set</span> -euo pipefail
</span></span><span class="line"><span class="cl"><span class="nb">cd</span> <span class="s2">&#34;</span><span class="k">$(</span>dirname <span class="s2">&#34;</span><span class="nv">$0</span><span class="s2">&#34;</span><span class="k">)</span><span class="s2">/..&#34;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="c1"># coverage&#39;s C tracer: from Python 3.14 coverage defaults to sys.monitoring,</span>
</span></span><span class="line"><span class="cl"><span class="c1"># which reports a line only the first time a process runs it, so testmon</span>
</span></span><span class="line"><span class="cl"><span class="c1"># would credit each line to one test. Changing this means --all.</span>
</span></span><span class="line"><span class="cl"><span class="nb">export</span> <span class="nv">COVERAGE_CORE</span><span class="o">=</span>ctrace
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nv">STAMP</span><span class="o">=</span>.testmondata.started
</span></span><span class="line"><span class="cl"><span class="nv">full</span><span class="o">=</span><span class="nb">false</span>
</span></span><span class="line"><span class="cl"><span class="nv">rebuild</span><span class="o">=</span><span class="nb">false</span>
</span></span><span class="line"><span class="cl"><span class="k">if</span> <span class="o">[</span> <span class="s2">&#34;</span><span class="si">${</span><span class="nv">1</span><span class="k">:-</span><span class="si">}</span><span class="s2">&#34;</span> <span class="o">=</span> <span class="s2">&#34;--all&#34;</span> <span class="o">]</span><span class="p">;</span> <span class="k">then</span>
</span></span><span class="line"><span class="cl">    <span class="nv">full</span><span class="o">=</span>true<span class="p">;</span> <span class="nb">shift</span>
</span></span><span class="line"><span class="cl"><span class="k">elif</span> <span class="o">[</span> ! -f .testmondata <span class="o">]</span> <span class="o">||</span> <span class="o">[</span> ! -f <span class="s2">&#34;</span><span class="nv">$STAMP</span><span class="s2">&#34;</span> <span class="o">]</span><span class="p">;</span> <span class="k">then</span>
</span></span><span class="line"><span class="cl">    <span class="nb">echo</span> <span class="s2">&#34;No record yet: running everything once.&#34;</span>
</span></span><span class="line"><span class="cl">    <span class="nv">full</span><span class="o">=</span><span class="nb">true</span>
</span></span><span class="line"><span class="cl"><span class="k">else</span>
</span></span><span class="line"><span class="cl">    <span class="c1"># Changed since the last run started, and not traceable per test:</span>
</span></span><span class="line"><span class="cl">    <span class="c1"># anything that isn&#39;t Python, plus settings and conftest.</span>
</span></span><span class="line"><span class="cl">    <span class="nv">newer</span><span class="o">=</span><span class="s2">&#34;</span><span class="k">$(</span>find myapp myproject fixtures pytest.ini <span class="se">\
</span></span></span><span class="line"><span class="cl">        -type f -newer <span class="s2">&#34;</span><span class="nv">$STAMP</span><span class="s2">&#34;</span> ! -path <span class="s1">&#39;*/migrations/*&#39;</span> <span class="se">\
</span></span></span><span class="line"><span class="cl">        <span class="se">\(</span> ! -name <span class="s1">&#39;*.py&#39;</span> -o -path <span class="s1">&#39;myproject/settings*&#39;</span> -o -name <span class="s1">&#39;conftest.py&#39;</span> <span class="se">\)</span> <span class="se">\
</span></span></span><span class="line"><span class="cl">        ! -path <span class="s1">&#39;*/__pycache__/*&#39;</span> <span class="p">|</span> head -5<span class="k">)</span><span class="s2">&#34;</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="o">[</span> -n <span class="s2">&#34;</span><span class="nv">$newer</span><span class="s2">&#34;</span> <span class="o">]</span><span class="p">;</span> <span class="k">then</span>
</span></span><span class="line"><span class="cl">        <span class="nb">echo</span> <span class="s2">&#34;Changed, and not traceable per test:&#34;</span><span class="p">;</span> <span class="nb">printf</span> <span class="s1">&#39;  %s\n&#39;</span> <span class="nv">$newer</span>
</span></span><span class="line"><span class="cl">        <span class="nv">full</span><span class="o">=</span><span class="nb">true</span>
</span></span><span class="line"><span class="cl">    <span class="k">fi</span>
</span></span><span class="line"><span class="cl">    <span class="c1"># A new migration needs a fresh test database, not a full run.</span>
</span></span><span class="line"><span class="cl">    <span class="o">[</span> -n <span class="s2">&#34;</span><span class="k">$(</span>find myapp -path <span class="s1">&#39;*/migrations/*.py&#39;</span> -newer <span class="s2">&#34;</span><span class="nv">$STAMP</span><span class="s2">&#34;</span> <span class="p">|</span> head -1<span class="k">)</span><span class="s2">&#34;</span> <span class="o">]</span> <span class="o">&amp;&amp;</span> <span class="nv">rebuild</span><span class="o">=</span><span class="nb">true</span>
</span></span><span class="line"><span class="cl"><span class="k">fi</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="c1"># Stamp the start, so an edit made while the tests run counts next time.</span>
</span></span><span class="line"><span class="cl"><span class="nv">started</span><span class="o">=</span><span class="s2">&#34;</span><span class="k">$(</span>mktemp .testmondata.run.XXXXXX<span class="k">)</span><span class="s2">&#34;</span>
</span></span><span class="line"><span class="cl"><span class="nv">args</span><span class="o">=(</span>--testmon --reuse-db<span class="o">)</span>
</span></span><span class="line"><span class="cl"><span class="c1"># --create-db alone deletes the database when the run ends; with</span>
</span></span><span class="line"><span class="cl"><span class="c1"># --reuse-db as well, the rebuilt one is kept for next time.</span>
</span></span><span class="line"><span class="cl"><span class="o">[</span> <span class="s2">&#34;</span><span class="nv">$rebuild</span><span class="s2">&#34;</span> <span class="o">=</span> <span class="nb">true</span> <span class="o">]</span> <span class="o">&amp;&amp;</span> <span class="nv">args</span><span class="o">=(</span>--testmon --reuse-db --create-db<span class="o">)</span>
</span></span><span class="line"><span class="cl"><span class="o">[</span> <span class="s2">&#34;</span><span class="nv">$full</span><span class="s2">&#34;</span> <span class="o">=</span> <span class="nb">true</span> <span class="o">]</span> <span class="o">&amp;&amp;</span> <span class="nv">args</span><span class="o">=(</span>--testmon-noselect --reuse-db --create-db<span class="o">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nv">status</span><span class="o">=</span><span class="m">0</span>
</span></span><span class="line"><span class="cl">uv run pytest <span class="s2">&#34;</span><span class="si">${</span><span class="nv">args</span><span class="p">[@]</span><span class="si">}</span><span class="s2">&#34;</span> -q <span class="s2">&#34;</span><span class="nv">$@</span><span class="s2">&#34;</span> <span class="o">||</span> <span class="nv">status</span><span class="o">=</span><span class="nv">$?</span>
</span></span><span class="line"><span class="cl"><span class="c1"># 0: passed, or nothing selected. 1: some failed (still recorded).</span>
</span></span><span class="line"><span class="cl"><span class="c1"># 5: nothing collected at all.</span>
</span></span><span class="line"><span class="cl"><span class="k">case</span> <span class="s2">&#34;</span><span class="nv">$status</span><span class="s2">&#34;</span> in 0<span class="p">|</span>1<span class="p">|</span>5<span class="o">)</span> mv <span class="s2">&#34;</span><span class="nv">$started</span><span class="s2">&#34;</span> <span class="s2">&#34;</span><span class="nv">$STAMP</span><span class="s2">&#34;</span> <span class="p">;;</span> *<span class="o">)</span> rm -f <span class="s2">&#34;</span><span class="nv">$started</span><span class="s2">&#34;</span> <span class="p">;;</span> <span class="k">esac</span>
</span></span><span class="line"><span class="cl"><span class="o">[</span> <span class="s2">&#34;</span><span class="nv">$status</span><span class="s2">&#34;</span> <span class="o">=</span> <span class="m">5</span> <span class="o">]</span> <span class="o">&amp;&amp;</span> <span class="nb">exit</span> <span class="m">0</span>
</span></span><span class="line"><span class="cl"><span class="nb">exit</span> <span class="s2">&#34;</span><span class="nv">$status</span><span class="s2">&#34;</span></span></span></code></pre></div></div>
<p>Có hai chi tiết trong đó đáng giải thích. <code>--reuse-db</code> là cờ của pytest-django để giữ lại cơ sở dữ liệu kiểm thử giữa các lần chạy, và điều này trở nên quan trọng khi một lần chạy chỉ còn mất vài giây: tạo lại cơ sở dữ liệu mỗi lần có khi còn lâu hơn chính các bài kiểm thử. Lần chạy toàn bộ, hoặc lần chạy ngay sau khi có migration mới, thì thêm <code>--create-db</code> để cơ sở dữ liệu có đúng cấu trúc bảng (schema) hiện tại. Hãy giữ <code>--reuse-db</code> đi kèm với nó: nếu chỉ có <code>--create-db</code> thì pytest-django sẽ xóa cơ sở dữ liệu khi lần chạy kết thúc, và lần chạy sau lại phải dựng lại tất cả từ đầu.</p>
<p>Còn khi testmon bỏ chọn mọi bài, lần chạy sẽ thoát với mã 0, nên &ldquo;không có gì thay đổi&rdquo; được tính là qua. Mã thoát (exit code) 5 là cách pytest báo &ldquo;không thu thập được bài kiểm thử nào&rdquo;, và script cũng coi trường hợp đó là ổn.</p>
<p>Hãy để ý những gì không có trong danh sách: <code>pyproject.toml</code> và tệp khóa phiên bản (lock file). Phiên bản đầu tiên của tôi chạy toàn bộ mỗi khi tệp lock thay đổi, khiến phương án dự phòng chậm chạp kia bị kích hoạt gần như ngày nào cũng có, và mọi thứ còn tệ hơn cả lúc chưa có script. testmon vốn đã tự theo dõi phiên bản của các gói đã cài, nên chuyện này nó không cần ai giúp.</p>
<p><strong>6. Cho nó cơ sở dữ liệu và bộ nhớ đệm riêng.</strong> Nếu trên cùng máy còn có thứ khác chạy kiểm thử, chẳng hạn một terminal thứ hai, một agent viết code (coding agent) hay <code>manage.py test</code>, hãy trỏ script tới một cơ sở dữ liệu kiểm thử riêng và một số hiệu bộ nhớ đệm riêng (trong ví dụ là database số 8 của Redis), để cơ sở dữ liệu được giữ lại không bao giờ đụng phải lần chạy của người khác:</p>
<div class="highlight-wrapper"><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl"><span class="nb">export</span> <span class="nv">DATABASE_URL</span><span class="o">=</span><span class="s2">&#34;postgresql://myapp:myapp@localhost:5432/myapp_changed&#34;</span>
</span></span><span class="line"><span class="cl"><span class="nb">export</span> <span class="nv">REDIS_URL</span><span class="o">=</span><span class="s2">&#34;redis://localhost:6379/8&#34;</span></span></span></code></pre></div></div>
<p><strong>7. Xóa sạch bộ nhớ đệm đó trước mỗi lần chạy.</strong> Chuyện này tôi phải vấp mới biết. Các lần chạy một phần bắt đầu thất bại với những lỗi <code>KeyError</code> mà lần chạy toàn bộ không hề gặp. Nguyên do là một số nhãn danh mục được cache mà không có thời hạn hết hạn, và một cơ sở dữ liệu kiểm thử giữ lại từ lần chạy này lại gặp phải bộ nhớ đệm vẫn còn &ldquo;ấm&rdquo; từ một lần chạy trước đó nữa. Xóa cache ngay đầu script là hết lỗi:</p>
<div class="highlight-wrapper"><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">uv run python -c <span class="s2">&#34;import os, redis; redis.Redis.from_url(os.environ[&#39;REDIS_URL&#39;]).flushdb()&#34;</span></span></span></code></pre></div></div>
<p>Đó chính là testmon làm đúng như tài liệu của nó đã nói: mỗi lần chạy một tập con khác nhau sẽ làm lộ ra những bài kiểm thử chỉ qua được nhờ những gì đã chạy trước chúng. Chỗ cần sửa là phần thiết lập kiểm thử, không phải testmon.</p>
<p><strong>8. Nắm các cờ để dùng khi testmon chọn sai.</strong></p>
<ul>
<li><code>--testmon-noselect</code> chạy mọi bài kiểm thử nhưng đưa những bài có khả năng thất bại lên trước. testmon tự chuyển sang chế độ này khi bạn truyền thêm <code>-k</code>, <code>-m</code>, <code>--lf</code> hoặc node ID của một bài kiểm thử.</li>
<li><code>--testmon-forceselect</code> chỉ chạy những bài bị ảnh hưởng mà đồng thời khớp với <code>-k</code> hoặc <code>-m</code> của bạn.</li>
<li><code>--testmon-nocollect</code> dùng bản ghi hiện có nhưng không ghi thêm gì vào. Chế độ này bị bật bắt buộc khi chạy dưới trình gỡ lỗi (debugger) hoặc khi coverage đang chạy sẵn.</li>
<li><code>--no-testmon</code> tắt nó cho một lần chạy, dùng khi bạn đã đặt nó trong <code>addopts</code>.</li>
<li><code>--testmon-env=&lt;name&gt;</code> giữ các bản ghi riêng biệt trong cùng một tệp, dành cho bộ kiểm thử mà bạn chạy dưới hai module settings khác nhau.</li>
</ul>
<p>Nếu dự án có cả phần JavaScript thì Jest có sẵn một phiên bản riêng của tính năng này. <code>jest --changedSince=main</code> chạy những bài kiểm thử import bất cứ thứ gì đã thay đổi kể từ <code>main</code>, dựa theo các câu import chứ không dựa theo coverage. Tôi đã thêm nó vào <code>package.json</code> của ứng dụng dưới tên <code>npm run test:changed</code>, để cả hai nửa của dự án có cùng một thói quen. Một lần sửa ở một module tiện ích đã chọn ra 7 trong số 121 tệp kiểm thử của ứng dụng.</p>

<h2 class="relative group">Nó tiết kiệm được gì
    <div id="nó-tiết-kiệm-được-gì" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#n%c3%b3-ti%e1%ba%bft-ki%e1%bb%87m-%c4%91%c6%b0%e1%bb%a3c-g%c3%ac" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>Khi script bọc đã vào chỗ, và sau khi sửa lỗi được kể ở phần tiếp theo, tôi đo thời gian của nó, tính cả phần khởi động:</p>
<table>
	<thead>
			<tr>
					<th>Thứ đã thay đổi</th>
					<th style="text-align: right">Số bài đã chạy</th>
					<th style="text-align: right">Thời gian</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td>Không có gì</td>
					<td style="text-align: right">0</td>
					<td style="text-align: right">1.0 s</td>
			</tr>
			<tr>
					<td>Một lần sửa trong phần code đứng sau một banner ở màn hình chính</td>
					<td style="text-align: right">17</td>
					<td style="text-align: right">8.5 s</td>
			</tr>
			<tr>
					<td>Hoàn tác lần sửa đó</td>
					<td style="text-align: right">17</td>
					<td style="text-align: right">8.7 s</td>
			</tr>
			<tr>
					<td>Toàn bộ bộ kiểm thử, để so sánh (4 tiến trình)</td>
					<td style="text-align: right">2,248</td>
					<td style="text-align: right">khoảng 3½ phút</td>
			</tr>
	</tbody>
</table>
<p>Với một lần sửa thường ngày, như vậy là nhanh hơn khoảng 25 lần so với bộ kiểm thử chạy song song, còn khi không có gì thay đổi thì nhanh hơn khoảng hai trăm lần.</p>
<p>Bản ghi cũng cho thấy điều tương tự, ở phạm vi rộng hơn. Trong 307 tệp Python không phải tệp kiểm thử mà bộ kiểm thử chạy qua, thay đổi ở tệp trung vị chạm tới 22 bài kiểm thử, tức khoảng 8 giây thời gian kiểm thử. Ở đầu bên kia là vài module lõi: gần như bài kiểm thử nào cũng chạy qua chúng, nên một thay đổi ở đó chạm tới khoảng 1,500 bài, và testmon sẽ chạy lại phần lớn bộ kiểm thử. Đó là câu trả lời đúng, chứ không phải một thất bại. Các con số này là giới hạn trên tính theo từng tệp: testmon làm việc theo từng khối, nên đổi một hàm sẽ chỉ chọn những bài đã chạy qua hàm đó.</p>
<p>Cái giá lộ ra khi script bọc phải quay về phương án dự phòng. Một lần chạy toàn bộ cũng là một lần ghi trên một tiến trình giống như lần đầu, mất khoảng 12 phút, tức là còn chậm hơn bộ kiểm thử chạy song song mà nó thay thế. Nó chạy trên một tiến trình chỉ vì tôi chưa thử testmon cùng pytest-xdist; testmon đã hỗ trợ xdist từ bản 1.4, nên đó là thứ tiếp theo cần đo. Vì vậy, danh sách các tệp kích hoạt nó nên ngắn hết mức có thể, miễn là vẫn trung thực.</p>

<h2 class="relative group">Lỗi trông như một lần chạy toàn xanh
    <div id="lỗi-trông-như-một-lần-chạy-toàn-xanh" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#l%e1%bb%97i-tr%c3%b4ng-nh%c6%b0-m%e1%bb%99t-l%e1%ba%a7n-ch%e1%ba%a1y-to%c3%a0n-xanh" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>Những con số đầu tiên của tôi còn đẹp hơn thế này: một lần sửa, 6 bài kiểm thử, 3.3 giây. Chúng sai, và không có gì trên màn hình cho biết điều đó.</p>
<p>Từ Python 3.14, coverage.py mặc định dùng một lõi (core) mới, xây dựng trên <code>sys.monitoring</code> của trình thông dịch. Lõi này chỉ báo một dòng ở lần đầu tiên một tiến trình chạy qua dòng đó. testmon dựng bản ghi bài nào đã chạy dòng nào từ dữ liệu của coverage, nên mỗi dòng chỉ được tính cho bài kiểm thử đầu tiên tình cờ chạy qua nó, chứ không tính cho bài nào khác. Sửa một dòng mà tám bài kiểm thử cùng dùng, testmon sẽ chỉ chọn một trong số đó.</p>
<p>Lỗi này lộ ra trên một dự án khác của tôi, nhỏ hơn, nơi tôi chép lại cách thiết lập này. Một phần của việc áp dụng nó ở đó là cố ý làm hỏng một dòng rồi so sánh kết quả, và các con số không khớp nhau. Quay lại bộ kiểm thử này, tôi làm đúng phép thử đó. Tôi làm hỏng một dòng trong phần code của banner ở màn hình chính, cụ thể là tiêu đề của một slide. Chạy pytest bình thường thì có 8 bài thất bại. testmon chỉ chọn 4. 4 bài hỏng còn lại không hề được chạy, và đầu ra không có dòng nào cho biết chúng đã bị bỏ qua.</p>
<p>Cách sửa chỉ là một dòng, <code>export COVERAGE_CORE=ctrace</code>, để đưa coverage về lại trình theo dõi (tracer) cổ điển viết bằng C của nó. Đổi tracer thì bản ghi cũng khác, nên tôi ghi lại từ đầu: 12 phút 3 giây cho 2,248 bài. Sau đó, cùng một kiểu sửa làm hỏng code như vậy đã chạy đủ cả 11 bài mà nó làm hỏng.</p>
<p>Cập nhật ngày 7 tháng 11: testmon 2.3.0, phát hành ngày 2 tháng 11, giờ tự đặt tracer C, cả trong tiến trình lẫn cho các tiến trình con, nên cài mới thì không cần dòng export này nữa. Phần kiểm tra ở đoạn tiếp theo thì vẫn cần.</p>
<p>Nếu phải truyền lại một bài học trước mọi thứ khác trong bài này, tôi sẽ chọn bài học này. Một công cụ chọn bài kiểm thử mà chọn quá ít thì trông y hệt như thành công: ít bài hơn, chạy nhanh hơn, toàn màu xanh. Vì vậy, khi thiết lập một công cụ như thế, hãy cố ý làm hỏng một thứ dùng chung, chạy cả bộ kiểm thử thông thường lẫn công cụ chọn bài, rồi kiểm tra xem hai bên có báo thất bại đúng những bài giống nhau không. Sau đó, làm lại việc này mỗi khi Python hoặc coverage.py lên phiên bản mới.</p>

<h2 class="relative group">Khi agent viết code vào cuộc
    <div id="khi-agent-viết-code-vào-cuộc" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#khi-agent-vi%e1%ba%bft-code-v%c3%a0o-cu%e1%bb%99c" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>Tôi không còn tự tay làm mọi thay đổi trong kho mã đó nữa. Một agent viết code, trong trường hợp của tôi là Claude Code, làm khá nhiều thay đổi nhỏ, và một agent tốt sẽ chạy kiểm thử sau mỗi lần sửa. Đứng trước một bộ kiểm thử 11 phút, nó cũng chỉ có đúng hai lựa chọn tồi như tôi từng có: ngồi chờ, hoặc đoán xem tệp kiểm thử nào mới quan trọng.</p>
<p>Vì vậy, phần hướng dẫn dành cho agent trong kho mã giờ ghi rằng script bọc kia là cách mặc định để chạy kiểm thử trong lúc làm việc, còn <code>--all</code> dành cho lần chạy toàn bộ. Sau mỗi lần sửa, agent nhận được đúng tập bài kiểm thử chính xác như tôi, chỉ trong vài giây. Đây cũng là lý do bước 6 cho script một cơ sở dữ liệu và bộ nhớ đệm riêng: vào một ngày bận rộn, sẽ có nhiều hơn một phiên làm việc cùng chạy kiểm thử trên một máy, và cơ sở dữ liệu được giữ lại tuyệt đối không được đụng phải lần chạy của người khác.</p>
<p>Không phần nào trong số này đòi hỏi testmon phải có gì dành riêng cho AI. Vẫn là bản ghi đó, vẫn là cách chọn đó. Chỉ là nó trở nên quan trọng hơn khi thứ đang tạo ra thay đổi lại tạo ra rất, rất nhiều thay đổi.</p>

<h2 class="relative group">Vì sao CI chỉ nhận một phiên bản thô hơn
    <div id="vì-sao-ci-chỉ-nhận-một-phiên-bản-thô-hơn" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#v%c3%ac-sao-ci-ch%e1%bb%89-nh%e1%ba%adn-m%e1%bb%99t-phi%c3%aan-b%e1%ba%a3n-th%c3%b4-h%c6%a1n" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>testmon không có chế độ dành riêng cho CI. Trên runner nó hoạt động y như trên laptop, và chính tác giả của nó viết rằng việc chia sẻ hoặc cache <code>.testmondata</code> giữa các runner CI kém hiệu quả hơn nhiều so với dịch vụ lưu trữ sẵn (hosted) của họ là testmon.net. Một bản ghi được cache lại cũng sẽ mù theo đúng những cách đã kể ở trên, mà CI của tôi lại chạy bộ kiểm thử bằng trình chạy của Django trên bốn tiến trình, nên tôi không đưa testmon vào CI.</p>
<p>Thay vào đó, CI nhận cùng ý tưởng này nhưng ở cấp độ tệp. Workflow kiểm tra giờ bắt đầu bằng một job nhỏ, lấy diff của lần push rồi xác định nó đã chạm vào nửa nào của kho mã: API Python, ứng dụng di động, cả hai, hay không bên nào. Trước đây, CI chạy cả job Python lẫn job ứng dụng ở mọi lần push, kể cả những lần chỉ sửa tài liệu. Giờ thì một lần push chỉ sửa tài liệu không chạy gì cả, còn một lần push chỉ đụng tới ứng dụng thì bỏ qua bộ kiểm thử Django. Tôi đã chạy thử (dry run) job này trên năm commit thật: commit chỉ sửa tài liệu không chạy gì, commit chỉ sửa ứng dụng bỏ qua job Python, còn commit chỉ sửa backend thì bỏ qua job ứng dụng. Một ví dụ đã cắt gọn:</p>
<div class="highlight-wrapper"><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-yaml" data-lang="yaml"><span class="line"><span class="cl"><span class="nt">jobs</span><span class="p">:</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="nt">changes</span><span class="p">:</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="nt">runs-on</span><span class="p">:</span><span class="w"> </span><span class="l">ubuntu-latest</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="nt">outputs</span><span class="p">:</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span><span class="nt">python</span><span class="p">:</span><span class="w"> </span><span class="l">${{ steps.diff.outputs.python }}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="nt">steps</span><span class="p">:</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span>- <span class="nt">uses</span><span class="p">:</span><span class="w"> </span><span class="l">actions/checkout@v7</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nt">with</span><span class="p">:</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">          </span><span class="nt">fetch-depth</span><span class="p">:</span><span class="w"> </span><span class="m">0</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span>- <span class="nt">id</span><span class="p">:</span><span class="w"> </span><span class="l">diff</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nt">env</span><span class="p">:</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">          </span><span class="nt">BEFORE</span><span class="p">:</span><span class="w"> </span><span class="l">${{ github.event.before }}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">          </span><span class="nt">HEAD</span><span class="p">:</span><span class="w"> </span><span class="l">${{ github.sha }}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nt">run</span><span class="p">:</span><span class="w"> </span><span class="p">|</span><span class="sd">
</span></span></span><span class="line"><span class="cl"><span class="sd">          FILES=&#34;$(git diff --name-only &#34;$BEFORE&#34; &#34;$HEAD&#34;)&#34;
</span></span></span><span class="line"><span class="cl"><span class="sd">          # Python&#39;s inputs include the non-Python files its tests read.
</span></span></span><span class="line"><span class="cl"><span class="sd">          PY=&#39;^(myapp/|myproject/|fixtures/shared\.json$|web/dist/|pyproject\.toml$|uv\.lock$)&#39;
</span></span></span><span class="line"><span class="cl"><span class="sd">          if printf &#39;%s\n&#39; &#34;$FILES&#34; | grep -qE &#34;$PY&#34;; then
</span></span></span><span class="line"><span class="cl"><span class="sd">            echo &#34;python=true&#34; &gt;&gt; &#34;$GITHUB_OUTPUT&#34;
</span></span></span><span class="line"><span class="cl"><span class="sd">          else
</span></span></span><span class="line"><span class="cl"><span class="sd">            echo &#34;python=false&#34; &gt;&gt; &#34;$GITHUB_OUTPUT&#34;
</span></span></span><span class="line"><span class="cl"><span class="sd">          fi</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  </span><span class="nt">python</span><span class="p">:</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="nt">needs</span><span class="p">:</span><span class="w"> </span><span class="l">changes</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="nt">if</span><span class="p">:</span><span class="w"> </span><span class="l">needs.changes.outputs.python == &#39;true&#39;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="nt">runs-on</span><span class="p">:</span><span class="w"> </span><span class="l">ubuntu-latest</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="nt">steps</span><span class="p">:</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span>- <span class="nt">uses</span><span class="p">:</span><span class="w"> </span><span class="l">actions/checkout@v7</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span>- <span class="nt">run</span><span class="p">:</span><span class="w"> </span><span class="l">uv run python manage.py test --parallel 4 --noinput</span></span></span></code></pre></div></div>
<p>Workflow thật còn chạy toàn bộ khi không có khoảng commit nào để so sánh: một nhánh mới, một lần force push hoặc một lần chạy tay.</p>
<p>Điểm mù vẫn là điểm mù cũ, chỉ mang một hình dạng khác. testmon không nhìn thấy tệp JSON, và bộ lọc theo đường dẫn cũng vậy, trừ khi bạn liệt kê tệp đó ra. Vì thế, mẫu ở trên ghi rõ tên tệp fixture dùng chung, gói web đã dựng và trang được sinh ra, kèm một dòng chú thích nhắc người sửa nó giữ cho danh sách luôn đúng. Phiên bản cấp tệp thô hơn, nhưng khi sai thì sai về phía an toàn: chỉ cần bên phía Python có gì thay đổi là cả bộ kiểm thử sẽ chạy.</p>

<h2 class="relative group">Có đáng không?
    <div id="có-đáng-không" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#c%c3%b3-%c4%91%c3%a1ng-kh%c3%b4ng" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>Với một bộ kiểm thử chạy mất vài phút thì có. Cái giá thật sự nằm ở những gì nó không nhìn thấy, và script bọc sinh ra là để lo việc đó. Dù vậy, chỗ của testmon là vòng lặp làm việc trên laptop. CI vẫn chạy toàn bộ bộ kiểm thử mỗi khi phía Python có thay đổi, và đó mới là lần chạy tôi tin tưởng trước khi triển khai.</p>
]]></content:encoded>
      <media:content url="https://jared.lynskey.co.nz/en/posts/2026/2026-10-26-pytest-testmon/featured.jpg" medium="image" type="image/jpeg" />
    </item>
    <item>
      <title>Coffee chat là gì? Khác gì với phỏng vấn, và nên hỏi gì?</title>
      <link>https://jared.lynskey.co.nz/vi/posts/2024/2024-07-12-coffee-chats/</link>
      <guid isPermaLink="true">https://jared.lynskey.co.nz/vi/posts/2024/2024-07-12-coffee-chats/</guid>
      <pubDate>Fri, 12 Jul 2024 00:30:03 +0000</pubDate>
      <dc:creator>Jared Lynskey</dc:creator>
      <category>Engineering Manager</category>
      <category>Team</category>
      <category>People</category>
      <category>Team Size</category>
      <category>Scaling</category>
      <category>Efficiency</category>
      <category>Talent Scouting</category>
      <category>Coffee Chat</category>
      <category>Recruitment</category>
      <category>Hiring</category>
      <category>Culture Fit</category>
      <category>Networking</category>
      <description>Coffee chat là một buổi trò chuyện không chính thức chừng 30–45 phút, ở quán cà phê hoặc qua cuộc gọi video, để hai bên xem có nên nói chuyện sâu hơn hay không. Nó không phải buổi phỏng vấn. Vì sao đây đã thành cách tôi thích nhất để làm quen với lập trình viên, tôi tổ chức ra sao, nên hỏi gì, nên mặc gì và nói chuyện gì nếu bạn là người được mời, và những kiểu làm hỏng buổi gặp thường gặp.</description>
      <content:encoded><![CDATA[<p>Những lập trình viên mà tôi muốn tuyển nhất thì chẳng bao giờ xuất hiện trên các trang tuyển dụng. Họ đang cắm cúi xây dựng một thứ gì đó, khá hài lòng với chỗ làm hiện tại, và luôn dè chừng tin nhắn của chuyên viên tuyển dụng, mà dè chừng cũng phải thôi. Từ khi chuyển sang làm quản lý kỹ thuật (Engineering Manager) hồi đầu năm nay, công cụ tôi dựa vào để gặp được những người như vậy đơn giản đến mức hơi ngại nói ra: một ly cà phê.</p>
<p>Một buổi cà phê trò chuyện (coffee chat) kéo dài khoảng 30–45 phút, không chính thức, ngồi ở quán cà phê hoặc gọi video. Không có bảng trắng, không có hội đồng, không có câu hỏi mẹo. Tôi kể về sản phẩm chúng tôi đang làm và vì sao lại làm nó, còn họ kể về công việc hiện tại và điều họ muốn làm tiếp theo. Cuối buổi, cả hai đều biết có nên nói chuyện sâu hơn hay không. Với tôi, tuyển dụng giống bài toán ghép cặp hơn là bài toán sàng lọc, và đây là cách nhanh nhất tôi biết để hai bên trao đổi đúng những thông tin cần cho việc ghép cặp đó.</p>
<figure><div class="film-pair">
  <div class="mc-film film-dark">
  <video
    class="my-0 rounded-md"
    controls playsinline preload="none"
    poster="https://jared.lynskey.co.nz/en/posts/2024/2024-07-12-coffee-chats/coffee-chats-film-poster.jpg" style="background:url('data:image/webp;base64,UklGRmoAAABXRUJQVlA4IF4AAACwBACdASogABIAPw12qkmmI6GYDAQAYxDE9IABIX0/HUGa/BwFLmQiaci9B73wAP7ouyxmkTX73K2EljbawAtCxwSblm7y7euMLarkzUk+r7wjHZ1dwA9tzx/08AAA') center/cover no-repeat"
    width="1280"
    height="720"
    aria-label="Video ngắn có lời dẫn kể lại bài viết này">
    <source src="https://jared.lynskey.co.nz/en/posts/2024/2024-07-12-coffee-chats/coffee-chats-film.webm" type="video/webm">
    <track kind="subtitles" src="https://jared.lynskey.co.nz/en/posts/2024/2024-07-12-coffee-chats/coffee-chats-film_en.vtt" srclang="en" label="English">
    <track kind="subtitles" src="https://jared.lynskey.co.nz/en/posts/2024/2024-07-12-coffee-chats/coffee-chats-film_ja.vtt" srclang="ja" label="日本語">
    <track kind="subtitles" src="https://jared.lynskey.co.nz/en/posts/2024/2024-07-12-coffee-chats/coffee-chats-film_ko.vtt" srclang="ko" label="한국어">
    <track kind="subtitles" src="https://jared.lynskey.co.nz/en/posts/2024/2024-07-12-coffee-chats/coffee-chats-film_vi.vtt" srclang="vi" label="Tiếng Việt" default>
    <track kind="subtitles" src="https://jared.lynskey.co.nz/en/posts/2024/2024-07-12-coffee-chats/coffee-chats-film_zh-cn.vtt" srclang="zh-cn" label="简体中文">
  </video>
  </div>
  <div class="mc-film film-light">
  <video
    class="my-0 rounded-md"
    controls playsinline preload="none"
    poster="https://jared.lynskey.co.nz/en/posts/2024/2024-07-12-coffee-chats/coffee-chats-film-light-poster.jpg" style="background:url('data:image/webp;base64,UklGRoQAAABXRUJQVlA4IHgAAAAwBQCdASogABIAPw1yq0omI6GYDAQAYxDE9IAECBxAX9Q7kIyd+ZdexoqRRzGjpObyCAD+82xiqEeejshY20Dlsk/rGQ/XxZ1l6LikpJD6mF94kq3JymaOuDWqzKA/RTf0sM9DNRh6p/OQdQxkloY1GBk/Gszp4AA=') center/cover no-repeat"
    width="1280"
    height="720"
    aria-label="Video ngắn có lời dẫn kể lại bài viết này">
    <source src="https://jared.lynskey.co.nz/en/posts/2024/2024-07-12-coffee-chats/coffee-chats-film-light.webm" type="video/webm">
    <track kind="subtitles" src="https://jared.lynskey.co.nz/en/posts/2024/2024-07-12-coffee-chats/coffee-chats-film_en.vtt" srclang="en" label="English">
    <track kind="subtitles" src="https://jared.lynskey.co.nz/en/posts/2024/2024-07-12-coffee-chats/coffee-chats-film_ja.vtt" srclang="ja" label="日本語">
    <track kind="subtitles" src="https://jared.lynskey.co.nz/en/posts/2024/2024-07-12-coffee-chats/coffee-chats-film_ko.vtt" srclang="ko" label="한국어">
    <track kind="subtitles" src="https://jared.lynskey.co.nz/en/posts/2024/2024-07-12-coffee-chats/coffee-chats-film_vi.vtt" srclang="vi" label="Tiếng Việt" default>
    <track kind="subtitles" src="https://jared.lynskey.co.nz/en/posts/2024/2024-07-12-coffee-chats/coffee-chats-film_zh-cn.vtt" srclang="zh-cn" label="简体中文">
  </video>
  </div>
  <script>(function(){if(window.mcFilm)return window.mcFilm();var a={play:'<path d="M8 5.6v12.8a1 1 0 0 0 1.52.85l10.2-6.4a1 1 0 0 0 0-1.7L9.52 4.75A1 1 0 0 0 8 5.6z"/>',pause:'<rect x="6.5" y="5" width="4" height="14" rx="1.2"/><rect x="13.5" y="5" width="4" height="14" rx="1.2"/>',volume:'<path d="M4 9.5v5a1 1 0 0 0 1 1h3l4.4 3.6a.6.6 0 0 0 1-.47V5.37a.6.6 0 0 0-1-.47L8 8.5H5a1 1 0 0 0-1 1z"/><path d="M16.5 8.5a5 5 0 0 1 0 7M19 6a8.5 8.5 0 0 1 0 12" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"/>',muted:'<path d="M4 9.5v5a1 1 0 0 0 1 1h3l4.4 3.6a.6.6 0 0 0 1-.47V5.37a.6.6 0 0 0-1-.47L8 8.5H5a1 1 0 0 0-1 1z"/><path d="M16.5 9.5l5 5m0-5l-5 5" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"/>',cc:'<rect x="3" y="5.5" width="18" height="13" rx="3" fill="none" stroke="currentColor" stroke-width="1.8"/><path d="M10.5 10.3a2.2 2.2 0 1 0 0 3.4M17 10.3a2.2 2.2 0 1 0 0 3.4" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round"/>',full:'<path d="M4.5 9V5.5a1 1 0 0 1 1-1H9M15 4.5h3.5a1 1 0 0 1 1 1V9M19.5 15v3.5a1 1 0 0 1-1 1H15M9 19.5H5.5a1 1 0 0 1-1-1V15" fill="none" stroke="currentColor" stroke-width="1.9" stroke-linecap="round"/>',exit:'<path d="M9 4.5V8a1 1 0 0 1-1 1H4.5M19.5 9H16a1 1 0 0 1-1-1V4.5M15 19.5V16a1 1 0 0 1 1-1h3.5M4.5 15H8a1 1 0 0 1 1 1v3.5" fill="none" stroke="currentColor" stroke-width="1.9" stroke-linecap="round"/>'},s={en:["Play","Pause","Mute","Unmute","Subtitles","Off","Full screen","Exit full screen","Seek"],ko:["재생","일시정지","음소거","음소거 해제","자막","끄기","전체 화면","전체 화면 종료","탐색"],ja:["再生","一時停止","ミュート","ミュート解除","字幕","オフ","全画面","全画面を終了","シーク"],zh:["播放","暂停","静音","取消静音","字幕","关闭","全屏","退出全屏","进度"],vi:["Phát","Tạm dừng","Tắt tiếng","Bật tiếng","Phụ đề","Tắt","Toàn màn hình","Thoát toàn màn hình","Tua"]},r=(document.documentElement.lang||"en").toLowerCase().slice(0,2),e=s[r]||s.en,t=function(e){return'<svg viewBox="0 0 24 24" aria-hidden="true" focusable="false">'+a[e]+"</svg>"},o={},i=function(e,t){if(o[e]||typeof window.gtag!="function")return;o[e]=!0;var n=(t.currentSrc||(t.querySelector("source")||{}).src||"").split("/").pop();window.gtag("event",e,{film:n.replace(/-light(?=\.)/,"")})},n=function(e){(!isFinite(e)||e<0)&&(e=0),e=Math.floor(e);var t=Math.floor(e/3600),n=Math.floor(e%3600/60),s=String(e%60).padStart(2,"0");return t?t+":"+String(n).padStart(2,"0")+":"+s:n+":"+s};function c(s){var a,r,c,d,u,m,p,g,v,b,j,_,w,O,C,E,k,A,o=s.querySelector("video");if(!o)return;s.classList.add("is-ready"),o.controls=!1,o.removeAttribute("controls"),s.insertAdjacentHTML("beforeend",'<button type="button" class="mc-film__big" aria-label="'+e[0]+'">'+t("play")+'</button><div class="mc-film__bar"><button type="button" class="mc-film__btn" data-act="play" aria-label="'+e[0]+'">'+t("play")+'</button><span class="mc-film__time"><span data-cur>0:00</span><span class="mc-film__of"> / </span><span data-dur>0:00</span></span><input class="mc-film__seek" type="range" min="0" max="1000" step="1" value="0" aria-label="'+e[8]+'"><span class="mc-film__cc"><button type="button" class="mc-film__btn" data-act="cc" aria-label="'+e[4]+'" aria-haspopup="true" aria-expanded="false">'+t("cc")+'</button><span class="mc-film__menu" role="menu" hidden></span></span><button type="button" class="mc-film__btn" data-act="mute" aria-label="'+e[2]+'">'+t("volume")+'</button><button type="button" class="mc-film__btn" data-act="full" aria-label="'+e[6]+'">'+t("full")+"</button></div>"),A=s.querySelector(".mc-film__big"),a=s.querySelector(".mc-film__bar"),j=a.querySelector('[data-act="play"]'),p=a.querySelector('[data-act="mute"]'),u=a.querySelector('[data-act="full"]'),d=a.querySelector('[data-act="cc"]'),r=a.querySelector(".mc-film__menu"),c=a.querySelector(".mc-film__seek"),w=a.querySelector("[data-cur]"),O=a.querySelector("[data-dur]"),g=!1,v=0,b=function(){return Array.prototype.filter.call(o.textTracks,function(e){return e.kind==="subtitles"||e.kind==="captions"})},b().length||(d.parentNode.hidden=!0),_=null;function f(e){var n,i,t=!s.classList.contains("is-idle")&&s.classList.contains("is-started");if(e!==!0&&t===_)return;_=t,n=o.clientHeight,i=n?Math.max(40,100-(a.offsetHeight+22)/n*100):85,b().forEach(function(e){if(e.mode!=="showing"||!e.cues)return;for(var n,s=0;s<e.cues.length;s++)n=e.cues[s],t?(n.snapToLines=!1,n.line=i,n.lineAlign="end"):(n.snapToLines=!0,n.line="auto",n.lineAlign="start")})}m=function(){f(!0)},window.addEventListener("resize",m),Array.prototype.forEach.call(o.querySelectorAll("track"),function(e){e.addEventListener("load",m)});function y(){o.paused||o.ended?o.play().catch(function(){}):o.pause()}function l(){s.classList.remove("is-idle"),f(),clearTimeout(v),v=setTimeout(function(){!o.paused&&r.hidden&&!a.querySelector(":focus-visible")&&(s.classList.add("is-idle"),f())},2600)}function M(){clearTimeout(v),h(),s.classList.add("is-idle"),f()}function h(){r.hidden=!0,d.setAttribute("aria-expanded","false")}function F(){var t=b(),n=t.filter(function(e){return e.mode==="showing"})[0];r.innerHTML="",[null].concat(t).forEach(function(s){var o=document.createElement("button");o.type="button",o.setAttribute("role","menuitemradio"),o.setAttribute("aria-checked",String(s?s===n:!n)),o.textContent=s?s.label||s.language:e[5],o.addEventListener("click",function(){t.forEach(function(e){e.mode=e===s?"showing":"disabled"}),h(),setTimeout(m,0),l()}),r.appendChild(o)}),r.hidden=!1,d.setAttribute("aria-expanded","true")}function x(){var n=!o.paused&&!o.ended;s.classList.toggle("is-playing",n),j.innerHTML=t(n?"pause":"play"),j.setAttribute("aria-label",n?e[1]:e[0]),n||l()}function S(){if(w.textContent=n(o.currentTime),!g&&o.duration){var e=o.currentTime/o.duration*1e3;c.value=e,c.style.setProperty("--p",e/10+"%")}}A.addEventListener("click",function(){o.play().catch(function(){})}),C="mouse",s.addEventListener("pointerdown",function(e){C=e.pointerType}),o.addEventListener("click",function(){if(!s.classList.contains("is-started"))return o.play().catch(function(){});if(C==="mouse")return y();s.classList.contains("is-idle")?l():M()}),j.addEventListener("click",y),o.addEventListener("play",function(){s.classList.contains("is-started")||i("film_play",o),s.classList.add("is-started"),x(),l()}),"IntersectionObserver"in window&&(E=new IntersectionObserver(function(e){if(!e.some(function(e){return e.isIntersecting}))return;E.disconnect(),i("film_view",o)},{threshold:.5}),E.observe(s)),o.addEventListener("pause",x),o.addEventListener("ended",x),o.addEventListener("timeupdate",S),o.addEventListener("durationchange",function(){O.textContent=n(o.duration),S()}),o.addEventListener("loadedmetadata",function(){O.textContent=n(o.duration)}),o.addEventListener("volumechange",function(){p.innerHTML=t(o.muted?"muted":"volume"),p.setAttribute("aria-label",o.muted?e[3]:e[2])}),p.addEventListener("click",function(){o.muted=!o.muted}),c.addEventListener("input",function(){g=!0,c.style.setProperty("--p",c.value/10+"%"),o.duration&&(o.currentTime=c.value/1e3*o.duration,w.textContent=n(o.currentTime))}),c.addEventListener("change",function(){g=!1}),d.addEventListener("click",function(e){e.stopPropagation(),r.hidden?F():h()}),document.addEventListener("click",function(e){!r.hidden&&!r.contains(e.target)&&h()}),u.addEventListener("click",function(){document.fullscreenElement||document.webkitFullscreenElement?(document.exitFullscreen||document.webkitExitFullscreen).call(document):s.requestFullscreen?s.requestFullscreen().catch(function(){}):s.webkitRequestFullscreen?s.webkitRequestFullscreen():o.webkitEnterFullscreen&&o.webkitEnterFullscreen()}),k=function(){var n=(document.fullscreenElement||document.webkitFullscreenElement)===s;s.classList.toggle("is-fullscreen",n),u.innerHTML=t(n?"exit":"full"),u.setAttribute("aria-label",n?e[7]:e[6])},document.addEventListener("fullscreenchange",k),document.addEventListener("webkitfullscreenchange",k),s.addEventListener("pointermove",function(e){e.pointerType==="mouse"&&l()}),s.addEventListener("focusin",l),s.addEventListener("keydown",function(e){if(e.target===c&&/^Arrow/.test(e.key))return;var t=e.key.toLowerCase();if(t==="k"||t===" "&&e.target===o)y();else if(t==="arrowleft")o.currentTime=Math.max(0,o.currentTime-5);else if(t==="arrowright")o.currentTime=Math.min(o.duration||0,o.currentTime+5);else if(t==="m")o.muted=!o.muted;else if(t==="f")u.click();else if(t==="escape"&&!r.hidden)h();else return;e.preventDefault(),l()}),o.tabIndex=0}window.mcFilm=function(){document.querySelectorAll(".mc-film:not(.is-ready)").forEach(c)},window.mcFilm()})()</script></div>
  <script>
  new MutationObserver(() => {
    const dark = document.documentElement.classList.contains("dark");
    document.querySelectorAll(".film-pair").forEach((pair) => {
      const from = pair.querySelector(dark ? ".film-light video" : ".film-dark video");
      const to = pair.querySelector(dark ? ".film-dark video" : ".film-light video");
      if (!from || !to || !from.currentTime) return;
      const playing = !from.paused;
      from.pause();
      to.currentTime = from.currentTime;
      [...from.textTracks].forEach((track, i) => { if (to.textTracks[i]) to.textTracks[i].mode = track.mode; });
      if (playing) to.play().catch(() => {});
    });
  }).observe(document.documentElement, { attributes: true, attributeFilter: ["class"] });
  </script><figcaption>Bài viết này dưới dạng video dài tám phút. Lời dẫn bằng tiếng Anh, có phụ đề tiếng Việt. Một số cảnh quay lấy từ Coverr.</figcaption>
</figure>


<h4 class="relative group">Vì sao tôi chịu khó làm việc này
    <div id="vì-sao-tôi-chịu-khó-làm-việc-này" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#v%c3%ac-sao-t%c3%b4i-ch%e1%bb%8bu-kh%c3%b3-l%c3%a0m-vi%e1%bb%87c-n%c3%a0y" aria-label="Cọc dấu">#</a>
    </span>
    
</h4>
<p>Tôi không còn coi những buổi này là tuyển dụng nữa. Đó chỉ là những cuộc trò chuyện, và thỉnh thoảng lại có một cuộc dẫn tới việc tuyển được người, có khi mười tám tháng sau, khi hoàn cảnh của người đó thay đổi. Những nguồn ứng viên đều đặn mang lại người giỏi đều được xây từ những mối quan hệ như vậy, chứ không phải từ tin đăng tuyển.</p>
<p>Những buổi cà phê này cũng giải quyết luôn vấn đề của bản mô tả công việc (JD). Bản mô tả công việc thì kiểu gì cũng phải viết chung chung. Còn khi ngồi cà phê, ứng viên có thể hỏi những câu thật sự quan trọng với họ: sáu tháng đầu thế nào thì được coi là thành công, tôi sẽ làm việc với ai, bài toán kỹ thuật khó nhằn nhất của đội lúc này là gì. Được nghe câu trả lời thành thật cho những câu hỏi đó, người ta thường tự biết mình có hợp hay không.</p>
<p>Hơn nữa, một buổi cà phê cho người ta tận mắt thấy văn hóa công ty bạn, thay vì chỉ nghe kể. Bạn có chuẩn bị trước không, có thật sự tò mò không, có tôn trọng thời gian của người khác không: những điều đó nói lên nhiều hơn bất kỳ trang tuyển dụng nào. Chiều ngược lại cũng thế. Cách một người cư xử trong một cuộc nói chuyện thoải mái cho bạn biết làm việc cùng họ sẽ ra sao, rõ hơn hẳn một buổi phỏng vấn mà họ đã tập dượt kỹ.</p>
<p>Hình thức này phát huy tác dụng nhất trong mấy trường hợp: khi tiếp cận một người hoàn toàn không tìm việc, khi muốn làm quen trước với một người được giới thiệu trước khi bắt đầu quy trình chính thức, và khi nói chuyện với ai đó đang cân nhắc rẽ hướng sự nghiệp, chẳng hạn từ người làm chuyên môn (IC) lên quản lý, từ startup sang tập đoàn, hoặc ngược lại. Khi thị trường nhân lực khan hiếm, chừng đó trường hợp đã bao gồm gần hết những người bạn muốn tuyển.</p>

<h4 class="relative group">Tôi tổ chức một buổi như thế nào
    <div id="tôi-tổ-chức-một-buổi-như-thế-nào" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#t%c3%b4i-t%e1%bb%95-ch%e1%bb%a9c-m%e1%bb%99t-bu%e1%bb%95i-nh%c6%b0-th%e1%ba%bf-n%c3%a0o" aria-label="Cọc dấu">#</a>
    </span>
    
</h4>
<p>Tin nhắn đầu tiên quyết định tất cả. Tin nhắn chung chung sẽ bị xóa ngay. Hãy tìm hiểu kỹ về người đó trước, và nói thẳng mục đích của mình:</p>
<p><em>&ldquo;Chào Sarah, mình có xem bài nói của bạn về hệ thống phân tán ở QCon và mấy bài blog của bạn về event sourcing. Bên mình ở [Company] cũng đang vật lộn với những bài toán tương tự trong lúc mở rộng hạ tầng thanh toán. Bạn có muốn đi cà phê 30 phút không? Không phải phỏng vấn đâu, chỉ là mình tò mò muốn nghe góc nhìn của bạn và kể bạn nghe bên mình đang làm gì.&rdquo;</em></p>
<p>Tin nhắn này hiệu quả vì nó cụ thể, nói rõ mục đích ngay từ đầu, và mang lại cho người nhận một thứ gì đó (một cuộc trò chuyện về những bài toán thú vị) chứ không chỉ xin thời gian của họ. Sau đó hãy làm cho mọi thứ thật dễ dàng: đưa ra vài khung giờ để họ chọn, chọn một chỗ tiện cho họ hoặc một công cụ gọi video không cần cài đặt, và gửi lời mời qua lịch hẳn hoi để không ai phải đoán giờ đoán chỗ.</p>
<p>Bản thân buổi nói chuyện chỉ cần một khung sườn lỏng lẻo. Mở đầu bằng vài phút hỏi han thật lòng và lý do bạn liên hệ. Tiếp theo là câu chuyện của họ: công việc hiện tại, điều họ thích, điều khiến họ bực mình, điều họ mong muốn ở chỗ làm tiếp theo. Ở đoạn này, việc của bạn chủ yếu là lắng nghe. Sau đó đến lượt bạn: sứ mệnh của công ty, những thách thức thật mà đội đang gặp, kể cả những phần khó khăn, vì ứng viên đánh giá cao sự minh bạch và nhận ra ngay khi bạn đang chào hàng. Đoạn đáng giá nhất là phần trò chuyện cởi mở gần cuối: cần những điều kiện gì thì họ mới cân nhắc chuyển việc? Kết thúc bằng các bước tiếp theo rõ ràng, kể cả khi bước tiếp theo chỉ là &ldquo;mình giữ liên lạc nhé&rdquo;.</p>
<p>Trong vòng 24 giờ, hãy nhắn lại một lời ngắn gọn có nhắc tới một chi tiết cụ thể trong buổi nói chuyện, và làm đúng những gì bạn đã hứa, dù là giới thiệu một người, gửi một liên kết hay bất cứ thứ gì. Chính phần việc nhàm chán sau buổi gặp này mới thể hiện rõ nhất văn hóa của bạn.</p>
<p>Nếu bạn làm việc này thường xuyên, hãy giữ một bảng tính đơn giản ghi lại những người đã nói chuyện và thỉnh thoảng hỏi thăm họ, kể cả khi không có vị trí nào đang tuyển. Và đây cũng không nhất thiết là việc riêng của quản lý. Nhiều buổi cà phê hay nhất lại là khi các kỹ sư của bạn đi cà phê với những người giỏi trong mạng lưới quen biết của chính họ. Những lời giới thiệu chất lượng thường đến từ đó.</p>

<h4 class="relative group">Những câu hỏi đáng dành thời gian
    <div id="những-câu-hỏi-đáng-dành-thời-gian" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#nh%e1%bb%afng-c%c3%a2u-h%e1%bb%8fi-%c4%91%c3%a1ng-d%c3%a0nh-th%e1%bb%9di-gian" aria-label="Cọc dấu">#</a>
    </span>
    
</h4>
<p>Những câu tôi hay hỏi:</p>
<ul>
<li>&ldquo;Gần đây bài toán thú vị nhất mà bạn từng làm là gì?&rdquo;</li>
<li>&ldquo;Ở công việc tiếp theo, bạn muốn điều gì khác đi?&rdquo;</li>
<li>&ldquo;Bạn hay học theo cách nào? Bạn muốn phát triển chuyên môn ra sao?&rdquo;</li>
<li>&ldquo;Bạn có câu hỏi nào để đánh giá xem chỗ này có hợp với mình không?&rdquo;</li>
</ul>
<p>Những câu tôi sẽ hỏi nếu ngồi ở phía bên kia bàn:</p>
<ul>
<li>&ldquo;Thách thức lớn nhất mà đội đang đối mặt lúc này là gì?&rdquo;</li>
<li>&ldquo;Anh/chị đánh giá thế nào là thành công ở vị trí này?&rdquo;</li>
<li>&ldquo;Con đường thăng tiến ở đây như thế nào?&rdquo;</li>
<li>&ldquo;Vì sao anh/chị vào công ty này? Điều gì khiến anh/chị ở lại?&rdquo;</li>
<li>&ldquo;Có điều gì khi làm ở đây mà có thể khiến tôi bất ngờ không?&rdquo;</li>
</ul>

<h4 class="relative group">Nếu bạn là người được mời
    <div id="nếu-bạn-là-người-được-mời" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#n%e1%ba%bfu-b%e1%ba%a1n-l%c3%a0-ng%c6%b0%e1%bb%9di-%c4%91%c6%b0%e1%bb%a3c-m%e1%bb%9di" aria-label="Cọc dấu">#</a>
    </span>
    
</h4>
<p>Phần lớn những người tra &ldquo;coffee chat là gì&rdquo; lại đang ngồi ở phía bên kia bàn so với tôi: có ai đó vừa mời họ đi cà phê, và họ muốn biết mình sắp bước vào chuyện gì. Dưới đây là những điều tôi muốn nói với bạn, từ phía người hay gửi lời mời.</p>
<p>Đây không phải buổi phỏng vấn. Không ai chấm điểm bạn, cũng chẳng có bài kiểm tra nào, nên bạn không cần chuẩn bị sẵn câu trả lời. Dù vậy, đây vẫn là lần gặp đầu tiên và ấn tượng ban đầu vẫn quan trọng, nên hãy coi nó như gặp một người đồng nghiệp tương lai, chứ không phải gặp bạn của một người bạn. Điểm khác với phỏng vấn là ở đây bạn được phép tò mò, và người ta mong bạn hỏi cũng nhiều như bạn trả lời.</p>
<p>Về trang phục, hãy mặc như khi bạn đi làm ở công ty đó vào một ngày bình thường. Nếu không biết họ mặc thế nào thì cứ chọn phong cách lịch sự mà thoải mái (smart casual), không bao giờ sai. Nếu gặp qua video, hãy bật camera và tìm một phòng yên tĩnh; mấy chuyện đó quan trọng hơn chiếc áo bạn mặc.</p>
<p>Chuẩn bị mất khoảng nửa tiếng. Tìm hiểu xem công ty đó làm sản phẩm gì, và đọc qua những gì người mời bạn đã viết hoặc đã làm ra. Chuẩn bị sẵn một phần giới thiệu dài chừng hai phút về công việc hiện tại và điều bạn muốn làm tiếp theo, vì kiểu gì bạn cũng sẽ được hỏi câu đó. Mang theo hai, ba câu hỏi của riêng mình; danh sách ở phần trên là một điểm khởi đầu không tệ.</p>
<p>Còn nên nói chuyện gì: công việc của bạn, điều bạn thích ở công việc đó, và những gì bạn tò mò về công việc của họ. Chuyện lương thì để sau, trừ khi họ chủ động nhắc tới. Bạn hoàn toàn có thể hỏi thẳng xem họ có đang nghĩ tới vị trí nào cho bạn không, và nếu có thì quy trình tuyển dụng sẽ diễn ra thế nào.</p>
<p>Thường thì ai mời người đó trả tiền. Bạn cứ ngỏ ý trả, nhưng đừng giành nhau. Trong vòng một ngày, hãy gửi một lời cảm ơn ngắn có nhắc tới điều gì đó hai bên thực sự đã nói, vậy là bạn đã làm tốt hơn phần lớn mọi người rồi.</p>
<p>Còn nếu chính bạn muốn có một buổi coffee chat, cứ chủ động hỏi. Viết tin nhắn ngắn thôi, nói rõ vì sao bạn muốn gặp đúng người đó, và làm sao cho họ dễ nhận lời: &ldquo;Chào bạn, mình vẫn theo dõi phần việc của đội bạn với tính năng tìm kiếm mới, và mình đang tính chuyển sang mảng platform engineering. Trong vài tuần tới, bạn có thể dành cho mình 30 phút đi cà phê hoặc gọi điện không? Mình sẽ sắp xếp theo lịch của bạn.&rdquo; Với một lời đề nghị cụ thể như vậy, phần lớn mọi người đều đồng ý.</p>

<h4 class="relative group">Những cách làm hỏng buổi cà phê
    <div id="những-cách-làm-hỏng-buổi-cà-phê" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#nh%e1%bb%afng-c%c3%a1ch-l%c3%a0m-h%e1%bb%8fng-bu%e1%bb%95i-c%c3%a0-ph%c3%aa" aria-label="Cọc dấu">#</a>
    </span>
    
</h4>
<p>Cách nhanh nhất là biến nó thành một buổi phỏng vấn trá hình. Hễ bạn bắt đầu hỏi kiểm tra kỹ năng kỹ thuật hay lồng vào mấy câu hỏi hành vi là bạn đã phá vỡ thỏa thuận ngầm giữa hai bên, nên hãy để dành những thứ đó cho quy trình chính thức. Đứng thứ hai là chào hàng quá đà: những người ở lại lâu dài là những người đã biết rõ các khó khăn ngay từ lúc nhận lời. Đến mà không chuẩn bị, hoặc im bặt sau buổi gặp, thì gây hại âm thầm hơn; buổi cà phê nào cũng góp phần định hình những gì người đó kể về bạn với mạng lưới của họ.</p>
<p>Từ phía tôi, dấu hiệu đáng lo là một ứng viên không tò mò về bất cứ điều gì, một cuộc nói chuyện chỉ thuần túy trao đổi lợi ích, hoặc một người nhắc đến chỗ làm cũ nào cũng bằng cùng một giọng cay đắng. Ứng viên cũng nên có danh sách dấu hiệu của riêng mình: người đại diện công ty không giải thích được vì sao công việc này có ý nghĩa, những câu trả lời né tránh về tỷ lệ nghỉ việc hay định hướng của công ty, và bất kỳ ai chỉ lo chào mời bạn hơn là tìm hiểu bạn.</p>
<p>Không phải buổi cà phê nào cũng dẫn tới kết quả, và điều đó hoàn toàn bình thường, vì phần lớn là không. Mục đích là lần tới khi cần tuyển gấp cho một vị trí quan trọng, bạn không phải bắt đầu từ một tin tuyển dụng trống trơn, mà từ cả một loạt những cuộc trò chuyện thật. Hãy liên hệ bằng một lời mời đi cà phê, chứ không phải bằng một bản mô tả công việc.</p>

<h4 class="relative group">Đọc thêm
    <div id="đọc-thêm" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#%c4%91%e1%bb%8dc-th%c3%aam" aria-label="Cọc dấu">#</a>
    </span>
    
</h4>
<p><strong>Bài viết liên quan trên blog này:</strong></p>
<ul>
<li><a href="https://jared.lynskey.co.nz/vi/posts/2024/2024-12-19-star-interviews/" >Dùng phương pháp STAR để phỏng vấn lập trình viên</a> - khi buổi cà phê chuyển thành quy trình phỏng vấn chính thức</li>
<li><a href="https://jared.lynskey.co.nz/vi/posts/2024/2024-02-10-prioritizing-onboarding/" >Ba điều tôi ưu tiên khi mới làm quản lý kỹ thuật</a> - điều gì giúp một đội làm việc tốt với nhau, cũng chính là thứ bạn đang tìm khi ghép cặp</li>
<li><a href="https://jared.lynskey.co.nz/vi/posts/2024/2024-07-01-internships/" >Vì sao bạn nên thực tập ở startup</a> - bối cảnh hữu ích khi nói chuyện với người đang cân nhắc chuyển sang startup</li>
</ul>
<p><strong>Tài liệu bên ngoài:</strong></p>
<ul>
<li><a href="https://review.firstround.com/articles/hiring-engineers/"  target="_blank" rel="noreferrer">First Round Review: Hiring Engineers</a> - các hướng dẫn tuyển dụng cho startup từ những người điều hành giàu kinh nghiệm</li>
<li><a href="https://larahogan.me/blog/first-one-on-one-questions/"  target="_blank" rel="noreferrer">Lara Hogan: &ldquo;Questions for Our First 1:1&rdquo;</a> - viết cho các buổi gặp riêng 1:1, nhưng dùng khi đi cà phê cũng rất hợp</li>
<li><a href="https://www.kalzumeus.com/2012/01/23/salary-negotiation/"  target="_blank" rel="noreferrer">Patrick McKenzie bàn về đàm phán lương</a> - đáng đọc để hiểu góc nhìn của ứng viên</li>
<li><a href="https://whothebook.com/" target="_blank" rel="noreferrer">Who: The A Method for Hiring</a> - khung phương pháp tuyển dụng bài bản của Geoff Smart và Randy Street</li>
<li><a href="https://hbr.org/topic/subject/hiring-and-recruitment"  target="_blank" rel="noreferrer">Harvard Business Review: Hiring and Recruitment</a> - các bài viết dựa trên nghiên cứu về thu hút nhân tài</li>
</ul>
]]></content:encoded>
      <media:content url="https://jared.lynskey.co.nz/en/posts/2024/2024-07-12-coffee-chats/featured.jpg" medium="image" type="image/jpeg" />
    </item>
    <item>
      <title>Orval: sinh mã máy khách API (API client) có định kiểu và mock từ đặc tả OpenAPI</title>
      <link>https://jared.lynskey.co.nz/vi/posts/2024/2024-04-10-openapitools/</link>
      <guid isPermaLink="true">https://jared.lynskey.co.nz/vi/posts/2024/2024-04-10-openapitools/</guid>
      <pubDate>Wed, 10 Apr 2024 00:30:03 +0000</pubDate>
      <dc:creator>Me</dc:creator>
      <category>API Development</category>
      <category>Orval</category>
      <category>OpenAPI</category>
      <category>TypeScript</category>
      <category>React Query</category>
      <category>MSW</category>
      <category>Frontend</category>
      <category>Backend</category>
      <category>Teamwork</category>
      <category>Efficiency</category>
      <description>Orval đọc bản đặc tả OpenAPI rồi sinh ra mã máy khách TypeScript có định kiểu, các hook React Query và mock MSW, để không ai phải tự tay viết lớp gọi API nữa. Cách cài đặt, cách phần mock hoạt động, và Orval so với openapi-generator, openapi-typescript và Hey API ra sao.</description>
      <content:encoded><![CDATA[<p>Orval là một công cụ sinh mã (code generator): nó đọc bản đặc tả OpenAPI (Swagger) rồi viết sẵn lớp gọi API cho frontend của bạn. Bạn có một hàm có định kiểu hoặc một hook React Query cho từng endpoint, các mô hình dữ liệu TypeScript khớp chính xác với hợp đồng API (contract), và nếu bật thêm thì có cả các handler mock của MSW trả về dữ liệu giả do Faker tạo ra. Bạn chỉ cần commit một tệp cấu hình, chạy <code>orval</code>, rồi chạy lại mỗi khi đặc tả thay đổi.</p>
<p>Ở bài đầu tiên trong loạt bài này, tôi đã giải thích vì sao các đội nên thống nhất một bản hợp đồng API theo chuẩn OpenAPI trước khi ai bắt tay vào viết mã. Bài này nói về công cụ giúp bản hợp đồng đó thực sự phát huy tác dụng.</p>
<p>Tự tay viết lớp gọi API cho frontend là một trong những việc chẳng ai dám nhận là mình thích. Bạn chép các kiểu dữ liệu (type) từ tài liệu của backend, viết đi viết lại hàm bọc (wrapper) cho yêu cầu lần thứ bốn mươi, rồi ba tuần sau có ai đó đổi tên một trường và thế là một nửa số chỗ gọi API của bạn âm thầm hỏng. Orval xóa sổ luôn công việc đó. Chỉ cần trỏ nó tới bản đặc tả (spec) OpenAPI, Orval sẽ sinh mã máy khách cho bạn: hàm có định kiểu cho từng endpoint, mô hình dữ liệu khớp chính xác với hợp đồng, và cả dữ liệu giả lập (mock) để bạn phát triển trước khi backend kịp làm xong.</p>

<h2 class="relative group">Vì sao đội frontend thích Orval
    <div id="vì-sao-đội-frontend-thích-orval" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#v%c3%ac-sao-%c4%91%e1%bb%99i-frontend-th%c3%adch-orval" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>Phần sinh dữ liệu giả lập là phần bị đánh giá thấp nhất. Một khi đặc tả đã chốt, frontend có thể dựng một máy chủ giả rồi làm toàn bộ giao diện dựa trên nó, thay vì ngồi chờ những endpoint lúc nào cũng &ldquo;sắp xong rồi&rdquo;. Khi backend thật được triển khai, bạn chỉ việc trỏ máy khách sang đó và gần như mọi thứ chạy được luôn, vì cả hai bên đều làm dựa trên cùng một tài liệu.</p>
<p>Cái lợi còn lại là phần mã nhàm chán giờ đúng ngay từ khi được sinh ra. Không còn ai gõ nhầm tên trường trong phần thân yêu cầu (request body) tự viết, vì đơn giản là chẳng còn ai phải tự viết phần đó nữa.</p>

<h2 class="relative group">Vì sao đội backend cũng thích
    <div id="vì-sao-đội-backend-cũng-thích" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#v%c3%ac-sao-%c4%91%e1%bb%99i-backend-c%c5%a9ng-th%c3%adch" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>Khi bản đặc tả là nguồn dữ liệu gốc duy nhất, những trao đổi hằng ngày giữa hai bên cũng thay đổi hẳn. Thay vì những chuỗi tin nhắn kiểu &ldquo;endpoint này trả về gì ấy nhỉ?&rdquo;, frontend chỉ việc đọc các kiểu dữ liệu đã được sinh ra. Lập trình viên backend ít bị làm phiền hơn, mà lại nhận được góp ý sớm hơn: nếu frontend làm dựa trên dữ liệu giả lập rồi thấy API có chỗ nào khó dùng, bạn sẽ biết ngay từ lúc sửa còn rẻ, chứ không phải đợi đến khi nó đã lên môi trường production.</p>

<h2 class="relative group">Orval nằm ở đâu trong quy trình làm việc
    <div id="orval-nằm-ở-đâu-trong-quy-trình-làm-việc" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#orval-n%e1%ba%b1m-%e1%bb%9f-%c4%91%c3%a2u-trong-quy-tr%c3%acnh-l%c3%a0m-vi%e1%bb%87c" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>Chẳng có gì cầu kỳ cả. Backend đề xuất bản đặc tả, hai đội cùng rà soát, frontend dùng Orval để sinh mã máy khách và dữ liệu giả lập rồi bắt đầu làm, còn backend thì hiện thực các endpoint thật theo đúng hợp đồng đó. Khi đặc tả thay đổi, cả hai bên sinh lại mã, và trình biên dịch sẽ chỉ ra chính xác chỗ nào bị hỏng. Phần cuối đó mới là mấu chốt: những chỗ lệch nhau giữa frontend và backend sẽ hiện ra thành lỗi biên dịch, thay vì thành lỗi trên production.</p>

<h2 class="relative group">Cài đặt và cấu hình
    <div id="cài-đặt-và-cấu-hình" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#c%c3%a0i-%c4%91%e1%ba%b7t-v%c3%a0-c%e1%ba%a5u-h%c3%acnh" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>Cài Orval dưới dạng gói phụ thuộc chỉ dùng khi phát triển (dev dependency), cùng với những thư viện mà mã được sinh ra sẽ import. Nếu muốn có hook React Query và mock thì đó là TanStack Query, MSW và Faker:</p>
<div class="highlight-wrapper"><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">npm install --save-dev orval msw @faker-js/faker
</span></span><span class="line"><span class="cl">npm install @tanstack/react-query</span></span></code></pre></div></div>
<p>Sau đó thêm tệp <code>orval.config.ts</code> ở thư mục gốc của dự án. Cấu hình dưới đây gần giống ví dụ trong tài liệu chính thức của Orval:</p>
<div class="highlight-wrapper"><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-ts" data-lang="ts"><span class="line"><span class="cl"><span class="kr">import</span> <span class="p">{</span> <span class="nx">defineConfig</span> <span class="p">}</span> <span class="kr">from</span> <span class="s1">&#39;orval&#39;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kr">export</span> <span class="k">default</span> <span class="nx">defineConfig</span><span class="p">({</span>
</span></span><span class="line"><span class="cl">  <span class="nx">petstore</span><span class="o">:</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">input</span><span class="o">:</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="nx">target</span><span class="o">:</span> <span class="s1">&#39;./openapi.yaml&#39;</span><span class="p">,</span> <span class="c1">// a path or a URL
</span></span></span><span class="line"><span class="cl">    <span class="p">},</span>
</span></span><span class="line"><span class="cl">    <span class="nx">output</span><span class="o">:</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="nx">mode</span><span class="o">:</span> <span class="s1">&#39;single&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">      <span class="nx">target</span><span class="o">:</span> <span class="s1">&#39;./src/api/petstore.ts&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">      <span class="nx">schemas</span><span class="o">:</span> <span class="s1">&#39;./src/api/model&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">      <span class="nx">client</span><span class="o">:</span> <span class="s1">&#39;react-query&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">      <span class="nx">httpClient</span><span class="o">:</span> <span class="s1">&#39;fetch&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">      <span class="nx">mock</span>: <span class="kt">true</span><span class="p">,</span> <span class="c1">// MSW handlers plus Faker data
</span></span></span><span class="line"><span class="cl">      <span class="nx">override</span><span class="o">:</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nx">fetch</span><span class="o">:</span> <span class="p">{</span> <span class="nx">includeHttpResponseReturnType</span>: <span class="kt">false</span> <span class="p">},</span>
</span></span><span class="line"><span class="cl">      <span class="p">},</span>
</span></span><span class="line"><span class="cl">    <span class="p">},</span>
</span></span><span class="line"><span class="cl">  <span class="p">},</span>
</span></span><span class="line"><span class="cl"><span class="p">});</span></span></span></code></pre></div></div>
<p>Tùy chọn <code>client</code> quyết định bạn nhận được gì: các hàm <code>fetch</code> hoặc <code>axios</code> thuần, hook cho React Query, Vue Query, Svelte Query hay SWR, service cho Angular, hoặc schema Zod. Dòng <code>includeHttpResponseReturnType: false</code> khiến máy khách fetch trả về thẳng phần thân phản hồi (response body) thay vì <code>{ data, status }</code>, mà thường thì component chỉ cần đúng phần đó.</p>
<p>Thêm một script vào <code>package.json</code> để không ai phải nhớ câu lệnh:</p>
<div class="highlight-wrapper"><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-json" data-lang="json"><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;scripts&#34;</span><span class="p">:</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nt">&#34;api&#34;</span><span class="p">:</span> <span class="s2">&#34;orval&#34;</span>
</span></span><span class="line"><span class="cl">  <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span></span></span></code></pre></div></div>
<p>Chạy <code>npm run api</code> là các hook và mô hình dữ liệu được sinh ra. Sau đó component dùng chúng như mọi hook React Query khác, với kiểu dữ liệu đã có sẵn đầy đủ:</p>
<div class="highlight-wrapper"><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-tsx" data-lang="tsx"><span class="line"><span class="cl"><span class="kr">import</span> <span class="p">{</span> <span class="nx">useListPets</span> <span class="p">}</span> <span class="kr">from</span> <span class="s1">&#39;./api/petstore&#39;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kr">export</span> <span class="kd">function</span> <span class="nx">PetList() {</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="p">{</span> <span class="nx">data</span>: <span class="kt">pets</span><span class="p">,</span> <span class="nx">isLoading</span> <span class="p">}</span> <span class="o">=</span> <span class="nx">useListPets</span><span class="p">();</span>
</span></span><span class="line"><span class="cl">  <span class="k">if</span> <span class="p">(</span><span class="nx">isLoading</span><span class="p">)</span> <span class="k">return</span> <span class="p">&lt;</span><span class="nt">p</span><span class="p">&gt;</span><span class="nx">Loading</span><span class="err">…</span><span class="p">&lt;/</span><span class="nt">p</span><span class="p">&gt;;</span>
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="p">&lt;</span><span class="nt">ul</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">      <span class="p">{</span><span class="nx">pets</span><span class="o">?</span><span class="p">.</span><span class="nx">map</span><span class="p">((</span><span class="nx">pet</span><span class="p">)</span> <span class="o">=&gt;</span> <span class="p">&lt;</span><span class="nt">li</span> <span class="na">key</span><span class="o">=</span><span class="p">{</span><span class="nx">pet</span><span class="p">.</span><span class="nx">id</span><span class="p">}&gt;{</span><span class="nx">pet</span><span class="p">.</span><span class="nx">name</span><span class="p">}&lt;/</span><span class="nt">li</span><span class="p">&gt;)}</span>
</span></span><span class="line"><span class="cl">    <span class="p">&lt;/</span><span class="nt">ul</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">  <span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span></span></span></code></pre></div></div>
<p>Thử đổi tên một trường trong đặc tả rồi chạy lại <code>npm run api</code>, bạn sẽ thấy <code>pet.name</code> bị gạch đỏ ở mọi chỗ đang dùng nó. Đó chính là cách bắt chỗ lệch giữa frontend và backend mà tôi nói ở trên, và bạn chẳng tốn gì để có nó.</p>

<h2 class="relative group">Phát triển dựa trên mock
    <div id="phát-triển-dựa-trên-mock" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#ph%c3%a1t-tri%e1%bb%83n-d%e1%bb%b1a-tr%c3%aan-mock" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>Khi bật <code>mock: true</code>, Orval còn viết thêm cho mỗi endpoint một handler xử lý yêu cầu (request handler) của MSW, trả về dữ liệu do Faker tạo ra theo đúng cấu trúc (schema) của phản hồi, kèm một hàm trả về toàn bộ các handler đó. Đưa danh sách này cho <code>setupWorker</code> của MSW khi chạy trên trình duyệt, hoặc cho <code>setupServer</code> khi chạy kiểm thử, là ứng dụng sẽ chạy trên một backend giả vốn đã khớp sẵn với hợp đồng API. Mỗi handler còn nhận thêm phần ghi đè (override), nên một bài kiểm thử có thể trả về một payload cụ thể, một danh sách rỗng hay một trạng thái lỗi, mà không ai phải tự tay viết dữ liệu mẫu (fixture).</p>
<p>Chính phần này giúp frontend bắt tay vào làm ngay từ ngày đầu tiên. Mock không phải một thứ riêng mà ai đó phải ngồi bảo trì; chúng được sinh lại từ cùng bản đặc tả với mã máy khách, nên không thể nào bị tụt lại so với đặc tả.</p>

<h2 class="relative group">So sánh Orval với openapi-generator, openapi-typescript và Hey API
    <div id="so-sánh-orval-với-openapi-generator-openapi-typescript-và-hey-api" class="anchor"></div>
    
    <span
        class="absolute top-0 w-6 transition-opacity opacity-0 -start-6 not-prose group-hover:opacity-100 select-none">
        <a class="text-primary-300 dark:text-neutral-700 !no-underline" href="#so-s%c3%a1nh-orval-v%e1%bb%9bi-openapi-generator-openapi-typescript-v%c3%a0-hey-api" aria-label="Cọc dấu">#</a>
    </span>
    
</h2>
<p>Cả bốn công cụ đều bắt đầu từ bản đặc tả OpenAPI, nhưng mỗi công cụ sinh ra đến đâu thì khác nhau.</p>
<table>
	<thead>
			<tr>
					<th></th>
					<th>Sinh ra những gì</th>
					<th>Phù hợp nhất khi</th>
			</tr>
	</thead>
	<tbody>
			<tr>
					<td><strong>Orval</strong></td>
					<td>Hàm máy khách có định kiểu hoặc hook cho framework (React Query, SWR, Vue, Svelte, Angular), mô hình dữ liệu, mock MSW, schema Zod</td>
					<td>Frontend viết bằng TypeScript, muốn có cả hook lẫn mock từ cùng một tệp cấu hình</td>
			</tr>
			<tr>
					<td><strong>openapi-generator</strong></td>
					<td>Mã máy khách và khung mã phía máy chủ (server stub) cho hàng chục ngôn ngữ, trong đó có TypeScript</td>
					<td>Đội cần biến cùng một bản đặc tả thành mã Java, Kotlin, Swift và TypeScript</td>
			</tr>
			<tr>
					<td><strong>openapi-typescript</strong></td>
					<td>Chỉ sinh kiểu dữ liệu, đi kèm <code>openapi-fetch</code> làm một lớp bọc fetch nhỏ gọn có định kiểu</td>
					<td>Bạn chỉ cần kiểu dữ liệu, gần như không muốn thêm mã nào chạy lúc runtime</td>
			</tr>
			<tr>
					<td><strong>Hey API</strong> (<code>@hey-api/openapi-ts</code>)</td>
					<td>Một SDK có định kiểu, với các plugin cho TanStack Query, Zod và nhiều thứ khác</td>
					<td>Phạm vi gần giống Orval, nhưng xây dựng quanh một hệ thống plugin</td>
			</tr>
	</tbody>
</table>
<p>Nếu chỉ cần kiểu dữ liệu thì openapi-typescript là lựa chọn nhẹ nhất, khó mà chê được. openapi-generator đáng dùng khi cùng một bản đặc tả phải sinh mã cho nhiều ngôn ngữ; mã TypeScript nó sinh ra vẫn chạy được, nhưng đọc lên cứ như được viết cho Java trước rồi mới chuyển sang. Giữa Orval và Hey API thì chủ yếu là chuyện sở thích, và bạn thấy mã sinh ra của bên nào dễ đọc hơn. Tôi vẫn dùng Orval vì mock được sinh ra trong cùng một lần chạy với các hook, và chính tính năng đó đã thay đổi cách đội frontend và đội backend làm việc với nhau.</p>
<p>Đây không phải loại công cụ hào nhoáng gì. Nó chỉ lặng lẽ dẹp bỏ cả một kiểu tranh cãi giữa các đội, và lần nào có cơ hội đổi như vậy, tôi cũng sẵn lòng.</p>
]]></content:encoded>
      <media:content url="https://jared.lynskey.co.nz/en/posts/2024/2024-04-10-openapitools/featured.jpg" medium="image" type="image/jpeg" />
    </item>
  </channel>
</rss>
