OpenText UFT One Reviews

We are using Micro Focus UFT One for automating the test cases.

The most valuable feature of Micro Focus UFT One is you are able to use it with many other technologies. I have not had an instance where the solution was not able to automate or execute automation. I was able to use COBOL to manage some automation.

Micro Focus UFT One could benefit from creating modules that are more accessible to non-technical users. Without a developer background or at least basic knowledge of VBScript, using Micro Focus UFT One may not be feasible for everyone. This is something that Micro Focus, now owned by OpenText, should consider in order to cater to business professionals as well. While Micro Focus UFT One does have a recording function, it still requires a certain level of IT proficiency to create effective automation, which may be challenging for those outside of the technical field.

I have been using Micro Focus UFT One for approximately two years.

The stability of Micro Focus UFT One is good.

We have 10 people in my company using this solution.

The solution is scalable.

The support could be improved.

I rate the support from Micro Focus UFT One a seven out of ten.

Neutral

The initial setup of Micro Focus UFT One was not difficult. However, we had an IT team do it.

We had our IT team do the implementation of the solution.

We have seen a return on investment using Micro Focus UFT One.

The solution is priced reasonably for what features it is providing. However, it might be expensive for some.

I would recommend this solution for those who do repetitive activities in testing. 

I rate Micro Focus UFT One a nine out of ten.

We use Micro Focus UFT Developer because we had a desktop-based application. To automate it, we used UFT for the automation framework and to run tests, including the regression test, smoke test, and integration test. We use the data from the UFT framework.

We had 10 users. That's where the license challenge comes into the picture because we couldn't afford that many licenses, so we had to reduce the team. We don't have plans to increase the number of users because we have been using UFT One for the past three months.

The solution is deployed on-premises.

UFT is very strongly built. It's widely used, so there's a lot of support.

They need to reduce the licensing cost. There's pushback from customers because of the cost.

The tool also takes a lot of memory. It's really heavy on the CPU. If I need to run the virtual machine, I cannot go beyond 8GB RAM. 

I have used this solution for four years.

The solution is stable.

Technical support is good. I didn't work with Micro Focus directly. I used Stack Overflow and another blog. People who have used Micro Focus technical support have told me that it's good.

We're currently using UFT One.

Deployment was quick. We're not on the cloud and all, so everything was done manually. We haven't faced any challenges in deployment.

Deployment was completed in-house.

We have reduced 20% of our total efforts. A lot of automation has been put into place.

The licensing cost is high. There are no additional costs to the standard license.

It's a yearly subscription.

The current proof of concept is for Tosca.

I would rate this solution as eight out of ten. 

I would recommend this solution to those who want to use it.

For desktop-based applications, the automation is good. They offer wide support if you're stuck with anything. There are a lot of support groups like Stack Overflow and other community groups where you can find the resolution for a technical issue. There's a lot of support because it's an older tool. 

It's pretty comprehensive and easy to learn. The industry is full of open source and cheaper options because everything is moving to the cloud. For instance, Tosca poses a challenge to HP. Micro Focus should reduce the license cost. Otherwise, they will be very much cornered in the market.

We use Micro Focus UFT One for testing web pages and the script is in AngularJS.

Micro Focus UFT One could improve by having more maintenance. Every time when we run the solution and develop something, the next time when we run it it doesn't recognize the object. I have to redesign the object again and then run the solution. It's really a headache, it's not consistent.

I have been using Micro Focus UFT One for approximately three years.

Micro Focus UFT One is not stable.

The scalability of Micro Focus UFT One is good.

The support from Microsoft is not good. They are very lazy in answering anything. If we create a request, it takes months for them to respond to us.

I have used previously C Sharp and Selenium HQ, and I prefer them over Micro Focus UFT One.

The setup of Micro Focus UFT One is easy.

I would advise others to use Selenium HQ and C Sharp because they are better, consistent, reliable, and scalability than Micro Focus UFT One.

I rate Micro Focus UFT One a five out of ten.

We use it for automation. It helps to automate test scenarios for graphical user use cases.

Historically, we have faced a lot of maintenance issues with automation using traditional UFT, because UFT has a mechanism for identifying an object where you have to add object properties. However, if a change happens in the application and your object properties change, then you have to go and update the object properties again, only then can you use those scripts. So, we were using a lot of personnel for script maintenance. Whereas, in UFT One, I like that our maintenance costs have been reduced by a lot because UFT One is using an artificial intelligence feature to identify objects visually.

We use it to do multi-platform testing. 

UFT One Automation provides Codeless Test Automation.

The solution will automatically run a script, so you need less knowledge to run a script.

OpenText UFT One gives us integration capabilities with both API and GUI components. I like the user interface. It doesn't require that much skill to use and has automatic settings, which is useful for users who don't know what to select. It also has dark and light themes.

It improves automation efficiency.

The AI feature needs improvement. For banking applications, we input formatted text from documents, but the AI feature is recognizing three fields as one field, e.g., for a phone number, it puts all 10 digits in the international code or country code. Then, the script fails. 

I have been using UFT for the last seven or eight years. UFT One was just launched three or four months back, so I have been using it for a couple of months. 

It is reliable. Sometimes, the GUI does crash.

It is highly scalable. 

There are around 150 users of UFT One with 8,000 test scenarios running four times a month. We are also running around 500 scripts in UFT One.

Our internal team is sufficient for technical issues.

We have used a lot of different tools. We have used Selenium and Python as well as Java-based REST API for regular testing. With UFT one, we have all the solutions under an umbrella, so we don't have to think about other tools. It also supports API and HTML testing. Selenium only supports Java, and there is no support for HTML.

We didn't need to do too much with the initial setup because there is an installation team.

It takes one or two days to create test automation scripts.

Object maintenance is reduced.

We have not yet implemented the license for the AI features. However, I got a chance from OpenText to join a Hackathon for India when they launched the product, which included the AI feature. I am hoping that my company will implement this feature soon because the solution's AI capabilities will reduce my test creation time.

Every day, tools are getting smarter. UFT One is like this.

Before implementing, do a demo with your existing applications.

I would rate this solution as an eight out of 10.

I personally have experience with UFT One, yet only with the GUI part. I'm not familiar with the AP part. There are projects which work with UFT One and also with the AP part as well.

It's not a capture-and-replay. We don't use this only for getting something into the editor. There are possibilities to materialize the scripts.

We use the object repository, which is really great. And so is the way objects are organized in UFT and the way you can use modules by yourself - not the actions, rather, the self-scripted modules in the function library. That's the main benefit for us.

It's simple to set up. 

Last year, we had a discussion with Micro Focus, and they said they have plans to switch from DBS to Python - or at least to offer Python as an additional programming language for building automation scripts. Then, there was no progress in these plans. That's our main concern with UFT. PBS, as the programming language, is pretty old-fashioned, and a lot of things would be much easier with Python.

We had problems with the last version of the solution. There seems to be something wrong with the loading of external data into the internal data sheets. We loaded Excel sheets dynamically during test execution and stored them into the built-in data sheets of UFT, and it seems that sometimes you cannot reuse already existing internal sheets for storing new data in it from outside, from external Excel sheets. We used it a lot, and we didn't have any problems with that in the previous version. This is a new issue, and we tried to isolate this problem, and then we wanted to discuss it with Micro Focus directly. We have yet to contact them.

The solution is expensive. 

We've worked with the solution across several releases. We've used it for about ten years or so. 

The licensing is scalable. That said, the product itself is the product and we really build large test sets with hundreds and thousands of test scripts. So we didn't have any problem scaling the test sets, so to speak. Just not the product itself. I don't know how to scale the product itself.

There are a few alternatives when you want to automate tests for non-web applications. For example, Java applications or PowerBuilder applications, or .NET applications. UFT One is really, really good. When you only have to automate tests for web applications, then Selenium is maybe the better solution since it is much cheaper. It costs nothing as far as I know. You have to learn some programming language, however. You need to use Python or Java or something else in conjunction with Selenium. Maybe the first hurdle is a little bit steeper than using UFT. Then, when you can build some framework around Selenium, then maybe when I would have the personal choice, I would choose Selenium - only for web applications. While we know that there are some alternatives to UFT for non-web applications, we know there are not that many. Tosca is one of the big players. However, we don't know it. We only know that it exists, and most people who use it say it's really good.

The initial setup is pretty easy.

When I installed it on my virtual machine, it was less than an hour, and then it's up and running. We are well trained in such things, so maybe for one who is really new, this will take two or three hours to set up. I don't know. That said, it's not a major concern.

The pricing could definitely be lower. I don't know the prices by heart. I'm not the one who discussed this with Micro Focus. I've heard several times that this is really expensive and we also have problems exactly for that reason. For example, for a user interface test to Selenium. At least when the SUT, the system under test, is web-based. There's not only the buying price. It's also the maintenance price. 

I'm an end-user.

Currently, there is a 2022 version. For a couple of reasons, we've switched back to the 2021 release. We thought that we found an error in some strange special scenarios.

It's extremely useful for us with a little bit of potential to become better here and there. I would give the product an overall rating of eight out of ten.

We are working with a desktop-based application and we use the solution to automate testing of the application.

UFT One has helped us to reduce testing timelines. Earlier, during our manual testing days, it would take 15 days to certify a release, but with UFT One and automation, we are able to achieve that within five days. That's how important it is. It also improves the quality of our testing.

We have also seen an improvement in test coverage, going from 80 percent to over 90 percent.

In addition, it helps in identifying defects earlier. With manual testing, that 15-day timeline meant there were times when we would find defects on the 11th or 12th day of the cycle, but with automation we are able to run the complete suite within a day and we are able to find the failures. It helps us to provide early feedback.

There are a few limitations when it comes to automating desktop-based application testing. You need a medium to run the test cases. We used to run it as a test suite. OpenText provides that in terms of a test management tool as ALM, but when we think of integrating with a distributed version control system, like Jenkins, there isn't much integration available. That means we need to make use of external solutions to make it work. We have other apps which help us to integrate all the tests into a dashboard. So one area for improvement would be to allow us to run that test suite.

We would also like to see improvement when it comes to generating reports.

OpenText UFT One is the latest edition, but I have been using UFT for four years.

UFT One provides pretty good stability.

Scalability isn't really applicable to us because we have 10 virtual machines and UFT is installed in all of them. Jenkins is what takes care of the scalability, based on the workload. It allocates the jobs to any number of servers that are available.

I don't know how many people are using UFT One in our company, but on our team we have 15 people working with it. They are testers and automation engineers.

Plans to increase usage depend on the new initiatives that are coming up. For about a year and a half we have been using UFT on 15 virtual machines, to its full potential. There are plans to increase its usage, because there are new projects coming up and we intend to deploy UFT on them.

If there are issues, when we reach out to the support team, they are able to assist us. It may be something like we were running an older version and there was a new deployment that created this kind of issue. But the support team is always able to assist us. I would rate their technical support at nine out of 10 or even a 10.

We didn't have a previous solution. We were looking for a solution where, once the elements of the object repository are created they stay there. Also, when there are changes to the application, how quickly would it be able to transition as a result? We were mainly looking for object identification and consistency of the tool.

There aren't many tools on the market for automating desktop application testing, but one of them is OpenText UFT. We tried UFT and it seemed to be suitable, so we started using it for automation testing. It suited our requirements for desktop application testing.

We tried TestComplete, but I was not part of the team when the decision was made to go with UFT One.

Everyone has their own requirements, but based on my experience with UFT, I have found it to be very consistent. If anyone is looking to automate web-based or mobile-based applications, UFT is very good. My advice would be to try it and explore UFT a lot.

Using it, we have learned how to design our framework and how to adapt it to improve our test suite. We have learned how to write effective test cases and how to improve the usability of the functions that we add.

AI is kind of exciting but, at the same time, it's not available for desktop-based applications yet. So we are waiting to make use of AI. In general, AI helps to reduce testing time. It increases the amount of reusability and it also makes the tester's life easier by asking them to identify the objects and differentiate them. In addition, it helps to identify any elements that could be missed by the human eye. Those are the features that we think will be helpful for us, once they are available for desktop application testing.

UFT (erstwhile QTP) is a widely popular test automation tool. During my initial days, I used UFT extensively to automate test cases. Now, with the latest version of OpenText UFT One, there are added features that address the new-age testing requirements. In my current position as Practice Head of Test Automation competency at a Tier 1 company, we propose various befitting tools to our existing or new customers. Whenever we work on a particular solution or requirement, we propose automation tools to support the entire environment to support end-to-end automation. If my customer is looking for an automation solution, they will typically ask, "Can you provide a solution to automate my end-to-end scenario?" Every proposal or potential requirement is a new business case for us.

In some of our recent customer requirements, we have proposed the OpenText UFT One tool. The primary reason behind this is that a customer may have different systems, for e.g., a mainframe system, which is a legacy technology, their current web applications, like AngularJS or ReactJS, could include SAP ERP. In such an ecosystem, UFT One is the right fit to automate end-to-end systems.

Scripting is a basic feature of UFT One. Some tools may use programming languages like Java, Python, or Ruby; but UFT One uses a very basic, simple programming language called VBScript. The advantage of VBScript for a manual tester is if he/she has a basic knowledge of automation, and loops/conditions, then he can easily understand whatever script is created in UFT One, using VBScript. The point is that VBScript is very easy to understand with minimal knowledge. It can easily be modified as per requirement. UFT One all the technologies including a legacy to modern technologies.

For one of our customers, we proposed integration between UFT One and Azure DevOps (ADO). We were able to easily establish that integration, which means the solution's integration capability with third-party tools is s. With some tools, you may need additional effort to communicate with source code management (SCM) tools, whereas UFT One connects easily. There is a keyword view available in UFT One. Using that keyword view, you can see all the statements in proper order.

UFT One has its own feature called Test Combinations Generator to prepare test data. If I have data in an Excel file, then it is very easy to create an object in either Notepad, file system object, or database object. We can easily retrace the data.

Particularly, I like the Help feature in UFT One. For example, if you are navigating a particular window, where there are different options. One wouldn’t know the purpose of every option, but there is no need to search because that window contains a Help button. If you click on that Help button, it directly navigates to the respective help needed.

UFT One supports AI features to automate web and mobile applications. For example, suppose, if earlier there was a button in the left corner, which now has moved to the right corner. In such a situation, we would need to update the script. However, with AI, there is no need to update the script. Within the screen, if that particular button is placed anywhere on the screen, then we can easily handle it and the script will not fail. The integration part is very easy for mobile automation, as well.

We can also automate PDF and forms, using UFT One. For example, one of our customers prepared a lot of macros in an Excel file and created their own custom options in the toolbar. Their requirement was to automate the Excel file, but not read the data, so we had to handle the different icons in the Excel file. Therefore, it generated the pivot table, selecting different options in the pivot table and validating some third-party applications.

UFT One can automate different technologies like SAP, Oracle, SFDC, Microsoft products, Mobile applications, and many more technologies.

From a sales pitch perspective, everyone is now looking for script less automation, whether they are using the feature or not. So, if UFT One is made as a script less tool entirely, that would be very good.

UFT also has a recording feature. They could make the recording feature window bigger for whatever activities that I am recording. It would improve the user experience if they could create a separate floating panel (or have it automatically show on the side) once the recording starts.

We have been using the solution for 13 to 14 years. I started by using an older version of UFT One, Quick Test Professional (QTP) 6.5.

UFT One is 100 percent stable. There have been no crashes of any kind.

It is easily scalable. It supports increases in automation as well as integrates with third-party tools, like ALM Octane and Jenkins.

OpenText technical support is prompt. They will try to get you a proper solution to your inquiry.

It is very easy to install and configuration is not required.

Deployment time takes three to four minutes, though it depends on the RAM and performance of the processor. However, if you install MS Office, that will definitely take some time.

Our customers are always looking to reduce their efforts. This solution will give you such an advantage.

Depending on the landscape and stability of the customer application, they should see ROI (or the breakeven point) within six to nine iterations.

The license is important. If the license is up and running when you open it, there won't be any issues.

Compared to other tools in the market, UFT One is very cheap. The recent Covid pandemic situation also hit customer budgets significantly, so OpenText offered some discounted prices, which is definitely competitive.

There are a lot of tools available in the market, however, the primary advantageous feature identified in UFT One is simple: It supports legacy to modern technologies. This is why I propose UFT One.

Everybody is aware of mainframe systems because of Y2K. This solution supports a lot of terminal emulators that communicate and connect to mainframe systems. That is one of its key advantages. Some automation tools provide only a fewer number of terminal emulators, but UFT One supports a lot of terminal emulators to communicate with mainframes.

If someone is new to test automation, we will typically propose UFT One.

OpenText recently started offering UFT One as a PaaS, which has been helpful for our customers.

I would rate this solution as a nine (out of 10).