DEV Community: ujwalabothe

Jmeter and Listener

ujwalabothe — Mon, 04 Sep 2023 11:00:41 +0000

As a Senior QA Automation professional at Luxoft, I have had the opportunity to work extensively on projects using listeners in JMeter. I aim to provide beginners and individuals seeking a deeper understanding with valuable insights into leveraging listeners in JMeter.

Listener allows us to view and analyze the Sampler request and response in the form of tables, graphs, trees etc. You can also save results in a file and read saved results later. You can access the sampler result in an ongoing load/stress test without waiting till end.

A listener can be added anywhere in the test plan e.g under thread group or sampler based on test scenarios. It will gather data only from elements defined in its scope and create a report/graph based on that. All listeners use the same data and result for generating the report/graph only difference is the visualization or the way the represent on GUI .

The list of listeners is as follows:

Aggregate Graph
Aggregate Report
Assertion Results
Backend Listener
BeanShell Listener
BSF Listener
Comparison Assertion Visualizer
Generate Summary Results
Graph Results
JSR223 Listener
Mailer Visualizer
Monitor Results
Response Time Graph
Saves Responses to a file
Simple Data Writer
Summary Report
View Results in Table
View Results Tree

Samples : No of thread denotes number of sampler for the sampler request .

samples= No of threads * loop count = 10*10 =100 samples

Average: It gives the time for avg samplers to execute the test plan

Min: It gives the minimum value a sampler request has taken to complete out during the execution of the sampler based on loop and thread count. ( out of 100 samplers)

Max: It gives the maximum value a sampler request has taken to complete out during the execution of the sampler based on loop and thread count. ( out of 100 samplers)

Std Dev : The “Std. Dev.” column provides an indication of how much individual response times deviate from the average

Error %: This column will give you error percentage

Throughput : Throughput measures how many actions a system can handle in a given time, indicating its processing capacity in performance testing

Received KB/sec: This measures the rate at which data (in kilobytes) is received by the system from external sources (like users or servers) per second. It reflects how quickly the system is getting data from outside.

Sent KB/sec: This measures the rate at which data (in kilobytes) is sent from the system to external destinations (like users or servers) per second. It indicates how fast the system is sending out data.

Avg Bytes : This stands for “Average Bytes.” It’s the average amount of data (in bytes) transferred in each request or response between the system and external sources. It helps understand the typical data size being exchanged

Aggregate Report
Aggregate report shows a separate table row for each differently named sampler request in the test.

Run the Test plan

Backend Listener
The “Backend Listener” in JMeter is like a messenger that sends test performance data to a special place for better understanding, similar to sharing race statistics with a friend who records them.

So, the “Backend Listener” is like your helper to get the test results to a place where you can easily see how your application is handling things, just like your friend helps you keep track of how fast a car goes during a race.

Aggregate Graphs:
Aggregate graphs allow us to generate bar graphs easily and let us select graph display settings. The generated graph and table data can be saved explicitly in the form of PNG and CSV.

Assertion Results:
Assertion Results displays the results of assertions applied on the Sampler. You can see in the below figure, if any assertion fails it will look like this.

Please Note that Assertion Results SHOULD NOT BE USED during Load/Stress test as it consumes a lot of resources like memory and CPU. It is recommended to use it with functional testing or debugging purposes.

To add the assertion where we are asserting response code =400 if not then sampler should be failed

Response assertion or any assertion can be at any level .

If the sampler is failed then you will sampler name followed by a failure message else sampler name only .

Comparison Assertion Visualizer
The “Comparison Assertion Visualizer” in JMeter allows you to compare the responses of two or more requests during a performance test, helping you identify differences and inconsistencies between them. It’s like having a tool that highlights variations in how different parts of your application respond under load.

Generate Summary Results
“Generate Summary Results” in JMeter refers to the process of creating a summarized report that provides key performance metrics from a test run. It’s like creating a condensed overview of how well your application performed under specific conditions, offering insights into response times, throughput, error rates, and other important data points.

Rest listener will be covered in next article .

Happy Reading !!

Mastering JSON Extraction in Apache JMeter for Effective API Testing

ujwalabothe — Wed, 16 Aug 2023 10:43:11 +0000

JsonExtraction # Jmeter # Luxoft # APItesting #PerformanceTesting

Xpath

Working with Luxoft for over a year, I have gained invaluable experience in my 11+ years of overall professional journey. The culture of knowledge sharing at Luxoft not only fosters continuous learning but also plays a vital role in our collective success.
In today’s fast-paced software development industry, ensuring the optimal performance of your product is paramount. However, as the sole tester on your project or even within the entire company, selecting the right performance testing or API tool can feel overwhelming. With a vast array of options available, making an informed choice is crucial. I will provide a step-by-step guide to help you become familiar with JMeter and successfully execute your first performance test /API test .
I have had the opportunity to work extensively on performance projects using Jmeter where I have learned and used various JSON and Xpath exactor in my project .

Now, let’s dive into the process of functional testing REST APIs and uncover the power of Apache JMeter in conjunction with a JSON extractor for parsing responses.

By the end of this blog post, you will have a good understanding of how to perform functional testing on REST APIs with JSON responses using Apache JMeter and leverage the JSON extractor to retrieve and manipulate data efficiently.

Configure the JSON Extractor in JMeter to extract data from JSON responses. Define JSON Path expressions to target specific elements within the JSON structure, and store the extracted values in variables for later use.

Understanding JSON and Its Relationship with JMeter:
JSON, short for JavaScript Object Notation, is a widely adopted data format for representing structured information. On the other hand, JMeter is an open-source performance testing tool developed by the Apache Software Foundation, primarily utilized for load testing, stress testing, and performance assessment of web applications. JSON and JMeter are closely intertwined in the context of web services and APIs. Modern web applications often communicate with clients or other services using JSON-formatted data. JMeter comes equipped with built-in support for working with JSON data during performance testing. Let's explore how JSON and JMeter are intertwined:

JSON Extractor: JMeter provides a JSON Extractor post-processor element that allows you to extract specific data from JSON responses. With the JSON Extractor, you can define JSON path expressions to extract values from JSON responses and store them in variables for further use in your test scripts.

JSON Request: JMeter allows you to send HTTP requests with JSON payloads. You can use the HTTP Request sampler to send POST or PUT requests with JSON data as the request body. This is useful for testing APIs that expect JSON data as input.

JSON Assertion: JMeter provides a JSON Assertion element to validate JSON responses. You can specify JSON path expressions to extract specific values from the response and define assertions based on expected values or patterns. This helps in verifying the correctness of the JSON responses during testing.

JSON Pre-Processor: JMeter offers a JSON Pre-Processor element that allows you to manipulate JSON data before sending it as part of an HTTP request. This can be useful for dynamically modifying JSON payloads based on test scenarios or test data.

Exploring JSON Extractor Expressions

Extracting a Single Value
Extracting a Value from a Nested Object
Extracting Multiple Values
Extracting Values Using Filters
Extracting values based on a condition
Extracting specific array elements
Extracting values from multiple objects with the same key
Extracting values using a wildcard
Extracting values using regular expressions

In JMeter, you can extract JSON values or objects using various methods. Here are some of the ways you can extract JSON data in JMeter:

Sample JSON:
{
"name": "Ujwala",
"age": 30,
"user": {
"email": "ujwala@gmail.com",
"name": "Ujwala bothe"
},
"names": ["Ujwala", "Neha", "John"],
"users": [
{
"name": "Ujwala",
"age": 20,
"domain": "IT",
"email":"ujwala@gmail.com"
},
{
"name": "Neha",
"age": 40,
"domain": "SALES",
"email":"neha@gmail.com"
},
{
"name": "Sneha",
"age": 50,
"domain": "ADMIN",
"email":"sneha@gmail.com"
}
]
}

Extracting a Single Value:

JSON Path: $ .name or $.age

Extracting Value from a Nested Object:
You can specifiy the path to desire value e.g user's email using dot(.) notation to extarct a value from multiple object which in nested object .
For example, if your JSON response contains a nested object structure like this:

JSON Path: $.users.email or $.users.name

Extracting an Array of Values:

IF JSON contains n values i.e a array of object then you can you index i.e 1st for 2nd element or 3rd for 4th element or * to retreieve all the values for the attribute.
For example, if your JSON response contains an array of names like this:

Extract the name: $ .names[0]
Extract all names: $ .names[*]
Extracting Multiple Values:

JSON Path: $.name;$.age

Extracting Values Using Filters:

You can use filters to extract specific values based on certain conditions. For example, if your JSON response contains an array of objects where each object has a “domain” field, you can use a filter to extract objects with a specific category. The following JSON Path expression extracts objects with the category “IT”:

JSON Path: $[?(@.domain=='IT')]
Extracting values based on a condition:

JSON Path Expression: $[?(@.age>50].name
This expression retrieves the names of all objects in the JSON response where the “age” field is greater than 50.

Extracting specific array elements:

JSON Path Expression: $.employees[0].name
This expression retrieves the value of the “name” field from the first object within the “employees” array in the JSON response.

Extracting values from multiple objects with the same key:

Extracts all values of the “Name” element from the entire JSON structure, regardless of their location.

JSON Path: $..name
Extracting values using a wildcard:

This expression extracts the values of the “domain” from all levels of the JSON structure using a wildcard.

JSON Path: $..[*].domain

Extracting values using regular expressions:

This expression extracts values where the “Name” matches a specific regular expression pattern.

JSON Path: $..[?.name=~/pattern)]

JSON Path expressions commenly used in JMeter’s JSON Extractor.

You can also combine two three expressions and to make final json extratcor path accordingly to the JSON format . It is great to use while extracting , manipulating and validating the data while using for API /Performance testing.

Stay tuned for the next article on XPath extractor.

Controllers in JMeter!!

ujwalabothe — Tue, 08 Aug 2023 16:15:36 +0000

In JMeter, Logic Controllers are essential elements that enable you to control the flow and execution of samplers within a Thread Group. They play a crucial role in creating dynamic and conditional test scenarios, allowing for more realistic and versatile load-testing simulations. This blog will provide an overview of Logic Controllers, explaining their purpose and discussing why they are necessary for JMeter test plans.

As a Senior QA Automation professional at Luxoft, I have had the opportunity to work extensively on projects using logic controllers in JMeter. Through this comprehensive guide, I aim to provide beginners and individuals seeking a deeper understanding with valuable insights into leveraging logic controllers in JMeter

What is a Logic Controller?

A Logic Controller in JMeter is a configuration element that provides the ability to define the logical flow and conditions for executing samplers. It allows you to control the order, repetition, and selection of samplers, based on specified conditions or logic.

Why Use Logic Controllers?

Conditional Execution: Logic Controllers enable the execution of samplers based on specific conditions. For example, the If Controller allows you to execute samplers only if a given condition evaluates to true. This is useful when you want to simulate different scenarios based on dynamic data or specific criteria.

Looping and Iterations: Logic Controllers such as the Loop Controller or While Controller provide the capability to repeat the execution of samplers. This is valuable when you need to simulate multiple iterations of a particular test scenario or perform actions until a certain condition is met.

Dynamic Test Scenarios: Logic Controllers allow you to create dynamic test scenarios by selectively executing samplers based on variables or functions. The Switch Controller, for instance, lets you choose different paths based on the value of a variable, facilitating the simulation of varied user behavior or application responses.

Randomization: Logic Controllers like the Random Controller enable the random selection and execution of samplers. This is useful for simulating user interactions with different functionalities or performing random load distribution across various components.

Let's see different types of loop controllers in JMeter

Critical Section Controller
ForEach Controller
If Controller
Include Controller
Interleave Controller
Loop Controller
Module controller
Once Only Controller
Random Controller
Random Order Controller
Recording Controller
Runtime Controller
Simple Controller
Switch Controller
Throughput Controller!
Transaction Controller
While Controller

Note : In this blog, I will be covering only 8 controllers and the remaining 9 will be covered in the next blog.

*How to add any controller in Jmeter ? *
Under the test plan, add a Thread Group > Logic controller > Add any desired controller

Critical Section Controller
The Critical Section Controller ensures that its children elements (samplers/controllers, etc) will be executed by only one thread as a named lock will be taken before executing children of the controller.

For example, if one script has 2 Critical Section Controllers with requests DS3-${threadNum} and DS4-${threadNum} respectively. Then it ensures that:

DS3-${threadNum} is executed only by one thread at a time
DS4-${threadNum} is executed only by one thread at a time
Or you just want to make sure one thread run at a time ,below is an example of a global lock.

ForEach Controller
This controller is one of the many built-in controllers used to design and control the flow of a test script. It allows you to iterate over elements of a variable, such as an array or a list, and execute the samplers or other elements inside the controller for each element in the variable.

The ForEach Controller is useful when you need to perform an action multiple times, with each iteration using a different value from a set of values. It is commonly used in scenarios where you want to test different data inputs or perform actions on multiple items.

To use the ForEach Controller:

Right-click on the Thread Group or any other logical controller in the test plan.

From the context menu, go to “Add” > “Logic Controller” > “ForEach Controller”.

Once added, you need to set up the ForEach Controller using the following properties:

Input variable prefix: The prefix of the variable name containing the set of values you want to iterate over. For example, if you have a variable named “data” that contains an array of values, you would enter “data” as the input variable prefix.

Output variable name: The name of the variable that will be used to store each element of the input variable during each iteration. This variable can be referenced in samplers or other elements within the ForEach Controller. For example, you can set it to “currentData” to use “currentData” as the variable that holds each value during iteration.

Value to iterate: The delimiter-separated list of values you want to iterate over. The ForEach Controller will split this list using the specified delimiter and use each value in the iterations.

Delimiter: The character used to separate the values in the “Value to iterate” field. By default, it is set to “,” (comma).

If Controller
The If Controller is a logic controller in JMeter that allows you to control the execution of elements i.e samplers ,other controllers based on a specified condition. It evaluates an expression and executes the elements inside it only if the expression evaluates to “true.”

JMeter if controller Usage

Now let’s see the uses of the if controller as follows.

If we need to execute elements of the Thread Group based on their state at that time, we can use if controller.

Using the if controller, we provide control over the test execution per our requirement.
Using the if controller, we can check the Interpret condition.
We can also evaluate the runnable elements from the controller.
It allows us to implement the Boolean operator per our requirements. Step 1: Set up the Test Plan Create a new Test Plan and add a Thread Group to it.

Step 2: Add User-Defined Variables configuration element under the Thread Group. Here, we’ll define a variable named “company” and set its value to “Luxoft.” This variable will represent the company name for this example.

Name: Company Value: Luxoft

Step 3: Add If Controller Now, add an “If Controller” under the Thread Group. We’ll configure the If Controller to check if the company is “Luxoft” or not.

In the If Controller, set the following properties:

Condition: ${__groovy(vars.get(“company”) == “Luxoft”)}

The above condition uses a Groovy script to check if the value of the “company” variable is equal to “Luxoft” If it’s true, the elements inside the If Controller will be executed; otherwise, they will be skipped.

Include Controller
The “Include Controller” is a special type of logic controller that allows you to include other test fragments or external JMX files within your main test plan. This controller is useful when you want to reuse certain test elements across multiple test plans, making test maintenance and organization more efficient.

Here’s how you can use the Include Controller with an example:

Step 1: Create and save the Test Components that we want to reuse in your main test plan i.e PerformanceTesting.jmx

Step 2: Create the Main Test Plan

Create a new test plan e.g Employee where you want to include the components. This main test plan will call the components using the Include Controller.

Step 3: Add Include Controller Under the main test plan, add an “Include Controller” by right-clicking on the test plan > Add > Logic Controller > Include Controller.

Step 4: Configure the Include Controller In the Include Controller, specify the path to the JMX files of the components you want to include. Provide the relative or absolute path to the JMX files.

PerformanceTesting .jmx

Step 5: Run the test plan

Benefits of using Include Controller:

Code Reusability: The Include Controller promotes code reusability by allowing you to create modular test components and include them in multiple places, reducing redundancy and maintenance efforts.
Organization: It helps in organizing your test plan by breaking it into smaller components, making it easier to manage and maintain.
Collaboration: Multiple team members can work on separate components concurrently and later integrate them into the main test plan using the Include Controller.
Interleave Controller

Interleave Controller will select only one samplers/requests stored in it, to run in each loop of the thread. It will execute the samplers sequentially.

You can give a descriptive name for the controller (optional)
If the checkbox is selected, the interleave controller will consider sub-controllers as single request elements and permit only one request per controller at a time (optional)
Let’s consider an example of Interleave Controller, where Thread Group contains “Number of Threads” to “1”, “Loop Count” to 10, and a total of “4” Samplers (Http requests).

Total 1 * 10* 4 = 40 requests will be sent to web server under test without using any Logic Controller.

Loop Controller

The Loop Controller in JMeter is a logic controller that allows you to repeat the execution of its child elements (samplers or other controllers) a specified number of times. It’s a built-in feature of JMeter that facilitates creating loops in your test plan, where a specific set of elements is executed repeatedly.

Let’s go through an example of how to use the Loop Controller in JMeter

Test Plan
Thread Group
Loop Controller (Loop Count: 100)

HTTP Request Sampler (Executed 100times)
The HTTP Request sampler will be executed in a loop for a hundred times, simulating a hundred requests to the specified server.

The Loop Controller is commonly used to simulate multiple iterations of the same actions, such as:

Load Testing: Repeating HTTP requests to simulate multiple users accessing a website or API.
Stress Testing: Repeatedly executing test scenarios to assess system performance under high load.
Functional Testing: Running the same test steps multiple times to verify the consistency and reliability of the application.
Key features of the Loop Controller:

Loop Count: You can specify the number of times you want the child elements to be executed in the loop.

Independent Iterations: Each iteration of the Loop Controller is independent, meaning the variables and states are reset at the beginning of each iteration. This allows you to perform isolated test scenarios without interference between iterations.

Dynamic Loop Count: You can use variables or functions in the “Loop Count” field to dynamically control the number of iterations during the test run.

Nested Loops: You can nest Loop Controllers within each other to create complex looping patterns, simulating more intricate user behavior.

Module controller
The Module Controller is a logic controller in JMeter that allows you to include reusable components or modules from other parts of your test plan. It helps in organizing and reusing test elements, making it easier to manage complex test scripts.

When you use a Module Controller, it acts as a placeholder for another element, like a Sampler or a group of elements. The actual content of the Module Controller comes from an existing Test Fragment, which can be located anywhere in your test plan.

Here’s how you can use the Module Controller:

Step 1: Create a Test Plan Create a new Test Plan in JMeter.

Step 2: Add Elements to Be Reused Create the components that you want to reuse in your test plan as modules. These could be samplers, controllers, or other elements.

Step 3: Add a Module Controller Right-click on the location where you want to include the module, go to “Add” > “Logic Controller” > “Module Controller.”

Step 4: Select the Module to Include In the Module Controller, you need to specify the name of the module you want to include. The module name is the same as the name of the element you want to reuse. You can also use the “Browse” button to select the module directly.

Step 5: Run the Test Run the test, and JMeter will include the specified module at the location of the Module Controller during test execution.

The Module Controller is useful when you want to reuse specific test elements or group them into logical components without duplicating code. It promotes modularity, making your test plan more organized and easier to manage.

Once Only Controller
the Once Only Controller is a logic controller that ensures the elements (samplers or other controllers) inside it are executed only once per thread during the test execution. It is particularly useful for setting up configurations or initialization tasks that should be performed just once, regardless of the number of iterations in a Thread Group.

Here is an example of how to use the Once Only Controller in JMeter:

Step 1: Create a Test Plan in JMeter.

Step 2: Add a Thread Group to the Test Plan.

Step 3: Add a Once Only Controller under the Thread Group.

Step 4: Add an HTTP Request sampler under the Once Only Controller.

Step 5: Configure the HTTP Request sampler with the URL of the website you want to test.

Step 6: Run the Test.

For example, if you have 10 iterations in your Thread Group and the Once Only Controller contains an HTTP Request sampler, that HTTP request will be executed only once for each thread, and the result of that request will be reused for all iterations.

Kick off API Testing

ujwalabothe — Fri, 04 Aug 2023 11:04:46 +0000

#Luxoft #LuxoftTraining #API #APITesting #APITutorial

About Me :

My name is Ujwala, and I bring over more than 11 years experience as a Senior Automation QA professional. I have had the privilege of working with industry giants such as IBM and Synerzip, and I am currently contributing my expertise at Luxoft. My core proficiencies lie in the domains of Selenium automation, AWS, API testing, JMeter, and Worksoft. I have honed my skills in automating test scenarios using Selenium, ensuring efficient and robust software testing. Additionally, my knowledge extends to AWS, where I have leveraged cloud-based solutions for testing and deployment. I have gained substantial expertise in API testing, validating and optimizing communication between software components. I am proficient in JMeter, employing its capabilities to evaluate performance and scalability. Lastly, my agile methodology experience has facilitated effective collaboration and delivery of projects.
I'm excited to share that I have recently embarked on my journey of writing technical blogs. Through my blog, I aim to offer valuable insights, tutorials, and thought-provoking content on various topics related to automation testing, cloud computing, API testing, JMeter, and more. It's my way of contributing to the tech community and sharing my knowledge and experiences accumulated over my 11+ years as a Senior Automation QA professional. I look forward to engaging with fellow tech enthusiasts, exchanging ideas, and fostering a vibrant learning environment through my blog.

1) Terminologies
The following are the most important terms related to REST APIs

A resource is an object or representation of something, which has some associated data with it and there can be a set of methods to operate on it. E.g. Animals, schools, and employees are resources, and delete, add, update are the operations to be performed on these resources.
Collections are set of resources, e.g Companies is the collection of Company resource.
URL (Uniform Resource Locator) is a path through which a resource can be located and some actions can be performed on it.
2) API endpoint
Let’s write few APIs for Companies which has some Employees, to understand more.
/getAllEmployees is an API that will respond with the list of employees. Few more APIs around a Company will look like as follows:

/addNewEmployee
/updateEmployee
/deleteEmployee
/deleteAllEmployees
/promoteEmployee
/promoteAllEmployees
And there will be tons of other API endpoints like these for different operations. All of those will contain many redundant actions. Hence, all these API endpoints would be burdensome to maintain, when API count increases.

What is wrong?
The URL should only contain resources(nouns) not actions or verbs. The API path/addNewEmployee contains the action addNew along with the resource name Employee.

Then what is the correct way?
/companies endpoint is a good example, which contains no action. But the question is how do we tell the server about the actions to be performed on companies resource viz. whether to add, delete or update?

This is where the HTTP methods (GET, POST, DELETE, PUT), also called as verbs, play the role.

The resource should always be plural in the API endpoint and if we want to access one instance of the resource, we can always pass the id in the URL.

method GET path /companies should get the list of all companies
method GET path /companies/34 should get the detail of company 34
method DELETE path /companies/34 should delete company 34
In few other use cases, if we have resources under a resource, e.g Employees of a Company, then few of the sample API endpoints would be:

GET /companies/3/employees should get the list of all employees from company 3
GET /companies/3/employees/45 should get the details of employee 45, which belongs to company 3
DELETE /companies/3/employees/45 should delete employee 45, which belongs to company 3
POST /companies should create a new company and return the details of the new company created
Aren’t the APIs are now more precise and consistent? 😎

Conclusion: The paths should contain the plural form of resources and the HTTP method should define the kind of action to be performed on the resource.

3) HTTP methods (verbs)
HTTP has defined few sets of methods which indicates the type of action to be performed on the resources.

The URL is a sentence, where resources are nouns and HTTP methods are verbs.

The important HTTP methods are as follows:

GET method requests data from the resource and should not produce any side effect.
E.g /companies/3/employees returns list of all employees from company 3.
POST method requests the server to create a resource in the database, mostly when a web form is submitted.
E.g /companies/3/employees creates a new Employee of company 3.
POST is non-idempotent which means multiple requests will have different effects.
PUT method requests the server to update resource or create the resource, if it doesn’t exist.
E.g. /companies/3/employees/john will request the server to update, or create if doesn’t exist, the john resource in employees collection under company 3.
PUT is idempotent which means multiple requests will have the same effects.
DELETE method requests that the resources, or its instance, should be removed from the database.
E.g /companies/3/employees/john/ will request the server to delete john resource from the employees collection under the company 3.
There are few other methods which we will discuss in another post.

4) HTTP response status codes
When the client raises a request to the server through an API, the client should know the feedback, whether it failed, passed or the request was wrong. HTTP status codes are a bunch of standardized codes which has various explanations in various scenarios. The server should always return the right status code.
The following are the important categorization of HTTP codes:

2xx (Success category)
These status codes represent that the requested action was received and successfully processed by the server.

200 Ok The standard HTTP response representing success for GET, PUT or POST.
201 Created This status code should be returned whenever the new instance is created. E.g on creating a new instance, using POST method, should always return 201 status code.
204 No Content represents the request is successfully processed, but has not returned any content.
DELETE can be a good example of this.
The API DELETE /companies/43/employees/2 will delete the employee 2 and in return we do not need any data in the response body of the API, as we explicitly asked the system to delete. If there is any error, like if employee 2 does not exist in the database, then the response code would be not be of 2xx Success Category but around 4xx Client Error category.
3xx (Redirection Category)
304 Not Modified indicates that the client has the response already in its cache. And hence there is no need to transfer the same data again.
4xx (Client Error Category)
These status codes represent that the client has raised a faulty request.

400 Bad Request indicates that the request by the client was not processed, as the server could not understand what the client is asking for.
401 Unauthorized indicates that the client is not allowed to access resources, and should re-request with the required credentials.
403 Forbidden indicates that the request is valid and the client is authenticated, but the client is not allowed access the page or resource for any reason. E.g sometimes the authorized client is not allowed to access the directory on the server.
404 Not Found indicates that the requested resource is not available now.
410 Gone indicates that the requested resource is no longer available which has been intentionally moved.
5xx (Server Error Category)
500 Internal Server Error indicates that the request is valid, but the server is totally confused and the server is asked to serve some unexpected condition.
503 Service Unavailable indicates that the server is down or unavailable to receive and process the request. Mostly if the server is undergoing maintenance.
5) Field name casing convention
You can follow any casing convention, but make sure it is consistent across the application. If the request body or response type is JSON then please follow camelCase to maintain the consistency.

6) Searching, sorting, filtering, and pagination
All of these actions are simply the query on one dataset. There will be no new set of APIs to handle these actions. We need to append the query params with the GET method API.
Let’s understand with few examples of how to implement these actions.

Sorting In case, the client wants to get the sorted list of companies, the GET /companies endpoint should accept multiple sort params in the query.
E.g GET /companies?sort=rank_asc would sort the companies by its rank in ascending order.
Filtering For filtering the dataset, we can pass various options through query params.
E.g GET /companies?category=banking&location=india would filter the companies list data with the company category of Banking and where the location is India.
Searching When searching the company name in companies list the API endpoint should be GET /companies?search=Digital Mckinsey
Pagination When the dataset is too large, we divide the data set into smaller chunks, which helps in improving the performance and is easier to handle the response. Eg. GET /companies?page=23 means get the list of companies on 23rd page.
If adding many query params in GET methods makes the URI too long, the server may respond with 414 URI Too long HTTP status, in those cases params can also be passed in the request body of the POST method.

7) Versioning
When your APIs are being consumed by the world, upgrading the APIs with some breaking change would also lead to breaking the existing products or services using your APIs.

http://api.yourservice.com/v1/companies/34/employees is a good example, which has the version number of the API in the path. If there is any major breaking update, we can name the new set of APIs as v2 or v1.x.x

I would love to know your views on the pointers mentioned above. Please leave a comment, and let me know!

Happy Learning!!!

Unlocking Cosmos DB Potential: Testing API Performance with JMeter!!

ujwalabothe — Thu, 03 Aug 2023 16:25:29 +0000

Jmeter #CosmosDatabase #PeroformanceTesting #databasetesting #Luxoft #Poland

Working with Luxoft for over a year, I have gained invaluable experience in my 11+ years of overall professional journey. The culture of knowledge sharing at Luxoft not only fosters continuous learning but also plays a vital role in our collective success.
In today’s fast-paced software development industry, ensuring the optimal performance of your product is paramount. However, as the sole tester on your project or even within the entire company, selecting the right performance testing tool can feel overwhelming. With a vast array of options available, making an informed choice is crucial. This article aims to demystify the process by exploring Apache JMeter — an exceptionally powerful and user-friendly tool for performance testing. I will provide a step-by-step guide to help you become familiar with JMeter and successfully execute your first performance test.
I have had the opportunity to work extensively on performance projects using Jmeter.
Though jmeter is very popular among us but still we don't have lot of documentation for cosmos database so here I’m sharing my experience of Jmeter with cosmos which I have recently used in my project .

Azure Cosmos DB is a globally distributed, multi-model database service offered by Microsoft Azure. It is designed to provide high availability, scalability, and low-latency access to data for mission-critical applications.

Apache JMeter™ can also perform load testing against Azure Cosmos DB (SQL API).

Azure Cosmos DB (SQL API) is operated by the REST API.
So, it will be tested using the HTTP request sampler in Apache JMeter™.

For the request to be successful, it must be made with the appropriate method, header, and body.

Outline of steps

Install jmeter
Install the plugin for Microsoft Azure.
Cosmos database set up configuration.
Add a Thread Group.
HTTP Header Manager .
User Parameters.
JSON Extractor.
Extract the test data in CSV format.
Save the Response.
Run the test plan and check the result
Detailed steps with real-time examples :

Step 1: Download and Install JMeter

Download the latest stable version of JMeter from (https://jmeter.apache.org/).

Step 2 : Install Azure CosmosDB Plugin

To enable the connectivity download “Azure backend listerner” plugin from JMeter Plugins website (https://jmeter-plugins.org/) or you can use the JMeter Plugins Manager to install it.

Place it in lib/ext directory of your JMeter installation. Next restart JMeter to load the plugin.

Step 3: Cosmos database set up configuration

You can get all the below details from the cosmos database, go to the database and check the cosmos database properties.

Add > Config Element > User Defined Variables

cosmosdbHost: Hostname of Cosmos DB (***.documents.azure.com)
cosmosdbKey: Key of Cosmos DB
You can use either the primary or secondary key.
headers.x-ms-version: Version of Cosmos database

Step 4: Add a Thread Group

Add>Threads(Users)> SetUp Thread Group

This will be set up once and can be used many times throughout the test plan. Eg data extracted/saved from this script can be used in various thread groups.

Protocol : https/http ,ServerName or IP : you can directly provide here e.g test.com or you can define a variable and use it here e.g ${cosmosdbHost},

Method : POST ( small correction in SS :( )and Path .

Note : all these varibles are defined in

Step 5: HTTP Header Manager

Configure the parmaters (x-ms-version, authorizaton and other parameters) as per below screenshot .

Step 6: User Parameters

Step 7 : JSON Extractor

Here I have given two examples but you can extract as many as you want. Also you can change the JSON expression ( may be we can cover JSON expression in next article )

Step 8 : Extract the test data in csv format.

Step 9: Save the Response:

Save the response in txt or json format . You can also define a reference varible for response file name in the variable section and use a variable here eg ${responseFilePath}

Go to Http request >> Add>Listener> Save Response to a file and provide a file name and location else it will be saved in Jmeter bin folder ( default location )

Step 10 : Run the test plan and check the result

Testing Azure Cosmos DB with Apache JMeter provides valuable insights into the performance and reliability of your database deployments. By following the basic steps outlined in this article, you can establish a strong foundation for testing and ensuring optimal performance of your Cosmos DB applications. Harness the power of JMeter to validate the behavior of your Cosmos DB and deliver robust and scalable solutions.

Stay tuned for the next article where I will cover JSON extractor in detail :)