Understanding the Internals of an AI Chatbot

                                 AI chatbots have become an integral part of our digital experience, assisting users in customer support, content generation, and even general conversations. But have you ever wondered how these chatbots work behind the scenes? 

In this article, we’ll break down the internals of an AI chatbot, covering its key components and how it processes user inputs to generate meaningful responses.

Core Components of an AI Chatbot:

An AI chatbot comprises of several key components that work together to understand and generate human-like responses.

• Natural Language Processing (NLP):  NLP is the backbone of chatbot intelligence. It enables the bot to understand, interpret and generate human language. NLP is composed of several subcomponents:

• Tokenization: Breaking down sentences into individual words or tokens.
• Part-of-Speech Tagging (POS): Identifying the grammatical type of each word.
• Named Entity Recognition (NER): Recognizing important entities like names, dates and locations.
• Sentiment Analysis: Detecting the emotion behind the text
  
  

• Machine Learning Models: Most modern chatbots use machine learning models trained on large datasets of conversations. These models help the bot learn context, grammar and response generation. Some popular models are:

• Rule-Based Models: These respond to inputs based on defined patterns/keywords.
• Retrieval-Based Models: Selecting the best response from a set of predefined responses.
• Generative Models: AI models such as GPT that generate responses dynamically based on context.
  
  

• Dialog Management System: This system make sure that conversations flow logically. It keeps track of context, user preferences and previous interactions to provide clear and relevant responses.

• Backend & APIs: Backend consists of servers, databases and APIs that store conversation history, integrate with external systems and process requests efficiently.

How an AI Chatbot Processes a User Query:

When an user interacts with chatbot, the below process happen behind the scenes:

• User Input: The user types a query.
• Preprocessing: The input text is cleaned and prepared.
• NLP Understanding: The chatbot extracts intent, context and key information.
• Passing Input to LLM: The processed text is sent to the LLM (Large Language Model).
• LLM Generates a Response: The model predicts the most relevant response using deep learning techniques.
• Postprocessing: The generated response is refined.
• Sending the Response: The chatbot displays the response to the user.

Challenges in Building an AI Chatbot:

Developing a AI chatbot comes with lot of challenges like:

• Understanding Complex Queries: Handling ambiguous or multi-intent queries.
• Context Retention: Maintaining long-term conversational context.
• Bias and Ethical Concerns: Avoiding biases in response and ensuring responsible AI use.
• Integration with External Systems: Seamless connection with databases and APIs for accurate and relevant responses.

Future of AI Chatbots:

With advancements in deep learning, AI chatbots are becoming more sophisticated. Future trends include:

• More Human-Like Conversations: Improved emotional intelligence and personalization.
• Multimodal Capabilities: Combining text, voice and images for better interactions.
• Autonomous AI Agents: Self-learning bots that adapt to user preferences dynamically.

Techniques to Improvise LLMs and thier differences

                                                 As large language models (LLMs) keep transforming natural language processing (NLP), their capabilities can be further enhanced through specialized techniques that enhance accuracy, flexibility, and contextuality to boost their capabilities further. Although LLMs are strong enough by themselves, augmenting techniques such as Retrieval-Augmented Generation (RAG), fine-tuning, and other advanced methodologies can optimize the performance for targeted applications. These methods enable models to tap external knowledge, adapt to new domains, and return more accurate, contextually intelligent outputs. 

This blog discusses multiple methods, including RAG, CAG (Context Augmented Generation), KAG (Knowledge Augmented Generation), and fine-tuning by which LLMs can be extended and broadened in function, with descriptions of how each works and under what circumstances best to use them.

Large Language Models - LLM on Local Machine

                        Large Language Models (LLMs) have revolutionized AI by enabling machines to understand and generate human-like text. While major companies are offering these models over cloud, many users are exploring the benefits of running LLMs on locally on their machines, especially when privacy, cost-efficiency, and data control are key considerations. Running LLMs traditionally requires powerful GPUs, tools like Ollama make it possible to run models locally on your machine, even with just a CPU.

Let's explore how to use Ollama on a local machine via the command line (CLI), without writing any code, and discuss the advantages of running LLMs locally using only CPUs.

Why run LLMs locally on your CPU?

Running LLMs on a CPU offers several key benefits, especially when you do not have access to high-end GPUs:

1. Cost Efficiency

• Cloud-based APIs can incur significant costs, particularly if you're running models regularly. By running the model locally, you eliminate the costs.

2. Privacy and Security

• Keeping all data processing local ensures that sensitive information doesn’t have to leave your machine, protecting your privacy and offering full control over your data.

3. Flexibility and Control

• Running an LLM locally on your machine gives you the freedom to customize it for specific use cases without being constrained by cloud service terms or API limitations. You can use it in your preferred workflow and modify it as needed.

4. Zero Latency

• By using a local installation, you avoid delays that come from network calls to cloud services, giving you near-instant access to the model.

Ollama

Ollama is a simple, user-friendly tool that allows you to run pre-trained language models locally on your machine. Ollama is optimized for both CPU and GPU usage, meaning you can run it even if your machine doesn’t have powerful GPU hardware. It abstracts the complexity of setting up models and running them, offering a clean command-line interface (CLI) that makes it easy to get started.

Setting up Ollama:

Step 1:

• Visit the Ollama website to download the installer for your platform (Windows, macOS, or Linux).
• Follow the installation instructions provided for your operating system.

Once installed, you’ll have access to the ollama command directly in your terminal.

Step 2: 

• Open the terminal and check the ollama installation with the below command

• ollama --version

  
  
  This confirms that ollama is installed properly.
• Pull any locally deployable model like llama 3.2 

• ollama pull llama3.2:1b 

  
  
  
  
  
• List the models downloaded in the local system

• ollama list

  
  
  
• Run the model and start the conversation with ollama

• ollama run modelname

  
  
  
  

Useful Ollama Commands:

Comamnd	Description
ollama serve	Starts Ollama on your local system.
ollama show	Displays details about a specific model, such as its configuration and release date
ollama run	Downloads the specified model to your system.
ollama list	Lists all the downloaded models
ollama ps	Shows the currently running models
ollama stop	Stops the specified running model
ollama pull	Pulls the specified model to the local system
ollama rm	Removes the specified model from your system
bye	Exit the ollama conversation

Challenges and Limitations of running LLMs locally on CPUs

While running LLMs locally with Ollama has many advantages, there are some limitations to keep in mind:

• Performance on CPUs: Running large models on CPUs can be slower than using GPUs. Although Ollama is optimized for CPUs, you may still experience slower response times, especially with more complex tasks.

• Memory Usage: LLMs can consume a lot of memory, and running them locally may require a significant amount of RAM. Ensure that your machine has at least 16 GB of RAM for decent performance. Larger models will require more memory, which could lead to slowdowns or crashes on systems with limited resources.

• Model Size: Some larger models, such as GPT-3, may not be practical to run on a CPU due to their massive size and resource requirements. Ollama offers smaller models that are more feasible to run on CPU-based machines, but for the largest models, you may still need a GPU for optimal performance.

Conclusion:

Ollama makes running LLMs locally on a CPU simple and accessible, offering an easy-to-use CLI for tasks like text generation and question answering, without needing code or complex setups. It lets you run models efficiently on various hardware, providing privacy, cost savings, and full data control.

How to Deploy Selenium grid on AWS / Amazon EKS

  

                                    Selenium Grid is good for parallel execution but maintenance is a nightmare in an era where you see a frequent upgrades to browsers and corresponding drivers. No sooner the usage of automation framework / selenium grid increases, scalability and maintenance becomes a challenge. To address such issues, we do have solutions based on dockers, docker swarm etc. Having said that, there are some caveats in scaling, managing container health etc.

Below solution would try to address most of them. Major chunks of the solution include Selenium, Zalenium, Docker, Kubernetes and Amazon EKS.

This article would outline the process of deploying Selenium grid(Zalenium) on AWS (Amazon EKS) using Kubernetes and Helm.

What do we achieve with this setup..?

• Scalability: EKS can scale the nodes and pods as per the given configuration.
• Visibility: Zalenium provides a feature to view the live executions on the containers.
• Availability: Amazon EKS cluster makes selenium grid available all the time.
• Maintenance: Low maintenance as the containers are destroyed after each execution.

Pre-requisites:

• An active Amazon AWS account.
• IAM user is created in AWS account
• AWS CLI is connected to AWS account providing the user credentials using local powershell or any terminal
                                                              OR
• Use AWS cloudshell which is automatically connected to logged in account.
• Install AWS CLI (for local terminal), kubectl, helm in the given order.

Lets Get Started!

Once the above pre-requisites are met, next task to deploy any application on kubernetes is to create a kubernetes cluster. There are different ways to create a cluster on AWS, I'll brief couple of ways to achieve the same.

First, Create cluster from AWS GUI.

1. Create master node or cluster 

• Open Amazon EKS console
• Choose Create Cluster
• Provide details like cluster name, k8s version, role
• Select VPC, security groups, endpoint access
• Further steps as shown on GUI which will make 'master' ready.

2. Create worker nodes and connect to the above created cluster.

• Create Node Group (Amazon EC2) instances.
• Choose the cluster, to which the above node group should get attached.
• Select security group, resources etc.,
• Define min and max number no. of nodes.

Sounds complex?. No issues, there is another simple and efficient way to make the whole process look simple.

Second, Create cluster using eksctl (The official CLI for Amazon EKS)

The above complex task can be achieved with a single command.

How to Deploy Selenium grid on Google Cloud Platform using Kubernetes and Helm

                                          

                                        It is a open secret that Selenium Grid maintenance is a nightmare in an era where you see a frequent upgrades to browsers and corresponding drivers. No sooner the usage of automation framework / selenium grid increases, scalability and maintenance becomes a challenge. To address such issues, we do have solutions based on dockers, docker swarm etc. Having said that, there are some caveats in scaling, managing container health etc.

Below solution would try to address most of them. Major chunks of the solution include Selenium, Zalenium, Docker, Kubernetes and Google Cloud Platform.

This article would outline the process of deploying Selenium grid(Zalenium) on Google cloud platform using Kubernetes and Helm.

What do we achieve with this setup..?

• Scalability: GCP/GKE can scale the nodes and pods as per the given configuration.
• Visibility: Zalenium provides a feature to view the live executions on the containers.
• Availability: GKE kubernetes cluster makes selenium grid available all the time.
• Maintenance: Low maintenance as the containers are destroyed after each execution.

Pre-requisites:

• An active Google Cloud Platform account
• Enable Kubernetes engine by setting up a Billing Account.

How to setup Selenium Grid using Docker Desktop - Windows

                            Selenium Grid has made the test automation execution much faster and smarter. The excessive usage of selenium grid has its own hitches like too much of system resource utilization, all browsers to be installed on the system etc. 

With the introduction of docker images for selenium, made the life of testers lot easier. Out of multiple ways to bring up selenium grid with docker, I would choose the simple & quick way to bring up using docker-compose.

Pre-requisite: Docker desktop for windows is installed.

Steps to bring up Selenium Grid:

• Pull required version of selenium hub and nodes using the command "docker pull" as below

         docker pull selenium/node-chrome-debug:3.141.59 

• Create a yaml file with the below docker-compose instructions.

• run the command 

         docker-compose -f docker-compose.yml up -d

Dockers and Kubernetes Cheat sheet

Below are list of frequently used commands. This would come very handy while working with docker & kubernetes.

Docker & Kubernetes Commands 

How to create and execute Jmeter script using Java

Performance Test!. When we say this term, one of the first things that gets into our mind is 'Jmeter'.

           Jmeter is the go-to tool for the performance testing needs in open source community. It is built completely using Java, designed to perform load test and measure performance. It can simulate load on a server, group of servers, network to check the threshold limit and analyze performance under different types of loads. Vast list of plug-ins which extends jmeter capabilities and making it handle most of the performance test requirements.

Mostly the Jmeter GUI is used to create the scripts, configure the users, capture other details and execute the scripts. But, when it comes to integrate the performance tests to code driven automation frameworks, one has to switch to Jmeter GUI to create scripts & fallback to framework to execute the jmeter scripts. In order to make the integration seamless, Jmeter scripts can be created & executed during runtime using code driven framework. Below code snippet would lead you to achieve the same.

Below snippet will let you create a jmeter script (jmx) for a webservice by adding minimal elements to test plan. Typical hierarchy of a web request in a jmx would be as below:

 Test Plan à Thread Group à Sampler à Assertions à Listeners 

Steps:

• Create a maven project through eclipse or any IDE.
• Add the below Jmeter dependencies in your POM file:
• ApacheJMeter_core
• ApacheJMeter_components
• ApacheJMeter_http
• jorphan
• ApacheJMeter_java
• Create a class named "APITest" and copy the below code snippet
• Change the service details & file locations accordingly.
• DONE..! You are all set to create and run the jmeter script from java.

import java.io.File;
import java.io.FileOutputStream;
import org.apache.commons.io.FileUtils;
import org.apache.jmeter.config.Arguments;
import org.apache.jmeter.config.gui.ArgumentsPanel;
import org.apache.jmeter.control.LoopController;
import org.apache.jmeter.control.gui.LoopControlPanel;
import org.apache.jmeter.control.gui.TestPlanGui;
import org.apache.jmeter.engine.StandardJMeterEngine;
import org.apache.jmeter.protocol.http.control.gui.HttpTestSampleGui;
import org.apache.jmeter.protocol.http.sampler.HTTPSamplerProxy;
import org.apache.jmeter.report.config.ConfigurationException;
import org.apache.jmeter.report.dashboard.ReportGenerator;
import org.apache.jmeter.reporters.ResultCollector;
import org.apache.jmeter.reporters.Summariser;
import org.apache.jmeter.save.SaveService;
import org.apache.jmeter.testelement.TestElement;
import org.apache.jmeter.testelement.TestPlan;
import org.apache.jmeter.threads.ThreadGroup;
import org.apache.jmeter.threads.gui.ThreadGroupGui;
import org.apache.jmeter.util.JMeterUtils;
import org.apache.jorphan.collections.HashTree;

public class APITest {
	
    public void createAndExecute() {
		File jmeterHome = new File("C:/apache-jmeter");
		try {
			if (jmeterHome.exists()) {
				// JMeter Engine
				StandardJMeterEngine jmeter = new StandardJMeterEngine();
				setconfig(jmeterHome, "./htmlreportsdir");

				// JMeter Test Plan, basic all u JOrphan HashTree
				HashTree testPlanTree = new HashTree();
				// HTTP Sampler
				HTTPSamplerProxy httpSampler = new HTTPSamplerProxy();
				httpSampler.setName("HTTP Sampler");
				httpSampler.setProtocol("https");
		        httpSampler.setDomain("testjmeter.com");
		        httpSampler.setPort(8080);
		        httpSampler.setPath("/getservicepath");
		        httpSampler.setMethod("GET");
		        httpSampler.setProperty(TestElement.TEST_CLASS, HTTPSamplerProxy.class.getName());
		        httpSampler.setProperty(TestElement.GUI_CLASS, HttpTestSampleGui.class.getName());
		        httpSampler.setEnabled(true);
		        
		        httpSampler.addArgument("Arg1","val1");//Arguments
		        httpSampler.addArgument("Arg1","val1");//Arguments
		        
		        httpSampler.addNonEncodedArgument("", "serviceBody", "=");//payload
	        	httpSampler.setPostBodyRaw(true);
	        	
				//Loop Controller
				LoopController loopController = new LoopController();
		        loopController.setLoops(1);
		        loopController.setFirst(true);
		        loopController.setProperty(TestElement.TEST_CLASS, LoopController.class.getName());
		        loopController.setProperty(TestElement.GUI_CLASS, LoopControlPanel.class.getName());
		        loopController.initialize();
		        
				//Thread Group
				ThreadGroup threadGroup = new ThreadGroup();
		        threadGroup.setName("API Thread Group");
				threadGroup.setNumThreads(20); //Users
		        threadGroup.setRampUp(10); //Seconds
		        threadGroup.setSamplerController(loopController);
		        threadGroup.setProperty(TestElement.TEST_CLASS, ThreadGroup.class.getName());
		        threadGroup.setProperty(TestElement.GUI_CLASS, ThreadGroupGui.class.getName());
		        
		        threadGroup.setIsSameUserOnNextIteration(true);
		        threadGroup.setScheduler(false);
				
				//Test Plan
				TestPlan testPlan = new TestPlan("JMeter Script From Java Code");
		        testPlan.setProperty(TestElement.TEST_CLASS, TestPlan.class.getName());
		        testPlan.setProperty(TestElement.GUI_CLASS, TestPlanGui.class.getName());
		        testPlan.setUserDefinedVariables((Arguments) new ArgumentsPanel().createTestElement());
				
				//Construct Test Plan from previously initialized elements
				testPlanTree.add(testPlan);
				HashTree threadGroupHashTree = testPlanTree.add(testPlan, threadGroup);
				threadGroupHashTree.add(httpSampler);

				// save generated test plan to JMeter's .jmx file format
				String jmxFilePath = "./jmxfiles/TestAPI.jmx";
				SaveService.saveTree(testPlanTree, new FileOutputStream(jmxFilePath));

				// add Summarizer output to get test progress in stdout like:
				String jtlFilePath = ".jtlFiles/TestAPI.jtl";
				ReportGenerator reportGenerator = setReportInfo(testPlanTree, jtlFilePath);
				
				//Run Test Plan
				jmeter.configure(testPlanTree);
		        jmeter.run();
		        
				// Report Generator
				FileUtils.deleteDirectory(new File("./htmlreportsdir"));// delete old report
				FileUtils.deleteDirectory(new File("./reportsdir"));// delete old report
				reportGenerator.generate();

				System.out.println("Test completed. See " + jtlFilePath + " file for results");
				System.out.println("JMeter .jmx script is available at " + jmxFilePath);
				
			} else {
				System.out.println("Jmeter Home not found..");
			}

		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
	}
    
	public void setconfig(File jmeterHome,String htmlrepDir){
		File jmeterProperties = new File(jmeterHome.getPath() +"/bin/jmeter.properties");
        //JMeter initialization (properties, log levels, locale, etc)
        JMeterUtils.setJMeterHome(jmeterHome.getPath());
        JMeterUtils.loadJMeterProperties(jmeterProperties.getPath());
        JMeterUtils.initLocale();
        
        //Set directory for HTML report
        JMeterUtils.setProperty("jmeter.reportgenerator.exporter.html.property.output_dir",htmlrepDir);
	}
	
	
	public ReportGenerator setReportInfo(HashTree testPlanTree,String jtlFilePath) throws ConfigurationException{
		Summariser summer = null;
        String summariserName = JMeterUtils.getPropDefault("summariser.name", "summary");
        if (summariserName.length() > 0) {
            summer = new Summariser(summariserName);
        }
        
        // Store execution results into a .jtl file
        File logFile = new File(jtlFilePath);
        //delete log file if exists
        if (logFile.exists()){
            boolean delete = logFile.delete();
            System.out.println("Jtl deleted: " + delete);
        }
        
        //Summary Report
        ResultCollector logger = new ResultCollector(summer);
        logger.setEnabled(true);
        logger.setFilename(logFile.getPath());
        //creating ReportGenerator for creating HTML report
        ReportGenerator reportGenerator = new ReportGenerator(jtlFilePath, logger); 
        testPlanTree.add(testPlanTree.getArray()[0], logger);
         
	return reportGenerator;
	}
		
}

How to establish a connection to Remote Host & Copy file

Many times we do get the requirement, to connect a remote server & perform operations like copying a file from local to remote, vice versa and many others. But, have you ever thought how do we do that through java.? Yes, We can. Java has multiple libraries which can perform this task. One such java library which can perform this task is Jcraft's 'JSch (Java Secure Channel)' . 

Below example will let you know how to connect a remote host & perform copy operations.

public void copyFiletoRemotehost(String username,String pwd,String[] remotehosts, String port) {
        Session jschSession = null;
        int SESSION_TIMEOUT = 10000;
        final int CHANNEL_TIMEOUT = 5000;
        String REMOTE_HOST = "";
        int REMOTE_PORT = 22;
		
	String lFile = "C:/localhost/local.txt";
        String rFile = "/localtoRemote.txt";
        try {
            JSch jsch = new JSch();
            for(int i=0; i < remotehosts.length; i++) {
            	REMOTE_HOST = remotehosts[i].toString();
            	jschSession = jsch.getSession(username, REMOTE_HOST, REMOTE_PORT);

                //Remove known_hosts requirement
                java.util.Properties config = new java.util.Properties();
                config.put("StrictHostKeyChecking", "no");
                jschSession.setConfig(config);
                
                //authenticate using password
                jschSession.setPassword(pwd);
                jschSession.connect(SESSION_TIMEOUT);
                Channel sftp = jschSession.openChannel("sftp");
                sftp.connect(CHANNEL_TIMEOUT);

                ChannelSftp channelSftp = (ChannelSftp) sftp;
                channelSftp.put(lFile, rFile);
                channelSftp.exit();
                
                //Copy from one location to another with remote server
                copyFile(jschSession);
                jschSession.disconnect();
            }
        } catch (JSchException | SftpException e) {
            e.printStackTrace();
        } finally {
            if (jschSession != null) {
                jschSession.disconnect();
            }
        }
    }
    
    /**
    * This method will let you copy from one folder to another within the remote server
    */
    public static void copyFile(Session jschSession) throws JSchException {
	String cmd1 = "cp C:/username/localtoRemote.txt  C:/anotherfolder/localtoRemote.txt";
	Channel exec = jschSession.openChannel("exec");
		
	ChannelExec channelExec = (ChannelExec) exec;
	channelExec.setCommand(cmd1);
	exec.connect(CHANNEL_TIMEOUT);
	channelExec.setErrStream(System.err);
   }

References:

http://www.jcraft.com/jsch/

Hybrid App Automation using Appium

In the Mobile world, we see multiple types of apps namely Native App, Hybrid App & the browser based application, Web App. Also, we see multiple types of operating systems like Android, iOS, Windows, Firefox OS etc.

Automated testing of these many variation of apps, is very tricky & difficult task. Not all of them are supported by single automation tool. Having said that, Appium which is built over Selenium webdriver supports most of the OS & apps with various configurations.

In this article, you would know a way to automate the Hybrid App using AndroidDriver.

Prerequisites:

1. Android SDK is downloaded and installed. (ANDROID_HOME env. variable should be set)
2. Either Emulator or  Real device (USB debugging enabled) is available.
3. Appium desktop app or non GUI package is installed. 

Steps:

1. Create a java project in eclipse 'AppiumMobileTesting'.
2. Create a class 'TestHybridApp.java'.
3. Connect your device(USB debugging enabled), to system's USB port & accept if any confirmation pop ups.
4. Start Appium Server. Once the device is connected, open the 'Appium Inspector Session' providing the suitable capabilities.
5. Open the Hybrid app in the device and you see the same screen on inspector session.
6. Click on the required control in inspector session & then the related locator details are shown on the right hand side in appium inspector.

How to query or filter Json using RestAssured JsonPath

REST Assured(RA) is a framework built on Java to test the REST services. It supports any HTTP method but has explicit support for GET, POST, PUT, DELETE, HEAD, OPTIONS, PATCH and includes specifying & validating like Headers, Cookies etc.

For validating and querying the Webservice responses, it has couple of libraries 'JsonPath' and 'XMLPath' for parsing Json and XML responses accordingly.

Even-though we know that, we have to use these libraries but most of the times we get into situations where we forget or we are not sure of the actual syntax. Here are list of few scenarios and it's JsonPath syntax (XMLPath syntax are almost similar) for your reference.

All the Jsonpath examples in this post, use the following Json:

 
{
   "store":{
      "book":[
         {
            "category":"reference",
            "author":"Nigel Rees",
            "title":"Sayings of the Century",
            "price":8.95
         },
         {
            "category":"fiction",
            "author":"Evelyn Waugh",
            "title":"Sword of Honour",
            "price":12.99
         },
         {
            "category":"horror",
            "author":"Herman Melville",
            "title":"Moby Dick",
            "isbn":"0-553-21311-3",
            "price":8.99
         },
         {
            "category":"fiction",
            "author":"J. R. R. Tolkien",
            "title":"The Lord of the Rings",
            "isbn":"0-395-19395-8",
            "price":22.99
         }
      ],
      "bicycle":{
         "color":"red",
         "price":19.95
      }
   },
   "city":"Bangalore"
}

Following examples let you know,how to effectively use the JsonPath to extract the required values from the RESTful json in different scenarios:

How to send Cookies from Web(GUI) to Web Service

Cookies: Browser Cookies are also referred as Internet Cookie,Web Cookie or HTTP Cookie. A cookie is a "small piece of data" sent from the website to the user's device while the user is accessing the website.
There are multiple ways these cookies are being used in modern world like authentication, browser state information, storing user personal information like name, address etc., tracking the user activity on web, etc., Different types of cookies satisfy different needs.

In certain cases, one might have to test web services which needs cookies to be passed as part of request. One way to address this, is to combine Web application plus web service test steps. 

Below code snippet would open the web application, capture the cookies stored by the application and pass it to web service using Rest Assured.


public class CookiesToWebServices {
static WebDriver driver;
static String driverPath = "C:/Drivers/chromedriver.exe";

public static void main(String[] args) {

System.setProperty("webdriver.chrome.driver",driverPath);
ArrayList cookieList = new ArrayList();

String url = "www.testurl.com/testpath/id";
HashMap headermap = new HashMap<>();
headermap.put("Content-Type", "application/json");
headermap.put(....

HashMap queryParammap = new HashMap<>();
queryParammap.put("id", "12345");
queryParammap.put(....

How to Connect Zephyr For Jira Programmatically (ZAPI)

Jira by default is a 'Defect Management Tool'. However, available add-on for Jira make it much more capable than just defect Management tool. Couple of such add-ons like 'Zephyr For Jira' & 'ZAPI' (API to access data from 'Zephyr For Jira' programmatically) make Jira capable for 'Test Management'. Both of these add-ons have different version for Server & Cloud accordingly. Let us look at, how do we work with ZAPI server version.

Use Case: Whenever the automation is run, it has to update the status of execution in test cycle.

Pre-requisite: Manual Tests are created in Jira with Issue Type - Test & Test cycle is created with tests added into it (Adding tests into test cycle creates execution ids for each test case in test cycle).

High Level Steps:

1. Login to Jira using proper credentials.
2. Provide the Cycle Id OR ProjectId,Version & Cycle Id of the Test cycle to ZAPI api.
3. Update the Test case status in test cycle based on the execution id of each test case.

Example to Update Status of Test case execution Using ZAPI API:

This example shows how to consume ZAPI REST APIs from Java using REST Assured libraries.

How to run Chrome & Firefox Webdriver in Headless mode

Headless Browser! What does it mean.? As name suggests, It is a browser without head.i.e., without GUI. 

Headless Browsers are a kind of simulation programs of real browsers, but without GUI. Having said that, these may not be 100% equal to real browsers as they have its own limitations. Here are few popular headless browsers:

• Headless Chrome
• Headless Firefox
• HtmlUnit Driver
• PhantomJS
• SlimmerJS

Headless browsers come with its own Pros & Cons.

Pros:

• Improves the execution speed,in turn increases the performance.
• Can be executed on Browser-less setups like Servers(without browsers).
• Useful while scraping the web.
• Simulate multiple browser versions on a single machine.

Cons:

• It doesn't mimic the real user.
• Debugging is quite difficult.

Below snippet would show you, How to make Chrome & Firefox work in Headless mode.

Compare Images in Selenium Test

Visual / UI Validation of web pages across different browsers & devices is very important these days as more and more applications are getting web enabled. And most of the websites are eyeing on 'Responsive Web Design' to create a single website across multiple resolutions.

This type of testing is usually performed manually. However, now you can automate these type of tests to an extent using different image comparison libraries like Thumbnailator, Slenium-Shutterbug, ImageMagick Applitools Eyes etc.

Using these libraries, both Functional Testing & Visual Testing can go hand-in-hand without having to maintain separate set of scripts.
One such example using Image-comparison.jar based on Thumbnailator library is as below:

Steps: