The role of machine learning in Automated Software Testing...

Coming soon....

Galen Framework for RWD/Layout/Cross Browser Automation

   Automating the layout testing for websites is always a challenging. But is very important in the current industry as the Responsive Web Design has become more popular than ever in the Front End Development. Testing these responsive web application manually is a herculean task as the testing spans across multiple resolutions,devices and browsers. Huge amount of manual effort and infrastructure support is required in order to  cover the above scenarios.

      In the quest of finding out sophisticated tool I had two things in mind. First thing was, tool should be able to integratable with any Selenium based automation frameworks by considering its usage in the industry. Second thing was, tool should be Open source. I was able to find out a very good tool which can be integrated with Selenium named Applitools. But applitools is a Paid tool. I have already shared a post that explains how applitools can be used with selenium framework. You can find the post here.

http://seleniumocean.blogspot.com/2015/08/automated-visual-testing-with-selenium.html

    This time I am going to share a Open source tool which can be used for RWD Layout tests.

    Galen Framework is built on top of selenium. This checks each individual component of the page with another element.The fundamental testing concept in Galen Framework centers on checking the location and size of all page elements relative to each other. This way, you can describe the layout for any browser window’s size and you don’t have to use absolute positioning. Selenium offers functionality for getting location and dimension of element in all browsers. When it comes to testing a responsive layout it works in a following way:

1. Open a page in browser

2. Resize it to specified size

3. Test the layout according to user-defined specs

     Galen allows you to express your expectations towards website layout and then uses selenium to retrieve the information about the page elements. These expectations should be written in a special laguage called GalenSpec language. The Galen Specs language was designed to resemble natural English as closely as possible and has been implemented in a semi-Markdown way. The below link gives you  more details about Galen Spec Language.

http://galenframework.com/docs/reference-galen-spec-language-guide/

    Once your test is completed Galen provides very comprehensive reporting. Galen provides good explanations using Object Definition names in reports when a test failed or passed. You can also have a nice screenshot in a popup after clicking on the failed test.It highlights the failed object on the screenshot. It will show you what's wrong at a glance. These reports would automatically generated under "target/galen-html-reports". But these can also be saved into user specific HTML Reports.

Once you click on any report, it opens the below view with hierarchical details.

  The initial version of Galen Framework was in JavaScript. But now it is supporting Java as well. Here is the sample project with Galen Java API. 

https://github.com/galenframework/galen-sample-java-tests

You can download this project and add your own pages with the Galen Spec Language. This can also be integrated with the existing java and selenium based automation frameworks by its Maven dependency. 

Below are some other features of Galen:

1. We can use it for image comsprison as well with percentage  of tolerance

2. This can be iintegrated with saucelabs for cloud based devices

3. This can be used for internatiolization

4. Galen also tests the Colors of your website

5. Galen is very good for cross browser testing

6. This will fit into the behavior testing processes such as BDD,TDD etc.

Conclusion:

In my personal opinion, this is a very good open source tool for RWD automation. But if you are looking for only layout testing, I would use it for the main lines of a project like the global layout of a given page or when a feature really needs a particular layout. I would recommend using Galen aside your daily tests, it's just another security before going in production. This can also be used by the front end developers before they push code changes to QA. 

Cobertura War Instrumentation and Coverage in a web application

In a day to day work we typically run our tests and presumably check that we are getting the expected results.Our tests may all pass with flying colours, but if we've only tested 50% of the code, how much confidence can we have in it? So a step ahead would be to ensure how much of the application code is exercised by our tests which ensures the quality of the tests that we typically run and thus code coverage comes into picture.

What is Code Coverage?
Code Coverage is a measurement of how many lines/blocks of the application code are executed while the automated/unit tests are running. Though code coverage is a white box testing methodology(as it requires knowledge of and access to the code itself rather than simply using the interface provided), we might come across situations where we need to analyse/collect code coverage metrics for our functional test cases.This post briefs the need of code coverage,coverage analysis,instrumentation for functional test cases with an example using Cobertura.

How is Code Coverage achieved?
Code coverage is collected by using a specialized tool to instrument the binaries to add tracing calls and run a full set of automated/unit tests against the instrumented product. A good tool will give you not only the percentage of the code that is executed, but also will allow you to drill into the data and see exactly which lines of code were executed during particular test. There are many coverage tools in market for Java Code Coverage -Cobertura,Clover,Emma,Jcoverage.In this post we will generate coverage metrics using cobertura -one of the most widely used java coverage tool as it has edge over other tools.

Features of Cobertura:

• Open source Java tool.
• Can be executed from simple ant build script.
• Instruments Java bytecode after it has been compiled.
• Can generate reports in HTML/XML by class name, percent of lines covered, percent of branches covered, etc.
• Shows the percentage of lines and branches covered for each class, each package, and for the overall project.

What is instrumentation?
Instrumentation is all about manipulating the application code by injecting reporting code into strategic positions. In fact, the art of instrumentation falls in either of the two: class instrumentation and source instrumentation. Not surprisingly, the difference is that class instrumentation injects the reporting code directly into compiled .class files while source instrumentation creates an intermediary version of the sources which are then compiled into the final, source-instrumented .class files. Most of the code coverage tools will follow either of these instrumentation techniques.

For this post we are using a sample war file from (https://tomcat.apache.org/tomcat-6.0-doc/appdev/sample/)for instrumentation wherein for real time scenario,this should be replaced with your application war file.

Sample Cobertura War Instrumentation and Coverage in a web application

PreRequisite:

• Tomcat 7 and above
• JDK 1.7 and above
• Ant 1.8 and above
• Cobertura 1.9 and above
• A sample war file for instrumentation/use your application war file

Pre-coverage steps:

• Extract classes from your war.
• Create an ant script for instrumenting the classes.
• Add required libs/dependencies for instrumentation (Sample attached- Refer build.xml and build.properties).

Coverage steps:

• Perform Cobertura instrumentation using your build target as below.
• Now we have instrumented classes generated as below ,Replace the generated files in the war (replace with the existing classes) and cobertura.ser file generated.
• Put your updated war in the tomcat webapps.
• Put your cobertura.ser file in the tomcat bin .
• Add cobertura.jar in the tomcat lib .
• Start your tomcat.
• Hit the required test cases (run ur web application flows either manually or through your automation scripts)
(for this sample war -we are hitting http://localhost:8080/sample home page -this application has Hello page-hello class alone so we are executing a test to hit the hello page)
• Now put the updated cobertura.ser in the project ant home folder

Post-coverage steps:

• Run coverage targets as below.
• Now we have coverage for the test cases that we have run!

Automated Visual Testing with Selenium and Applitools

      UI comparison across multiple resolutions with different dimensions such as Content, Layout, cross browsers is a difficult task with the help of manual testing. 

Why should visual testing be automated:
1. Lot of areas needs to be covered such as browsers, devices, screen resolutions, RWDs etc.
2. Manual visual testing is error prone and time taking.
3. In the process of “Continues Deployment”, it is mandatory that every task should be automated.

In the search of a automated tool for this purpose, many things comes in mind. Particularly, when we think about open source tools, selenium will be the first choice. But we cannot accomplish the task with selenium due to certain limitations such as desktop application support, iOS support, screenshots comparison etc.

Now in Paid tools, there is a tool named applitools which is designed for this particular purpose. The Applitools is the Applitools Eyes automatically validates the correctness of the UI layout, content and appearance on all browsers, devices and screen resolutions, and enables to automate tests that can only be done manually without it. 

Features of Applitools:

• Automated testing of all the visual aspects of your application:
• One simple test validates all the fields on a given screen.No need to write separate test for each UI element on the screen
• Easy integration with existing test automation and ALM frameworks:
• Test automation tools: Selenium, Appium, MS Coded UI, HP QTP (coming soon) and more.ALM tools: HP QC, MS TFS, IBM Rational Quality Manager, Atlassian, Rally and more.Cloud testing environments.
• Seamless testing on multiple platforms, screen-resolutions and form-factors:
• Define expected results or volatile areas for one browser, one screen resolution or one form factor and all tests would automatically be updated in all browsers, all screen resolutions and all form factors. Any change in your application should only be approved once in one specific test and all other tests would automatically be updated for all browsers, all screen resolutions and all form factors
• Visual self-explanatory logs:
• No more reading of complex text-based failure logs.
  Visual test timeline points you immediately to any failed steps.
  Smart visual test playback shows step by step the user actions and the screen displays during a test.

You can find more about applitools from https://applitools.com/

Now in this article we are going to learn about integrating applitools with selenium.

1. Download the latest version of the Eyes Java Selenium SDK from https://store.applitools.com/download/eyes_selenium_java/ and extract it to a folder of your choice. Add the extracted files to your path.
2. When running tests, make sure to use your personal API key: XFkqR77qRm9GZkvw9STuox8gBrECZt298F1101ur39cioY110

Sample code is as below:
public static void main(String[] args) throws URISyntaxException, InterruptedException {
        WebDriver driver = new FirefoxDriver();
        Eyes eyes = new Eyes();
        // This is your api key, make sure you use it in all your tests.
        eyes.setApiKey("XFkqR77qRm9GZkvw9STuox8gBrECZt298F1101ur39cioY110");
        try {
            // Start visual testing with browser viewport set to 1024x768.
            // Make sure to use the returned driver from this point on.
            driver = eyes.open(driver, "Applitools", "Test Web Page", new 
            RectangleSize(1024, 768));
            driver.get("http://applitools.com");
            // Visual validation point #1
            eyes.checkWindow("Main Page");
            driver.findElement(By.cssSelector(".features>a")).click();
            // Visual validation point #2
            eyes.checkWindow("Features page");
            // End visual testing. Validate visual correctness.
            eyes.close();
        } finally {
            // Abort test in case of an unexpected error.
            eyes.abortIfNotClosed();
            driver.quit();
        }
    }
 }
3. after running a test for the first time, it will automatically be saved as a baseline for future test runs. Now run your test again and open Applitools eyes to analyze the changes. For each step either 'Accept New' in    case the changes are expected or 'Keep Baseline' in case the changes reflect a bug.

Advantages of this integration:

• Single page validation replaces hundreds of lines of validation code and hours of manual testing.
• Automatic maintenance – approved changes are automatically propagated to other tests and execution environments.
• Cognitive vision – avoiding false positives, by ignoring differences that are invisible to the human eye.
• Automatically test your app in multiple languages.
• Easily tests complex application pages including dynamic content, size and moving elements.
• It takes the pressure off manual QA and increases the coverage, test faster & more accurately.

This is one of the effective tool to automate Visual Testing in Mobile, Web, Desktop Applications. Happy Testing :) 

Do Makeup to your Jenkins Server

   In continuous Integration Process Jenkins plays a major role in terms of providing a very good platform to perform the task. It gives us the basic requirements such as normal UI, Trend chart. However it is always useful to have comprehensive dash boards, trend charts for better tracking purpose and eye catching UI themes that makes difference. We can also change the email configurations such as Subject lines, body content, including the report into the body of the email etc. For every requirement that is mentioned above, jenkins provides us the plugins. We will tweak those plugins and add the changes that we need. 

HTML Publisher

This plugin is handy with built-in copy to master functionality. Imagine that you have some files generated through your builds that are not actual artifacts. Let’s say logs, execution reports. This plugin lets you to copy them to a master and provide an easy HTML file that will have links to these special files of yours for really quick access.

    To configure this follow the below steps:
1. Click on the Configure option for your Jenkins job.
2. In the post build portion, look for the Publish HTML Reports option and select the check box. See the screen shot below

Fill the path to the directory containing the html reports in the "HTML directory to archive" field. Specify the pages to display (default index.html); you can specify multiple comma-separated pages and each will be a tab on the report page. Finally, give a name in the Report Title field, which will be used to provide a link to the report. By default, only the most recent HTML report will be saved, but if you'd like to be able to view HTML reports for each past build, select "Keep past HTML reports."

Some time at HTML directory, you don't have to specify project name, but have to start one level below. For e.g. if your project name is "ABC" and if HTML files are at "ABC/report-output/html" then you have to specify just \test-output\html\.

3. After saving the configuration, run build once. The published HTML reports are available to view from within Jenkins with convenient links in the dashboard.

Green Balls

Historically Jenkins has used the blue color to denote successful builds. So, all status messages throughout the GUI use blue as the color of success. But if you feel that green is the way to go (Green Hornet, Green Lantern, Gumby, traffic lights, etc) then you can change your preference to green with the Green Balls plugin.

Simple Theme Plugin:
This is a plugin for Jenkins that supports custom CSS & JavaScript.
You can customize Jenkins's appearance (ex. his gentle face on the background) as below:

Navigate to Jenkins > Manage Jenkins > Configure System > Theme
Set URL of theme CSS and JS to URLs of your customized CSS and JS

Some example themes are as below:
http://daniilyar.github.io/Jenkins-themes/themes/canon-jenkins/min/styles.css
http://daniilyar.github.io/Jenkins-themes/themes/canon-jenkins/min/script.js

Wall display Plugin:

A wall display that shows job build progress in a way suitable for public wall displays. Rendering is performed using javascript based on REST API calls, so requires no page refreshes.

After installing the plugin you will get a option on the left hand sidebar.To get it display simply click on the 'Wall Display' link in the sidebar of your project.

Email Extension Plugin:
This plugin allows you to configure every aspect of email notifications. You can customize when an email is sent, who should receive it, and what the email says. 

After installing this, go to the job, which has to configured for mail trigger, Click on “configure”. Go to the postbuild actions, click on “Editable Email Notification”. This will have options like the recipent details etc. Select “HTML(text/Content)” for “Content Type” option. under the Default content text area type the below text as it is though it contains html tags.

Hi All,

 Please find the overall Results of this build as below. You can click on http://10.40.60.186:8080/view/MCS/job/LETSCRETSAutomation/HTML_Report/ for more details.

${FILE,path=”test-output/emailable-report.html”}

Bottom of the line in the above script specifies the path. Change it according to your html path. Remember here, if ur html report depends on any resources like images etc, we have configure them accordingly.

https://wiki.jenkins-ci.org/display/JENKINS/Email-ext+plugin

Dash Board Plugin:
This plugin contributes a new view implementation that provides a dashboard / portal-like view for Jenkins.
The configuration is done in 2 parts, selecting the Jenkins jobs to include in the view, and selecting which dashboard portlets to have included in the view.  The jobs that you select are used for all the portlets to draw their information from. 

 

XPath Writing Techniques and Strategies

Introduction:

        This article illustrates on how we can identify the objects in an Optimized manner using XPath which are reliable and consistent. We observed that there are applications which deal with different kind of objects; not having any id/name(s) and many dynamic objects not having any unique identification. Also there are lots of technologies integrated in an application such as GWT, DOJO, Flash etc which makes it difficult to develop a consistent code.

       

       So handling such complex scenarios and making scripts run successfully, is a big challenge. This article describes accurate methodologies with xpath and Xpath axes to overcome such difficulties.

Basics of XPath :

         In Selenium automation, the XPath is a very powerful way to parse the HTML code of any web page and find out the XPath path for identifying the elements on the web page. If properly used, it can produce very reliable and low maintenance locators. But when used an inefficient xpath, it can lead to very inconsistent results.

         XPath is a syntax for defining parts of an XML document. It uses the path expressions to navigate in XML documents. It is like a small programming language, it has functions, expressions, wild card characters etc. XML documents consist of trees of nodes. The topmost element of the tree is called the root element followed by descendant nodes.

Let’s look into the terminology used to identify these nodes: 

• Each element has one parent except root
• Each element may have zero or one or more child elements referred as child Nodes can have same parent called siblings. Among siblings, the nodes which are to the immediate left are referred as preceding-sibling and other left nodes as preceding. The nodes to the immediate right are referred as following-sibling and other right nodes are referred as following.
• A nodes parent, parent’s parent is referred as Ancestor
• A nodes children, children’s children is referred as Descendant

XPath Axes:

An axis defines a node-set relative to the current node.

Following example explains the various facets of Xpath identification

 

In the above example we illustrate by considering Employee2 as node for reference for referring to other nodes

Employee2 node has

• Employee3 as following sibling
• Employee1 as Preceding sibling.

For Employee2,

• Manager1 is the parent
• Department is the ancestor (Parent of Parent).

For Employee2,

• Section is the Child node
• Employee4 and Employee5 are Descendant nodes

Optimization of XPath

         We observed that there many cases where simple changes are made to the application and previously identified XPath Statements won’t work. In order to avoid such problems, it’s necessary to optimize the XPath Statements before using them in Selenium Automation.

         The Advantage of Optimizing the Xpath Statements are to get the shortest and least breakable XPath Statements.

Following are the few strategies in order to optimize the XPath:

1. Use id attribute if available
2. Use the combination of attributes to make the XPath more specific
3. Use the Relative XPath instead of Absolute XPath Statements
4. Always avoid using indexes in Xpath.
5. Verify the xpath using Selenium IDE commands
6. Using … to move to parent of the present node
7. Use XPath functions in XPath wherever necessary to better identification
8. Identification of objects with same attribute values
9. Don't identify the images using src or alt attributes
10. Handling dynamic attribute Values
11. Handling multiple Xpaths for a single object

Let’s look into each of them in detail:

Consider the following XML example “Example1” for illustration of these strategies

Example-1

</pre>

<table>

<tbody>

<tr id="item1">

<td class="name item">Mp3 Download: foobar.mp3</td>

<td class="name item">

<input class="name item form field disabled" type="text" name="qty" />

</td>

</tr>

<tr id="item2">

<td class="name item">Mp3 Player</td>

<td class="name item">

<input id="item2_quantity" class="name item form field required" type="text" name="qty"/>

</td>

</tr>

</tbody>

</table>

<pre>

Use ID attribute if available

If the ID attribute is present for an object, use it in XPath even though the object can be identified with any other attributes. ID attribute should have the highest priority. For example : Based on Example1, It can be used as

//tr*@id=’item1’+

@ symbol indicate following is an attribute of the object.

Use combination of attributes in XPath

If ID attribute is not available, any other attribute which uniquely identifies the object can be used. Also combination of 2 or more attributes can be used to identify the object such as name, type, class, value etc. This will make the XPath more specific. For example, based on Example1, we can have

//input*@type=’text’ and @name=’qty’+

In the above example Boolean operator ‘and ‘operator is used in XPath statement to combine more than one attributes.

Using combination of properties in XPath is useful in following cases

There are cases where there does not exist any single attribute which uniquely identify the object

 Even if there is exist single attribute which uniquely identifies the object, we can use combination of attributes to make Xpath more robust and hence there is less chances of failure in identification.

Use Relative XPath instead of Absolute Xpath

Absolute Path refers that Xpath starts from root i.e. from ‘/’ to till the desired html element is reached such as /html/body/p[2].

Relative path refers to the Xpath that starts from specific point to the desired element. It starts with ‘//’.

It is always recommended to use Relative Xpath then Absolute xpath for following reasons.

• Absolute Xpath will be very long compare to Relative xpath and hence difficult to manage
• In case of Absolute Xpath , there are high chances that Xpath may break even if there are small changes introduced
• Absolute Xpath has the disadvantage of typing the expression to a particular input structure

For example, based on Example1, we can have an absolute path as follows

/pr/table/tbody/tr*@id=’item1’+

Using Relative path we can have

//tr*@id=’item1’+

Avoid Using Indexes in XPath

In XPath always avoid using indexes to identify a specific node. These are not reliable and with slightest modification xpath may break.

Let us see example Exmaple1:

You can target the highlighted input field using

xpath=//table/tr[2]/td/input

xpath=(//table[@name='cart']//input)[2]

xpath=//input[@id='item2_quantity']

xpath=//input[contains(@class='required')]

 xpath=//input[contains(@class='required')] and @type='text']

As you can guess, the first two expressions are not as reliable as others. Of these //table/tr[2]/td/input is the worst because it would break even with slight modifications to the page structure. In any case do not rely on tools, including selenium IDE, to generate the right xpath expression for you – they are usually the worst.

It always advisable to code the Selenium test to find that item in relation to an existing item that *has* been programmed properly rather than to rely on meaningless indexes. This means, when reading through your script you are more likely to understand where

//input[@id='BottomTotal']/following-sibling::input[contains(@value,'Add')]

is compared to

//li[6]/input[4].

This becomes more obvious when you have a large number of tests in your test suite.

Verify the xpath using Selenium IDE commands

Once Xpath is formed, verify it using Selenium IDE. There are cases where a specific Xpath may satisfy two or more objects. Use “highlight” command in Selenium IDE to highlight the intended object. This will ensure that Xpath is accurate.

Further we can also use “click”, “verifyVisible” , “type” etc. command in selenium IDE to verify the object.

It is advisable to use both “highlight” as well as “verifyVisible” commands to verify the as some of the objects may successfully highlight but not visible.

“click” command can be used for objects such as “Button” and “type” can be used to type the characters into a text box.

Using .. (double dot symbol) to move to parent of the present node:

Assume that you are in a specific node and want to move to parent of that node then it is advisable to use .. (double dot symbol) to navigate to parent node then using Parent::<node

type> or ancestor::<node type>. This will reduce the length of the XPath and identification of node faster during execution.

In XPath . (a Single dot) refers to present node and ..(a double dot) refers to parent of present node. Consider the following example

Based on Example1, the parent of the node td i.e. tr can be reached using

//td*@class=’name item’+/../*@id=’item1+

Use XPath functions in XPath wherever necessary to better identification

As XPath is a Programming Language, it has many built-in functions which we can use in Xpath Statements. During selenium automation, sometime there are problems of identifying the objects on a page which have same attributes there is no way of distinguishing them. In such cases XPath function comes very handy

Some of the XPath functions used are:

Position() –This function is for locating specific html tag such as //input[position()=5] to locate 5th element

Last() – This function is for locating last element node of the specific node type such as //input[last()].

Further it can be specified as //input[last()-1] to identify an node before the last node

Starts-with()- This is one of the predefined methods of XPath Language which is used in XPath Statements to locate the element starting with the specified text or to locate the element node containing an attribute value which is starting with the specified text.

For Example

//div[starts-with(text(),’Approver’)+ -Matches the element with string which begins with ‘Approver’

//div[starts-with(@id,’test’)+ – Matches the element with attribute begins with string ‘test’

Contains () –This is one of the predefined methods of XPath Language which is used in XPath Statement to locate the element node containing specified text on the page or to locate the element node containing specific text in its attribute value.

For example

//span*contains(text(),’Approver’)+—Matches any element with text contains the string ‘Approver’

//span*contains(@id,’testing’)] – Matches any element with id attribute containing string ‘testing’

Identification of objects with same attribute values

There are cases were two objects have same attribute value in a specific web page. In such cases identify a nearby object with unique identification and then navigate to intended object.

Consider the following example:

In the below example there are 2 checkboxes with same name as resendChkBox, so to identify such cases we can initiate relative X-Path with Escalation Rule value and proceed to that checkbox object.

//td[text()='Escalation Rule #1']/parent::tr/following-sibling::tr/descendant::span/input[@name='resendChkBox']

//td[text()='Escalation Rule #2']/parent::tr/following-sibling::tr/descendant::span/input[@name='resendChkBox']

Don't identify the images using src or alt attributes

The objects of type Image can be usually identified by src and alt attributes such as

//img[contains(@src,'cancel')]

//img[@alt='Search']

But it is not suggestable to use src or alt as these two attributes does change quite frequently.

Handling dynamic attribute Values

If we need to use value of an attribute which is dynamic, then we can use Selenium.getAttribute or selenium.getText or any other methods to fetch the values and use it in a XPath

As for example:

String fetchText=selenium.getAttribute("//a[contains(text(),'click')]/@href")

In this case the value of href attribute will be stored in a variable fetchText .

Similarly in the following case the the text value of element with name containing ‘testing’ will be stored in the variable p.

String p=selenium.getText("//p*contains(@name,’testing’)+")

Handling multiple Xpaths for a single object

        Consider the below scenario, where the home page of the application is having multiple versions(Ex: Version A, Version B, Version C etc) and it displays random version of the page depending upon server hit. Now the test scenario is to check the Logo of the company. This logo is under <div> in Version A, <img> in version B, <span> in Version C. As we are not sure of the page when we hit the URL, it is difficult to identify the logo object.

       To handle such scenario, we have '|' (pipe) symbol. Using this, we can combine more than one xpath for a single object. For the above explained scenario Xpath looks like as below:

//div[contains(something)]|//image[something]|//span[something]

Some Illustration on usage of XPath

//a[text()='ApproverName']/ancestor::td/preceding-sibling::td/input

//span[text()='Confirmation Instructions:']/ancestor::td/following-sibling::td/descendant::a/img

//div[text()='Send Reminder Every']/parent::td/following-sibling::td/descendant::td/select

//td[text()='Escalation Rule #1']/../following-sibling::tr/descendant::td/div[contains(text(),' Use for the first')]/input

             Though this articles gives the clear information about the usage of keywords and their examples, the scenarios which makes us strong in using these keywords.

Generating HTML Alerts Report through ZAP API

In our previous post we have seen how to use ZAP API for automated security testing. This post deals with generating the alert report.

When the user automates the security testing, he/she looks for below kind of reporting.

• alerts based on id 
• alerts for the baseurl
• html consolidated report 

    
        With the help of getAlerts() method of zaproxy class, we can generate the alerts based on id and url. For generating the consolidated report, API doesn't support HTML report generation as it does by ZAP tool. But it generates xml report. As a work around we can generate this xml report and convert that into HTML with the help of XSLT file.

Users can get the XSLT file from the below path:
https://code.google.com/p/zaproxy/source/browse/trunk/src/xml/report.html.xsl

The below code snippet will be handy in converting xml report into HTML report
        public void generateHTMLReport() throws ClientApiException, TransformerException, IOException{
TransformerFactory tFactory=TransformerFactory.newInstance();
InputStream is = ZAProxyScanner.class.getResourceAsStream("<XSLT REPORT PATH>");
Source xslDoc=new StreamSource(is);
Source xmlDoc=new StreamSource(new ByteArrayInputStream(clientApi.core.xmlreport("")));
OutputStream htmlFile=new FileOutputStream("<PATH TO GENERATE HTML>");
Transformer trasform=tFactory.newTransformer(xslDoc);
trasform.transform(xmlDoc, new StreamResult(htmlFile));
htmlFile.close();
         }


Happy Testing :)