עבור לבדיקת חבילות לשיפור הפרודוקטיביות

בדיקת תוכנה היא תהליך שמעריך את המדדים של תוכניות באמצעות כלים, סקריפטים או באופן ידני.

בדיקות הן חלק בלתי נפרד ממחזור פיתוח התוכנה. בדיקה מקיפה מספקת מידע מעמיק על שלמות האפליקציה שלך.

אתה יכול למנוע ולתקן באגים על ידי כתיבת בדיקות, הערכת ביצועי התוכנית ואוטומציה של זרימות עבודה.

תחילת העבודה עם בדיקות ב-Go

ספריית התקן Go מספקת התפתחות בדיקה חֲבִילָה. ה בדיקה לחבילה יש benchmarking, fuzzing, דילוג, בדיקות משנה, sub-benchmarking ופונקציות אחרות.

בדיקה עם חבילה זו היא קלה. להלן מבנה מבחן פשוט שישמש מודל למבחן:

סוּג מקרים מבנה {
// הפלט הצפוי של המבחן
 צָפוּי int
// הפלט של הפונקציה
 מַמָשִׁי int
// הערך שאתה מעביר לפונקציה
 טַעֲנָה חוּט
}

הנה פונקציה פשוטה הממירה מחרוזות למספרים שלמים. הבדיקה שלך תבדוק את הפונקציה הזו.

יְבוּא (
 "strconv"
)
funcStringToInteger(str חוּט)int {
 מספר שלם, שגיאה := strconv. Atoi (str)
אם טעות != אֶפֶס {
לַחֲזוֹר0
 }
לַחֲזוֹר מספר שלם
}

ה StringToInteger הפונקציה חוזרת 0 אם יש שגיאה בהמרה והמספר השלם אם אין שגיאות.

להלן פונקציית בדיקה עבור StringToInteger:

funcTestStringToInteger(מבחן *בדיקה. ט)





instagram viewer
 {
 expectInt := StringToInteger("3")
caseInstance := מקרים {
 צפוי: צפויInt,
 מַמָשִׁי: 3,
 }
אם caseInstance.expected == caseInstance.actual {
// כאן קצת קוד
 } אַחֵר {
 מִבְחָן. לְהִכָּשֵׁל()
 }
}

ה TestStringToInteger פונקציית הבדיקה מקבלת א בדיקה. ט האובייקט כטיעון שלו. ה צפויInt משתנה מחזיק את התוצאה של המרת המחרוזת. ה caseinstance המשתנה הוא מבנה המקרים המוצג עבור המבחן. ה אם הצהרה משווה בין הערכים הצפויים לבין הערכים בפועל.

ה לְהִכָּשֵׁל שיטה מחזירה מבחן שנכשל בהצהרת else אם הערכים אינם שווים.

Go מספקת א מִבְחָן פקודה לאוטומציה ואחזור של תובנות על הבדיקות והתוכניות שלך.

ללכת מִבְחָן
ללכת עזרה בבדיקה 

דף העזרה מספק מידע מפורט כיצד ללכת לבדיקה עובד:

המערכת האקולוגית של Go היא ביתם של ספריות רבות שהופכות את הבדיקות לנגישות וגמישות יותר. יש הרבה פונקציונליות מעבר ל בדיקה חבילה, כולל רגרסיה ובדיקת יחידות.

חבילת העדות

חבילת עדות היא אחת ממסגרות ה-Go הפופולריות ביותר לבדיקת חבילות. הוא מספק כלים שתצטרכו לכתיבת מבחנים יעילים, עם קביעות קלות, לעג ופונקציות חבילת בדיקה.

Testify מתאימה לפיתוח מונחה מבחן מכיוון שהחבילה מספקת א לִלְעוֹג חֲבִילָה. זה מספק מנגנון לכתיבת אובייקטים מדומים שבהם אתה יכול להשתמש במקום אובייקטים אמיתיים בבדיקה.

החבילה מספקת גם:

• א לִטעוֹן חבילה המספקת שיטות מועילות לכתיבת מבחנים ידידותיים וקריאים.
• א לִדרוֹשׁ חבילה דומה ל- לִטעוֹן חבילה להחזרת תוצאות בוליאניות.
• א סְוִיטָה חבילה עבור חבילות בדיקה עם מבנים.

עדות משתרע על בדיקה חבילה, ואתה יכול להשתמש ב- ללכת לבדיקה פקודה להפעלת בדיקות שנכתבו עם חבילת Testify.

Testify תומך בגרסאות Go מ-1.13. אתה יכול להוסיף את החבילה כתלות בפרויקט עם הפקודה הזו:

ללכת קבל github.com/stretchr/testify

הנה מבחן הצהרות פשוט עם חבילת Testify לִטעוֹן חֲבִילָה:

חֲבִילָה רָאשִׁי
יְבוּא (
 "בדיקה"
 "github.com/stretchr/testify/assert" // חבילת טענה בלבד
)
// שם הפונקציה צריך להיות "משהו" לפי המוסכמה
funcבדוק משהו(ט *בדיקה. ט) {
// בטענה לשוויון
 לִטעוֹן. שווה (ת, 123, 123, "הם צריכים להיות שווים")
// בטענה לאי שוויון
 לִטעוֹן. NotEqual (t, 123, 456, "הם לא צריכים להיות שווים")
}

ה בדוק משהו פונקציית הבדיקה לוקחת את מבנה סוג הבדיקה של בדיקה חבילה כטיעון. ה שווה ו לא שווה השיטות מבוססות על שוויון ואי שוויון קביעות מאת Testify's לִטעוֹן חֲבִילָה.

חבילת GoConvey

GoConvey הוא כלי לבדיקת Go המיועד להבעה על פני בדיקה חֲבִילָה. זה כולל מסוף (CLI) ודפדפן (GUI) בדיקת פונקציונליות.

חבילת GoConvey משתלבת עם בדיקה חבילה, המספקת ממשק משתמש אינטרנטי לעבודה עם מבחני Go מקוריים. זה כולל גם פונקציונליות עבור מבחני רגרסיה, פלטים הניתנים להתאמה אישית ויצירת קוד בדיקה. אתה יכול להריץ בדיקות באופן אוטומטי, לגשת לפורמטי כיסוי ב-HTML ולהתאים אישית את ה-GUI.

הפעל פקודה זו בטרמינל של סביבת העבודה שלך Go כדי להתקין את חבילת Go Convey.

ללכת קבל github.com/smartystreets/goconvey

הנה דוגמה פשוטה לכתיבת מבחנים עם חבילת GoConvey.

חֲבִילָה רָאשִׁי
יְבוּא (
. "github.com/smartystreets/goconvey/convey"
 "בדיקה"
)
funcבדוק משהו(ט *בדיקה. ט) {
// העבירו t רק לשיחות Convey ברמה העליונה
 Convey("הכרז על משתנה", t, func() {
 x := 1
Convey("increment variable", func() {
 x++
Convey("לטעון שוויון", func() {
 אז (x, ShouldEqual, 2)
 })
 })
 })
}

תצטרך לייבא את ה לְהַעֲבִיר חבילה באמצעות סימון נקודות עבור הבדיקה.

הפונקציה Convey מ- לְהַעֲבִיר החבילה עוזרת עם היקף הבדיקה. האחרון לְהַעֲבִיר call function בדוגמה של הקוד קובעת שוויון בין ה איקס משתנה ו 2, משתמש ב ShouldEqual פוּנקצִיָה.

חבילת ה-HTTP Expect

ה HTTP מצפה חבילה היא חבילה קלה לשימוש, תמציתית, הצהרתית לבדיקת HTTP ו-REST API מקצה לקצה של Go. אתה יכול להשתמש בו כדי לבנות בקשות HTTP בהדרגה ולבדוק את התגובות ואת המטענים שלהן באופן רקורסיבי.

ה httpexpect החבילה היא קבוצה של בונים הניתנים לשרשרת עבור בקשות HTTP והצהרות לגבי תגובות HTTP ומטעני. זה בנוי על http, בדיקה, וחבילות אחרות. החבילה עובדת היטב גם עם המובנה httptest חֲבִילָה.

httpexpect מספק פונקציונליות לבניית בקשות עם בניית כתובות אתרים, כותרות, קובצי Cookie ומטענים. הוא מטפל בהצהרות תגובות, בקביעות מטען, הדפסה יפה ו-WebSockets.

הפעל פקודה זו במסוף של ספריית העבודה שלך כדי להתקין את httpexpect חֲבִילָה.

ללכת קבל github.com/gavv/httpexpect

הנה דוגמה פשוטה לבדיקת פונקציית מטפל עם ה httpexpect חֲבִילָה.

חֲבִילָה רָאשִׁי
יְבוּא (
 "fmt"
 "github.com/gavv/httpexpect/v2"
 "נטו/http"
 "net/http/httptest"
 "בדיקה"
)
funcדוגמה המטפל()http.מטפל {
לַחֲזוֹר http. HandlerFunc(func(כותב http. כותב תגובה, בקשה *http. בַּקָשָׁה) {
 fmt. Fprintln (סופר, "שלום עולם")
 })
}
funcTestexampleHandler(ט *בדיקה. ט) { 
// ליצור http. מטפל
 מטפל := exampleHandler()
// הפעל שרת באמצעות httptest
 שרת := httptest. NewServer (מטפל)
לִדחוֹת שרת. סגור()
// צור מופע של http מצפה
 מצפה := http מצפה. חדש (t, שרת. כתובת URL)
// זה עובד?
 לְצַפּוֹת. לקבל("/").
 לְצַפּוֹת().
 סטטוס (http. StatusOK).JSON().Array().Empty()
}

ה דוגמה המטפל פונקציית המטפל מחזירה מטפל HTTP עבור ה- httpexpect חֲבִילָה. ה TestexampleHandler function מכריזה על מופע של פונקציית המטפל. לאחר מכן הוא יוצר שרת חדש לבדיקת נקודת הקצה עם httptest חֲבִילָה.

ה לְצַפּוֹת המשתנה הוא שלך httpexpect מופע שפוגע ב- לקבל בקש נתיב שורש נקודת קצה בשרת. ה סטָטוּס הפונקציה חוזרת קוד המצב (במקרה הזה, 200) אם הבדיקה תצליח.

כתוב מבחנים מקיפים ואינטואיטיביים

מבחנים עושים דרך ארוכה בהערכת תקינות היישום שלך, ויש הרבה דפוסי בדיקה ושיטות שבהם אתה יכול להשתמש עבור התוכניות שלך. בליבת זרימת העבודה של הבדיקות שלך, עליך לכתוב מבחנים אינטואיטיביים שתוכל לשפר בהם ככל שהתוכניות שלך משתנות עם הזמן.