streamalism.org

1. הקדמה

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

במדריך זה נסקור כיצד להקביל בדיקות באמצעות תוסף Surefire של JUnit ו- Maven. ראשית, נריץ את כל הבדיקות בתהליך JVM יחיד, ואז ננסה זאת עם פרויקט רב-מודולי.

2. תלות Maven

נתחיל בייבוא ​​התלות הנדרשת. נצטרך להשתמש ב- JUnit 4.7 ואילך יחד עם Surefire 2.16 ואילך:

 מבחן junit junit 4.12 

 org.apache.maven.plugins maven-surefire-plugin 2.22.0 

בקצרה, Surefire מספק שתי דרכים לביצוע בדיקות במקביל:

• ריבוי הליכי משנה בתהליך JVM יחיד
• זיוף תהליכי JVM מרובים

3. ריצת מבחנים מקבילים

כדי להריץ מבחן במקביל עלינו להשתמש במבחן רץ שמתארך org.junit.runners.ParentRunner.

עם זאת, גם מבחנים שאינם מכריזים על רץ מבחן מפורש עובדים, מכיוון שרץ ברירת המחדל מרחיב כיתה זו.

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

3.1. באמצעות פרמטר מקביל

ראשית, בואו נאפשר התנהגות מקבילה ב- Surefire באמצעות ה- מַקְבִּיל פָּרָמֶטֶר. הוא מציין את רמת הפירעונות בה נרצה ליישם מקבילות.

הערכים האפשריים הם:

• שיטות - מריץ שיטות בדיקה בשרשורים נפרדים
• שיעורים - מריץ שיעורי מבחן בשרשורים נפרדים
• שיעורים ושיטות - מריץ שיעורים ושיטות בשרשורים נפרדים
• סוויטות - מנהלת סוויטות במקביל
• סוויטות ומשקפיים - מריץ סוויטות ושיעורים בחוטים נפרדים
• suites AndMethods - יוצר שרשורים נפרדים לשיעורים ולשיטות
• את כל - מריץ סוויטות, שיעורים וכן שיטות בשרשורים נפרדים

בדוגמה שלנו, אנו משתמשים את כל:

 את כל 

שנית, בואו נגדיר את המספר הכולל של האשכולות שאנחנו רוצים ש- Surefire תיצור. אנו יכולים לעשות זאת בשתי דרכים:

באמצעות threadCount המגדיר את מספר האשכולות המרבי ש- Surefire תיצור:

10

או באמצעות useUnlimitedThreads פרמטר שבו נוצר שרשור אחד לכל ליבת מעבד:

נָכוֹן

כברירת מחדל, threadCount הוא לליבת מעבד. אנו יכולים להשתמש בפרמטר perCoreThreadCount כדי להפעיל או להשבית התנהגות זו:

נָכוֹן

3.2. שימוש במגבלות ספירת חוטים

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

בואו נשלב פרמטרים אלה עם threadCount מהתצורה הקודמת:

2 2 6

מאז השתמשנו את כל ב מַקְבִּיל, הגדרנו את ספירת החוטים לשיטות, סוויטות ושיעורים. עם זאת, אין חובה להגדיר את פרמטר העלה. Surefire מסיק את מספר החוטים לשימוש במקרה של פרמטרים של עלים.

לדוגמא, אם threadCountMethods מושמט, אז אנחנו רק צריכים לוודא threadCount >threadCountClasses + threadCountSuites.

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

אנו יכולים להחיל מגבלות על ספירת חוטים גם במקרים כאלה:

נכון 2

3.3. הגדרת פסק זמן

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

לשם כך אנו יכולים להשתמש ב- parallelTestTimeoutForcedInSeconds פָּרָמֶטֶר. פעולה זו תפריע לשרשורים הפועלים כרגע ולא תבצע אף אחד מהשרשורים בתור לאחר שחלף הזמן הקצוב:

5

אפשרות נוספת היא להשתמש parallelTestTimeoutInSeconds.

במקרה זה, רק ההשחלות בתור יופסקו מביצוע:

3.5

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

3.4. אזהרות

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

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

4. ביצוע מבחן בפרויקטים מרובי-מודולים של Maven

עד עכשיו התמקדנו בהפעלת מבחנים במקביל במודול Maven.

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

אנו יכולים לשנות את התנהגות ברירת המחדל הזו באמצעות Maven's -ט פרמטר הבונה מודולים במקביל. ניתן לעשות זאת בשתי דרכים.

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

mvn -T 4 בטוח: מבחן

או השתמש בגרסה הניידת וציין את מספר האשכולות ליצור לכל ליבת מעבד:

mvn -T 1C בטוח: מבחן

כך או כך, אנו יכולים להאיץ את הבדיקות וכן לבנות זמני ביצוע.

5. מזלגות JVM

עם ביצוע המבחן המקביל דרך ה- מַקְבִּיל אפשרות, מקביליות מתרחשת בתהליך JVM באמצעות שרשור.

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

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

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

בכל מקרה, על מנת לאפשר מזלג, עלינו רק להשתמש ב- forkCount והגדר אותו לכל ערך חיובי:

3

כאן, בטוח תיצור לכל היותר שלוש מזלגות מה- JVM ותריץ בהן את הבדיקות. ערך ברירת המחדל עבור forkCount הוא אחד, כלומר תוסף maven-surefire יוצר תהליך JVM חדש אחד לביצוע כל הבדיקות במודול Maven אחד.

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

2.5C

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

כברירת מחדל, Surefire יעשה שימוש חוזר במזלגות שנוצרו לבדיקות אחרות. עם זאת, אם הגדרנו את reuseForks נכס ל שֶׁקֶר, זה יהרוס כל מזלג לאחר הפעלת כיתת מבחן אחת.

כמו כן, על מנת להשבית את המזלגות, אנו יכולים להגדיר את forkCount לאפס.

6. מסקנה

לסיכום, התחלנו בכך שאפשרנו התנהגות מרובת שרשראות והגדרנו את מידת ההקבלה באמצעות ה- מַקְבִּיל פָּרָמֶטֶר. לאחר מכן, החלנו מגבלות על מספר הנושאים ש- Surefire אמור ליצור. מאוחר יותר, קבענו פרמטרים של פסק זמן לבקרת זמני ביצוע הבדיקה.

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

כמו תמיד, הקוד המוצג כאן זמין ב- GitHub.