OpenText UFT One Reviews

We use the solution for defect tracking and test automation features.

They should include AI-based testing features in the solution for assessment and identifying potential databases.

We have been using the solution for more than ten years.

It is a scalable solution. I rate its scalability as a ten.

The solution's customer service is excellent. They always prioritize our tickets.

Positive

The solution's initial setup process is easy. I rate it as a ten.

We purchase the solution's yearly license. It costs 700k. There are no additional costs involved.

The solution is easy to integrate and adapt for manual testing. It manages tests very well. It is an excellent tool in terms of customization. I rate it as a nine.

Micro Focus UFT One is an automation tool, that is primarily used to automate web and desktop applications.

It is very simple to use, and the scripting language is even easier.

Object Identification is very easy. 

The integration with other test management tools is good, which is very good.

When it comes to pricing Micro Focus is expensive, and it doesn't support test case panel execution.

I think that over time, Micro Focus has not really understood the market needs.

They are still improvising the UI. 

They need to really understand how this tool fits into the DevSecOps ecosystem. We have been giving that advice, but they have not taken it into account.

I would want to see a significant improvement in the tool's features. The most significant enhancements are support for panel execution and integration with DevSecOps.

I have been working with Micro Focus UFT One for ten years.

We are working with the latest version.

It's very nice. The stability is good.

Micro Focus UFT One is a scalable product.

We have approximately 100 end users in our company who use this solution.

I am reducing my usage slowly. I am reducing 30 to 40% of the licenses.

We have contacted technical support. They're fine. I don't see the benefit in the chats I had with them about the issues we were having. They are, nonetheless, fine. Our requirement was a far more serious issue. As a result, they were unable to assist us. They're fine, though. They are quite knowledgeable.

Previously, we did not use another solution.

The initial setup was very straightforward.

We did not need any assistance. We are good with the knowledge that we have internally.

We have to pay for licenses. The licensing fee is paid on a yearly basis.

The price is one aspect that could be improved.

I would not recommend this solution to others who are considering it.

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

I recently took became a QA for our company and was trained on various tools including the solution as part of job orientation. 

We have 100 engineers in our company who use the solution for automation testing. 

It is very easy to create shared repositories that can be used throughout all testing. This feature makes our jobs easier. 

The speed could be improved because a large test suite takes some time to execute.

The solution's size could be improved because it takes up a lot of space. 

I have been using the solution for one year. 

The solution is very stable. 

The solution is scalable. 

There was one issue so support was emailed for assistance. I am not sure of support's response because it was handled by our unit manager.

The setup process could be improved because reinstallation is required if you miss an add-in during initial setup. It would be beneficial to have an installation outline or information about selecting add-ins. 

Deployment is quick and takes only a couple of minutes. 

Technical support from Edgewood guided us through the initial setup and installation. 

One in-house engineer can handle ongoing maintenance. 

Our engineers were also were trained on and use TestComplete. 

I like the direction the solution is heading and am really happy with how they keep adding new features. 

I rate the solution an eight 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.

The solution is in the top list for automatic functional testing. It enables you to test a lot of infrastructure, a lot of applications: web, not web, with the different protocols, and so on.

HP UFT can do GUI testing (Graphical User Interface testing) and also can test directly web services using different protocols.
In the first case, the tool interact directly with the graphical interface, recognizing the objects inside (buttons, links, titles, etc.) and interacting with them (clicking, compiling forms, etc.); so the test is done like a human tester do, but automatically.
In the second case, the tool use the web services of the back-end of the application under test, that can be of different protocols (SOAP, REST, database queries, etc.).

At this moment, we are using version 12. Version 14 will be released soon.

It is very flexible. There are a lot of features. We can do a lot of things with it.

We use it to automate our integration testing. This lowers our total cost because tests are done automatically rather than manually by people. This saves time. With automatic tests, we can run different types of tests simultaneously. This is the most valuable thing.

There a lot of things that can be improved:

• Support for other environments and other infrastructures.
• I hoped that it would also be useful for the internet of things and big data. At this moment, it is not useful at all for big data. I don’t really know for the internet of things, but I think that it's not very substantial; but I hope that it will be in the future.
• For automatic functional testing, it works fine and covers a lot of statistics, but there is always something that doesn't work. It could be little or not.

I have been using this product for six years. When it totally changes in a new version, the stability is not very good. For example, when we changed from version 11 to 12, from my point of view it was a mess. It was totally not ready to go into production in companies. Now it very much seems to work for some things. It is not stable, of course; but remember that we are working on different environments. It could be that something doesn't work.

The scalability is good. They add a lot of features with every new release. I just learned about the two things that are being added now that are valuable for my organization.

It works fine at this moment. We had some problems before with the product. They understood that we were in trouble, and now they are giving us support. Normally, if a company is not having any particular problems, technical support is a little bit slow; but, in the end, if you wait, they either solve the problem or promise to fix it in the next version.

I did this kind of work for some years, so when I did the setup in the organization where I am now, I knew how to set up the product. It was a little bit simple. From that point of view, it is a normal installation; so it's okay.

It wasn’t involved in the decision to buy this product, but I would say the top vendors: IBM, CA, or Oracle.

I saw some products that are very simple. Ease of use is one of the best things and most important about HPE products.

Other products, for example, are less easy to use, but they work fine.

HP products sometimes have a lot of bugs to fix. You get in trouble sometimes because you want to adhere to some timelines, but then you find that the solution doesn't work. This is a mess for you. The issues of reliability and licensing are also very important, of course, when choosing a vendor.

If you want something that covers a lot of testing topologies, use UFT because it has a lot of features. If you are looking for something simpler, and don’t need a lot of automatic functional testing topologies, then maybe I could suggest something else.

We are currently using it for migration.

Micro Focus UFT One is useful. However, there is an issue with the scripts. We are going to collaborate with multiple automatic specialists to identify the problem. If we can fix the issue, we will continue with UFT, otherwise, we'll switch to other automation tools.

The high-level security, high standard and compatible SAP are great.

The solution does not have proper scripting, which impacts the solution. We are currently deciding whether we want to keep the UFT and will decide by the end of December. We paid a lot of money for the UFT, and we will only drop it as a last option.

We have been using this solution for four years. It is deployed in the client-server application with SAP.

The performance is not great, which is why we are currently conducting a review.

The solution is very scalable for a UFT. We have more than ten people using this solution.

There is a gap in technical support which is also part of our review. We've raised issues in the past, which have not been fixed in two years.

We used QTP and LoadRunner in the past.

Our deployment was completed in-house, and we have an in-house software development and architecture team. We do all our products and services and also provide services to third parties.

I rate this solution an eight out of ten. Micro Focus UFT One is outstanding. All HP processes are excellent. I used to use HP Test Director, HP QC and HP ALM. So I am confident that Micro Focus UFT One is useful.

We primarily use the solution as a front end for testing for our customers, to automate installations, for behavior testing, and for various types of API testing. We mostly use the technology on our websites, and sometimes on older technologies, such as for Oracle Forms applications.

One of the ways the product has improved our organization is that we are able to quickly get detailed information about the behavior of our applications, and we can provide this information to our customers through screenshots and additional information so that they can also easily check the reason for the defect or bug. We can work together without our customers needing special knowledge of programming. This is very important.

UFT allows us to install our applications much more easily, without our customers having to do anything. They don’t even need to click on anything. We can use UFT One to install via scripts. This eases the installation process.

The solution has allowed us to reduce test execution time. If we use it in continuous integration or in headless mode, it improves performance. Between the normal run mode with debugging, and the fast mode in Jenkins, it can reduce it by about 30 percent. That's a lot.

We can run the solution on virtual machines. This greatly affects our ability to control machine configuration and allocate appropriate resources for testing. We wouldn't be able to conduct tests or to carry out work without this solution. This is both very helpful and useful and we consider this a necessity.

The most valuable features include

• the simplicity with which the product can be maintained
• the ability to reuse its components
• the record and play
• AI

We haven't been using the AI feature for very long.

These features allow us to provide good functionality to all our customers without the overhead of maintenance costs, while at the same time allowing us to work with many customers with varying capabilities on different projects. With only a few technicians we can help a lot of customers.

Running the solution on virtual machines allows us to run tests in parallel. It reduces a lot of the time it takes to test or to do certain kinds of work. We are dealing with customers who give an API to their customers and they're using our tools in the background. As a result we must use it to scale the load for these tests. This is a very important and useful feature.

There is a lot of room for improvement when it comes to friction-free continuous testing across the software life cycle, as a local installation is required to run UFT. Most of the time, administrative rights are required which necessitate much trouble to integrate it seamlessly. When integrated, it works fine, but to maintain it in CI, special systems and privileges must be utilized. This is challenging for us.

In addition, UFT One has a Jenkins plugin that provides us the connection we need to OpenText so that we can obtain our UFT test cases. The problem is that the plugin does not come with exception handling, meaning that if we enter the wrong credentials we don’t know why it does not work. This can lead to the Jenkins server crashing.

Another issue is that we can't address the UFT output to the Jenkins console. This means that when carrying out our tests in a continuous integration server, we cannot know what the UFT tested, step-by-step.

The usability can also be improved. When we receive new versions of UFT, some of the icons are altered so that things are not recognizable to us or to the customer.

Another issue is that the application requires slow work. If you go too fast while debugging, the Step Over button may easily change to the Stop button.

The Git integration is also a point when it comes to continuous integration. There are aspects that are not recognized by Git. We cannot do a side by side comparison of changes, such as comparing the QSL side and the object repository side.

When they updated UFT from version 14 to 15, they changed the data table structure of UFT, such as the first data line turning into the column name. This is a problem as our customers may have different versions of UFT. An example would be if we wish to change the data table of version 15 but a customer has version 14, it can be problematic. This destroys the tests.

Another question we have is why everything is in read mode during the execution. With other IDEs, like Visual Studio, you can change the variables while you execute or debug something, and this is not possible in UFT. It's only in read mode, so you can’t play with variables or objects.

Also on our list is the fact that UFT allows you to work on 11 or 12 tests. If you want to change something with search and replace, you can only change it in the 11 or 12 tests that are open in the solution. But what if we have a 13th test case that is not included in the solution? We then need to open that test after we have already searched and replaced. That's a little bit inconvenient because other IDEs give you the opportunity to make those changes everywhere, in every script, not only the 11 or 12.

We have already addressed some of these issues with technical support, but not all of them have been handled. For example, we brought up the issue of the icons changing with every version some years ago and nothing has happened. It gets worse and worse from version to version.

We also have menus and instructions for our customers, but because all the screenshots become outdated with the next version, we have to do maintenance on them all the time. And it’s not because of new functionality. Most of the time, only the icon style and the design is changing and sometimes it’s the positioning that changes and we are not able to reconfigure it. We end up having to do a lot of work without any need for it.

The old VBS language can be a nuisance. It could be easier to use and it could be better integrated in continuous integration pipelines. And it could always be faster.

OpenText UFT One has been available for around two years. We have been using it since inception.

The stability is very good, except for the example I mentioned regarding the data table. Most of the time you can switch to the next version without any problems. The old features and behaviors are, in terms of the code base, the same. It’s just that you have to find the icons, asking yourself “Where is my feature?” But the stability is very good.

We use the product as often as we can. Between 50 to 100 people are using the solution. We are constantly looking for additional customers and projects so we have ongoing plans to increase usage.

The overall scalability is very good and utilizing the licensing server allows us to scale the solution as we need. One area which can be improved involves the running of instances on a single machine.

Overall, if you are able to reproduce an issue, their technical support can help you. But sometimes it can be very hard to find a technician with a high level of technical background and knowledge of the product, so that they can understand the situation, the problem, and the behavior. This can be a challenge. Sometimes we have had to escalate to get a technician with the necessary background and knowledge.

We utilized QuickTest Pro (known now as OpenText Unified Functional Testing) for between eight and 10 years.

We found the initial setup to be very easy. It is very robust and leaves no room for making errors. The availability of config files for setting up all the installations from a single master configuration is nearly perfect. The customer would have no problem simply opening the machine and using it.

As for deployment, the time can vary. Sometimes there are only minor changes and sometimes there are a lot more changes. Including tests, and to be sure it’s working in all cases, it should take no more than one business day.

It’s the same for upgrades. OpenText support has advised us that, in case of an error or a problem with upgrades, they cannot be sure whether that problem would exist on a clean installation. So we always uninstall the entire product and install it on a clean system.

We use one or two people for deployment and maintenance, in the role of test automation engineers.

Even without being able to provide exact figures, this product has given our company a return on its investment.

If you use it all the time and for different use cases then it is a good price. If you only use it one time a day for half an hour then it is pricey.

The ability of the solution to cover multiple enterprise apps, technologies, and environments is very important to us and it forms part of our company policy. It is a point we had to validate before going with this solution. The reason for this is that we must meet the technical needs of our customers, many of whom lack a technical background.

UFT One provides cross-browser and desktop application support, although the cross platform support, which is not good, is not so important to us at the moment. These capabilities are important to us because our customers are using different kinds of technologies, some that are newer, some that are very old, and all kinds that are in between. To provide a good solution, the cross-browser and cross-platform functionalities are very helpful and necessary.

UFT One gives us integration capabilities with the API and GUI components, which is very important to us since we must occasionally alternate between the two. We can use the API to make calls through scripts, so we don’t have to use the GUI for UFT One. That’s why it’s important for us to have the REST API.

We can run the solution on virtual machines. This greatly affects our ability to control machine configuration and allocate appropriate resources for testing. We wouldn't be able to conduct tests or to carry out work without this solution. This is both very helpful and useful and we consider this a necessity. We have 100 percent usage of UFT on virtual machines -- All our instances are running on them. This allows us to help the customer access his application under test. The customer can configure the system with permissions and the like. All these points are, in some cases, not possible on hardware in our company, because of political restrictions, security reasons, et cetera.

The solution has allowed us to reduce test execution time. If we use it in continuous integration or in headless mode, it improves performance. Between the normal run mode with debugging, and the fast mode in Jenkins, it can reduce it by about 30 percent. That's a lot.

Overall, it's really easy. Try it out. There is nothing one can do wrong.

The most valuable feature for me is that it works on multiple platforms and technologies. I need that because we have an application based on Oracle Forms and Oracle DB, and I'm not aware of any other tool that would provide the same level of functionality.

Since I started, we invested in UFT and automation and we have significantly reduced our release cycle time. That has freed up the people who were doing manual regression testing to do more valuable work. The net result is that our cycle time has gone down by a factor of hundreds of percent. And year-on-year, over the three years our error detection rate, by the same people who are now doing good manual testing, has increased by over 300%.

One thing that confused me, and now just mildly irritates me, is that we migrated from QuickTest Pro to HP UFT, Unified Functional Test. After we did the migration, it turned out that we didn't really have Unified Functional Test at all. We only had the functional test piece of Unified Functional Test. Which, from a marketing or an understanding point of view, was a little bit questionable. So then I needed to go and spend a significant sum of money to get the "Unified" aspect of the Unified Functional Test.

It’s awfully stable. Not even something I consider, to be honest, in regards to UFT. It's always worked for the last ten years. It just works.

We have not really had to scale it much. It is something that we're looking at, which is why I spoke to some representatives at a recent conference. One thing that's unclear to me at the moment is the benefits, or otherwise, of integrating the UFT product with the architecture that we're going towards; more open source and continuous development, continuous integration type tools. I know HPE does integrate, but I'm not sure how and where it integrates and what the benefits are.

I have used technical support and it was okay. What I was doing, in fairness, was fairly non-standard. I was transferring licenses between different locations, different countries, different currencies, different regions; it was all part of the takeover process. It was a little bit complex and drawn-out, but we got there in the end.

UFT was already installed upon my arrival to the organisation. However, having said that, it is the solution I would have gone for. UFT really doesn’t have a comparable competitor in that space. They used to have competition, but I don't think they really have competition anymore.

The UFT is a simple product. With the exception of the licence server, a six-year-old can do it.

The licensing and pricing model is confusing.

There's actually two parts to this, because we use UFT for two different functions. For one of those functions, there really were no other vendors on a shortlist. For the other technology stack, we were looking at SmartBear. We were looking at Selenium, which we still use some. We were also looking at various open source tools. The reason we went for UFT specifically was because you could integrate API testing with client-server type testing, which was important to us.

When looking at a vendor, I look for stability first, but that's almost a prerequisite anyway. What is really important to me, and will be increasingly important to me, and I'm guessing, the majority of our customers or potential customers, is HPE's and their product’s ability to integrate with an ever diverging technology landscape. That's the difficult part.

I would tell those looking for a solution to go back to good old-fashioned tool selection based on analysis criteria. Do the homework properly and have an appropriate set of expectations. Get vendors in and have them demo against your application or specification as opposed to generically. Do the CBA appropriately and be wary of open-source tools from the point of view of maintenance and support. But, at the same time, don’t pass over on those, but embrace them. Look for a solution that would allow them to exist in a sometimes chaotic and potentially ever-changing landscape from a technology point of view or architecture point of view. Do not to overthink it.