Merge pull request #2855 from Microsoft/users/nigurr/FixAntCC-105

Fix Code coverage issue with Ant build tool

Author: Nitin Gurram

Tasks/ANT/anttask.ts

@@ -108,6 +108,7 @@ function readJavaHomeFromRegistry(jdkVersion: string, arch: string): string {
     return javaHome;
 }
 
+
 async function doWork() {
 
     function execEnableCodeCoverage(): Q.Promise<string> {
@@ -134,9 +135,13 @@ async function doWork() {
         reportDirectory = path.join(buildRootPath, reportDirectoryName);
         var reportBuildFileName = "CCReportBuildA4D283EG.xml";
         reportBuildFile = path.join(buildRootPath, reportBuildFileName);
-        var summaryFileName = "coverage.xml";
-        summaryFile = path.join(buildRootPath, reportDirectoryName);
-        summaryFile = path.join(summaryFile, summaryFileName);
+        var summaryFileName = "";
+        if (ccTool.toLowerCase() == "jacoco") {
+            summaryFileName = "summary.xml";
+        }else if (ccTool.toLowerCase() == "cobertura") {
+            summaryFileName = "coverage.xml";
+        }
+        summaryFile = path.join(buildRootPath, reportDirectoryName, summaryFileName);
         var coberturaCCFile = path.join(buildRootPath, "cobertura.ser");
         var instrumentedClassesDirectory = path.join(buildRootPath, "InstrumentedClasses");
 
@@ -263,7 +268,7 @@ async function doWork() {
         var ccTool = tl.getInput('codeCoverageTool');
         var isCodeCoverageOpted = (typeof ccTool != "undefined" && ccTool && ccTool.toLowerCase() != 'none');
         var buildRootPath = path.dirname(antBuildFile);
-        
+
         var summaryFile: string = null;
         var reportDirectory: string = null;
         var ccReportTask: string = null;

Tasks/ANT/task.json

@@ -13,7 +13,7 @@
     "version": {
         "Major": 1,
         "Minor": 0,
-        "Patch": 55
+        "Patch": 56
     },
     "demands": [
         "ant"

Tasks/ANT/task.loc.json

@@ -13,7 +13,7 @@
   "version": {
     "Major": 1,
     "Minor": 0,
-    "Patch": 55
+    "Patch": 56
   },
   "demands": [
     "ant"

Tasks/Common/codecoverage-tools/cobertura/cobertura.ant.ccenabler.ts

@@ -46,10 +46,8 @@ export class CoberturaAntCodeCoverageEnabler extends cc.CoberturaCodeCoverageEna
 
         tl.debug("Reading the build file: " + _this.buildFile);
 
-        return util.readXmlFileAsJson(_this.buildFile)
-            .then(function (resp) {
-                return _this.addCodeCoverageData(resp);
-            })
+        let buildContent = util.readXmlFileAsDom(_this.buildFile);
+        return _this.addCodeCoverageData(buildContent)
             .thenResolve(true);
     }
 
@@ -68,25 +66,20 @@ export class CoberturaAntCodeCoverageEnabler extends cc.CoberturaCodeCoverageEna
         return ccfilter;
     }
 
-    protected getClassData(): any {
+    protected getClassData(): string {
         let _this = this;
-        let fileset = [];
+        let classData = "";
         let classDirs = _this.classDirs;
 
         if (str(classDirs).isEmpty()) {
             classDirs = ".";
         }
         classDirs.split(",").forEach(cdir => {
-            let filter = {
-                $: {
-                    dir: cdir,
-                    includes: _this.includeFilter,
-                    excludes: _this.excludeFilter
-                }
-            };
-            fileset.push(filter);
+            classData += classData + `
+            <fileset dir="${cdir}" includes="${_this.includeFilter}" excludes="${_this.excludeFilter}" />
+            `;
         });
-        return fileset;
+        return classData;
     }
 
     protected createReportFile(reportContent: string): Q.Promise<void> {
@@ -97,94 +90,70 @@ export class CoberturaAntCodeCoverageEnabler extends cc.CoberturaCodeCoverageEna
         return util.writeFile(reportFile, reportContent);
     }
 
-    protected addCodeCoverageData(pomJson: any): Q.Promise<any[]> {
+    protected addCodeCoverageData(pomJson: CheerioStatic): Q.Promise<any[]> {
         let _this = this;
 
-        if (!pomJson || !pomJson.project) {
+        if (!pomJson || !pomJson("project")) {
             return Q.reject<any>(tl.loc("InvalidBuildFile"));
         }
 
         let reportPluginData = ccc.coberturaAntReport(_this.sourceDirs, path.join(path.dirname(_this.buildFile), _this.reportDir));
         return Q.all([_this.addCodeCoverageNodes(pomJson), _this.createReportFile(reportPluginData)]);
     }
 
-    protected addCodeCoverageNodes(buildJsonContent: any): Q.Promise<any> {
+    protected addCodeCoverageNodes(buildJsonContent: CheerioStatic): Q.Promise<any> {
         let _this = this;
 
-        if (!buildJsonContent.project.target) {
-            tl.debug("Build tag is not present");
+        if (!buildJsonContent("project").children("target")) {
+            tl.debug("Target tasks are not present");
             return Q.reject(tl.loc("InvalidBuildFile"));
         }
 
-        ccc.coberturaAntCoverageEnable(buildJsonContent.project);
-
-        if (!buildJsonContent.project.target || typeof buildJsonContent.project.target === "string") {
-            buildJsonContent.project.target = {};
-        }
+        buildJsonContent("project").prepend(ccc.coberturaAntCoverageEnable());
+        buildJsonContent("project").children("target").each(function (i, elem) {
+            _this.enableForking(buildJsonContent, elem);
+        });
 
-        if (buildJsonContent.project.target instanceof Array) {
-            buildJsonContent.project.target.forEach(element => {
-                _this.enableForking(element);
-            });
-        } else {
-            _this.enableForking(buildJsonContent.project.target);
-        }
-        return util.writeJsonAsXmlFile(_this.buildFile, buildJsonContent);
+        return util.writeFile(_this.buildFile, buildJsonContent.xml());
     }
 
-    protected enableForking(targetNode: any) {
+    protected enableForking(buildJsonContent: CheerioStatic, targetNode: CheerioElement) {
         let _this = this;
-        let coberturaNode = ccc.coberturaAntInstrumentedClasses(path.dirname(_this.buildFile), _this.reportDir);
-        coberturaNode.fileset = _this.getClassData();
         let testNodes = ["junit", "java", "testng", "batchtest"];
-
-        if (targetNode.javac) {
-            if (targetNode.javac instanceof Array) {
-                targetNode.javac.forEach(jn => {
-                    jn.$.debug = "true";
-                });
-            }
+        let buildDir = path.dirname(_this.buildFile);
+        let coberturaNode = ccc.coberturaAntProperties(path.join(buildDir, _this.reportDir), path.dirname(_this.buildFile));
+        let classData = ccc.coberturaAntInstrumentedClasses(buildDir, path.join(buildDir, _this.reportDir), _this.getClassData());
+
+        if (targetNode.children) {
+            targetNode.children.forEach(n => {
+                if (n.name && n.name === "javac") {
+                    n.attribs["debug"] = "true";
+                }
+            });
         }
 
         testNodes.forEach(tn => {
-            if (!targetNode[tn]) {
+            if (!targetNode.children) {
                 return;
             }
 
-            let node = targetNode[tn];
-            _this.enableForkOnTestNodes(node, true);
-            if (node instanceof Array) {
-                node.forEach(n => {
-                    ccc.coberturaAntProperties(n, _this.reportDir, path.dirname(_this.buildFile));
-                });
-            } else {
-                ccc.coberturaAntProperties(node, _this.reportDir, path.dirname(_this.buildFile));
+            targetNode.children.forEach(node => {
+                if (node.name && node.name === tn) {
+                    _this.enableForkOnTestNodes(node);
+                    buildJsonContent("project").children("target").children(tn).prepend(coberturaNode);
+                    buildJsonContent("project").children("target").children(tn).append(ccc.coberturaAntClasspathRef());
+                };
+            });
+            if (buildJsonContent("project").children("target").children(tn)
+                    && (!buildJsonContent("project").children("target").children("cobertura-instrument")
+                        || buildJsonContent("project").children("target").children("cobertura-instrument").length === 0)) {
+                buildJsonContent("project").children("target").children(tn).before(classData);
             }
-
-            targetNode["cobertura-instrument"] = coberturaNode;
         });
     }
 
-    protected enableForkOnTestNodes(testNode: any, enableForkMode: boolean) {
-        if (testNode instanceof Array) {
-            testNode.forEach(element => {
-                if (!element.$) {
-                    element.$ = {};
-                }
-                if (enableForkMode) {
-                    element.$.forkmode = "once";
-                }
-                element.$.fork = "true";
-
-            });
-        } else {
-            if (!testNode.$) {
-                testNode.$ = {};
-            }
-            if (enableForkMode) {
-                testNode.$.forkmode = "once";
-            }
-            testNode.$.fork = "true";
-        }
+    protected enableForkOnTestNodes(testNode: CheerioElement) {
+        testNode.attribs["forkmode"] = "once";
+        testNode.attribs["fork"] = "true";
     }
 }

Tasks/Common/codecoverage-tools/codecoverageconstants.ts

@@ -373,34 +373,34 @@ export function coberturaMavenReport(): Q.Promise<any> {
 }
 
 export function jacocoAntReport(reportDir: string, classData: string, sourceData: string): string {
-    return `
-      <?xml version='1.0'?>
-        <project name='JacocoReport'>
-               <target name='CodeCoverage_9064e1d0'>
-                  <jacoco:report xmlns:jacoco='antlib:org.jacoco.ant'>
-                      <executiondata>
-                         <file file='${path.join(reportDir, "jacoco.exec")}'/>
-                      </executiondata>
-                      <structure name = 'Jacoco report'>
-                            <classfiles>${classData}</classfiles>
-                            <sourcefiles>${sourceData}</sourcefiles>
-                      </structure>
-                      <html destdir='${reportDir}' />
-                      <csv destfile='${reportDir + path.sep}summary.csv' />
-                      <xml destfile='${reportDir + path.sep}summary.xml' />
-                  </jacoco:report>
-              </target>
-        </project>
+    return `<?xml version="1.0"?>
+<project name="JacocoReport">
+    <target name="CodeCoverage_9064e1d0">
+        <jacoco:report xmlns:jacoco="antlib:org.jacoco.ant">
+            <executiondata>
+                <file file="${path.join(reportDir, "jacoco.exec")}"/>
+            </executiondata>
+            <structure name="Jacoco report">
+                <classfiles>${classData}</classfiles>
+                <sourcefiles>${sourceData}</sourcefiles>
+            </structure>
+            <html destdir="${reportDir}" />
+            <csv destfile="${reportDir + path.sep}summary.csv" />
+            <xml destfile="${reportDir + path.sep}summary.xml" />
+        </jacoco:report>
+    </target>
+</project>
     `;
 }
 
-export function jacocoAntCoverageEnable(): any {
+export function jacocoAntCoverageEnable(reportDir: string): any {
+    let file = path.join(reportDir,"jacoco.exec");
     return {
         $:
         {
-            "destfile": "jacoco.exec",
+            "destfile": file,
             "append": true,
-            "xlmns:jacoco": "antlib:org.jacoco.ant"
+            "xmlns:jacoco": "antlib:org.jacoco.ant"
         }
     };
 }
@@ -424,80 +424,38 @@ export function coberturaAntReport(srcDir: string, reportDir: string): string {
     `;
 }
 
-export function coberturaAntCoverageEnable(buildJsonContent: any): void {
-    let propertyNode = {
-        $: {
-            environment: "env"
-        }
-    };
-    util.addPropToJson(buildJsonContent, "property", propertyNode);
-
-    let pathNode = {
-        $: {
-            id: "cobertura-classpath",
-            description: "classpath for instrumenting classes"
-        },
-        fileset: {
-            $: {
-                dir: "${env.COBERTURA_HOME}"
-            },
-            include: [
-                {
-                    $: {
-                        name: "cobertura*.jar"
-                    }
-                },
-                {
-                    $: {
-                        name: "**/lib/**/*.jar"
-                    }
-                }
-            ]
-        }
-    };
-    util.addPropToJson(buildJsonContent, "path", pathNode);
-
-    let taskdefNode = {
-        $: {
-            classpathref: "cobertura-classpath",
-            resource: "tasks.properties"
-        }
-    };
-    util.addPropToJson(buildJsonContent, "taskdef", taskdefNode);
+export function coberturaAntCoverageEnable(): string {
+    return `
+<property environment="env" />
+<path id="cobertura-classpath-vsts" description="classpath for instrumenting classes">
+    <fileset dir="\${env.COBERTURA_HOME}">
+        <include name="cobertura*.jar" />
+        <include name="**/lib/**/*.jar" />
+    </fileset>
+</path>
+<taskdef classpathref="cobertura-classpath-vsts" resource="tasks.properties" />
+`;
 }
 
-export function coberturaAntInstrumentedClasses(baseDir: string, reportDir: string): any {
-    let ccProperty = {
-        $: {
-            todir: path.join(baseDir, "InstrumentedClasses"),
-            datafile: path.join(baseDir, reportDir, "cobertura.ser")
-        },
-        fileset: []
-    };
-    return ccProperty;
+export function coberturaAntInstrumentedClasses(baseDir: string, reportDir: string, classData: string): any {
+  return `
+<cobertura-instrument todir="${path.join(baseDir,"InstrumentedClasses")}" datafile="${path.join(reportDir,"cobertura.ser")}">
+    ${classData}
+</cobertura-instrument>
+  `;
 }
 
-export function coberturaAntProperties(node: any, reportDir: string, baseDir: string): any {
-    node.sysproperty = {
-        $: {
-            key: "net.sourceforge.cobertura.datafile",
-            file: path.join(baseDir, reportDir, "cobertura.ser")
-        }
-    };
-
-    let classpath = [
-        {
-            $: {
-                location: path.join(baseDir, "InstrumentedClasses"),
-            }
-        }
-    ];
+export function coberturaAntProperties(reportDir: string, baseDir: string): any {
+    return `
+        <sysproperty key="net.sourceforge.cobertura.datafile" file="${path.join(reportDir,"cobertura.ser")}" />
+        <classpath location="${path.join(baseDir,"InstrumentedClasses")}" />
+`;
+}
 
-    if (node.classpath && node.classpath instanceof Array) {
-        node.classpath = classpath.concat(node.classpath);
-    } else {
-        node.classpath = classpath;
-    }
+export function coberturaAntClasspathRef(): string {
+    return `
+        <classpath refid="cobertura-classpath-vsts" />
+`;
 }
 
 // Gradle Coberutra plugin