ReadyAPI Reviews

My experience with Katalon Studio is that we used Katalon for one of our projects, and then I started leveraging Katalon by integrating it with AI tools, AP tools, and aptly tools. Aptly tool is an add-on which we can integrate with the existing Katalon. So we didn't have any licensed tool as such, but I integrated a tool to one of our case studies for our clients and made use of it. Predominantly, I used Katalon without using a license just to show our clients that we can use Katalon full-fledged for one of our automation scripts, which already existed for different tools. That is how I started with Katalon.

Beyond Katalon, I've also worked with other tools, including TestIM, which we used for automating mobile applications and APIs.

For payments, I worked predominantly in the ed-tech domain, enabling a student to select and enroll in courses. This required payment processing where we automated a dummy payment gateway using REST API. The entire enrollment process was seamless, ensuring smooth transitions from selecting courses to payment deductions.

For non-functional testing, I focus on performance and security. For performance and security tests, I used REST API, SoapUI, and JMeter. These tools help us conduct thorough testing across these dimensions.

I find ReadyAPI helpful especially in overcoming security issues, as we experienced slowness in the application after merging our JAR files. For instance, if a person wants to access a university database and encounters a timeout error, we learned through ReadyAPI that the issue was due to HTML protocol limits with the payload. We fine-tuned this process to display the expected data effectively.

I consider ReadyAPI a cost-effective solution because it covers three verticals without needing to purchase separate tools for security, performance, or functional testing. ReadyAPI is a versatile tool for creating multiple testing frameworks and validating various parameters seamlessly.

REST API is the tool I use to test all three types of articles, meaning I validate the APIs I send to my peers or clients for functional testing, and I also perform security testing to ensure the URL and data passed through multiple components adhere to policies and user privileges. This is done through functional security testing using the REST API tool, and for performance, I ensure that applications can be accessed simultaneously by multiple users without hindrance or slowness through thorough performance testing.

My primary use case for ReadyAPI is for companies dealing more with backend services. ReadyAPI provides services for accessing these services, conducting testing, generating test data, and offers Docker containers for cloud integration. This capability makes it feasible to integrate ReadyAPI right out of the box into any cloud environment, including private and public cloud environments.

ReadyAPI enhances my workflows by allowing us to use Docker containers based on the ReadyAPI test runner. It helps extend our functional tests, even though we are not heavily using performance testing. It supports a wide range of protocols such as Kafka and GRPC, depending on the project. It also aids in faster feedback to developers, allowing them to implement developments in a sprint without the need for extensive testing afterwards, thus improving our time to market metrics.

I use ReadyAPI for API testing and functional testing. We have transitioned from using SoapUI to using ReadyAPI, and we utilize it for verifying request and response from the backend. We also use ReadyAPI to generate data based on responses, storing it in our internally-created database.

ReadyAPI is valuable for web service automation and allowing us to generate test cases and automate processes. We use it to verify request and response from the backend and to generate and store data in the database. The Groovy scripting feature is essential, although sparingly complex compared to other tools.

Our use case for ReadyAPI is REST API Testing. We essentially test student data because we're working for a school domain that can have different ReadyAPI test cases.

We have the positive test scenario where we collect real-time data and they pass through ReadyAPI, then post different data types for students, such as the school students enrolled in, whether students are full-time or part-time, what courses the students took, etc. There are positive scenarios and negative scenarios that we try to create in the system, including some junk data, then we'll see how ReadyAPI will behave.

ReadyAPI being a tool, means that you can also feed it any junk data, and it's going to post that data, but what we'll be looking forward to is the HTTP code generated towards the end of the day, to see whether it's valid or not.

If there are irrelevant data, for example, there's an address field that can accept any characters, that should be fine, but if we have a name that we need to find and we provide some special characters, then ReadyAPI will give an error message similar to this "Hey, it looks like you're using special characters, so that won't work for me."

There are multiple edge cases, but it isn't about the tool. It's about the applications being used, and there may be some loose ends within the applications. Edge case scenarios could come up, such as the positive scenario and the X, Y, and Z scenario, and ReadyAPI helps us and makes it easy for us by allowing us to post the data. It lets us create multiple test cases, for example, if we have fifteen resources for a test case, we can tightly bundle those resources under one test case, then execute the test case, then ReadyAPI will run everything under that particular test case.

ReadyAPI solves different business problems, and I've seen that, particularly in the education sector where I worked. One is that because ReadyAPI is a licensed tool and it's deployed on-premises, you can host multiple data sets on it. You can host more than a million records on ReadyAPI, and it will still be able to run because it's deployed on an on-premise server. It essentially runs on the CPU, and you don't need to consider resource utilization as much, compared to other tools that depend on memory space, so those tools are unable to run more than fifteen thousand or twenty thousand data, while ReadyAPI is very helpful in that area. The tool is also more user-friendly than other tools.

I use ReadyAPI for all things API testing – functional, migration, and security testing. It helps me automate tests, ensure reliability, and spot performance issues. The tool offers versatility, especially in virtualizing APIs and integrating with CI/CD.

The most valuable features of ReadyAPI are its robust functionality and collaboration capabilities. It excels in collaborating with tools like Jira, and its reporting capabilities are a game-changer for me. 

Our company uses the solution's SaaS to provide API testing for customers. 

Our quality and automation engineers use the solution. Senior directors randomly open it to ensure that it is working fine. Everyone thinks the solution is convenient to use. 

Most scripts are developed by automation engineers and used by different groups of people who are only comfortable with manual testing. They run scripts but some have challenges with the solution's Groovy programming at first because they are completely new to programming. Other than that, running scripts and using the tool is quite simple. 

The solution offers a wide range of API testing capabilities. 

The built-in Smart Assertion capability allows us to validate API responses quite easily without additional data inputs. You can easily add a table with unlimited rows and columns to pass line input. In contrast, Parasoft SOAtest sometimes requires an Excel document as input. 

Reporting is more robust than other products because test reports can be exported in multiple ways such as JUnit, Excel, or Azure. The most surprising thing is the built-in Azure capabilities because Azure uses a different framework. Previously when we worked on Java or Selenium projects, we used Azure as a dependency and imported that utility. Now, we can complete these projects within the solution's built in functionality.

The integration with GitHup and HTML is very good. 

The backward capability ensures scripts developed in very old versions also run on new versions. 

We have a product, a financial application, that uses a lot of services to connect to our backend systems, so we use ReadyAPI to test those services. Primarily, we use it to build out or mimic the exact services that the development team uses. Second, we use it to build out scripts in Groovy to automate certain scenarios and verify without any manual intervention.

The feature that allows you to import an API collection or a project is valuable. It reduces a lot of manual effort to give the endpoint and the parameters, etc. If the development team gives me the collection, I can directly import it into  ReadyAPI and it maps the entire project so that I can start hitting the APIs directly.

Our web application is completely dependent on backend APIs. Instead of automating all the clients' use cases, we make sure that all the backend APIs are automated and are false-proof so that any issues can be tackled upfront. 

On the client side, we have a UI where a user will interact with the application. On that end, it's simply the API that is being called and is fished through the UI that is getting rendered. We capture all those APIs and connect them using ReadyAPI.

We use ReadyAPI to automate our APIs and make sure that all the individual APIs are automated with different possible positive cases and negative cases. Then, we use an end-to-end test where we used to have multiple APIs. In the past, we used to combine all the APIs for a scenario, whereby a particular API would get a value that we would pass to other APIs. In the final result, we have assertions, the Groovy script, which is in ReadyAPI.

For anyone who does not have experience with automation, ReadyAPI provides a sense of comfort, especially for testers who find it hard to go directly into coding. It is a good solution to start with.

ReadyAPI has a cool feature called Smart Assertion. This feature lets you add different values to your response which can be asserted, and you'll be able to modify that. It requires a click of a button and the assertion will get added. 

The assertion which is currently built into the tool would be more than enough in 95% of the scenarios. In less than 5% of the scenarios would you need to write a code to make sure something needs to be really asserted. 

ReadyAPI has been around for a while, it's stable, and it's from a strong brand, SmartBear.