Feel free to bookmark this page or share it with your peers. Dive in and make the most of this MySQL cheat sheet!

Download Options:

• Download in PDF

Table of Contents

• What is MySQL?
• Sample Data
• Querying tables
  • Filtering Data
  • Filtering on numeric columns
  • Filtering on text columns
  • Filtering on multiple columns
  • Filtering on missing data
• Aggregating Data
  • Simple aggregations
  • Grouping, filtering, and sorting
• MySQL-Specific Syntax

What is MySQL?

MySQL is an open-source relational database management system (RDBMS) known for its fast performance and reliability. Developed by Oracle Corporation, it’s widely used for web applications and online publishing.

Sample Data

The dataset contains details of the world’s highest valued media employees by gross sales. Each row contains one department, and the table is named employees.

Querying tables

• Get all the columns from a table using SELECT *

SELECT * FROM employees

• Get a column from a table by name using SELECT col

SELECT department FROM employees

• Get multiple columns from a table by name using SELECT col1, col2

SELECT department, inception_year FROM employees

• Override column names with SELECT col AS new_name

SELECT department, inception_year AS creation_year FROM employees

• Arrange the rows in ascending order of values in a column with ORDER BY col

SELECT department, inception_year FROM employees ORDER BY inception_year

• Arrange the rows in descending order of values in a column with ORDER BY col DESC

SELECT department, incentive FROM employees ORDER BY incentive DESC

• Limit the number of rows returned with LIMIT n

SELECT * FROM employees LIMIT 2

• Get unique values with SELECT DISTINCT

SELECT DISTINCT client_name FROM employees

Filtering Data

Filtering on numeric columns

• Get rows where a number is greater than a value with WHERE col > n

SELECT department, inception_year FROM employees WHERE inception_year > 1928

• Get rows where a number is greater than or equal to a value with WHERE col >= n

SELECT department, inception_year FROM employees WHERE inception_year >= 1928

• Get rows where a number is less than a value with WHERE col < n

SELECT department, inception_year FROM employees WHERE inception_year < 1977

• Get rows where a number is less than or equal to a value with WHERE col <= n

SELECT department, inception_year FROM employees WHERE inception_year <= 1977

• Get rows where a number is equal to a value with WHERE col = n

SELECT department, inception_year FROM employees WHERE inception_year = 1996

• Get rows where a number is not equal to a value with WHERE col <> n or WHERE col != n

SELECT department, inception_year FROM employees WHERE inception_year <> 1996

• Get rows where a number is between two values (inclusive) with WHERE col BETWEEN m AND n

SELECT department, inception_year FROM employees WHERE inception_year BETWEEN 1928 AND 1977

Filtering on text columns

• Get rows where text is equal to a value with WHERE col = ‘x’

SELECT department, original_medium FROM employees WHERE original_medium = ‘book‘ 

• Get rows where text is one of several values with WHERE col IN (‘x’, ‘y’)

SELECT department, original_medium FROM employees WHERE original_medium IN (‘movie‘, ‘video game‘)

• Get rows where text contains specific letters with WHERE col LIKE ‘%abc%’ (% represents any characters)

SELECT department, original_medium FROM employees WHERE original_medium LIKE ‘%oo%‘

Filtering on multiple columns

• Get the rows where one condition and another condition holds with WHERE condn1 AND condn2

SELECT department, inception_year, insentive FROM employees WHERE inception_year < 1950 AND insentive > 50

• Get the rows where one condition or another condition holds with WHERE condn1 OR condn2

SELECT department, inception_year, insentive FROM employees WHERE inception_year < 1950 OR insentive > 50

Filtering on missing data

• Get rows where values are missing with WHERE col IS NULL

SELECT department, sales FROM employees WHERE sales IS NULL

• Get rows where values are not missing with WHERE col IS NOT NULL

SELECT department, sales FROM employees WHERE sales IS NOT NULL

Aggregating Data

Simple aggregations

• Get the total number of rows SELECT COUNT(*)

SELECT COUNT(*) FROM employees

• Get the total value of a column with SELECT SUM(col)

SELECT SUM(insentive) FROM employees

• Get the mean value of a column with SELECT AVG(col)

SELECT AVG(insentive) FROM employees

• Get the mean value of a column with SELECT AVG(col)

SELECT AVG(insentive) FROM employees

• Get the maximum value of a column with SELECT MAX(col)

SELECT MAX(insentive) FROM employees

Grouping, filtering, and sorting

• Get summaries grouped by values with GROUP BY col

SELECT client_name, COUNT(*) FROM employees GROUP BY client_name

• Get summaries grouped by values, in order of summaries with GROUP BY col ORDER BY smmry DESC

SELECT original_medium, SUM(sales) AS total_products FROM employees GROUP BY original_medium ORDER BY total_products DESC

• Get rows where values in a group meet a criterion with GROUP BY col HAVING condn

SELECT original_medium, SUM(sales) AS total_products FROM employees GROUP BY original_medium ORDER BY total_products  DESC HAVING total_products > 10

• Filter before and after grouping with WHERE condn_before GROUP BY col HAVING condn_after

SELECT original_medium, SUM(sales) AS total_products FROM employees WHERE client_name = ‘UG Tech Holdings’ GROUP BY original_medium ORDER BY total_products DESC HAVING total_products > 10

MySQL-Specific Syntax

Not all code works in every dialect of SQL. The following examples work in MySQL, but are not guaranteed to work in other dialects.

• Limit the number of rows returned, offset from the top with LIMIT m, n

SELECT * FROM employees LIMIT 2, 3

• By default, MySQL uses case insensitive matching in WHERE clauses.

SELECT * FROM employees WHERE client_name = ‘UG Tech Holdings‘

• To get case-sensitive matching, use WHERE BINARY condn

SELECT * FROM employees WHERE BINARY client_name = ‘UG Tech Holdings‘

• Get the current date with CURDATE() and the current datetime with NOW() or CURTIME()

SELECT NOW(), CURDATE(), CURTIME()

Conclusion

In conclusion, MySQL is a widely used and powerful relational database management system known for its performance and reliability. This comprehensive MySQL cheat sheet provides essential commands and tips for database administrators and beginners alike. It covers various aspects of MySQL usage, from querying and filtering data to aggregating and sorting information. Additionally, it offers insights into MySQL-specific syntax, ensuring you can leverage the full potential of this database system.

The post Streamline Database Operations with Our MySQL Cheat Sheet appeared first on OptimumBrew Technology.

The Simple Test plan of JMeter is that one user is hitting only one API/request. But in the real scenario, multiple users will always be there who will hit either a single API or multiple APIs. This can be understood by a simple example that a live application will be used by many users simultaneously and also multiple requests can be send by the same user on that application. Thus checking the application with this test scenario is very important. In JMeter, we can create multiple users and multiple requests and also a combination of both of them.

Let’s understand this with examples:

Scenario 1 : How to send 10 requests per second?

=> Steps to Perform API Testing in JMeter

1. Adding a Thread Group

• Firstly, you have to start your JMeter and select the Test Plan.
• Next, Right click on the Test Plan and add a Thread Group.
• Rename the Thread Group and save it.

•     Add Thread Group Property as per below.
  • • Number of Threads (Users) : 10
    • Ramp-up period(seconds) : 10
    • Loop Count : 6
    • Specify Thread lifetime : 

                                Duration(Seconds) : 60
                                Startup delay (Second): 1  

2. Add an HTTP Request Sampler

• Next, you have to add HTTP Request and enter the Server name or IP of your API and set the Path and Parameters. Right-click on Thread Group, select Sampler and add HTTP Request.
• Rename the HTTP Request.
• Here I have changed the sampler name as HTTP Request-1 and add the parameters, select the method type and give the path of the login page as below image.
• Add the parameter, I have given “email_id” &  “password” as a parameter and the value is Functions(this value we will fetch from the CSV file)

3. Adding CSV Data Set Config

Create a text file and enter values into it. Now save the text file with proper name and “.csv” extension.

Then, in JMeter create a CSV Data Set Config under the Thread Group. Click on “HTTP Request-1-> Add->Config Element -> CSV Data Set Config”.

Now, open CSV Data Set Config and enter exact Filename and Parameters.

CSV file path : If you have created CSV file in bin folder then you have to just give file name with extension otherwise you have to give absolute path : C:\Users\ob-7\Downloads\cred.csv

This below image is showing how I am saving my file in CSV format.

4. Add Constant Throughput Timer

• JMeter Constant Throughput Timer is used as a goal-oriented element which helps to achieve the desired throughput (Total Number of Requests). This timer tries to maintain a constant throughput throughout the test and achieve the target. Of course, if the server is not able to handle such a load, the throughput will be lower.
• If you want to execute a Goal-oriented scenario where the target is not to simulate the number of concurrent users, but the number of requests per second then Constant Throughput Timer is best for such type of scenario. A Constant Throughput Timer works precisely on the “minute” level, so make sure that your test lasts long enough (1 minute or more) and you use a reasonable ramp-up time to avoid spikes (unless you’re doing some form of stress testing). 

=> How to add ‘Constant Throughput Timer’ in JMeter script?

1. 1. Right-click on the Thread Group.
   2. Hover the mouse on ‘Add’
   3. Hover the mouse on ‘Timer’
   4. Click ‘Constant Throughput Timer’

=> What are the input fields of ‘Constant Throughput Timer’?

• • Name: To provide the name of the timer
  • Comments: To provide arbitrary comments (if any)
  • Target throughput (in samples per minute): Number of requests that need to be triggered in a minute. If you need to achieve a 10,000 requests target in an hour then the target throughput value will be around 167 (=10000/60). 
  • Calculate Throughput based on: Choose an appropriate option as per the requirement. A description of the option is given below:
  • this thread only: This option allows each thread to maintain its own target throughput irrespective of group. The overall throughput will be proportional to the number of active threads. Let’s take an example: if there are 5 users with 5 samplers and the target throughput value is set to 3 seconds then each thread will send 3 requests per minute separately. So, the triggered request after 1 minute will be 45 (=5 x 3). Each thread will send 3 requests per minute:

5. Add multiple requests 

• Create 9 other requests with another API in the same thread group. 

6. Adding Listeners

• Now all you need to do is run the script and verify the result for that. Click on “Thread group->Add > Listener > View Results Tree”.

• Add below all listeners in the Thread group.

1. 1. Aggregate Report
   2. View Results Tree
   3. View Results in Table
   4. jp@gc – Active Threads Over Time
   5. jp@gc – Response Times vs Threads
   6. jp@gc – Transactions per Second
   7. jp@gc – Transaction Throughput vs Threads
   8. jp@gc – Response Times Over Time

 => Result

• • • Now you can see I am getting the positive response after running my thread group and also verifying that it takes passphrases sequentially.

1. 1. Aggregate Report

2. View Results Tree

3. View Results in Table

4. jp@gc – Active Threads Over Time

5. jp@gc – Response Times vs Threads

6. jp@gc – Transactions per Second

7. jp@gc – Transaction Throughput vs Threads

8. jp@gc – Response Times Over Time

Scenario 2 : How to send 50 requests per second?

=> Steps to Perform API Testing in JMeter

1. Adding a Thread Group

• Firstly, you have to start your JMeter and select the Test Plan.
• Next, Right click on the Test Plan and add a Thread Group.
• Rename the Thread Group and save it.
• Add Thread Group Property as per below.
  • • Number of Threads (Users) : 50
    • Ramp-up period(seconds) : 50
    • Loop Count : 6
    • Specify Thread lifetime : 

                                Duration(Seconds) : 60
                                Satrtup delay (Seconds) : 1

2. Add Constant Throughput Timer

3. Add 50 HTTP Request Sampler

Next, you can search for REST APIs that are freely available on the internet. Copy the Server Name, Path, and Parameters for that particular API.

• Now, select some sample APIs, as given below;
• Go to your browser 
• Search for “some sample rest API for testing”
• Open the first link “https://reqres.in/”
• Let’s create and run GET Rest API requests in JMeter in the demo. 
• Here, in this link, you can GET, POST, PUT, and DELETE Rest APIs.

• So, choose the first link: List Users. 
  • Here, click on the request link
  • Open the link that appears in the new tab
  • Identify the URL for this API
  • Copy this URL and open the JMeter window

• Then in the JMeter window, do the following:
  • Right-click on the Thread Group
  • Navigate to “add”
  • In the box that appears, select “samplers”

• You can see the types of requests that JMeter can work on
  • Choose the HTTP request. 

• Here, you will have to give the address to some home pages or websites
  • In the Server Name or IP box, give paste the GET API request URL 
  • In the Protocol box, put “HTTPS”

• If the URL in the protocol was HTTP, this box would have been left empty. In the URL, put the URL link; remember not to put any slashes in the IP Address. Also, anything after the URL should be put in the path.
  • Now, put the path from the URL in the path box
    

• Next, you must take part of the URL, beginning with the “question mark” and use it to assign the parameters. This is required since it is the GET API type.
  • Add the name in the parameters
  • Give the name as page and value as 2
  • Here I have changed the sampler name as HTTP Request-1 and created other samplers with different APIs as HTTP Request-2 up to HTTP Request-50 as per the below image.

4. Add Flow Control Action

• Flow Control Action sampler is used along with the logical controllers to control the sampler execution.
• To pause (sleep) current or all thread for specified amount of time (duration is set in milliseconds). You could use a JMeter variable or property to set a dynamic value
• To stop the current or all threads after completing the execution of samples in progress
• To stop the current or all threads immediately without waiting for samples in progress to complete. Stop Now option should be selected.

• Now, select Flow Control Action, as given below;
  • Right-click on the Thread group
  • Navigate to “add”
  • In the box that appears, select “samplers”
  • You can see the types of requests that JMeter can work on
  • Choose the Flow Control Action. (Note:  Must be put “Flow Control Action” at ends of the request)

• • Next, set the value as per the below image.

6. Adding Listeners

• Now all you need to do is run the script and verify the result for that. Click on “Thread group->Add > Listener > View Results Tree”.

• Add below all listeners in the Thread group.

1. 1. Aggregate Report
   2. View Results Tree
   3. View Results in Table
   4. jp@gc – Active Threads Over Time
   5. jp@gc – Response Times vs Threads
   6. jp@gc – Transactions per Second
   7. jp@gc – Transaction Throughput vs Threads
   8. jp@gc – Response Times Over Time

1. Aggregate Report

2. View Results Tree

3. View Results in Table

4. jp@gc – Active Threads Over Time

5. jp@gc – Response Times vs Threads

6. jp@gc – Transactions per Second

7. jp@gc – Transaction Throughput vs Threads

8. jp@gc – Response Times Over Time

With these steps, you have successfully completed your API Testing. I hope you understood what is API and how you can test your API in JMeter.

The post API Load Testing Using Apache JMeter (Step by Step Guide) appeared first on OptimumBrew Technology.

Why JMeter is gaining popularity among app testers and app development industry? Does JMeter truly deserve the popularity it is gaining?

To answer this, we have to start with the basics.

1. What is JMeter?
2. Why do we use Jmeter?
3. How JMeter Works?
4. Advantages of JMeter
5. Disadvantages of JMeter
6. Demo 1 : How to Perform JMeter Load Testing

What is JMeter?

JMeter also known as ‘Apache JMeter’ is an open-source, 100% java based application with a graphical interface. It is designed to analyze and measure the performance and load functional behavior of web applications and a variety of services.

JMeter is mainly used for testing Web applications or FTP applications but currently, it is applicable in functional testing, JDBC database connections, Web services, generic TCP connections, and OS native processes. You can perform various testing activities like Performance, Load, Stress, Regression, and Functional testing, in order to get accurate performance metrics against your web server.

JMeter was originally written and developed by Stefano Mazzocchi of the Apache Software Foundation. It was primarily written to test the performance of Apache JServ(currently known as the Apache Tomcat project). Apache redesigned JMeter to enhance the GUI, to add more features and functional testing capabilities.

JMeter is not a browser and it doesn’t render HTML pages like any browser does, rather it works on a protocol level.

Following is a list of protocols supported by JMeter:

• Web Services – SOAP / XML-RPC
• Web – HTTP, HTTPS sites ‘web 1.0’ web 2.0 (ajax, flex and flex-ws-amf)
• Database via JDBC drivers
• Directory – LDAP
• Messaging-oriented service via JMS
• Service – POP3, IMAP, SMTP

Why do we use Jmeter?

In addition to load testing, testers can use Apache JMeter to perform performance, spike, and unit testing.

• Performance testing is the process of determining the speed, responsiveness, and stability of a computer, network, software program or device under a workload.

• Spike testing is a form of load testing which rapidly increases and decreases the load over short bursts of time before returning to an average load. Spike tests simulate a system where there is an unexpected increase and decrease in loads (for example an e-commerce store on Black Friday).

• Unit tests will analyze the smallest testable parts of an application. Jmeter can be used to unit test processes and protocols such as JDBCdatabase connections, LDAP, JMS and HTTP.

While JMeter has gained immense popularity in Load testing, it is also a great tool to test other application areas like APIs, FTP servers, database performance, etc. It helps to measure and analyze the performance of web applications and other variety of services.

Let’s say that your organization recently launched a commercial web application that will be accessed across the globe. Your organization is expecting that it will have hundreds and thousands of concurrent users accessing the website. So, the web servers must be able to handle the user action efficiently.

Your organization is keen to know how the web servers will perform in such situations.

As a tester, you need to provide results in such a scenario. It is not feasible for any organization to arrange that many testers to manually check the performance.

The next question which arises here is: How would you test your website in such a situation? How can you apply such a huge load on web servers and get results?

In such situations, a tool that can simulate real-time user’s behavior is required and thankfully, JMeter is such a tool that can help you do such testing. JMeter has proved to be the best tool for load testing so far.

How JMeter Works?

JMeter simulates a number of users sending requests to the Application Under Test.  As soon as JMeter simulates requests, the server responds and Jmeter starts collecting data. Jmeter saves all the responses and based on the server response it returns statistics. These statistics show the performance of the AUT in the form of various formats as per the requirements.

Thus, with the help of JMeter, we can simulate load on the server, networks, or objects which are coming from different machines to implement real-world scenarios.

=> JMeter Workflow

• The group of users will send the request to the target server.
• The server will respond back to the user’s request.
• Next, it will save all the responses for the given request.
• Now, it returns the statistics information of the targeted server to show the performance of an application.
• In the last step, it will display the performance report of an application.

Advantages of JMeter

• Free of cost – It is an open-source product with zero licensing cost.
• Can load test different kinds of applications – It can be used for performance testing of all kinds of applications ranging from – Web applications, web services, databases, LDAP, shell scripts, etc.
• Platform independent – Since, it is 100% Java-based, so it is platform-independent and can run on multiple platforms such as Windows, Linux, etc. 
• Record and Playback feature – It provides record and playback options along with drag and drop features which makes it easier and faster to create scripts.
• Customizable – Since JMeter is open source, developers can customize its source code as per their specific requirements.
• Supports distributed load testing – It supports distributed load testing features in which we can create a master-slave set up for carrying out load tests on multiple machines.
• Good community support – It has many online tutorials and helps community support. It also has freely available plugins that help in different aspects of script creation and analysis.
• GUI: It is very easy to use as it has a friendly graphic user interface and you can become familiar with it in a short period of time.
• Multithreading Framework: It gives permission for the synchronous and parallel sampling of various functions by using different thread groups.
• Visualize Test Result: By using the JMeter tool, you can view the test results in various formats like chart, table, tree and log file.
• Easy Installation: There is no need for installation. The installation can be done very easily by running the *.bat file.
• Highly Extensible: JMeter allows to extend your own tests by using visualization plugins.
• Supports Multiple Testing: JMeter supports numerous testing processes like Load Testing, Distributed Testing, and Functional Testing.
• Support Multi-protocol: JMeter supports web application testing and also estimates the performance of database server. It gives multi-protocols such as HTTP, JDBC, LDAP, SOAP, JMS, and FTP.
• Script Test: You can incorporate the Bean Shell and Selenium with automated testing.

Disadvantages of JMeter

• Memory Utilization: JMeter reproduces heavy load and generates the information of the test. This leads to the utilization of plenty of memory and produces a large amount of memory from the heavy load.
• Web Application: You can test web applications by using JMeter, but cannot be used for the testing desktop application.
• Limited support: JMeter doesn’t support ajax, javascript, etc. We can’t render it like a browser so we can’t run the Javascript in the web application. It has limited support for the flash and other scripting languages, which will affect the accuracy of the application.
• Lack of Knowledge in Scripting: There is a lack of knowledge to understand scripting in JMeter. It needs some experience for understanding JMeter elements, regular expressions, session handling, etc.
• No visualization features: JMeter doesn’t support network visualization features compared to other performance testing tools like Loadrunner.
• Requires high configuration capacity: Single configuration machine is not sufficient to carry out load tests with a large number of users. In order to meet this requirement, we need high-configuration cloud machines or we have to do distributed testing.
• Limited real-time testing options: JMeter has very limited real-time test monitoring capabilities compared to other tools.
• No vendor support: JMeter is an open-source tool so it lacks vendor support for the application development compared to other commercial applications and their support. Only support possibilities are referring to the open source forums and communities.
• Large-scale testing: In case we want to perform large-scale testing, we have to create test servers and a centralized orchestrator should be built. All such things will become complicated when we use JMeter. It requires dedicated hardware and network resources, so it is unrealistic to perform large-scale testing.
• Lack of cloud adoption: Similar to other on-prem tools, JMeter doesn’t offer an option to host the application on the cloud or management opportunities. If we want our application to scale significantly or have distributed geographies then cloud adoption is a must.
• Excess memory consumption: JMeter can simulate heavy workloads and visualize the test report. It causes major memory consumption and results in the applications running out of memory.

Demo 1 : How to Perform JMeter Load Testing?

Before we begin with JMeter load testing, make sure you have JMeter installed in your system.

https://jmeter.apache.org/download_jmeter.cgi

In this, we are going to create a basic test plan in a few simple steps. 

1. Setting up Apache JMeter

• • The first step is to go to the Apache JMeter folder
  • Go inside the bin folder 
  • Select the JMeter .bat file
  • Double-click on this file

This might take a while, and then the JMeter window will open on the screen.

2. Adding a Thread Group

• • Open the JMeter window.
  • The window is divided into two parts. The left side has all the added elements, while the right side has all the configurations of that element.
  • Rename the test plan and save it.
  • Let’s rename it as the FirstJMeter.
  • Right-click on the test plan.
  • Go to add -> Threads (Users) -> Thread Group

Now once you click on Thread Group, there are three things on the screen that are important concerning the load test:

• • Number of Threads
  • Ramp-Up Period
  • Loop Count

Let’s explore the Thread Group options:

Action to be taken after a Sampler error: These are the actions that can be taken by the user if an error occurs in any sampler. By default, this is set to Continue. let us see what all are the options that actually can be used

• • Continue – To continue with the next element
  • Start next Thread loop – which means stop this Thread group and continue with other thread groups of test plan
  • Stop thread – To stop the current Thread
  • Stop Test – If any error comes stop the test completely
  • Stop Test Now – This is almost the same as above which means to stop the test immediately.

Thread Properties

• • Number of Threads – This is the count of virtual users that we are expecting to connect to the server. For example, if we give 100, Jmeter will simulate 100 virtual users that connect to the server and perform the same steps given. By default, it is set to 1 thread.
  • Ramp-Up Period – This can be defined as the time in which JMeter can bring the number of threads mentioned above into the running state. This is given in seconds. For Example: If you set “Number of Threads” to “20”, and “Ramp-Up Period to 40 seconds”, then JMeter will wait till 40 seconds to make all threads up and running. That means each thread will start 2 seconds late after the previous thread was started.

              Formula: Ramp-Up Period / Number of Threads i.e. 40 / 20 = 2 (seconds)

• • Loop Count – This indicates how many times each thread was supposed to perform the task. If the number of threads is 100 and the loop count is 2 then the same task will be performed 200 times. If this value is set to infinity the task will continue to run until the test was stopped. By default is value is one iteration.
  • below these properties, there are a few checkboxes among which “same user on each iteration” is checked by default.
  • Delay Thread Creation Until Needed – This is to be checked when the ramp-up delay and startup delay are to be performed even before the thread group is created. By default, this is not checked.
  • Specify Thread lifetime – Here we can give the duration and startup delay to the threads.

Note: In all properties of the thread group the time is taken in seconds, not in minutes or milliseconds.

For example, if you set the number of threads as 100; JMeter will create and simulate 100 user requests to the server under test.

Let’s add value in thread property.

• • Number of Threads(Users) : 100
  • Ramp-Up Period(Seconds): 60
  • Loop Count: 1
  • Specify Thread lifetime 
  • Duration(Seconds): 60   
  • Startup delay (Seconds): 0

3. Add an HTTP Request Sampler

• • Right-click on the Thread Group.
  • Go to Add -> Sampler -> HTTP Request

Under the HTTP Request section, HTTP Request gives the path that each thread or user will request. We will set it to be “/api/login” so that each thread can access the login page of our server.

   Any number of HTTP requests can be added. Further, all you need to do is repeat the above step.

4. Adding Listeners

Listeners are something that is used to provide the outputs of a load test. There are different types of listeners present in JMeter, and a good deal may be added using plugins.

The listener we will use here is the Table, as it is comparatively easy to read.

• • • Right-click on the Thread Group.
    • Go to Add -> Listener -> View Results in Table
    • Go to Add -> Listener -> View Results Tree
    • Go to Add -> Listener -> Aggregate Report

Now, it’s time to run the test.

5. Run the Basic Test Plan

• • • Save the test plan.
    • Click on View Results in Table.
    • Click on the Run button (green start button).

• • • Now when you visit the “View Results in Table,” you can see the test running. Same with View Results Tree & Aggregate Report results. Then you can also see the time the test has been executing.
    • You will see the test results in the Table, View Results Tree &  Aggregate Report as shown below:

     Result 1 : View Results in Table

• • • The result shows the status of all the requests as “Success”. Then there are two important columns, Sample Time (ms) and Latency.
    • Latency refers to the number of milliseconds between the time JMeter sent the request and when an initial response was received.
    • Sample time refers to the milliseconds taken by the server to complete the request.

   Result 2 : View Results Tree

  Result 3 : Aggregate Report

=> Statistics

In the feature image above, you can see the Aggregate Report has 13 headers in its table. Let see what do they mean and how to calculate these data?

• • • Label: The label/name of the samples.
    • Samples: The total number of samples executed. 

The formula: Samples = Number of Threads (users) * Loop Count

Example 1: Thread Group has a configuration

– Number of Threads (users): 100

– Loop Count: 1

So, an HTTP Request under this thread group will run 100 x 1 = 100 (times)

—> # Samples: 100

• • • Average(millisecond):  The average response time of a set of results.
    • Min(millisecond): represent Minimum Response Time, it’s the shortest time for the samples with the same label.
    • Max(millisecond): represent Maximum Response Time, it’s the longest time for the samples with the same label.
    • Percentiles(millisecond): A percentile (or a centile) is a measure used in statistics indicating the value below which a given percentage of observations in a group of observations fall. For example, the 20th percentile is the value (or score) below which 20% of the observations may be found.
    • Median: is a number which divides the samples into two equal halves. Half of the samples are smaller than the median, and half are larger (Some samples may equal the median.) This is a standard statistical measure. See, for example, Median entry at Wikipedia. The Median is the same as the 50th Percentile.

           In other words, the median is the time in the middle of a set of results. 50% of the samples took no more than this time; the remainder took at least as long.

• • • 90% Line (90th Percentile) means 90% of the samples took NO MORE THAN this time. The 10% remaining samples took at least as long as this.
    • 95% Line (95th Percentile) means 95% of the samples took NO MORE THAN this time. The 5% remaining samples took at least as long as this.
    • 99% Line (99th Percentile) means 99% of the samples took NO MORE THAN this time. The 1% remaining samples took at least as long as this.
    • Error %: Percent of requests with errors. Eg: the test runs Request A 100 times and got 15% Error, means the Request A has 15 times of error (100 * 15%).
    • Throughput: is calculated as requests/unit of time. The time is calculated from the start of the first sample to the end of the last sample. This includes any intervals between samples, as it is supposed to represent the load on the server. The formula is:

Throughput = (number of requests) / (total time) * conversion

Where:

number of requests = number of executed requests

total time = (lastSampleStartTime + lastSampleLoadTime – firstSampleStartTime)

conversion: the unit of conversion value, for example 1000 will convert the value to the second, 1000*60 will convert the value to the minute, etc.

Example: I will run this test with 100 threads and loop count 1. Refer result below:

I used View Results in Table to collect the Start Time, and Response Time in the easiest way.

firstSampleStartTime: 16:42:03.114 (1672744323114 in ms)

lastSampleStartTime: 16:43:02.405 (1672744382405 in ms)

lastSampleLoadTime: 11ms

total time = (1672744382405 + 11 – 1672744323114 ) = 59302

number of requests = 100

Throughput = (number of requests) / (total time) * conversion

                        Throughput = 100 / 59302* 1000 ≈ 1.7/sec

Let’s check with the Aggregate Report:

And it can prove that the formula works well. Let’s check it by yourself.

Note: The time unit is chosen so that the displayed rate is at least 1.0. When the throughput is saved to a CSV file, it is expressed in requests/second, i.e. 30.0 requests/minute is saved as 0.5.

• • • KB/sec: The throughput measured in Kilobytes per second. The formula is:
      • Throughput KB/sec = (Throughput * Average Bytes) / 1024
      • Where Average Bytes is the average size of the sample response in bytes. We can found this data on Summary Report.
    • Total: The last row in the table is Total, only # Samples, the value in Total is equal to the sum of all values above. For all remaining value, it’s equal to the average of all values above.

You can try the same demo by fluctuating the values of the number of threads or the loop. When you fluctuate these values, the sample time value or other output values will begin fluctuating, telling you if the system is overburdened or just fine.

Conclusion 

By now, you would have understood everything you need to know about basic JMeter and its usage in load, performance, and API testing. Then finally, you understood the process of Load API Testing using JMeter with a hands-on demo.

To know more about JMeter API load Testing with real scenarios, you can have a look at this API Load Testing Using Apache JMeter (Step by Step Guide).

The post What is JMeter? Introduction & Uses appeared first on OptimumBrew Technology.

• What is Regression Testing?
• What are the types of Regression Testing?
• What are the Techniques of Regression Testing?
• How does Regression Testing Work?
• What are the Benefits of Regression Testing?
• Regression Testing in Agile
• What are the Best practices of Regression Testing?
• Difference Between Retesting and Regression Testing
• What are the best Regression Testing Tools?
• Conclusion

What is Regression Testing?

Regression Testing is a process to make changes to an older program and also ensure that the old program still working even after making changes to a program. It is a normal part of software development in larger companies, performed by code specialists. Before the release of a new version of a software product, old test cases run against a new version to make sure that old capabilities are still working.

What are the Techniques of Regression Testing?

Software maintenance is the process of modifying a software application which includes improvements, bug fixing, deletion of existing features, and optimization. When we do these modifications, the system may work incorrectly. To avoid issues while modifying the code, we do follow regression testing techniques. These techniques help us to eliminate the risks associated with the modifying code.

Following are the various techniques.

1. Retest All
2. Regression Test Selection
3. Test Case Prioritization

1. Retest All

All the test cases in the existing test bucket or test suite are re-executed to verify that there are no bugs that occurred due to the modified code. This is a very expensive method as it needs enormous time as well as resources when compared to the other techniques.

2. Regression Test Selection

By using the regression test selection technique, we select a part of test cases from the test suite to run to verify whether the modified code affects the application or not instead of re-executing the complete test suite. This selection of test cases from the test suite is done on the basis of the modified code. The test cases chosen are categorized into two parts such as reusable test cases and obsolete test cases.

Reusable test cases – Test cases that can be used in succeeding regression cycles.

Obsolete test case – Test cases that cannot be used in succeeding regression cycles.

3. Test Case Prioritization

By using this technique, we select the test cases with high priority first to run instead of a medium and low priority ones. Test case priority depends on its business impact, frequency, and criticality.

How does Regression Testing Work?

It is done manually. However, as application development takes time, more and more functionality keeps increasing the scope of regression; therefore this Testing is executed in an automated way.

While preparing a test suite for regression, consider the following –

• Automate all the test cases of a test suite.
• Update the regression suite whenever required, like if any new defect which not covered in a test case found, update the test case for that issue in a test suite. Perform Testing for a bug and uncover it next time.
• Execute regression test cases, whenever changes made in code, perform bug fixing, new functionality added, and also an enhancement to existing functionality done.
• Create a test execution report which includes the pass/fails status of executed test cases.

What are the Benefits of Regression Testing?

• • Change in requirements and code modified according to the requirement.
  • New features added to the software.
  • Defect fixing.
  • Unit testing.
  • Schedule a time to test.

Regression Testing in Agile

What are the Best practices of Regression Testing?

To do this testing, select test cases in the best way. Best practices are as follows –

• Test cases that have frequent defects.
• Functionalities that are more visible to the users.
• Test cases that verify the deep /core features of a product.
• Test cases for functionalities that undergo more and recent changes.
• All Integration Test cases.
• All complex test cases.
• Boundary Value test cases.
• A sample of successful test cases.
• A sample of failed test cases.

Difference Between Retesting and Regression Testing

What are the best Regression Testing Tools?

If your software undergoes frequent changes, then regression testing costs will be very high. In such cases, using manual testing can increase test time as well as costs. However, automated regression testing is an intelligent choice in such situations.

Automaton testing is an area where we can reduce the efforts by using automated regression testing tools. It is an efficient as well as time-saving method. At the same time, the extent of automation depends on the test cases that will remain re-usable over time.

Most of the regression testing tools available in the market are record and playback types. Selecting a proper testing tool is necessary to maintain the quality of software.

Here is the list of top regression testing tools:

• Selenium
• IBM Rational Functional Tester
• Micro Focus Unified Functional Testing (UFT)
• Watir
• SilkTest
• TimeShiftX
• Sahi Pro

These are the standard tools for functional and regression testing. Here is a brief about the list of the most famous regression testing tools.

Conclusion

It is one of the most critical aspects of Testing as it helps to deliver a quality product, providing ensure that change in code, whether it’s small or large, should not affect the existing or old functionality. A large number of available automated tools help in the automation of a regression best test case. A tool should have the ability to update a test suite, as the Regression test suite needs to be updated frequently.

The post Regression Testing: Concepts, Tools & Guide appeared first on OptimumBrew Technology.

• What is Software Testing?
• Why Software Testing is Important?
• What are the benefits of Software Testing?
• Types of Software Testing
• Principles of Software Testing
• Testing Strategies in Software Engineering
• Program Testing
• Which Testing Tools Should You Use?

What is Software Testing?

Software Testing is a process of evaluating the functionality of a software application to find any software bugs. It checks whether the developed software met the specified requirements and identifies any defect in the software in order to produce a quality product. It is basically executing a system in order to identify any gaps, errors, or missing requirements in contrary to the actual requirements.

It is also stated as the process of verifying and validating a software product. It checks whether the software product:

• Meets the business and technical requirements that guided its design and development
• Works as per the requirement
• Can be implemented with the same characteristics

Why Software Testing is Important?

Software Testing is Important because if there are any bugs or errors in the software, it can be identified early and can be solved before delivery of the software product. Properly tested software product ensures reliability, security and high performance which further results in time saving, cost effectiveness and customer satisfaction.

Software Testing is Important because we all make mistakes. Some of those mistakes are unimportant, but some of them are expensive or dangerous. We need to check everything and anything we produce because things can always go wrong – humans make mistakes all the time.

Since we assume that our work may have mistakes, hence we all need to check our own work. However some mistakes come from bad assumptions and blind spots, so we might make the same mistakes when we check our own work as we made when we did it. So we may not notice the flaws in what we have done.

Ideally, we should get someone else to check our work because another person is more likely to spot the flaws.

There are several reasons which clearly tells us as why Software Testing is important and what are the major things that we should consider while testing of any product or application.

Software testing is very important because of the following reasons:

1. Software testing is really required to point out the defects and errors that were made during the development phases.
   • • Example: Programmers may make a mistake during the implementation of the software. There could be many reasons for this like lack of experience of the programmer, lack of knowledge of the programming language, insufficient experience in the domain, incorrect implementation of the algorithm due to complex logic or simply human error.
2. It’s essential since it makes sure that the customer finds the organization reliable and their satisfaction in the application is maintained.
   • • If the customer does not find the testing organization reliable or is not satisfied with the quality of the deliverable, then they may switch to a competitor organization.
     • Sometimes contracts may also include monetary penalties with respect to the timeline and quality of the product. In such cases, if proper software testing may also prevent monetary losses.
3. It is very important to ensure the Quality of the product. Quality product delivered to the customers helps in gaining their confidence.
   • • As explained in the previous point, delivering good quality product on time builds the customers confidence in the team and the organization.
4. Testing is necessary in order to provide the facilities to the customers like the delivery of high quality product or software application which requires lower maintenance cost and hence results into more accurate, consistent and reliable results.
   • • High quality product typically has fewer defects and requires lesser maintenance effort, which in turn means reduced costs.
5. Testing is required for an effective performance of software application or product.
6. It’s important to ensure that the application should not result into any failures because it can be very expensive in the future or in the later stages of the development.
   • • Proper testing ensures that bugs and issues are detected early in the life cycle of the product or application.
     • If defects related to requirements or design are detected late in the life cycle, it can be very expensive to fix them since this might require redesign, re-implementation and retesting of the application.
7. It’s required to stay in the business.
   • • Users are not inclined to use software that has bugs. They may not adopt a software if they are not happy with the stability of the application.
     • In case of a product organization or startup which has only one product, poor quality of software may result in lack of adoption of the product and this may result in losses which the business may not recover from.

What are the benefits of Software Testing?

Here are the benefits of using software testing:

• Cost-Effective: Testing has many benefits and one of the most important ones is cost-effectiveness. Testing our project on time can save money in the long run. Software development consists of many stages and if bugs are caught in the earlier stages it costs much less to fix them.
• Security: It is the most vulnerable and sensitive benefit of software testing. User are looking for trusted products.  It helps in removing problems and risks beforehand.
• Product quality: It is an essential requirement of any software product. In order to make your product vision come to life, it has to work as planned. It is important to follow the product requirements because it helps you get the required end results.
• Customer Satisfaction: The ultimate goal for a product owner is to give the best customer satisfaction.  Software should be tested in order to bring the best user experience possible. Being the best product in this saturated market will help you gain trustworthy clients which will have great long-term effects.

Types of Software Testing

Here are the software testing types:

Typically Testing is classified into three categories.

• • • Functional Testing
    • Non-Functional Testing or Performance Testing
    • Maintenance (Regression and Maintenance)

This is not the complete list as there are more than 150 types of testing types and still adding. Also, note that not all testing types are applicable to all projects but depend on the nature & scope of the project.

Principles of Software Testing

Testing of software is exceptionally imaginative and an intellectual task for testers to perform. Testing of software or applications consist of some principles that play a significant role for a software tester while testing the project.

The post Software Testing : Basic, Types, Tools & Guide appeared first on OptimumBrew Technology.

Table of Contents

• What is STLC (Software Testing Life Cycle)
• What to use the STLC for
• The role of the STLC in the SDLC
• What are the STLС phases
  • Requirement Analysis
  • Test Planning
  • Test Case Development
  • Test Environment Setup
  • Test Execution
  • Test Cycle Closure
• Conclusion

What is STLC (Software Testing Life Cycle)

The Software Testing Life Cycle (STLC) is a sequence of specific actions performed during the testing process to ensure that the software quality objectives are met. The STLC includes both verification and validation. Contrary to popular belief, software testing is not just a separate activity. It consists of a series of methodological activities to help certify your software product.

The STLC is a high-quality strategy directly associated with and part of the Software Development Life Cycle (SDLC), which in turn is a framework with 6 core principles:

1. Requirements analysis;
2. Planning;
3. Engineering and design;
4. Software development;
5. Testing;
6. Deployment.

In simple terms, the SDLC is a cycle where actions at each stage are reflected in subsequent stages.

The STLC also has its stages and most closely intersects with the SDLC at the fifth stage, which I’d describe below.

What to use the STLC for

By knowing that the STLC is a set of measures, we can assume that it includes various stages, such as planning, control, implementation, standardization, and so on. All this leads us to the fact that the STLC is needed not only to test the developed product but also for the following:

• Removing its shortcomings during the earliest and most profitable stage of development;
• Increasing the quality and transparency of the development process;
• Maximizing control over the quality of the product being developed at all stages of the SDLC;
• Influencing the application of Agile, Scrum, SAFe, etc.;
• Delivering a quality product not only to the Client but also to the Users.

The role of the STLC in the SDLC

As mentioned earlier, the Software Testing Life Cycle and the Software Development Life Cycle are closely related to each other, but they simultaneously pursue different tasks of the same goal, namely:

• collecting the requirements in the desired form and developing the declared functionality (as for the SDLC);
• analyzing requirements, assisting the client and the development team, and confirming the quality of the implemented functionality (as for the STLC).

The overall goal is client satisfaction and achieving the highest possible score at the Verification and Validation stages.

The role of the STLC in the SDLC can be represented with a double line graph:

Where the SDLC and the STLC lines move in parallel for most of the project but begin to converge rapidly during the software development phase with deep synchronization during the SDLC Test phase. This graph is relevant to many different types of projects, not just large or independent ones, and will remain the same for the implementation of a task within a project and reverse for a project with a huge number of iterations (but in this case, the lines will diverge and converge more often).

What are the STLС phases

The STLC has several interconnected phases and is generally very similar to the SDLC system. These phases are sequential and are called:

1. Requirement Analysis;
2. Test Planning;
3. Test Case Development;
4. Test Environment Setup;
5. Test Execution;
6. Test Cycle Closure.

Let’s take a closer look at each of them.

Requirement Analysis

Requirements analysis is one of the most important phases because this is when you can fix project flaws almost completely free of charge. The requirements analysis phase also identifies the potential need for automated testing and allows making economic calculations of labor costs based on the project estimation. This is also when the Entry Criteria and the Exit Criteria are discussed and documented.

Test Planning

At this phase, a test plan is formed. This is the concretization of all phases of the testing itself, timing, participants, and responsibilities. As a result of this, we receive data on:

• the participants and their roles in testing;
• the necessary testing tools;
• the necessary test environment.

Test Case Development

Test development implies using manual and automated testing to achieve full coverage of the software’s functionality, with the process being based on the requirements set up beforehand. More often than not, the test cases for automated testing are written separately, since the cases for manual testing are described in the form of cheat sheets.

Test Environment Setup

The test plan makes it clear which test environment should be used. At this STLC phase, operating systems and virtual machines are configured, testing tools like Selenium, Katalon Studio, and the project’s test environment and databases are deployed. We also make requests to DevOps and Admins if support is needed.

Test Execution

Tests are performed based on ready-made test documentation and a correctly configured test environment. All test results are recorded in the Test Management System. Negatively passed tests, where the actual result differs from the one expected, are recorded as errors and transferred to the development team for revision with subsequent rechecking after correction.

Test Cycle Closure

The last phase of the STLC is the final generation of testing reports for the client. These should include the time spent, the percentage of errors found to positive test results, the total number of errors found and fixed. As far as the testing department is concerned, this is the moment for analyzing its work, summing up the results, analyzing its productivity, and the opportunity to make suggestions for improving the quality of testing.

Conclusion

Now that we know what the STLC is and what it is for, we can say what the graph of interaction between the STLC and the SDLC will look like with full certainty:

The fact that the closest point of convergence happens during the “Test Execution” stage is direct proof of the importance of testing in software development. At the same time, we see that some phases of the STLC and the SDLC are very similar to each other both in name and in meaning, which suggests that the Software Testing Life Cycle and the Software Development Life Cycle are inevitably linked at all stages of software product development.

The post What is Software Testing Life Cycle? appeared first on OptimumBrew Technology.