streamalism.org

1. סקירה כללית

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

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

2. מושגי ליבה

2.1. ארכיונים לפריסה

יש דרך קלה לבדיקת היישום שלנו כשריצים בתוך מיכל.

קוֹדֶם כֹּל, עטיפה מתכווצת class מספק API ליצירת פריסה *.קַנקַן,*.מִלחָמָה, ו *.אֹזֶן קבצים.

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

2.2. מיכלים

ארקיליאן מבחין בין שלושה סוגים שונים של מכולות:

• מרחוק - נבדק באמצעות פרוטוקול מרחוק כמו JMX
• מנוהל - מכולות מרוחקות אך מחזור חייהם מנוהל על ידי ארקיליאן
• מוטבע - מכולות מקומיות בהן מבוצעות בדיקות באמצעות פרוטוקולים מקומיים

כמו כן, אנו יכולים לסווג מכולות לפי יכולותיהם:

• יישומי ג'קרטה EE פרוסים בשרת יישומים כמו Glassfish או JBoss
• מכולות סרוולט פרוסות בטומקט או במזח
• מכולות עצמאיות
• מכולות OSGI

הוא בוחן את מסלול הכיתה בזמן ריצה ובוחר אוטומטית את המכולה הזמינה.

2.3. העשרת מבחן

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

אנחנו יכולים להזריק תלות באמצעות @לְהַזרִיק, להזרים משאבים עם @מַשׁאָב, שעועית הפעלה EJB באמצעות @EJB, וכו '

2.4. רצי מבחן מרובים

אנו יכולים ליצור פריסות מרובות באמצעות ההערה:

פריסה @ (שם = "סדר שם שלי" = 1)

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

@Test @OperateOnDeployment ("שם שלי")

המבחן לפני מבוצע ב- השם שלי מיכל הפריסה באמצעות הסדר שהוגדר ב- @פְּרִיסָה ביאור.

2.5. הרחבות ארקיליאן

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

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

הרחבות נפוצות הן מזל"ט, גרפן וסלניום.

3. Maven תלות והתקנה

בואו נוסיף את התלות הבאה שלנו pom.xml קוֹבֶץ:

 org.jboss.arquillian arquillian-bom 1.1.13.יבוא סופי pom org.glassfish.main.extras glassfish-embedded-all 4.1.2 test org.jboss.arquillian.container arquillian-glassfish-embedded-3.1 1.0.0.Final מִבְחָן 

הגרסה האחרונה של התלות נמצאת כאן: arquillian-bom, org.glassfish.main.extras, org.jboss.arquillian.container.

4. מבחן פשוט

4.1. צור רכיב

נתחיל ברכיב פשוט. איננו כוללים כאן שום היגיון מתקדם בכדי שנוכל להתמקד במבחנים:

מחלקה ציבורית רכיב {public void sendMessage (PrintStream to, String msg) {to.println (message (msg)); } הודעת מחרוזת ציבורית (מחרוזת msg) {להחזיר "הודעה", + msg; }}

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

4.2. כתוב את מבחן הארקיליאן הראשון שלנו

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

@RunWith (Arquillian.class) 

אם אנו הולכים להריץ את הבדיקות שלנו בתוך מיכל, עלינו להשתמש ב- @פְּרִיסָה ביאור.

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

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

ה JavaArchive.class יוצר ארכיון אינטרנט mockup בשם test.war, קובץ זה נפרס למיכל ואז משמש את ארקיליאן לביצוע בדיקות:

@Deployment ציבורי סטטי JavaArchive createDeployment () {return ShrinkWrap.create (JavaArchive.class) .addClass (Component.class) .addAsManifestResource (EmptyAsset.INSTANCE, "beans.xml"); }

ואז אנו מזריקים את הרכיב שלנו במבחן:

@ הזריק רכיב רכיב פרטי;

לבסוף, אנו מבצעים את הבדיקה שלנו:

assertEquals ("הודעה, MESSAGE", component.message (("MESSAGE"))); component.sendMessage (System.out, "MESSAGE");

5. בדיקת שעועית ג'אווה ארגונית

5.1. שעועית Java Bean

בעזרת Arquillian אנו יכולים לבדוק הזרקת תלות של Enterprise Java Bean, לשם כך אנו יוצרים מחלקה שיש בה שיטה להמרת כל מילה לאותיות קטנות:

class class ConvertToLowerCase {public String convert (String word) {return word.toLowerCase (); }}

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

@Stateless class class CapsConvertor {public ConvertToLowerCase getLowerCase () {להחזיר ConvertToLowerCase חדש (); }}

ה CapsConvertor הכיתה מוזרקת לשעועית שירות:

@ סטטוס CapsService בכיתה ציבורית {@ Inject private CapsConvertor capsConvertor; מחרוזת ציבורית getConvertedCaps (מילת מחרוזת סופית) {return capsConvertor.getLowerCase (). convert (word); }}

5.2. בדוק את Enterprise Java Bean

כעת אנו יכולים להשתמש בארקיליאן כדי לבדוק את הארגון שלנו Java Bean ולהזריק את ה- CapsService:

@ הזריק CapsService פרטית capsService; @ מבחן ציבורי בטל givenWord_WhenUppercase_ThenLowercase () {assertTrue ("השתמש באותיות רישיות" .equals (capsService.getConvertedCaps ("CAPITALIZE"))); assertEquals ("אותיות רישיות", capsService.getConvertedCaps ("CAPITALIZE"); }

באמצעות עטיפה מתכווצת, אנו מבטיחים כי כל השיעורים מחוברים כראוי:

@Deployment סטטי ציבורי JavaArchive createDeployment () {return ShrinkWrap.create (JavaArchive.class) .addClasses (CapsService.class, CapsConvertor.class, ConvertToLowerCase.class) .addAsManifestResource (EmptyAsset.INSTANCE, "שעועית. }

6. בדיקת JPA

6.1. הַתמָדָה

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

רכב בכיתה ציבורית @Entity {@Id @GeneratedValue פרטי מזהה ארוך; @NotNull שם פרטי מחרוזת; // גטרים וקובעים}

יש לנו טבלה שמכילה שמות של מכוניות.

אז אנחנו הולכים ליצור את ה- EJB שלנו כדי לבצע פעולות בסיסיות על הנתונים שלנו:

@Stateless class class CarEJB {@PersistenceContext (unitName = "defaultPersistenceUnit") emity EntityManager em; רכב ציבורי saveCar (רכב רכב) {em.persist (רכב); רכב חוזר; } רשימה ציבורית findAllCars () {Query query = em.createQuery ("SELECT b FROM Car b ORDER BY b.name ASC"); ערכי רשימה = query.getResultList (); להחזיר ערכים == null? ArrayList חדש (): ערכים; בטל ציבורי deleteCar (רכב רכב) {car = em.merge (car); em.remove (מכונית); }}

עם saveCar אנחנו יכולים לשמור את שמות המכוניות בבסיס הנתונים, ואנחנו יכולים לאחסן את כל המכוניות findAllCars, וגם נוכל למחוק מכונית ממאגר המידע באמצעות deleteCar.

6.2. בדוק התמדה עם ארקיליאן

כעת אנו יכולים לבצע כמה בדיקות בסיסיות באמצעות ארקיליאן.

ראשית, אנו מוסיפים את השיעורים שלנו לשיעורים שלנו עטיפה מתכווצת:

.addClasses (Car.class, CarEJB.class) .addAsResource ("META-INF / persistence.xml")

ואז אנו יוצרים את הבדיקה שלנו:

@Test ציבורי בטל ציבורי () {assertTrue (carEJB.findAllCars (). IsEmpty ()); רכב c1 = רכב חדש (); c1.setName ("אימפלה"); רכב c2 = רכב חדש (); c2.setName ("לינקולן"); carEJB.saveCar (c1); carEJB.saveCar (c2); assertEquals (2, carEJB.findAllCars (). size ()); carEJB.deleteCar (c1); assertEquals (1, carEJB.findAllCars (). size ()); }

בבדיקה זו ראשית אנו יוצרים ארבעה מופעי רכב ובודקים שמספר השורות במסד הנתונים זהה שיצרנו.

8. מסקנה

במדריך זה אנו:

• הציג מושגי ליבה של ארקיליאן
• הזריק רכיב למבחן הארקיליאן
• בדק EJB
• נבדק התמדה
• ביצע את מבחן ארקיליאן באמצעות Maven

אתה יכול למצוא את הקוד מהמאמר ב- Github.