تست‌نویسی با تایپ اسکریپت: افزایش قابلیت اطمینان و نگهداری کد

در دنیای پرشتاب توسعه نرم‌افزار، اطمینان از صحت عملکرد و پایداری کد، بیش از هر زمان دیگری حیاتی است. با افزایش پیچیدگی سیستم‌ها و نیاز به ارائه مداوم قابلیت‌های جدید، مکانیزم‌های قوی برای تضمین کیفیت کد به یک ضرورت بدل شده‌اند. تست‌نویسی، به عنوان ستون فقرات مهندسی نرم‌افزار با کیفیت، نقش محوری در این فرآیند ایفا می‌کند. اما وقتی صحبت از کدبیس‌های بزرگ و تیم‌های توسعه متعدد می‌شود، صرفاً نوشتن تست کافی نیست؛ بلکه نیاز به ابزارهایی داریم که به ما در نوشتن تست‌های قابل اعتماد، قابل نگهداری و مقیاس‌پذیر کمک کنند.

اینجاست که تایپ اسکریپت (TypeScript) وارد میدان می‌شود. تایپ اسکریپت، فوق مجموعه‌ای (Superset) از جاوا اسکریپت است که با افزودن قابلیت‌های تایپ استاتیک، مزایای بی‌شماری را برای توسعه‌دهندگان به ارمغان می‌آورد. این مزایا نه تنها در زمان توسعه قابلیت‌های اصلی برنامه، بلکه در فرآیند حیاتی تست‌نویسی نیز نمود پیدا می‌کنند. هدف این مقاله، بررسی عمیق چگونگی بهره‌برداری از تایپ اسکریپت در فرآیند تست‌نویسی است؛ از تست‌های واحد گرفته تا تست‌های یکپارچه‌سازی و سرتاسری (End-to-End)، و نشان دادن اینکه چگونه تایپ اسکریپت می‌تواند به افزایش قابلیت اطمینان کد و کاهش هزینه‌های نگهداری کمک شایانی کند.

ما در این بحث، به بررسی ابزارها، الگوها، و بهترین شیوه‌های تست‌نویسی با تایپ اسکریپت خواهیم پرداخت. از مزایای ذاتی تایپ‌سیفتی (Type Safety) در تست‌ها گرفته تا نحوه پیکربندی محیط تست و نوشتن تست‌های قدرتمند برای سناریوهای مختلف. با درک و به‌کارگیری این مفاهیم، توسعه‌دهندگان می‌توانند فرآیند توسعه خود را بهبود بخشیده، با اطمینان خاطر بیشتری کد را refactor کنند و در نهایت، محصولاتی با کیفیت بالاتر و پایدارتر به بازار عرضه نمایند.

این مقاله به جامعه تخصصی توسعه‌دهندگان جاوا اسکریپت و تایپ اسکریپت، معماران نرم‌افزار و مهندسان تضمین کیفیت (QA Engineers) که به دنبال ارتقاء استراتژی‌های تست‌نویسی خود هستند، اختصاص دارد. با ما همراه باشید تا سفری به دنیای پیشرفته تست‌نویسی با تایپ اسکریپت داشته باشیم.

مقدمه‌ای بر اهمیت تست‌نویسی در توسعه نرم‌افزار مدرن

تست‌نویسی دیگر یک گزینه لوکس در توسعه نرم‌افزار نیست، بلکه به یک ضرورت مطلق تبدیل شده است. در اکوسیستم‌های نرم‌افزاری پیچیده و مقیاس‌پذیر امروزی، عدم وجود یک استراتژی تست قوی می‌تواند منجر به پیامدهای فاجعه‌بار از جمله باگ‌های بحرانی، کاهش رضایت مشتری، ضررهای مالی و آسیب به اعتبار برند شود. تست‌نویسی فراتر از صرفاً پیدا کردن باگ‌هاست؛ این یک رویکرد پیشگیرانه برای تضمین کیفیت، بهبود قابلیت نگهداری کد و تسریع چرخه توسعه است.

چرا تست‌نویسی حیاتی است؟

• افزایش قابلیت اطمینان کد: تست‌ها به عنوان یک شبکه ایمنی عمل می‌کنند. آن‌ها اطمینان حاصل می‌کنند که تغییرات جدید، عملکرد موجود سیستم را مختل نمی‌کنند. این موضوع به خصوص در پروژه‌های بزرگ با تیم‌های متعدد و کدهای میراثی (Legacy Code) اهمیت می‌یابد.
• کاهش هزینه‌ها در بلندمدت: پیدا کردن باگ‌ها در مراحل اولیه چرخه توسعه (مانند زمان تست‌نویسی یا توسعه) بسیار ارزان‌تر از رفع آن‌ها پس از انتشار محصول به کاربران نهایی است. باگ‌های شناسایی شده در تولید می‌توانند منجر به هزینه‌های گزافی برای رفع، پشتیبانی و جبران خسارت شوند.
• بهبود کیفیت طراحی کد: نوشتن کد تست‌پذیر، اغلب به معنای نوشتن کدی با طراحی بهتر است. تست‌ها توسعه‌دهندگان را ترغیب می‌کنند تا ماژول‌های مستقل، توابع خالص (Pure Functions) و وابستگی‌های مشخصی داشته باشند که این خود به سهولت درک، نگهداری و توسعه کد کمک می‌کند.
• سرعت بخشیدن به فرآیند توسعه: در نگاه اول ممکن است به نظر برسد تست‌نویسی سرعت توسعه را کاهش می‌دهد، اما در واقع، با کاهش ترس از ایجاد باگ و تسهیل فرآیند refactoring، به تیم‌ها اجازه می‌دهد تا با اطمینان خاطر و سرعت بیشتری کد را تغییر داده و قابلیت‌های جدید اضافه کنند.
• مستندسازی عملیاتی: تست‌ها به عنوان نوعی مستندات اجرایی عمل می‌کنند. آن‌ها نشان می‌دهند که یک تابع یا یک کامپوننت چگونه قرار است کار کند و چه ورودی‌هایی را انتظار دارد و چه خروجی‌هایی را تولید می‌کند. این امر برای توسعه‌دهندگان جدید یا هنگام انتقال دانش تیمی بسیار ارزشمند است.
• پشتیبانی از ریفکتورینگ (Refactoring): با داشتن تست‌های جامع، می‌توان با اطمینان خاطر کدهای قدیمی یا بد طراحی شده را بازسازی (refactor) کرد، بدون اینکه نگران ایجاد رگرسیون (Regression) باشیم. تست‌ها تضمین می‌کنند که پس از تغییرات ساختاری، عملکرد اصلی سیستم حفظ می‌شود.

انواع تست‌های نرم‌افزاری

برای پوشش جامع جنبه‌های مختلف یک سیستم نرم‌افزاری، انواع مختلفی از تست‌ها وجود دارند که هر کدام هدف خاصی را دنبال می‌کنند:

• تست واحد (Unit Tests): این تست‌ها کوچک‌ترین واحدهای منطقی کد (مانند یک تابع، یک کلاس یا یک ماژول) را به صورت ایزوله بررسی می‌کنند. هدف آن‌ها اطمینان از صحت عملکرد این واحدهای منفرد است. تست‌های واحد سریع‌ترین و ارزان‌ترین نوع تست‌ها هستند و بیشترین پوشش کد (Code Coverage) را ارائه می‌دهند.
• تست یکپارچه‌سازی (Integration Tests): این تست‌ها تعامل بین چندین واحد یا کامپوننت مختلف سیستم را بررسی می‌کنند. به عنوان مثال، تست ارتباط بین یک سرویس و پایگاه داده یا بین دو ماژول مختلف. هدف آن‌ها اطمینان از همکاری صحیح اجزای مختلف سیستم با یکدیگر است.
• تست End-to-End (E2E Tests) یا تست سرتاسری: این تست‌ها کل سیستم را از دید کاربر نهایی بررسی می‌کنند. آن‌ها یک سناریوی کامل کاربری را شبیه‌سازی می‌کنند، از تعامل با رابط کاربری (UI) گرفته تا تعامل با بک‌اند و پایگاه داده. تست‌های E2E کندترین و گران‌ترین تست‌ها هستند، اما بالاترین سطح اطمینان را نسبت به عملکرد کلی سیستم ارائه می‌دهند.
• تست عملکرد (Performance Tests): این تست‌ها عملکرد سیستم را تحت بار مشخصی (Load) یا استرس (Stress) اندازه‌گیری می‌کنند تا پایداری و پاسخگویی آن را در شرایط واقعی ارزیابی کنند.
• تست امنیت (Security Tests): این تست‌ها آسیب‌پذیری‌های امنیتی احتمالی در سیستم را شناسایی می‌کنند.
• تست قابلیت استفاده (Usability Tests): این تست‌ها بر تجربه کاربری تمرکز دارند و بررسی می‌کنند که سیستم چقدر برای کاربران نهایی آسان و شهودی است.

با درک این مفاهیم بنیادی، می‌توانیم به بررسی نقش تایپ اسکریپت در تقویت این استراتژی‌های تست‌نویسی بپردازیم و کشف کنیم که چگونه این زبان می‌تواند به ما در نوشتن تست‌های کارآمدتر و قابل اعتمادتر کمک کند.

چرا تایپ اسکریپت برای تست‌نویسی انتخابی هوشمندانه است؟

تایپ اسکریپت با ارائه سیستم تایپ ایستا (Static Type System) بر روی جاوا اسکریپت، مزایای قابل توجهی را به ارمغان می‌آورد که به طور مستقیم بر کیفیت و کارایی تست‌نویسی تاثیر می‌گذارد. انتخاب تایپ اسکریپت برای پروژه‌های بزرگ و نگهداری شده، به خودی خود یک تصمیم هوشمندانه است، اما در حوزه تست‌نویسی، این انتخاب حتی درخشان‌تر می‌شود.

مزایای کلیدی تایپ اسکریپت در تست‌نویسی:

1. شناسایی خطاهای زمان کامپایل (Compile-Time Error Checking):

   بزرگترین مزیت تایپ اسکریپت، توانایی آن در شناسایی طیف وسیعی از خطاها پیش از اجرای کد است. این بدان معناست که بسیاری از باگ‌هایی که در جاوا اسکریپت سنتی تنها در زمان اجرا (Runtime) و اغلب در سناریوهای خاص خود را نشان می‌دهند، در تایپ اسکریپت در زمان کامپایل (یا حتی در IDE شما هنگام کدنویسی) کشف می‌شوند. این موضوع نه تنها به کاهش زمان دیباگینگ کمک می‌کند، بلکه باعث می‌شود تست‌های شما از ابتدا بر روی کدی با سلامت ساختاری بیشتر نوشته شوند.

   به عنوان مثال، اگر تابعی را تست می‌کنید که انتظار یک آرگومان از نوع number را دارد و به اشتباه یک string به آن ارسال کنید، تایپ اسکریپت بلافاصله به شما هشدار می‌دهد. این جلوگیری از خطاهای نوعی، به ویژه هنگام ساخت mockها و stubها برای تست‌ها، بسیار مفید است و اطمینان می‌دهد که mock شما دقیقاً پروتکل مورد انتظار را رعایت می‌کند.

2. افزایش قابلیت اطمینان تست‌ها و کاهش تست‌های شکننده (Brittle Tests):

   تست‌های شکننده تست‌هایی هستند که با تغییرات کوچک و غیرمرتبط در کد تولیدی (Production Code) دچار شکست می‌شوند. یکی از دلایل رایج تست‌های شکننده، عدم تطابق بین انتظارات تست و واقعیت‌های کد است. تایپ اسکریپت این شکاف را با اعمال تایپ‌ها در سراسر کد و تست، پر می‌کند. وقتی یک تابع یا رابط کاربری تغییر می‌کند، تایپ اسکریپت به طور خودکار به شما هشدار می‌دهد که کدام تست‌ها یا mockها نیاز به به‌روزرسانی دارند تا با ساختار جدید مطابقت داشته باشند.

   این موضوع به خصوص در refactoring‌های بزرگ اهمیت پیدا می‌کند. با تایپ اسکریپت، می‌توانید با اطمینان خاطر بیشتری کد را refactor کنید، زیرا سیستم تایپ به شما کمک می‌کند تا تمامی نقاطی که باید تغییر کنند، شناسایی شوند؛ از جمله تست‌ها. این قابلیت اعتماد را به تست‌های شما افزایش می‌دهد، چرا که می‌دانید شکست یک تست به احتمال زیاد به دلیل یک باگ واقعی یا یک تغییر ساختاری مهم است، نه صرفاً یک خطای نوعی پنهان.

3. پشتیبانی بهتر از ابزارهای توسعه (IDE Support):

   محیط‌های توسعه یکپارچه (IDEs) مدرن مانند VS Code، به طور کامل از تایپ اسکریپت پشتیبانی می‌کنند. این پشتیبانی شامل تکمیل خودکار (Autocompletion)، بررسی خطاهای لحظه‌ای (Live Error Checking)، پیمایش کد (Go-to-Definition) و refactoring خودکار است. این قابلیت‌ها به طور چشمگیری تجربه نوشتن تست را بهبود می‌بخشند. هنگام نوشتن تست‌ها، می‌توانید به راحتی به تعریف توابعی که تست می‌کنید بروید، پارامترهای مورد انتظار را ببینید و از خطاهای تایپی جلوگیری کنید، که این امر به افزایش سرعت و دقت در نوشتن تست کمک می‌کند.

4. مستندسازی بهتر و خوانایی کد:

   تایپ‌ها به عنوان مستندات زنده برای کد عمل می‌کنند. وقتی یک توسعه‌دهنده جدید به پروژه‌ای ملحق می‌شود، یا حتی برای خودتان پس از مدتی، خواندن تایپ‌ها به درک سریع‌تر ورودی‌ها، خروجی‌ها و ساختار داده‌های مورد استفاده در توابع و کلاس‌ها کمک می‌کند. این موضوع در تست‌ها نیز صادق است. تست‌های تایپ‌شده، مقصود و عملکرد قطعه کد مورد تست را به وضوح نشان می‌دهند و درک و نگهداری آن‌ها را آسان‌تر می‌سازند.

5. بهبود تجربه Mocking و Stubbing:

   در تست‌های واحد و یکپارچه‌سازی، اغلب نیاز به Mock کردن یا Stub کردن وابستگی‌ها داریم. تایپ اسکریپت این فرآیند را ایمن‌تر و دقیق‌تر می‌کند. وقتی شما یک Mock یا Stub ایجاد می‌کنید، تایپ اسکریپت اطمینان حاصل می‌کند که mock شما دقیقاً همان متدها و ویژگی‌هایی را دارد که شیء اصلی مورد انتظار است. این از مشکلاتی مانند “Mock With Missing Method” جلوگیری می‌کند و اطمینان می‌دهد که mock شما به درستی رفتار می‌کند و از بروز خطاهای زمان اجرا جلوگیری می‌کند.

   
   // مثال: Mock کردن یک سرویس در TypeScript با اطمینان تایپی
   interface UserService {
     getUser(id: string): Promise<User>;
     createUser(data: UserCreationData): Promise<User>;
   }
   
   // در تست:
   const mockUserService: jest.Mocked<UserService> = {
     getUser: jest.fn(),
     createUser: jest.fn(),
   };
   
   // اگر متد getUser را اشتباه بنویسید (مثلا GetUser با G بزرگ)، TypeScript خطا می‌دهد.
   // اگر تعداد پارامترها یا نوع آن‌ها اشتباه باشد، TypeScript هشدار می‌دهد.
           

6. هم‌گام‌سازی آسان‌تر با ابزارهای تست:

   اکوسیستم جاوا اسکریپت مدرن، ابزارهای تست قدرتمندی مانند Jest، Vitest، Cypress و Playwright را شامل می‌شود که همگی از تایپ اسکریپت به خوبی پشتیبانی می‌کنند. این ابزارها با پیکربندی‌های ساده، به شما اجازه می‌دهند تا تست‌های تایپ‌شده خود را به راحتی اجرا کنید و از تمامی مزایای تایپ اسکریپت بهره‌مند شوید.

در مجموع، تایپ اسکریپت با ارائه یک لایه اضافی از ایمنی و وضوح، فرآیند تست‌نویسی را از یک فعالیت صرفاً برای یافتن باگ به یک جزء فعال و سازنده در چرخه توسعه تبدیل می‌کند. این نه تنها به توسعه‌دهندگان کمک می‌کند تا تست‌های بهتری بنویسند، بلکه به طور کلی به تولید کدی پایدارتر و با کیفیت‌تر منجر می‌شود.

راه‌اندازی محیط تست با تایپ اسکریپت: ابزارها و پیکربندی

برای شروع تست‌نویسی با تایپ اسکریپت، نیاز به پیکربندی صحیح محیط توسعه داریم. این پیکربندی شامل انتخاب ابزار تست مناسب و تنظیمات تایپ اسکریپت برای اطمینان از هم‌خوانی صحیح کد تست و کد تولیدی است. در اکوسیستم جاوا اسکریپت، Jest و Vitest از محبوب‌ترین و قدرتمندترین فریم‌ورک‌های تست هستند که هر دو پشتیبانی عالی از تایپ اسکریپت ارائه می‌دهند. در ادامه به نحوه راه‌اندازی با Jest و Vitest می‌پردازیم.

1. انتخاب فریم‌ورک تست: Jest در برابر Vitest

• Jest:

  Jest یک فریم‌ورک تست جاوا اسکریپت است که توسط فیس‌بوک توسعه یافته و به دلیل سهولت استفاده، قابلیت‌های گسترده (مانند mocking، assertion و coverage reporting داخلی) و عملکرد مناسب، بسیار محبوب است. Jest به طور پیش‌فرض بر روی Node.js اجرا می‌شود و برای تست‌های واحد و یکپارچه‌سازی ایده‌آل است. برای پشتیبانی از تایپ اسکریپت، Jest از ts-jest یا Babel استفاده می‌کند تا کد تایپ اسکریپت را به جاوا اسکریپت کامپایل کند.

• Vitest:

  Vitest یک فریم‌ورک تست جدیدتر است که بر پایه Vite (یک ابزار بیلد سریع برای توسعه وب) ساخته شده است. Vitest با تمرکز بر سرعت و تجربه توسعه‌دهنده، به سرعت در حال محبوب شدن است. این فریم‌ورک از قابلیت‌های مشابه Jest برخوردار است اما با بهره‌گیری از معماری Vite، زمان اجرای تست‌ها را به طور چشمگیری کاهش می‌دهد، به خصوص در پروژه‌های بزرگ. Vitest از تایپ اسکریپت به صورت بومی پشتیبانی می‌کند و نیازی به پیکربندی‌های اضافی مانند ts-jest ندارد.

انتخاب بین Jest و Vitest به نیازهای پروژه و ترجیحات تیم بستگی دارد. Vitest برای پروژه‌های جدید که از Vite استفاده می‌کنند یا به دنبال سریع‌ترین تجربه تست هستند، گزینه عالی است. Jest برای پروژه‌هایی که قبلاً از آن استفاده می‌کرده‌اند یا به دنبال یک فریم‌ورک تست با جامعه کاربری بسیار بزرگ و منابع آموزشی فراوان هستند، همچنان یک انتخاب مطمئن است.

2. راه‌اندازی پروژه و نصب وابستگی‌ها (با تمرکز بر Jest):

فرض می‌کنیم که یک پروژه Node.js با تایپ اسکریپت دارید. اگر ندارید، می‌توانید با دستورات زیر یک پروژه جدید راه‌اندازی کنید:

mkdir my-ts-app
cd my-ts-app
npm init -y
npm install typescript --save-dev
npx tsc --init

سپس، Jest و ts-jest (برای کامپایل تایپ اسکریپت) و تایپ‌های مربوطه را نصب کنید:

npm install --save-dev jest @types/jest ts-jest

3. پیکربندی Jest برای تایپ اسکریپت:

الف) فایل jest.config.js یا jest.config.ts:
برای اینکه Jest بتواند فایل‌های .ts یا .tsx را پردازش کند، باید آن را پیکربندی کنید. یک فایل jest.config.js (یا jest.config.ts) در ریشه پروژه خود ایجاد کنید:

// jest.config.js
module.exports = {
  preset: 'ts-jest', // استفاده از preset ts-jest برای پردازش فایل‌های TypeScript
  testEnvironment: 'node', // محیط اجرا برای تست‌ها (برای تست‌های فرانت‌اند می‌توانید 'jsdom' را انتخاب کنید)
  roots: ['<rootDir>/src', '<rootDir>/tests'], // پوشه‌هایی که Jest باید برای تست‌ها اسکن کند
  testMatch: [ // الگوهای فایل‌های تست
    '<rootDir>/tests/**/*.test.ts',
    '<rootDir>/src/**/*.test.ts',
    '<rootDir>/src/**/__tests__/**/*.ts',
  ],
  moduleFileExtensions: ['ts', 'js', 'json', 'node'], // پسوندهای فایل‌هایی که Jest باید پردازش کند
  transform: {
    '^.+\\.ts$': 'ts-jest', // تنظیم Jest برای تبدیل فایل‌های .ts با ts-jest
  },
  // برای گزارش‌گیری از پوشش کد
  collectCoverage: true,
  coverageDirectory: 'coverage',
  coverageReporters: ['json', 'lcov', 'text', 'clover'],
  collectCoverageFrom: [
    'src/**/*.ts',
    '!src/**/*.d.ts', // فایل‌های Declaration را حذف کنید
    '!src/**/index.ts', // اگر فایل‌های index خاصی دارید که نمی‌خواهید تست شوند
  ],
  // تنظیمات برای aliasing (اگر در tsconfig.json از path alias استفاده می‌کنید)
  moduleNameMapper: {
    '^@src/(.*)$': '<rootDir>/src/$1',
    '^@tests/(.*)$': '<rootDir>/tests/$1',
  },
  setupFilesAfterEnv: ["<rootDir>/tests/setupTests.ts"], // فایل‌هایی که بعد از راه‌اندازی محیط Jest اجرا می‌شوند (مثلا برای افزودن متدهای Jest-extended)
};

ب) پیکربندی tsconfig.json:
اطمینان حاصل کنید که tsconfig.json شما به درستی برای Jest پیکربندی شده است. معمولاً کافی است تنظیم "module": "commonjs" یا "module": "esnext" و "target": "es2018" یا بالاتر را داشته باشید. ts-jest با این تنظیمات کار می‌کند.

// tsconfig.json
{
  "compilerOptions": {
    "target": "es2018",
    "module": "commonjs", // یا "esnext" اگر Jest از ESM پشتیبانی کند (نسخه‌های جدیدتر Jest)
    "lib": ["es2018", "dom"], // dom برای تست‌های فرانت‌اند
    "declaration": true,
    "outDir": "./dist",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    // برای پشتیبانی از alias
    "baseUrl": ".",
    "paths": {
      "@src/*": ["src/*"],
      "@tests/*": ["tests/*"]
    },
    // شامل فایل‌های تست در کامپایلر تایپ اسکریپت
    "types": ["jest", "node"] // برای دسترسی به تایپ‌های Jest در فایل‌های تست
  },
  "include": [
    "src/**/*.ts",
    "tests/**/*.ts" // اضافه کردن پوشه تست‌ها
  ],
  "exclude": [
    "node_modules",
    "dist"
  ]
}

ج) اسکریپت‌های package.json:
یک اسکریپت تست به فایل package.json خود اضافه کنید:

// package.json
{
  "name": "my-ts-app",
  // ...
  "scripts": {
    "test": "jest",
    "test:watch": "jest --watch",
    "test:coverage": "jest --coverage"
  },
  // ...
}

4. راه‌اندازی Vitest (جایگزین Jest):

اگر Vitest را ترجیح می‌دهید، نصب و پیکربندی آن کمی ساده‌تر است:

npm install --save-dev vitest @vitest/coverage-v8 @vitest/ui

الف) پیکربندی vite.config.ts:
در فایل vite.config.ts خود، بخش test را اضافه کنید:

// vite.config.ts
import { defineConfig } from 'vite';

export default defineConfig({
  // ... سایر تنظیمات Vite
  test: {
    globals: true, // برای استفاده از expect، describe و it بدون import
    environment: 'node', // یا 'jsdom' برای تست‌های فرانت‌اند
    include: ['**/*.test.ts', '**/*.spec.ts'], // الگوهای فایل‌های تست
    exclude: ['node_modules', 'dist', '.idea', '.git', '.cache'],
    coverage: {
      provider: 'v8', // یا 'istanbul'
      reporter: ['text', 'json', 'html'],
      reportsDirectory: './coverage',
    },
    setupFiles: ['./tests/setupVitest.ts'], // فایل‌های setup Vitest
  },
});

ب) پیکربندی tsconfig.json:
مطمئن شوید که تایپ‌های Vitest در tsconfig.json اضافه شده‌اند:

// tsconfig.json
{
  "compilerOptions": {
    // ...
    "types": ["vitest/globals", "node"] // اضافه کردن تایپ‌های Vitest
  }
}

ج) اسکریپت‌های package.json:

// package.json
{
  "name": "my-ts-app",
  // ...
  "scripts": {
    "test": "vitest",
    "test:watch": "vitest --watch",
    "test:coverage": "vitest run --coverage",
    "test:ui": "vitest --ui"
  },
  // ...
}

5. ایجاد فایل‌های Setup (اختیاری اما توصیه شده):

برای پیکربندی‌های عمومی تست یا افزودن متدهای کمکی، می‌توانید فایل‌های setup ایجاد کنید. به عنوان مثال، برای Jest:

// tests/setupTests.ts
import '@testing-library/jest-dom'; // برای استفاده از متدهای خاص DOM در Jest

// پیکربندی‌های گلوبال یا Mock‌های عمومی
// مثلا، اگر fetch را برای تمامی تست‌ها Mock می‌کنید:
// global.fetch = jest.fn(() => Promise.resolve({
//   json: () => Promise.resolve({ hello: 'world' }),
// })) as jest.Mock;

console.log('Jest setup file executed.');

با این پیکربندی‌ها، محیط تست شما آماده است تا با قدرت تایپ اسکریپت، تست‌های جامع و قابل اعتمادی را برای پروژه‌های خود بنویسید. در بخش‌های بعدی، به تفصیل به نحوه نوشتن انواع تست‌ها با استفاده از این ابزارها خواهیم پرداخت.

تست‌های واحد (Unit Tests) با تایپ اسکریپت: عمق بخشیدن به پوشش کد

تست‌های واحد، سنگ بنای هر استراتژی تست جامع هستند. هدف آن‌ها ایزوله کردن و تست کوچک‌ترین واحدهای منطقی کد (مانند یک تابع، یک متد در یک کلاس یا یک کامپوننت کوچک) برای اطمینان از صحت عملکرد آن‌ها به صورت مستقل است. تایپ اسکریپت، با ارائه تایپ‌سیفتی، این فرآیند را به طور قابل توجهی بهبود می‌بخشد، خطاهای رایج را در زمان کامپایل شناسایی کرده و به توسعه‌دهنده اطمینان بیشتری در صحت تست‌ها و کد می‌دهد.

اصول تست واحد:

• ایزوله‌سازی: هر تست واحد باید به طور کامل از سایر اجزای سیستم ایزوله باشد. این بدان معناست که هیچ وابستگی خارجی (مانند پایگاه داده، API‌های خارجی، سیستم فایل) نباید در طول تست واقعی فراخوانی شود. وابستگی‌ها باید Mock یا Stub شوند.
• سریع بودن: تست‌های واحد باید بسیار سریع اجرا شوند تا بتوانند به صورت مکرر و در چرخه توسعه روزانه اجرا شوند.
• تکرارپذیری: یک تست واحد باید همیشه با همان ورودی‌ها، همان خروجی را تولید کند. نتایج تست نباید به عوامل خارجی یا وضعیت سیستم بستگی داشته باشد.
• خودبسندگی: هر تست باید بتواند بدون نیاز به ترتیب خاصی یا وابستگی به تست‌های دیگر، اجرا شود.

ساختار یک تست واحد با تایپ اسکریپت (با Jest):

معمولاً تست‌ها در فایل‌هایی با پسوند .test.ts یا .spec.ts در کنار فایل‌های اصلی کد (یا در یک پوشه __tests__) قرار می‌گیرند.

// src/math.ts
export function add(a: number, b: number): number {
  return a + b;
}

export function subtract(a: number, b: number): number {
  return a - b;
}

// src/math.test.ts
import { add, subtract } from './math';

describe('Math functions', () => {
  it('should add two numbers correctly', () => {
    // Arrange: آماده‌سازی داده‌های ورودی
    const num1 = 5;
    const num2 = 3;

    // Act: فراخوانی تابع یا متد مورد تست
    const result = add(num1, num2);

    // Assert: بررسی خروجی مورد انتظار
    expect(result).toBe(8);
  });

  it('should subtract two numbers correctly', () => {
    const result = subtract(10, 4);
    expect(result).toBe(6);
  });

  it('should handle negative numbers in addition', () => {
    const result = add(-5, 10);
    expect(result).toBe(5);
  });
});

در این مثال ساده، تایپ اسکریپت اطمینان حاصل می‌کند که num1 و num2 از نوع number هستند و تابع add نیز یک number برمی‌گرداند. اگر به اشتباه add("5", 3) را فراخوانی کنید، تایپ اسکریپت در زمان کامپایل به شما خطا می‌دهد، که از بروز خطاهای زمان اجرا در تست جلوگیری می‌کند.

Mocking و Stubbing در تست‌های واحد با تایپ اسکریپت:

هنگامی که واحد کد مورد تست دارای وابستگی‌هایی به سایر ماژول‌ها یا سرویس‌ها است، برای حفظ ایزوله‌سازی، باید این وابستگی‌ها را Mock یا Stub کنیم. Jest قابلیت‌های داخلی قدرتمندی برای این منظور دارد، و تایپ اسکریپت این فرآیند را ایمن‌تر می‌کند.

مثال: تست سرویسی که به یک API خارجی وابسته است:

// src/userService.ts
interface User {
  id: number;
  name: string;
  email: string;
}

export async function getUserById(id: number): Promise<User> {
  const response = await fetch(`https://api.example.com/users/${id}`);
  if (!response.ok) {
    throw new Error('User not found');
  }
  return response.json();
}

// src/userService.test.ts
import { getUserById } from './userService';

// Mock کردن تابع fetch گلوبال
const mockFetch = jest.fn();
// استفاده از jest.Mocked برای تایپ‌سیفتی
(global as any).fetch = mockFetch;

describe('getUserById', () => {
  beforeEach(() => {
    // قبل از هر تست، Mock را پاک کنید
    mockFetch.mockClear();
  });

  it('should fetch user data successfully', async () => {
    // Arrange
    const mockUser = { id: 1, name: 'John Doe', email: 'john@example.com' };
    mockFetch.mockResolvedValueOnce({ // mockResolvedValueOnce برای شبیه‌سازی یک Promise موفق
      ok: true,
      json: () => Promise.resolve(mockUser),
    });

    // Act
    const user = await getUserById(1);

    // Assert
    expect(mockFetch).toHaveBeenCalledTimes(1);
    expect(mockFetch).toHaveBeenCalledWith('https://api.example.com/users/1');
    expect(user).toEqual(mockUser);
  });

  it('should throw an error if user is not found', async () => {
    // Arrange
    mockFetch.mockResolvedValueOnce({
      ok: false, // شبیه‌سازی پاسخ ناموفق
    });

    // Act & Assert
    await expect(getUserById(999)).rejects.toThrow('User not found');
  });
});

در این مثال، jest.Mocked اطمینان می‌دهد که mockFetch دارای همان متدها و تایپ‌هایی است که تابع fetch اصلی دارد. این قابلیت تایپ اسکریپت، به جلوگیری از خطاهای پنهان در Mock‌ها کمک می‌کند.

Assertions (اعتبارسنجی‌ها) با تایپ اسکریپت:

Jest یک مجموعه گسترده از assertion‌ها را فراهم می‌کند که به شما امکان می‌دهند انواع مختلفی از بررسی‌ها را انجام دهید. تایپ اسکریپت به شما کمک می‌کند تا مطمئن شوید که شما در حال assertion بر روی انواع داده‌های صحیح هستید.

// Assertions رایج
expect(value).toBe(expected); // مقایسه دقیق (===)
expect(value).toEqual(expected); // مقایسه عمیق (برای آبجکت‌ها و آرایه‌ها)
expect(array).toContain(item); // بررسی وجود یک آیتم در آرایه
expect(string).toMatch(/regex/); // بررسی تطابق با Regex
expect(value).toBeDefined(); // بررسی تعریف شدن
expect(value).toBeNull(); // بررسی null بودن
expect(value).toBeUndefined(); // بررسی undefined بودن
expect(value).toBeTruthy(); // بررسی Truthy بودن
expect(value).toBeFalsy(); // بررسی Falsy بودن
expect(() => someFunction()).toThrow(); // بررسی throw کردن یک خطا
expect(promise).resolves.toBe(value); // برای Promise‌هایی که Resolve می‌شوند
expect(promise).rejects.toThrow(); // برای Promise‌هایی که Reject می‌شوند
expect(jest.fnCallback).toHaveBeenCalledTimes(count); // بررسی تعداد فراخوانی Mock
expect(jest.fnCallback).toHaveBeenCalledWith(arg1, arg2); // بررسی فراخوانی Mock با آرگومان‌های خاص

پوشش کد (Code Coverage):

پوشش کد نشان می‌دهد که چه میزان از کد شما توسط تست‌ها اجرا شده است. اگرچه پوشش کد 100% تضمین کننده عدم وجود باگ نیست، اما یک متریک مفید برای شناسایی بخش‌هایی از کد است که نیازمند تست بیشتری هستند. Jest و Vitest هر دو قابلیت گزارش‌گیری از پوشش کد را به صورت داخلی دارند.

با اجرای npm test -- --coverage (برای Jest) یا npm run test:coverage (برای Vitest)، گزارشی جامع از پوشش کد دریافت خواهید کرد که شامل اطلاعاتی در مورد پوشش خطی (Line Coverage)، پوشش توابع (Function Coverage)، پوشش شرطی (Branch Coverage) و پوشش بیانیه‌ها (Statement Coverage) است.

تست‌های واحد، با تمرکز بر ایزوله‌سازی و دقت، به توسعه‌دهندگان این امکان را می‌دهند که با اطمینان خاطر بیشتری کد را تغییر داده و از صحت عملکرد آن در کوچک‌ترین سطح اطمینان حاصل کنند. تایپ اسکریپت این فرآیند را با افزودن لایه‌ای از ایمنی و وضوح در زمان کامپایل، به سطح جدیدی ارتقاء می‌بخشد و به افزایش قابل توجه قابلیت اطمینان و نگهداری کد کمک می‌کند.

تست‌های یکپارچه‌سازی (Integration Tests) و End-to-End (E2E Tests) با تایپ اسکریپت

در حالی که تست‌های واحد بر روی ایزوله‌سازی و تست کوچک‌ترین بخش‌های کد تمرکز دارند، تست‌های یکپارچه‌سازی و E2E دید گسترده‌تری ارائه می‌دهند. این تست‌ها تعامل بین اجزای مختلف سیستم را بررسی می‌کنند و اطمینان می‌دهند که سیستم به عنوان یک کل، طبق انتظار عمل می‌کند. تایپ اسکریپت در این سطوح تست نیز مزایای قابل توجهی را به همراه دارد، به ویژه در تعریف داده‌های ورودی و خروجی و ساختار Mock‌های پیچیده‌تر.

تست‌های یکپارچه‌سازی (Integration Tests) با تایپ اسکریپت:

تست‌های یکپارچه‌سازی، تعامل بین چندین واحد از کد را بررسی می‌کنند. این واحدها می‌توانند شامل ارتباط یک سرویس با پایگاه داده، یک کامپوننت فرانت‌اند با یک API بک‌اند، یا دو ماژول داخلی که با هم کار می‌کنند، باشند. هدف اصلی این تست‌ها، اطمینان از صحت همکاری این اجزا است.

ویژگی‌های کلیدی:

• تمرکز بر تعامل: این تست‌ها به جای منطق داخلی یک واحد، بر نحوه تعامل واحدها با یکدیگر تمرکز دارند.
• دنیای واقعی‌تر: برخلاف تست‌های واحد که اغلب وابستگی‌ها را Mock می‌کنند، تست‌های یکپارچه‌سازی ممکن است از سرویس‌های واقعی (مانند یک پایگاه داده تستی یا یک API محلی) استفاده کنند تا سناریوی واقعی‌تر را شبیه‌سازی کنند.
• سرعت متوسط: این تست‌ها معمولاً کندتر از تست‌های واحد اما سریع‌تر از تست‌های E2E هستند.

مثال: تست یکپارچه‌سازی سرویس با پایگاه داده (با Jest و یک Mock Database):

فرض کنید یک سرویس ProductService دارید که با یک Repository برای دسترسی به پایگاه داده کار می‌کند.

// src/productRepository.ts
interface Product {
  id: number;
  name: string;
  price: number;
}

export interface IProductRepository {
  findById(id: number): Promise<Product | null>;
  create(product: Omit<Product, 'id'>): Promise<Product>;
}

// یک پیاده‌سازی ساده InMemory (برای تست)
export class InMemoryProductRepository implements IProductRepository {
  private products: Product[] = [];
  private nextId = 1;

  async findById(id: number): Promise<Product | null> {
    return this.products.find(p => p.id === id) || null;
  }

  async create(productData: Omit<Product, 'id'>): Promise<Product> {
    const newProduct = { id: this.nextId++, ...productData };
    this.products.push(newProduct);
    return newProduct;
  }

  // متدی برای پاک کردن داده‌ها بین تست‌ها
  clear() {
    this.products = [];
    this.nextId = 1;
  }
}

// src/productService.ts
import { IProductRepository, Product } from './productRepository';

export class ProductService {
  constructor(private productRepository: IProductRepository) {}

  async getProduct(id: number): Promise<Product | null> {
    return this.productRepository.findById(id);
  }

  async addProduct(name: string, price: number): Promise<Product> {
    // منطق بیزینس: مثلاً بررسی قیمت منفی
    if (price < 0) {
      throw new Error('Price cannot be negative');
    }
    return this.productRepository.create({ name, price });
  }
}

// src/productService.integration.test.ts
import { ProductService } from './productService';
import { InMemoryProductRepository } from './productRepository';

describe('ProductService Integration Tests', () => {
  let repository: InMemoryProductRepository;
  let service: ProductService;

  beforeEach(() => {
    // هر بار یک repository جدید و پاک‌شده برای هر تست
    repository = new InMemoryProductRepository();
    service = new ProductService(repository);
  });

  it('should create and retrieve a product successfully', async () => {
    // Act: اضافه کردن محصول
    const createdProduct = await service.addProduct('Laptop', 1200);

    // Assert: بررسی که محصول با موفقیت ایجاد شده است
    expect(createdProduct).toBeDefined();
    expect(createdProduct.name).toBe('Laptop');
    expect(createdProduct.price).toBe(1200);
    expect(createdProduct.id).toBe(1);

    // Act: بازیابی محصول
    const retrievedProduct = await service.getProduct(createdProduct.id);

    // Assert: بررسی که محصول بازیابی شده همان محصول ایجاد شده است
    expect(retrievedProduct).toEqual(createdProduct);
  });

  it('should return null for a non-existent product', async () => {
    const product = await service.getProduct(999);
    expect(product).toBeNull();
  });

  it('should throw an error for negative product price', async () => {
    await expect(service.addProduct('Invalid Product', -100)).rejects.toThrow('Price cannot be negative');
  });
});

در این مثال، InMemoryProductRepository به عنوان یک Mock/Stub با قابلیت‌های پایگاه داده عمل می‌کند. تایپ اسکریپت با تعریف IProductRepository اطمینان می‌دهد که ProductService و پیاده‌سازی‌های مختلف Repository (چه InMemory و چه واقعی) به درستی با یکدیگر ارتباط برقرار می‌کنند.

تست‌های End-to-End (E2E Tests) با تایپ اسکریپت:

تست‌های E2E یک سناریوی کامل کاربری را از ابتدا تا انتها شبیه‌سازی می‌کنند. این تست‌ها تمام لایه‌های برنامه را درگیر می‌کنند، از رابط کاربری (UI) گرفته تا بک‌اند و پایگاه داده. هدف آن‌ها اطمینان از این است که سیستم به عنوان یک کل، طبق انتظارات کاربر نهایی عمل می‌کند.

ویژگی‌های کلیدی:

• دیدگاه کاربر: این تست‌ها اقدامات واقعی کاربر را شبیه‌سازی می‌کنند (کلیک کردن، تایپ کردن، ناوبری).
• پوشش جامع: آن‌ها تمامی لایه‌های سیستم (فرانت‌اند، بک‌اند، پایگاه داده) را پوشش می‌دهند.
• کند و گران: به دلیل نیاز به راه‌اندازی کل سیستم و شبیه‌سازی تعاملات UI، این تست‌ها کندترین و گران‌ترین تست‌ها هستند.
• ابزارهای تخصصی: برای تست‌های E2E نیاز به ابزارهای خاصی مانند Cypress یا Playwright داریم.

ابزارهای E2E با پشتیبانی از تایپ اسکریپت:

• Cypress:

  Cypress یک ابزار تست E2E قدرتمند است که به طور مستقیم در مرورگر اجرا می‌شود. این ابزار تجربه توسعه‌دهنده عالی، دیباگینگ آسان و قابلیت‌های snapshot قوی دارد. Cypress به طور بومی از تایپ اسکریپت پشتیبانی می‌کند.

  مثال Cypress با TypeScript:

  
  // cypress/e2e/login.cy.ts
  describe('Login Feature', () => {
    beforeEach(() => {
      cy.visit('/login'); // فرض کنید اپلیکیشن در حال اجراست
    });
  
    it('should allow a user to log in successfully', () => {
      cy.get('input[name="username"]').type('testuser');
      cy.get('input[name="password"]').type('password123');
      cy.get('button[type="submit"]').click();
      cy.url().should('include', '/dashboard');
      cy.contains('Welcome, testuser').should('be.visible');
    });
  
    it('should show an error for invalid credentials', () => {
      cy.get('input[name="username"]').type('wronguser');
      cy.get('input[name="password"]').type('wrongpass');
      cy.get('button[type="submit"]').click();
      cy.get('.error-message').should('be.visible').and('contain.text', 'Invalid credentials');
      cy.url().should('not.include', '/dashboard');
    });
  });
          

  Cypress به شما امکان می‌دهد تا command‌ها و تایپ‌های سفارشی خود را تعریف کنید تا کد تست شما تایپ‌سیف‌تر باشد. به عنوان مثال، می‌توانید یک تایپ برای cy.login() ایجاد کنید.

• Playwright:

  Playwright یک فریم‌ورک تست E2E دیگر است که توسط مایکروسافت توسعه یافته. این فریم‌ورک از تمامی مرورگرهای اصلی (Chromium, Firefox, WebKit) پشتیبانی می‌کند و قابلیت‌های قدرتمندی برای اتوماسیون تعاملات مرورگر، از جمله قابلیت‌های پیشرفته برای Network Mocking و interception دارد. Playwright نیز از تایپ اسکریپت به صورت بومی پشتیبانی می‌کند و ابزارهای تولید تست (codegen) نیز تست‌های تایپ‌شده را تولید می‌کنند.

  مثال Playwright با TypeScript:

  
  // tests/login.spec.ts
  import { test, expect } from '@playwright/test';
  
  test.describe('Login Feature', () => {
    test.beforeEach(async ({ page }) => {
      await page.goto('/login'); // فرض کنید اپلیکیشن در حال اجراست
    });
  
    test('should allow a user to log in successfully', async ({ page }) => {
      await page.fill('input[name="username"]', 'testuser');
      await page.fill('input[name="password"]', 'password123');
      await page.click('button[type="submit"]');
      await expect(page).toHaveURL(/.*dashboard/);
      await expect(page.locator('text=Welcome, testuser')).toBeVisible();
    });
  
    test('should show an error for invalid credentials', async ({ page }) => {
      await page.fill('input[name="username"]', 'wronguser');
      await page.fill('input[name="password"]', 'wrongpass');
      await page.click('button[type="submit"]');
      await expect(page.locator('.error-message')).toBeVisible();
      await expect(page.locator('.error-message')).toContainText('Invalid credentials');
      await expect(page).not.toHaveURL(/.*dashboard/);
    });
  });
          

نقش تایپ اسکریپت در تست‌های یکپارچه‌سازی و E2E:

• تعریف رابط‌های داده (Data Interfaces): در تست‌های یکپارچه‌سازی که با API‌ها یا پایگاه داده تعامل دارند، تایپ اسکریپت به شما امکان می‌دهد تا رابط‌ها (interfaces) را برای ساختار داده‌های ورودی و خروجی تعریف کنید. این تضمین می‌کند که داده‌های Mock شده یا داده‌هایی که از سیستم واقعی دریافت می‌شوند، با ساختار مورد انتظار مطابقت دارند و از خطاهای زمان اجرا ناشی از ناسازگاری داده جلوگیری می‌کند.
• اعتبارسنجی ورودی و خروجی: هنگامی که یک API یا سرویس را Mock می‌کنید، می‌توانید اطمینان حاصل کنید که Mock شما دقیقاً همان پارامترها را قبول می‌کند و همان نوع خروجی را تولید می‌کند که سرویس واقعی تولید می‌کند. این امر به کاهش تست‌های شکننده که به دلیل تغییرات در API‌ها بدون به‌روزرسانی Mock‌ها ایجاد می‌شوند، کمک می‌کند.
• خوانایی و نگهداری تست‌ها: با توجه به پیچیدگی بالاتر تست‌های یکپارچه‌سازی و E2E، خوانایی و وضوح کد تست اهمیت بیشتری پیدا می‌کند. تایپ اسکریپت با وضوح بخشیدن به انواع داده‌ها و ساختارهای مورد استفاده، نگهداری این تست‌ها را آسان‌تر می‌کند.
• بهبود تجربه توسعه‌دهنده: با تکمیل خودکار و بررسی خطاهای لحظه‌ای که تایپ اسکریپت در IDE‌ها ارائه می‌دهد، نوشتن تست‌های پیچیده آسان‌تر می‌شود.

ترکیب صحیح تست‌های واحد، یکپارچه‌سازی و E2E، به همراه مزایای تایپ اسکریپت، یک استراتژی تست قدرتمند را برای هر پروژه نرم‌افزاری مدرن فراهم می‌کند. این رویکرد به شما اطمینان می‌دهد که هر لایه از سیستم، از کوچک‌ترین واحد تا تجربه کاربری نهایی، به درستی کار می‌کند.

بهترین شیوه‌ها و الگوهای طراحی برای کد تست‌پذیر در تایپ اسکریپت

نوشتن تست‌های عالی تنها بخشی از معادله است؛ بخش دیگر نوشتن کدی است که به راحتی قابل تست باشد. کد تست‌پذیر، کدی است که می‌توان آن را به راحتی از وابستگی‌هایش ایزوله کرد و در محیط‌های مختلف تست با سناریوهای مختلف ورودی و خروجی مورد بررسی قرار داد. تایپ اسکریپت نه تنها به تست‌نویسی کمک می‌کند، بلکه با ویژگی‌های خود، توسعه‌دهندگان را به سمت نوشتن کد با طراحی بهتر و در نتیجه تست‌پذیرتر سوق می‌دهد. در این بخش، به برخی از بهترین شیوه‌ها و الگوهای طراحی که به افزایش قابلیت تست‌پذیری کد تایپ اسکریپت کمک می‌کنند، می‌پردازیم.

1. توسعه مبتنی بر تست (Test-Driven Development – TDD):

TDD یک رویکرد توسعه نرم‌افزار است که در آن تست‌ها پیش از کد تولیدی نوشته می‌شوند. چرخه TDD به شرح زیر است:

1. قرمز (Red): ابتدا یک تست شکست‌خورده (به دلیل عدم وجود کد) می‌نویسید. این تست یک نیاز یا باگ جدید را توصیف می‌کند.
2. سبز (Green): کمترین میزان کد لازم را برای عبور از تست می‌نویسید. در این مرحله، هدف صرفاً سبز شدن تست است، نه نوشتن کد کامل و بهینه.
3. بازسازی (Refactor): پس از سبز شدن تست، کد تولیدی (و در صورت لزوم، کد تست) را بازسازی می‌کنید تا خواناتر، بهینه‌تر و با طراحی بهتری باشد، در حالی که مطمئن هستید تست‌ها همچنان سبز می‌مانند.

مزایای TDD با تایپ اسکریپت:

• وضوح در طراحی: نوشتن تست ابتدا شما را مجبور می‌کند تا در مورد رابط (interface) تابع یا کلاس مورد نظر فکر کنید. تایپ اسکریپت این فرآیند را با تعریف دقیق تایپ‌های ورودی و خروجی تقویت می‌کند.
• تمرکز بر رفتار: تست‌ها به عنوان توصیفی از رفتار مورد انتظار سیستم عمل می‌کنند.
• افزایش پوشش کد: با نوشتن تست‌ها برای هر ویژگی، پوشش کد بالا به طور طبیعی حاصل می‌شود.
• بازسازی با اطمینان: وجود یک مجموعه تست جامع به شما امکان می‌دهد تا کد را با اطمینان بازسازی کنید.

2. توسعه رفتارمحور (Behavior-Driven Development – BDD):

BDD یک بسط از TDD است که بر روی رفتار سیستم تمرکز دارد و از زبانی نزدیک به زبان طبیعی (مانند Given-When-Then) برای توصیف تست‌ها استفاده می‌کند. این رویکرد، همکاری بین توسعه‌دهندگان، QA و ذینفعان کسب‌وکار را تسهیل می‌کند.

مثال BDD با Jest و تایپ اسکریپت:

// src/calculator.ts
export class Calculator {
  add(a: number, b: number): number {
    return a + b;
  }
}

// src/calculator.spec.ts (با رویکرد BDD)
import { Calculator } from './calculator';

describe('Calculator', () => { // Context
  let calculator: Calculator;

  beforeEach(() => {
    calculator = new Calculator();
  });

  describe('When adding two numbers', () => { // Feature / Scenario
    it('Should return the correct sum', () => { // Behavior / Expectation
      // Given: ورودی‌ها آماده هستند
      const a = 5;
      const b = 3;

      // When: عمل انجام می‌شود
      const result = calculator.add(a, b);

      // Then: نتیجه مورد انتظار است
      expect(result).toBe(8);
    });

    it('Should handle negative numbers correctly', () => {
      // Given
      const a = -5;
      const b = 10;

      // When
      const result = calculator.add(a, b);

      // Then
      expect(result).toBe(5);
    });
  });
});

describe و it در Jest به خوبی با ساختار BDD همخوانی دارند.

3. تزریق وابستگی (Dependency Injection – DI):

یکی از مهم‌ترین اصول برای کد تست‌پذیر، کاهش coupling (وابستگی) بین ماژول‌ها است. تزریق وابستگی الگویی است که در آن به جای اینکه یک کلاس وابستگی‌های خود را به صورت داخلی ایجاد کند، این وابستگی‌ها از خارج به آن “تزریق” می‌شوند. این کار باعث می‌شود بتوانیم در زمان تست، Mock یا Stub‌ها را به جای وابستگی‌های واقعی تزریق کنیم.

مثال تزریق وابستگی با تایپ اسکریپت:

// src/emailService.ts
export interface IEmailService {
  sendEmail(to: string, subject: string, body: string): Promise<boolean>;
}

export class SmtpEmailService implements IEmailService {
  async sendEmail(to: string, subject: string, body: string): Promise<boolean> {
    // منطق ارسال ایمیل واقعی
    console.log(`Sending email to ${to}: ${subject}`);
    return true;
  }
}

// src/userService.ts
import { IEmailService } from './emailService';

export class UserService {
  constructor(private emailService: IEmailService) {} // وابستگی تزریق می‌شود

  async registerUser(email: string, username: string): Promise<boolean> {
    // منطق ثبت کاربر
    const success = await this.emailService.sendEmail(email, 'Welcome!', `Hello ${username}`);
    return success;
  }
}

// src/userService.test.ts
import { UserService } from './userService';
import { IEmailService } from './emailService';

describe('UserService', () => {
  let mockEmailService: jest.Mocked<IEmailService>;
  let userService: UserService;

  beforeEach(() => {
    mockEmailService = {
      sendEmail: jest.fn(), // Mock کردن متد sendEmail
    };
    userService = new UserService(mockEmailService); // تزریق Mock
  });

  it('should send a welcome email on user registration', async () => {
    mockEmailService.sendEmail.mockResolvedValueOnce(true); // شبیه‌سازی موفقیت‌آمیز بودن ارسال ایمیل

    const result = await userService.registerUser('test@example.com', 'testuser');

    expect(result).toBe(true);
    expect(mockEmailService.sendEmail).toHaveBeenCalledTimes(1);
    expect(mockEmailService.sendEmail).toHaveBeenCalledWith(
      'test@example.com',
      'Welcome!',
      'Hello testuser'
    );
  });
});

با استفاده از IEmailService به عنوان یک رابط، تایپ اسکریپت تضمین می‌کند که mockEmailService به درستی پیاده‌سازی شده و UserService انتظارات صحیح را از emailService خود دارد.

4. توابع خالص (Pure Functions) و اجتناب از Side Effects:

توابع خالص، توابعی هستند که با ورودی‌های یکسان، همیشه خروجی یکسانی تولید می‌کنند و هیچ گونه Side Effect (مانند تغییر وضعیت خارج از تابع، درخواست‌های شبکه، دسترسی به دیسک) ندارند. این توابع به شدت قابل تست هستند، زیرا تست آن‌ها تنها شامل ارسال ورودی و بررسی خروجی است، بدون نیاز به Mocking یا Stubbing.

تایپ اسکریپت با وضوح بخشیدن به ورودی و خروجی توابع، به شما کمک می‌کند تا توابع خالص را بهتر شناسایی و بنویسید.

// تابع خالص
export function calculateDiscount(price: number, discountPercentage: number): number {
  if (discountPercentage < 0 || discountPercentage > 100) {
    throw new Error('Discount percentage must be between 0 and 100.');
  }
  return price * (1 - discountPercentage / 100);
}

// تست تابع خالص
describe('calculateDiscount', () => {
  it('should apply discount correctly', () => {
    expect(calculateDiscount(100, 10)).toBe(90);
  });

  it('should return original price for 0% discount', () => {
    expect(calculateDiscount(100, 0)).toBe(100);
  });

  it('should return 0 for 100% discount', () => {
    expect(calculateDiscount(100, 100)).toBe(0);
  });

  it('should throw error for invalid discount percentage', () => {
    expect(() => calculateDiscount(100, -10)).toThrow('Discount percentage must be between 0 and 100.');
    expect(() => calculateDiscount(100, 110)).toThrow('Discount percentage must be between 0 and 100.');
  });
});

5. اینترفیس‌ها (Interfaces) برای تعاریف قرارداد:

در تایپ اسکریپت، اینترفیس‌ها نقش حیاتی در تعریف قراردادها بین اجزای مختلف دارند. استفاده از اینترفیس‌ها در هنگام تزریق وابستگی یا تعریف API‌های داخلی، به شما امکان می‌دهد تا پیاده‌سازی‌های مختلف را به راحتی جایگزین کنید (از جمله Mock‌ها برای تست) بدون اینکه نیاز به تغییر کد مصرف‌کننده داشته باشید.

6. مدیریت حالت (State Management) قابل تست:

در برنامه‌های فرانت‌اند، مدیریت حالت می‌تواند پیچیده باشد. استفاده از الگوهای طراحی مانند Redux، Zustand، XState یا React Context با اصول روشن برای به‌روزرسانی حالت، می‌تواند تست‌پذیری را افزایش دهد. این الگوها اغلب حالت را از کامپوننت‌های UI جدا می‌کنند، که امکان تست منطق حالت به صورت ایزوله را فراهم می‌کند.

7. استفاده از Utility Functions:

منطق‌های پیچیده یا محاسبات خاص را در توابع کمکی (Utility Functions) کوچک و مستقل کپسوله کنید. این توابع به دلیل نداشتن وابستگی‌های زیاد، بسیار قابل تست هستند و با تست کردن آن‌ها به صورت جامع، می‌توانید اطمینان حاصل کنید که منطق آن‌ها به درستی کار می‌کند، فارغ از اینکه در کجا مورد استفاده قرار می‌گیرند.

با به‌کارگیری این بهترین شیوه‌ها و الگوهای طراحی، توسعه‌دهندگان تایپ اسکریپت می‌توانند کدی را تولید کنند که نه تنها از نظر عملکردی قوی است، بلکه به راحتی قابل تست، نگهداری و گسترش است. این رویکرد پیشگیرانه در طراحی کد، به طور مستقیم به کاهش باگ‌ها، افزایش سرعت توسعه و بهبود کیفیت کلی نرم‌افزار کمک می‌کند.

اتوماسیون تست‌ها و ادغام مداوم (CI/CD): تضمین کیفیت در چرخه توسعه

نوشتن تست‌های جامع و با کیفیت تنها گام اول است. برای بهره‌برداری کامل از مزایای تست‌نویسی، این تست‌ها باید به صورت خودکار و منظم اجرا شوند. اینجاست که مفهوم اتوماسیون تست و ادغام مداوم (Continuous Integration – CI) و تحویل مداوم (Continuous Delivery – CD) وارد می‌شود. ادغام تست‌ها در خط لوله CI/CD، تضمین می‌کند که هر تغییر کد، پیش از ادغام شدن در شعبه اصلی یا استقرار در محیط‌های بالاتر، به طور کامل اعتبارسنجی می‌شود. تایپ اسکریپت، به دلیل ماهیت کامپایل‌شونده و تایپ‌سیف، به خوبی در این فرآیندها جای می‌گیرد و قابلیت اطمینان بیشتری را به ارمغان می‌آورد.

اهمیت اتوماسیون تست:

• اجرای منظم و خودکار: تست‌های خودکار می‌توانند به صورت منظم (مثلاً هر بار که یک تغییر به مخزن کد push می‌شود) اجرا شوند، بدون نیاز به دخالت دستی. این امر به شناسایی سریع باگ‌ها کمک می‌کند.
• بازخورد سریع: تیم‌ها بازخورد فوری در مورد سلامت کد دریافت می‌کنند. اگر تستی شکست بخورد، توسعه‌دهنده به سرعت مطلع می‌شود و می‌تواند مشکل را قبل از اینکه پیچیده‌تر شود، رفع کند.
• کاهش خطای انسانی: تست‌های دستی مستعد خطاهای انسانی هستند و ممکن است خسته‌کننده باشند. اتوماسیون این خطاها را از بین می‌برد.
• پوشش جامع‌تر: می‌توان سناریوهای تست بیشتری را در زمان کمتری اجرا کرد که به پوشش جامع‌تر سیستم کمک می‌کند.
• افزایش اعتماد به نفس: تیم‌ها با اطمینان خاطر بیشتری کد را تغییر داده و قابلیت‌های جدید اضافه می‌کنند، زیرا می‌دانند که سیستم تست خودکار، مشکلات احتمالی را شناسایی خواهد کرد.

ادغام مداوم (Continuous Integration – CI):

CI یک متدولوژی توسعه نرم‌افزار است که در آن توسعه‌دهندگان به طور مکرر (معمولاً چندین بار در روز) تغییرات کد خود را در یک مخزن مشترک ادغام می‌کنند. هر بار که کدی ادغام می‌شود، یک بیلد خودکار شروع می‌شود و تمامی تست‌ها (واحد، یکپارچه‌سازی و گاهی اوقات E2E) به صورت خودکار اجرا می‌شوند.

مراحل CI با تایپ اسکریپت:

1. Push کد: توسعه‌دهنده تغییرات کد خود را به مخزن (مثلاً GitHub، GitLab، Bitbucket) Push می‌کند.
2. Trigger CI Pipeline: سرویس CI/CD (مانند GitHub Actions, GitLab CI/CD, Jenkins, CircleCI) این تغییر را شناسایی کرده و یک Pipeline جدید را شروع می‌کند.
3. نصب وابستگی‌ها: ابزار CI وابستگی‌های پروژه (npm install یا yarn install) را نصب می‌کند.
4. کامپایل تایپ اسکریپت: تایپ اسکریپت کامپایل می‌شود (npx tsc --noEmit). این مرحله برای اطمینان از صحت تایپی کد بسیار مهم است و خطاهای تایپی را در زمان کامپایل، پیش از اجرای تست‌ها شناسایی می‌کند.
5. اجرای تست‌ها: تمامی تست‌های خودکار (npm test) اجرا می‌شوند. این شامل تست‌های واحد، یکپارچه‌سازی و در صورت لزوم، تست‌های E2E است.
6. گزارش‌گیری پوشش کد: ابزار CI گزارش پوشش کد (Code Coverage) را تولید می‌کند و می‌تواند آن را در داشبورد یا به صورت کامنت در Pull Request نمایش دهد.
7. اعلام نتیجه: اگر تمامی مراحل با موفقیت انجام شوند، بیلد “سبز” می‌شود. در غیر این صورت (مثلاً تست‌ها شکست بخورند یا خطای تایپی وجود داشته باشد)، بیلد “قرمز” شده و به توسعه‌دهنده اطلاع داده می‌شود.

مثال GitHub Actions برای یک پروژه TypeScript:

# .github/workflows/ci.yml
name: CI/CD Pipeline

on:
  push:
    branches:
      - main
      - develop
  pull_request:
    branches:
      - main
      - develop

jobs:
  build-and-test:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18' # یا نسخه مورد نظر شما

      - name: Install dependencies
        run: npm ci # npm ci برای نصب تمیز وابستگی‌ها در CI/CD

      - name: Run TypeScript compile check
        run: npm run tsc -- --noEmit # فرض کنید tsc --noEmit در package.json تعریف شده باشد

      - name: Run tests with coverage
        run: npm test -- --coverage # اجرای تست‌ها با گزارش پوشش کد

      - name: Upload coverage report
        uses: actions/upload-artifact@v3
        if: always() # همیشه آپلود شود، حتی اگر تست‌ها شکست بخورند
        with:
          name: coverage-report
          path: coverage/lcov-report # مسیر گزارش پوشش کد شما (مثلا Jest/Vitest)

      - name: Build project (optional)
        run: npm run build # اگر پروژه نیاز به بیلد نهایی دارد

      # می‌توانید مراحل استقرار (CD) را در اینجا اضافه کنید یا به یک Job جداگانه منتقل کنید

تحویل مداوم (Continuous Delivery – CD):

CD، فراتر از CI است و اطمینان می‌دهد که نرم‌افزار در هر لحظه آماده استقرار در محیط‌های تولید (Production) یا محیط‌های بالاتر (مانند Staging) باشد. این شامل خودکارسازی مراحل بیلد، تست و استقرار است.

مراحل CD:

1. پس از یک بیلد CI موفق، آرتیفکت‌های (Artifacts) آماده استقرار (مانند فایل‌های کامپایل‌شده جاوا اسکریپت) ساخته می‌شوند.
2. این آرتیفکت‌ها در یک مخزن آرتیفکت ذخیره می‌شوند.
3. با تأیید دستی یا خودکار، این آرتیفکت‌ها به محیط‌های بالاتر (Staging، Production) استقرار می‌یابند.

نقش تست‌ها در CD بسیار حیاتی است؛ زیرا آن‌ها تضمین می‌کنند که نسخه‌ای که استقرار می‌یابد، کیفیت لازم را دارد و رگرسیون ایجاد نکرده است.

چالش‌ها و نکات مهم:

• سرعت تست‌ها: در یک Pipeline CI/CD، سرعت اجرای تست‌ها اهمیت زیادی دارد. تست‌های E2E معمولاً کند هستند و ممکن است نیاز به اجرای موازی یا در Job‌های جداگانه داشته باشند.
• مدیریت محیط تست: اطمینان از اینکه محیط تست در CI/CD همانند محیط توسعه محلی است، حیاتی است تا از “روی لپ‌تاپ من کار می‌کند” جلوگیری شود. استفاده از Docker برای کانتینرسازی محیط تست می‌تواند کمک کننده باشد.
• مشکلات شبکه/API‌های خارجی: در تست‌های یکپارچه‌سازی و E2E، وابستگی به API‌های خارجی یا سرویس‌های شبکه می‌تواند باعث شکست‌های ناپایدار (Flaky Tests) شود. استفاده از Mock‌های سرویس، سرویس‌های Mock محلی (مانند MSW) یا تست‌های ایزوله در صورت امکان توصیه می‌شود.
• بازخورد سریع: مطمئن شوید که نتایج تست‌ها به سرعت به تیم اطلاع داده می‌شود.
• نظارت بر پوشش کد: به طور منظم پوشش کد را بررسی کنید و برای آن اهداف واقع‌بینانه تعیین کنید.

با ترکیب قدرت تایپ اسکریپت با اتوماسیون تست و خط لوله CI/CD، سازمان‌ها می‌توانند کیفیت نرم‌افزار خود را به طور چشمگیری افزایش دهند، زمان عرضه به بازار را کاهش دهند و با اطمینان خاطر بیشتری قابلیت‌های جدید را به مشتریان خود ارائه دهند. این نه تنها یک رویکرد فنی است، بلکه یک فرهنگ از کیفیت و مسئولیت‌پذیری در تیم توسعه را نیز تقویت می‌کند.

نتیجه‌گیری: تثبیت کیفیت و تسریع توسعه با تست‌نویسی مبتنی بر تایپ اسکریپت

در طول این مقاله، به بررسی عمیق ابعاد مختلف تست‌نویسی با تایپ اسکریپت پرداختیم و دریافتیم که چگونه این زبان قدرتمند می‌تواند به عنوان یک ابزار حیاتی در تضمین کیفیت و افزایش قابلیت نگهداری کد در پروژه‌های نرم‌افزاری مدرن عمل کند. از مزایای ذاتی سیستم تایپ استاتیک تایپ اسکریپت در شناسایی خطاها پیش از زمان اجرا، تا نحوه پیکربندی محیط‌های تست با ابزارهایی مانند Jest و Vitest، و پیاده‌سازی انواع تست‌ها از واحد تا E2E، همگی نشان‌دهنده پتانسیل بالای تایپ اسکریپت در این حوزه هستند.

ما آموختیم که چگونه تایپ اسکریپت با فراهم کردن Type Safety، نه تنها خطاهای رایج را در زمان کامپایل از بین می‌برد، بلکه به توسعه‌دهندگان اطمینان بیشتری در Refactoring کد می‌دهد و از بروز “تست‌های شکننده” (Brittle Tests) جلوگیری می‌کند. همچنین، پشتیبانی عالی IDE، بهبود خوانایی کد و تسهیل فرآیند Mocking و Stubbing، همگی به تجربه مثبت و کارآمد تست‌نویسی با تایپ اسکریپت کمک می‌کنند.

بحث پیرامون بهترین شیوه‌ها و الگوهای طراحی، مانند توسعه مبتنی بر تست (TDD)، توسعه رفتارمحور (BDD)، تزریق وابستگی و استفاده از توابع خالص، نشان داد که چگونه می‌توان کدی نوشت که نه تنها وظیفه خود را به درستی انجام می‌دهد، بلکه به آسانی قابل تست، نگهداری و گسترش است. این رویکرد پیشگیرانه در طراحی، به طور مستقیم به کاهش باگ‌ها و افزایش پایداری سیستم منجر می‌شود.

در نهایت، ادغام خودکارسازی تست‌ها در خطوط لوله ادغام مداوم و تحویل مداوم (CI/CD)، به عنوان نقطه اوج این فرآیند، بر اهمیت اجرای منظم و خودکار تست‌ها تأکید کرد. این ادغام، بازخورد سریع را به توسعه‌دهندگان ارائه می‌دهد، خطای انسانی را کاهش می‌دهد و تضمین می‌کند که هر تغییر کد، پیش از رسیدن به کاربر نهایی، به طور جامع اعتبارسنجی شده است.

در یک کلام، تست‌نویسی با تایپ اسکریپت نه تنها یک رویکرد فنی است، بلکه یک سرمایه‌گذاری استراتژیک در کیفیت و پایداری محصول نرم‌افزاری است. این ترکیب قدرتمند، به تیم‌های توسعه امکان می‌دهد تا با سرعت و اطمینان بیشتری نوآوری کنند، محصولاتی با کیفیت بالاتر ارائه دهند و در نهایت، به موفقیت بلندمدت پروژه و رضایت مشتریان دست یابند. امید است این مقاله، راهنمایی جامع و کاربردی برای توسعه‌دهندگانی باشد که به دنبال ارتقاء دانش و مهارت‌های خود در حوزه تست‌نویسی با تایپ اسکریپت هستند.