כיצד ליצור דוח שמירה על קוד באמצעות שיטת JaCoCo-Maven

מדריכים
Gradle JavaScript JUnit Selenium

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

יש מספר כלים לכיסוי קוד עבור שפות כמו Java, C#, JavaScript וכד'. שימוש בכלי כיסוי קוד המתאים הכי טוב חשוב להבנת אחוז הקוד שנבדק ולקחת פעולות הולמות להבטיח שתשיג את הכיסוי הקוד האידאלי.

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

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

מה זה כיסוי קוד?

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

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

יתרונות של כיסוי קוד

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

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

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

מהו הדברת JaCoCo-Maven?

הדברת JaCoCo-Maven (קיצור של Java Code Coverage) היא כלי כיסוי קוד פתוח לסיור עבור Java. היא יוצרת דוחות כיסוי קוד ומשתלבת היטב עם סביבות פיתוח מורכבות (IDE), כמו IDE של אפליקציות הבינה.

זה משתלב באופן חלק עם כלים לCI/CD (למשל Jenkins, Circle CI וכד') וכלים לניהול פרויקטים (למשל, SonarQube וכד'). זה חלק מקרן Eclipse והחליף את כלי ה�笼罩 EclEmma ב-Eclipse.

איך פלוגת JaCoCo-Maven עובדת?

  • פלוגת JaCoCo-Maven מבצעת הסקה על ידי מדידת קוד ג'אווה דרך סוכן ריצה. במילים פשוטות, אתה מחבר את הסוכן הזה ל-JVM (מכונת וירטואלית ג'אווה) כשהיא מתחילה. הסוכן הזה נקרא סוכן JaCoCo. הביצוע הראשון מתחיל את סוכן JaCoCo הזמני.
  • בכל פעם שמסוגלים מחלקה, JaCoCo יכולה למדוד את המחלקה כך שהיא יכולה לראות מתי המחלקה נקראת ואילו שורות (של קוד) נקראו במהלך תהליך הבדיקה. על ידי שמירת נוכחות זו, היא בונה את סטטיסטיקות הכיסוי של הקוד, שנעשה בזמן אמת בביצוע השני (כלומר, לייצר-דו"ח).
  • כברירת מחדל, הקובץ נוצר ברגע שה-JVM מסתיים, אך ייתכן גם להריץ את הסוכן במצב שרת. זה מפעיל דחיפה של התוצאות והדוח נוצר לפני הסיום. להלן הפנימיות של פלוגת JaCoCo:

  • אפשר להגדיר מטרות וכללים בהגדרת פלוגת JaCoCo-Maven. זה נותן לך את הגמישות לקבוע גבולות ועוזר בבדיקת כמות הכיסוי של הקוד.
  • פלוגת Maven-surefire היא הפלוגה הברירת מחדל של Maven. זה מריץ את הבדיקות ב-JVM ומספק דוחות כיסוי. בעוד שפלוגת JaCoCo ממדידת הקוד שכבר נבדק על ידי פלוגה (למשל, פלוגת Surefire). לכן, זה שיטה טובה לבדוק את התלות בפלוגת maven-surefire.

למה פלאגין JaCoCo-Maven טוב לסקירת קוד?

התוסף JaCoCo-Maven מתאים לסקירת קוד בגלל הסיבות הבאות:

  • במהלך עבודה על כל פרויקט, מפתחים מעדיפים בדרך כלל במה IDE מכיוון שזה מקל על חווית הקידוד והבדיקות. JaCoCo יכול להתקבל על ידי ממשק המשתמש של Eclipse IDE בשם EclEmma, על ידי הורדת EclEmma משוק המוצרים שלה.
  • קל להוסיף את פלאגין JaCoCo לכל סוגי הבניות, כולל ANT, Maven, ו- Gradle. זה יכול גם להישלב עם כלים CI/CD כמו Jenkins, Circle CI וכד'. זה הופך אותו לשימושי מאוד להרבה מקרים.
  • דוח הסקירה שנוצר על ידי JaCoCo הוא קובץ HTML פשוט ומידעי שניתן להציג בכל דפדפן או IDE.
  • JaCoCo מספק גם מדיטציה לאופן לא מקוון (כלומר, כל המחלקות מודטות לפני הרצת בדיקות כלשהן).
  • ניתוח של דוח גם די קל, מאחר שהוא מבוסס צבעים ומספק את האחוז המדויק של סקירת הקוד.

איך להגדיר את פלאגין JaCoCo עם Maven

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

הנה השלבים לשילוב פלאגין JaCoCo Maven עם פרויקט Maven:

1. כל פרויקט Maven כולל קובץ pom.xml המשמש להכרזה על כל ההפניות והתוספות. תוספת JaCoCo-Maven מוכרזת באותו קובץ POM.xml. הקוד XML לכך הוא:

  

<plugin>
  <groupId>org.jacoco</groupId>
  <artifactId>jacoco-maven-plugin</artifactId>
  <version>0.8.6</version>
</plugin>

זהו הקוד XML הבסיסי שנוסף תחת התג build לציון התוספת JaCoCo בפרויקט מבוסס Maven. אנו יכולים לשפר את הפונקציונליות (כמו לציין מתי כדאי לייצר דוח, וכו') על ידי ציון מטרות וכללים בתג הביצוע.

2. לאחר התג version, אנו מוסיפים את התג execution. תג זה מכין את התכונות או הביצועים להצביע על סוכן JaCoCo ומועבר כטענה VM (במקרה זה, JVM).

3. לרוץ בדיקות יחידה פשוטות, שתי מטרות שמוגדרות בתגים הביצוע יעבדו בסדר. הנימוק המינימלי הוא להגדיר מטרת prepare-agent ומטרת report.

  

<plugin>
  <groupId>org.jacoco</groupId>
  <artifactId>jacoco-maven-plugin</artifactId>
  <version>0.8.6</version>
  <executions>
  	<execution>
      	<id>prepare-agent</id>
            <goals>
            		<goal>prepare-agent</goal>
            </goals>
      </execution>
      <execution>
            <id>report</id>
            <phase>test</phase>
               <goals>
               	<goal>report</goal>
               </goals>
        </execution>
    </executions>
 </plugin>


  • מטרת prepare-agent: מטרת הprepare-agent מכינה את סוכן הריצה JaCoCo לרשום את נתוני הביצוע. היא רושמת את מספר השורות שבוצעו, הועקבו וכו'. כברירת מחדל, נתוני הביצוע נכתבים לקובץ target/jacoco-ut.exec.
  • מטרת report: מטרת הreport יוצרת דוחות של כספת הקוד מהנתונים שנרשמו על ידי סוכן הריצה JaCoCo. מאחר שציינו את תכונת השלב, הדוחות יוקבעו אחרי ההרכבה של שלב הבדיקה. כברירת מחדל, נתוני הביצוע נקראים מהקובץ target/jacoco-ut.exec, ודוח כספת הקוד נכתב לספרייה target/site/jacoco/index.html.

4. עבור ביצוע בדיקות יחידה פשוטות, הפרוטוקול הנ"ל עובד בצורה מצוינת. עם זאת, נצטרך להציב קידודים על דוחות כמות הקוד (למשל, לציין את ספריית היעד וכו'). זה יכול להיעשות דרך תג קישור:

  

<plugin>
  <groupId>org.jacoco</groupId>
  <artifactId>jacoco-maven-plugin</artifactId>
  <version>0.8.6</version>
  <executions>
  	<execution>
      	<id>prepare-agent</id>
            <goals>
            		<goal>prepare-agent</goal>
            </goals>
            <configuration>
<destFile>${project.build.directory}/coverage-reports/jacoco-ut.exec</destFile>
                <propertyName>surefireArgLine</propertyName>
            </configuration>
      </execution>
      <execution>
            <id>report</id>
            <phase>test</phase>
               <goals>
               	<goal>report</goal>
               </goals>
               <configuration>
<dataFile>${project.build.directory}/coverage-reports/jacoco-ut.exec</dataFile>
<outputDirectory>${project.reporting.outputDirectory}/jacoco-ut</outputDirectory>
               </configuration>
        </execution>
    </executions>
 </plugin>

התקנת הביצוע הראשונה

על פי הקוד הנ"ל, אפשר לראות כמה תגים, כמו destFile וכו', מוגדרים. הנה תיאור קצר של התגים:

  • destFileתג: התג destFile משמש להגדרת המסלול לקובץ המכיל את הנתונים של הביצוע.
  • propertyName-surefireArgLineתג: תג זה קובע את שמו של הנכס שמכיל את ההגדרות לסוכם ריצה JaCoCo. זה גם קובע את קו הווימ בזמן שבדיקות היחידה מתבצעות.

התקנת הביצוע השני

על פי הקוד הנ"ל, אפשר לראות תגים כמו dataFile וכו', מוגדרים. הנה תיאור קצר של התגים:

  • dataFileתג: התג dataFile משמש להגדרת המסלול לקובץ המכיל את נתוני הביצוע.
  • outputDirectoryתג: תג זה קובע את הספרייה המוצהבת עבור דוחות כמות הקוד.

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

  

<plugin>
  <groupId>org.jacoco</groupId>
  <artifactId>jacoco-maven-plugin</artifactId>
  <version>0.8.6</version>
  <executions>
  	<execution>
      	<id>prepare-agent</id>
            <goals>
            		<goal>prepare-agent</goal>
            </goals>
            <configuration>
<destFile>${project.build.directory}/coverage-reports/jacoco-ut.exec</destFile>
                <propertyName>surefireArgLine</propertyName>
            </configuration>
      </execution>
      <execution>
            <id>report</id>
            <phase>test</phase>
               <goals>
               	<goal>report</goal>
               </goals>
               <configuration>
<dataFile>${project.build.directory}/coverage-reports/jacoco-ut.exec</dataFile>
<outputDirectory>${project.reporting.outputDirectory}/jacoco-ut</outputDirectory>
               </configuration>
        </execution>
        <execution>
              <id>jacoco-check</id>
              <goals>
                <goal>check</goal>
              </goals>
              <configuration>
              	<rules>
                 	   <rule>
                    	<element>PACKAGE</element>
                    	<limits>
                      		<limit>
                        		<counter>LINE</counter>
                        		<value>COVEREDRATIO</value>
                        		<minimum>0.50</minimum>
                      		</limit>
                   	</limits>
                	   </rule>
            	      </rules>
             </configuration>
 	  </execution>
    </executions>
 </plugin>

התקנת הביצוע השלישי

כאן, מוגדר בדיקת יעד חדש. יעד jacoco:check קשור לאימות הכלל המסופק. הכלל מובא בתג הכלל. יש לך הגבלה לציין יותר מכלל אחד.

  • תג האלמנט: תג זה מציין את האלמנט שעליו יש ליישם את הכלל.
  • תג הגבול: תגים כמו מונה, ערך, מינימום וכד', משמשים להגבלת אחוז הכיסוי בקוד. פקודה כמו mvn clean verify יכולה לשמש להביע האם הכלל נשמר או לא.

6. יש כמה יעדים וכללים שניתן להגדיר בתצורת התוסף JaCoCo-Maven.

דוחות כיסוי קוד באמצעות Maven והתוסף JaCoCo

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

דרישות קדומות

  1. Maven 3.0 או גבוה יותר: Maven הוא כלי ניהול והבנה של פרויקטים. תוכל להתקין את הגרסה העדכנית ביותר מאתר ה-Apache Maven הרשמי.
  2. Java 1.5 או גבוה יותר: עליך לוודא ש-Java מותקן על המחשב שלך. במקרה שאין לך Java מותקן, אנא הורד את הגרסה העדכנית ביותר של Java מאתר Java הרשמי.
  3. IDE של Eclipse עבור מפתחי Java: אם כי אפשר להשתמש ב-IDE שלך הבחירה, עבור הדגמה זו השתמשנו ב-IDE של Eclipse.

שלבים ליצירת פרויקט Maven פשוט

  1. ב-IDE של Eclipse, גשו לקובץ > חדש > פרויקט Maven.

2. מופיע תיבת דיאלוג חדשה. וודא שהסריקה "השתמש במיקום עבודה ברירת מחדל" מסומנת ולחץ על "הבא."

3. לבחירת ארכאופט בפרויקט, הקלד org.apache.maven בתיבת הטקסט הממוקמת ליד הפילטר. בחר maven-archetype-quickstart ולחץ על "הבא."

4. עכשיו, הגדר את "קבוצת המזהה" כ com.example ואת "מזהה הדברית" כ jacoco-example. "מזהה הדברית" הוא שם הפרויקט שלנו. לבסוף, לחץ על כפתור "סיום."

5. אפשר לראות את מסד הנתונים של הפרויקט והיררכיה של הקבצים והתיקיות ב"מסקר הפרויקט."

כיצד לציין את פלאנק JaCoCo Maven ב-POM.xml

1. פתח POM.xml, גלול לתג. נציין את פלאנק JaCoCo-Maven בסעיף שמפרט את הפלאנקים של Maven. פשוט העתק את הקוד הבא והדבק אותו בתג הנ"ל:

  

<plugin>
  <groupId>org.jacoco</groupId>
  <artifactId>jacoco-maven-plugin</artifactId>
  <version>0.8.6</version>
  <executions>
     <!--first execution : for preparing JaCoCo runtime agent-->
      <execution>
      	<id>prepare-agent</id>
            <goals>
            		<goal>prepare-agent</goal>
            </goals>
      </execution>
     <!--second execution : for creating code coverage reports-->
      <execution>
            <id>report</id>
            <phase>test</phase>
               <goals>
               	<goal>report</goal>
               </goals>
        </execution>
    </executions>
 </plugin>

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

הנה כל תוכן POM.xml:

  

<?xml version="1.0" encoding="UTF-8"?>


<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>


  <groupId>com.example</groupId>
  <artifactId>jacoco-example</artifactId>
  <version>0.0.1-SNAPSHOT</version>

 <name>jacoco-example</name>


  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>


<!-- JUnit dependencies added to run test cases -->
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>


  <build>
      <plugins>
        <!-- Maven plugin for Project Management -->
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.7.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.19.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-jar-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
            <plugin>
                <groupId>org.jacoco</groupId>
                <artifactId>jacoco-maven-plugin</artifactId>
                <version>0.8.6</version>
                                  
                <executions>
                    <execution>
                        <id>prepare-agent</id>
                        <goals><goal>prepare-agent</goal></goals>
                    </execution>
                    <execution>
                        <id>report</id>
                        <phase>test</phase>
                        <goals><goal>report</goal></goals>
                    </execution>
                </executions>
            </plugin>
      </plugins>
  </build> 
</project>

3. מסדרת הפרויקט, נavigate לחבילה com.example.jacoco_lambdatest הקיימת ב-src/main/java. צור מחדש מחלקת Java בשם LambdaTest.java. נכתוב פונקציה פשוטה setUp() בה שמספקת את היכולות הרצויות של גריד Selenium.

  

package com.example.Jacoco_lambdatest;

import java.net.MalformedURLException;
import java.net.URL;
import org.junit.Before;
import org.junit.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;

public class LambdaTest {
	public static String username = "<LambdaTest_Username>";
	public static String accessKey = "<LambdaTest_AccessKey>";
	
  public static DesiredCapabilities setUp() throws Exception {
     DesiredCapabilities capabilities = new DesiredCapabilities();
      capabilities.setCapability("platform", "Windows 10");
	     capabilities.setCapability("browserName", "Chrome");
	     capabilities.setCapability("version", "87.0"); // If this cap isn't specified, it will just get the any available one
      capabilities.setCapability("resolution","1024x768");
      capabilities.setCapability("build", "First Test");
      capabilities.setCapability("name", "Sample Test");
      capabilities.setCapability("network", true); // To enable network logs
      capabilities.setCapability("visual", true); // To enable step by step screenshot
      capabilities.setCapability("video", true); // To enable video recording
      capabilities.setCapability("console", true); // To capture console logs
      return capabilities;
  }
}

הוספת מקרים בדיקה JUnit בפרויקט

1. ניצור מקרה של בדיקה פשוט ב-JUnit בקוד `AppTest.java`. זה מובא כברירת מחדל, בתיקיה `src/test/java` תחת שם החבילה `com.example.jacoco_lambdatest`.

  

package com.example.Jacoco_lambdatest;

import java.net.MalformedURLException;
import java.net.URL;
import org.junit.Before;
import org.junit.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import com.example.Jacoco_lambdatest.*;

public class AppTest {
	public static RemoteWebDriver driver;
	
	@Test
	public void testScript1() throws Exception {
		try {
	DesiredCapabilities capabilities = LambdaTest.setUp();
	String username =LambdaTest.username;
	String accessKey = LambdaTest.accessKey;
	RemoteWebDriver driver = new RemoteWebDriver(new URL("https://"+username+":"+accessKey+"@hub.lambdatest.com/wd/hub"),capabilities);       driver.get("https://lambdatest.github.io/sample-todo-app/");
     driver.findElement(By.name("li1")).click();
	driver.findElement(By.name("li2")).click();		      driver.findElement(By.id("sampletodotext")).clear();		driver.findElement(By.id("sampletodotext")).sendKeys("Yey, Let's add it to list");
	driver.findElement(By.id("addbutton")).click();
	driver.quit();					
	} catch (Exception e) {
		System.out.println(e.getMessage());
		}
	}
}

יצירת דו"חות שכפול קוד

1. לחץ על כפתור "`Run As`" והגדר את הפרוצדורה כבדיקת Maven.

2. במקום זאת, אפשר לפתוח את ה-cmd (שורת הפקודה), לעבור לתיקיית הפרויקט, ולרוץ את הפקודת Maven, "mvn test".

3. ריצת בדיקות JUnit תפעיל אוטומטית את סוכם JaCoCo. זה ייצור דוח בפורמט בינארי בתיקיית היעד, עם הנתיב `target/jacoco.exec`. הפלט של `jacoco.exec` אינו ניתן לפרשנות בנפרד אך כלים אחרים כמו SonarQube ותוספיות יכולים לפרשנו אותו. כפי שצוין קודם, מטרת `jacoco:report` תייצר דו"חות שכפול קוד קריאים בפורמטים פופולריים כמו HTML, CSV ו-XML.

4. כשהבניה מוצלחת, עבור לתיקיית היעד, לתיקיית site > jacoco. דו"ח השכפול (כלומר, `index.html`) ממוקם ב-`target/site/jacoco/index.html`. הדוח נראה ככה:

5. אפשר לחדור לרמה המיקרוסקופית על ידי לחיצה על `com.example.jacoco_lambdatest>LambdaTest` בדו"ח.

6. על ידי לחיצה על פונקציות ספציפיות, תקבל תצוגה מפורטת יותר ב-`LambdaTest.java`.

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

ניתוח דו"ח שמירת הקוד

דו"ח השמירה על הקוד שלנו מראה 94% שמירה על ההוראות ו-100% שמירה על הענפים, מה שהוא ציון שמירה על הקוד מעולה. מאוחר יותר, ננסה להשיג ציון של 100% בשמירה על הקוד על ידי הוספת מקרי בדיקה נוספים.

ה-38 הוראות שJaCoCo מראה בדו"ח מתייחסות להוראות של קוד בייט במקום להוראות של קוד Java. דו"ח JaCoCo עוזר לך לנתח ויזואלית את שמירת הקוד על ידי שימוש ביהלומים עם צבעים לענפים וצבעי רקע לשורות. הסבר קצר על היהלומים שנראים בדו"ח של שמירת הקוד נמצא להלן:

  • יהלום אדום; מצביע על כך שאף ענף לא פעל במהלך שלב הבדיקה.
  • יהלום צהוב: מצביע על כך שהקוד מכוסה חלקית (כלומר, חלק מהענפים לא פעלו).
  • יהלום ירוק: מצביע על כך שכל הענפים פעלו במהלך הבדיקה.

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

הדו"ח מספק שלושה מדדים קריטיים בעיקר:

  1. שמירה על השורה: זה משקף את כמות הקוד שפועל על פי מספר ההוראות של קוד בייט של Java שנקראו על ידי המבחנים.
  2. �笼脷脩禄脪脨: זה מציג את אחוז הענפים שנבדקו בקוד המקור. אלה הם מבוטאים באופן טיפוסי באמצעות הצהרות if/else או switch.
  3. מורכבות ציקלומטית: זה משקף את מורכבות הקוד באמצעות מספר המסלולים הדרוש כדי לכסות את כל המסלולים האפשריים בקוד. זה גם מתייחס למספר המקרים המבחן הנדרש כדי ליישם כדי לכסות את כל הקוד. מכיוון שאין בקוד מתג או הצהרה, המורכבות הציקלומטית תהיה אחת; מספיק מסלול אחד בלבד כדי לכסות את כל הקוד.

הכנסת מקרים מבחן נוספים לשיפור כיסוי קוד

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

2. עבור אל AppTest.java בsrc/test/java כדי להוסיף מקרים מבחן נוספים.

3. המקרים המבחן החדשים המוספים לAppTest.java יראו כדלקמן:

  

@Test
	public void testScript2() throws Exception {
	    try {
	    DesiredCapabilities capabilities = LambdaTest.setUp();
	    String username = LambdaTest.username;
	    String accessKey = LambdaTest.accessKey;
	    RemoteWebDriver driver = new RemoteWebDriver(new URL("https://"+username+":"+accessKey+"@hub.lambdatest.com/wd/hub"),capabilities);		 driver.get("https://lambdatest.github.io/sample-todo-app/");		    driver.findElement(By.name("li2")).click();
	    driver.findElement(By.name("li3")).click();
	   driver.findElement(By.id("sampletodotext")).clear();	driver.findElement(By.id("sampletodotext")).sendKeys("Yes, Let's add it to list");				driver.findElement(By.id("addbutton")).click();
					driver.quit();					
		} catch (Exception e) {
				System.out.println(e.getMessage());
			    }
			}
	

	@Test
	public void testScript3() throws Exception {
		try {
	    DesiredCapabilities capabilities = LambdaTest.setUp();
	    String username = LambdaTest.username;
	    String accessKey = LambdaTest.accessKey;
	    RemoteWebDriver driver = new RemoteWebDriver(new URL("https://"+username+":"+accessKey+"@hub.lambdatest.com/wd/hub"),capabilities);			  driver.get("https://lambdatest.github.io/sample-todo-app/");		    driver.findElement(By.name("li4")).click();
	    driver.findElement(By.id("sampletodotext")).clear();	driver.findElement(By.id("sampletodotext")).sendKeys("Yes, Let's add  it!");
	  driver.findElement(By.id("addbutton")).click();
	  driver.quit();					
	} catch (Exception e) {
		System.out.println(e.getMessage());
			}
			}

4. בואו נרוץ דו"ח דוח JaCoCo של Maven כדי לפרסם דו"ח כיסוי חדש.

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

6. דרישות אלה יכולות להיות מוגדרות ככללים בPOM.xml. פשוט ציין את הביצוע החדש על ידי ציון מטרת 'בדיקה' בPOM.xml. הוסף את הקוד הבא אחרי התג <execution> השני בPOM.xml.

  

<!--Third execution : used to put a check on the entire package-->
<execution>
    <id>jacoco-check</id>
    <goals>
        <goal>check</goal>
    </goals>
    <configuration>
        <rules>
            <rule>
                <element>PACKAGE</element>
                <limits>
                    <limit>
                        <counter>LINE</counter>
                        <value>COVEREDRATIO</value>
                        <minimum>0.50</minimum>
                    </limit>
                </limits>
            </rule>
        </rules>
    </configuration>
</execution>

7. עם זאת, אנו מגבילים את יחס הכיסוי שלנו ל-50%. זה מסמל כי לפחות 50% מהקוד צריך להיות מכוסה במהלך שלב הבדיקה.

8. אפשר להריץ את Maven clean verify כדי לבדוק האם הכללים שקבענו במטרה jacoco:check מתאימים או לא.

9. היישום מראה "All coverage checks have been met" כיוון שניתן ציון כמות הקוד שלנו הוא 94%, שזה גדול מהנמוך שלנו של 50%.

בדיקות אוטומציה ב-LambdaTest Selenium Grid

שימוש בפרויקט Maven עם תוסף JaCoCo

בדיקות Selenium בענן עוזרות לך להשיג כיסוי תוקף טוב יותר, כמות בדיקות מוגברת, וזמן השפעה המואץ. בדיקות מקביליות ב-Selenium עוזרות לך להשיג את הדרישות המוזכרות לעיל.

רשת LambdaTest Cloud Selenium Grid היא פלטפורמת בדיקות Selenium מבוססת ענן המאפשרת לך להריץ תסריטים האוטומציה שלך על 2000+ דפדפנים שונים ומערכות הפעלה.

דרישות קדימות

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

נשתמש בפרויקט דוגמה זה לבדיקות Java Selenium.

ייבוא הפרויקט ל-Eclipse IDE

לאחר הורדת קובץ zip של הפרויקט: junit-selenium-sample מ-GitHub, נייבא אותו ל-Eclipse IDE על ידי שמירה על השלבים הבאים:

1. היכנס ל-Eclipse IDE שלך, לחץ על תפריט "File" ובחר "Import". תופיע תיבת דוידון חדשה.

2. הקלד Maven בתיבת הטקסט למטה ובחר "Existing Maven Projects", ולאחר מכן לחץ על "Next".

3. בתיבת הדוידון הבאה, לחץ על "Browse" ועבור לתיקיית הפרויקט. גם, הצביעו על תיבת הביקורת שמספקת את הנתיב לקובץ POM.xml, ולחץ על "Finish".

4. הפרויקט שלך יתפרק ב-Eclipse IDE בהצלחה.

הוספת תלויויות בקובץ POM.xml

1. פתח את POM.xml, עכשיו הוסף את התלויויות של JUnit, Selenium ו-JaCoCo Maven Plugin. לאחר הוספת התלויויות לקוד של POM.xml צריך להיראות כך:

  

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.lambdatest</groupId>
    <artifactId>lambdatest-junit-sample</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <surefire.version>2.19.1</surefire.version>
        <config.file>default</config.file>
    </properties>

    <dependencies>
        <!--JUnit dependency-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>1.3.2</version>
            <scope>test</scope>
        </dependency>
        <!--Selenium dependency-->
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-java</artifactId>
            <version>2.52.0</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.googlecode.json-simple</groupId>
            <artifactId>json-simple</artifactId>
            <version>1.1.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!--Apache Maven Plugins-->
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
            <plugin>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.19.1</version>
            </plugin>
            <!--JaCoCo Maven Plugin-->
            <plugin>
                <groupId>org.jacoco</groupId>
                <artifactId>jacoco-maven-plugin</artifactId>
                <version>0.8.6</version>      
                <executions>
                    <execution>
                        <id>prepare-agent</id>
                      <goals><goal>prepare-agent</goal></goals>
                    </execution>
                    <execution>
                        <id>report</id>
                        <phase>test</phase>
                        <goals><goal>report</goal></goals>
                   </execution>
               </executions>
          </plugin>
        </plugins>
    </build>
</project>

  
<em><a href="https://github.com/rachnaagrawal/junit-selenium-sample/blob/master/pom.xml" target="_blank" rel="nofollow">Github</a></em>

הגדרת היכולות הרצויות עבור בדיקות אוטומטיות JUnit

1. כדי להתחבר ל-LambdaTest Selenium Automation Grid, הדבר הראשון שנעשה הוא קריאת דפדפן רחוק. דרישות רחוקות זו דורשת כמה יכולות כמו דפדפן, גרסאות דפדפן, מערכת הפעלה וכו', כדי לבנות סביבה. הקוד לזה נראה כך:

  

WebDriver driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + "@hub.lambdatest.com/wd/hub"),
DesiredCapabilities.firefox()); //A class named DesiredCapabilities is used to create an environment as a Firefox browser.

2. בקוד בדיקות אוטומטיות JUnit, היכולות כמו דפדפן, גרסאות דפדפן, מידע על מערכת הפעלה וכן הלאה, יכולים להתאים ומועברים דרך אובייקט היכולות.

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

שדות

ערכים נבחרים

מערכות הפעלה

Windows 10

דפדפן

Chrome

גרסת הדפדפן

62.0

רזולוציה

1024×768

גרסת Selenium

3.13.0

4. בחירת התצורה המפורשת לעיל במנבח היכולות והדבקתה לLambdaTestBseTest.java.

ציון שם משתמש ומפתח גישה של LambdaTest במחלקה הנדרשת

1. בProject Explorer, תראה שלושה מחלקות Java:

  • LambdaTestBaseTest.java (מכיל את ההתקנה הנדרשת לבדיקות Java Selenium).
  • Parallelized.java (מכיל בדיקות Junit לבדיקות מקביליות על רשת Selenium של LambdaTest).
  • SimpleTest.java (מכיל בדיקות יחידה פשוטות).

2. LambdaTestBaseTest.java משיג את הנתונים הנחוצים כמו יכולות רצויות, שם משתמש, ומפתח גישה מקובץ תכונות. זה מובא בsrc/test/resources כconfig.json.

3. ציין את היכולות הרצויות, שם משתמש, ומפתח גישה בconfig.json. קובץ JSON זה משמש כי אפשר לספק מספר תצורות בו לביצוע בדיקות מקביליות עם Selenium לציין מספר תצורות בconfig.json ולאחר מכן לשאוב אותם.

  

[ { "tunnelName":"LambdaTest tunnel", 
"buildName":"running Java Selenium Tests",
"testName":"Jacoco JUnit Test",
"username": "user-name",
"access_key":"access-key", 
 "operatingSystem" : "win10", 
 "browserName" : "chrome",  
 "browserVersion" : "62.0", 
 "resolution" : "1024x768" }]

בדיקת יחידה באמצעות JUnit עם Selenium:

1. SimpleTest.java היא המחלקה הג'אווה לצורך הגדרת מקרה בודק יחיד לבדיקה וביצוע כיסוי קוד באמצעות תוסף JaCoCo Maven.

  

package com.lambdatest;

import com.lambdatest.LambdaTestBaseTest;
import org.junit.Test;
import org.openqa.selenium.By;
import static org.junit.Assert.assertEquals;

public class SimpleTest extends LambdaTestBaseTest {
    /**
     * Simple Test case annotation for JUnit Test
     * @throws Exception
     */

   @Test
    public void validateUser() throws Exception {
    	  driver.get("https://lambdatest.github.io/sample-todo-app/");
	  driver.findElement(By.name("li1")).click();
	  driver.findElement(By.name("li2")).click();
	  driver.findElement(By.id("sampletodotext")).clear();
	  driver.findElement(By.id("sampletodotext")).sendKeys("Yey, Let's add it to list");
	  driver.findElement(By.id("addbutton")).click();
    }

}

2. זהו בדיקת Selenium WebDriver פשוטה שתפתח יישום דוגמא לרשימת מטלות שתבצע את המשימות הבאות:

  • סמן את שני הפריטים הראשונים כ"מושלמים".
  • הוסף פריט חדש לרשימה.
  • החזר את הפריט שהוסף.

3. הפעל את הפקודה mvn test במסוף כדי לבנות ולרוץ את המקרה הבודק.

4. כעת, התחבר לחשבון LambdaTest שלך ועבור ל"אוטומציה". תמצא שם את הבדיקות שביצעת תחת שם הבנייה "בדיקות JUnit JaCoCo".

5. לחץ על "בדיקות JUnit JaCoCo" ובדוק אותן בפירוט. LambdaTest תיעד את הווידאו, כך שתוכל לראות את התמונות גם כן.

יצירת דוח כיסוי קוד באמצעות תוסף JaCoCo Maven:

  1. עכשיו, לאחר שרצינו את מקרי הבודק JUnit ב-LambdaTest Selenium Grid, כדאי לייצר דוח כיסוי קוד באמצעות תוסף JaCoCo Maven.
  2. פשוט עבור לתיקיית ה-target, ותמצא את הפורמט הבינארי של הדוח כ-jacoco.exec.
  3. אתה יכול לצפות בפורמט HTML, CSV ו-XML של דוח הכיסוי קוד בתיקיית target/site/jacoco כ-index.html, jacoco.csv, ו-jacoco.xml בהתאמה.
  4. כעת אפשר גם לנסות לשפר את ציון כיסוי הקוד ולנתח את דוח הכיסוי קוד שנוצר.

מסקנה

במאמר זה ראינו כיצד להשתמש בתוסף JaCoCo-Maven כדי לייצר דוחות של שפעת קוד עבור פרויקטים ב-Java. השתמשנו גם בגמישות ובהישגים הקיימים של רשת LambdaTest Selenium Grid הענן לייתוך תהליכי בדיקה אוטומטית. זכור, עם זאת, ששפעת קוד של 100% אינה אחראית לשקול הבדיקות היעילות, שכן היא מצביעה רק על כמות הקוד שנבדק במהלך הבדיקות.

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

Source:
https://dzone.com/articles/how-to-generate-code-coverage-report-jacoco-maven