OpenText UFT Developer Reviews

In a very small location, we are using this solution for the infrastructure-related applications for testing and with a very low number of licenses, only two. 

We are planning to change to SAP S/4HANA.

The cost is the most important factor in this tool.

Feature-wise it's okay, and it's comparable with other tools. All of the features that we need for our testing are available. 

We have additional features such as reporting, and one other important feature, in UFT, is the AI-based object recognition plugin. This is a good feature in UFT.

UFT is more code-based, and we have to have knowledge of VB scripting to prepare the automation test cases. This is an area that is lagging behind with UFT.

One of the biggest challenges we face is not being able to easily interact with ALMs, other than HP ALM. This is an area that needs improvement.

In the next release, I would like to see the connectivity improved to be less complex and more stable. 

Also, they can improve the coding interfaces to be easier and closer to English or any other international language, rather than a programming language.

I recently started with this solution just two months ago, but the company has been using this tool for ten years.

This solution is quite stable. We have been using it for ten years with no technical challenges involved.

At times, we do have some problems connecting with other ALMs because somehow it is a managed connection.

There are many sharp and live connectivities provided by the UFT with other ALMS. We may face some hacks at times.

We have not yet explored this area, because we are extending our requirements and our requirement is not expanding a lot.

In the future, we have to scale it for mobile applications and for other non-UFT areas. We may have to purchase additional licenses for mobile testing.

I think that this tool is scalable, but have not used this feature yet.

Technical support is good. 

They are very quick, the response time is very good. 

We are satisfied with the support.

The initial setup was quite easy.

It's one installation file, then everything was just connected to the server. 

There is no complexity in the installation.

There are some tools in the market that are cloud-based and are much easier to use because you only have to log in and use it.

Pricing is the biggest feature. When we compare in the market with other tools that have similar features, it may be a little bit extra, but the cost is ten times less.

We are planning to use SAPS/4HANA for migration testing and to have more licenses for more testers.

If someone is starting right from the beginning, I would not recommend they go with UFT. Instead, I would recommend Tosca.

The good points in UFT are the cost, it's easy to use, the installation is quite clear, the licensing model is quite good, and the object recognition feature is very good.

The con is that the code-based it not a good thing. Tosca has better features in terms of analytical capabilities. The impact analysis is available in Tosca, yet not offered in UFT. 

I would rate this solution an eight out of ten.

I work a lot with guys who work with meta-mathematics, like applied maths and quantum mathematics. So for us, the most important feature is the ability to handle complex algorithms, such as fuzzy logic techniques which is the first step towards artificial intelligence in our field. The support for containerisation and continuous learning, adapting to our needs like support for DevOps practices, is paramount in our work.

By strengthening our understanding of our problems, HP’s solution allows us to be able to define problems. From an executive level to the lowest level, every company needs to be able to understand the infrastructure of every single aspect of challenges that businesses face today. It has helped us be able evolve to change.

In future releases, I'd like to see disruptors such as IOT and test drones. For some of the new stuff that’s coming through, we need to have a clear, well-defined road map of when we’re going to receive new capabilities and new features. This allows us to plan and better work with our customers so that we know exactly when to tell our customers to expect these new capabilities. These industry disruptors actually shape how companies are able to deal with these new technologies. So there’s always room for improvement.

It’s kind of irrelevant to us because it has to continuously evolve. We have to drive the product to adapt it towards our needs. So for us, we are responsible for the future stability of how we choose to adapt the solution to our needs. New technologies come out every single day, and we need to constantly evolve towards our new needs.

It’s designed for scalability. Cloud maps and complex ecosystems, which we’ve got today, even the internet, they’re all made up of nodes. And being able to scale is paramount to evolving those nodes. This solution gives us the ability to scale however we like, which is why we use it. There’s no use having 50,000 nodes that run wild and can’t be controlled, so allowing us to control it is the value of the product.

My view is that we have to have access to the product boards in order to give feedback on how the direction of the product is going. Technical support is good right now, but we, as users, need to be able to own control of how HP chooses to change the product.

I believe in evolution before revolution. I actually saw the birth of the product, which arose through demand from R&D teams to create it in the first place. This has been a global need from a tier-one investment bank that needed a solution that could stack across that many. One of the things I wrote was a charter that stated what we needed in terms of an automation solution for our needs.

Within a week, two of my global customers were able to leverage their automation through this solution. The adaptability of how this slotted in was just amazing, which was incredibly efficient. Our customers demand these results quickly, and this solution was able to deliver extremely well.

Tools like this only existed within companies, but now with the advent of HP’s product, we’ve been able to see a solution that can address problems that arise in the workplace. The open innovation is now able to be integrated, and we hadn't see a solution that was open previously.

First, continuous assessment, continuous insight and quality, as well as testing that continues to be driven onwards. We have to think about the end-to-end stack, from problem definition to solution delivery, a solution that sees the whole end-to-end lifecycle of the application. The whole vision is important for me.

The problem with automation is that, to research products, if you type in Google what you want to look at, you see a generic subset of the information that applies to you. If you’re paying for something, evaluate that against your own needs and your own company. Your choice of vendor should be working with you in working through your needs specifically from now on and into the future; and if they don’t, don’t choose them. You have to understand where you are now and where your tool should get you to.

This solution is used for testing. It is usually used with our Quality Center solution.

The most valuable feature for UFT is the ability to test a desktop application.

You need a more modern language to write test cases in because Visual Basic is not powerful enough.

I have to keep the remote machine open while the tests are running, otherwise, it leads to instability.

I have been working with Micro Focus UFT Developer since approximately 2011.

It can be very unstable. Basically, right now when I go running any of those test cases, I have to keep the remote machine that I'm running it on open, and can't minimize it or anything like that, because it's dependent on the actual location of the elements on the screen.

This is unlike Selenium, where you could run remotely and not have to log into the VM. On the UFT, you have to have it open and it's got to be up there. I'm assuming you are not running in on your own local machine, but rather in another environment. If you are running it on your own machine then it's going to be moving the mouse everywhere and you won't be able to get anything done. In my mind, this defeats the purpose of automation, to begin with, because you're stuck having to watch the testing.

This solution is not scalable at all. We have a test suite of approximately 45 test cases and things take three and a half hours to complete. I've got to sit there watching it the entire time.

I have worked with Selenium and while it is better in some ways, Selenium is not able to handle desktop applications

The licensing is very expensive, so often, we don't have enough VMs to run all of our tests.

We have a lot of manual test cases that are still waiting to be imported into UFT. The way it was set up was that they imported Excel spreadsheets. They never went in and defined the test steps or integrated with our Jira requirements.

My advice for anybody who is implementing this product is to make sure that you've got your manual test steps documented somewhere for when the tests fail. In my case, I'm working with many tests that were written by other people. I'm trying to run them, and then debug when half of them are failing. There's no documentation around to explain what the tests were even supposed to be doing. So, the bottom line is to make sure that you've got documentation.

I would rate this solution a five out of ten.

I am a software developer and at my company, we use this solution for testing a banking ATM application that is written in C#. There is a customer screen that is part of a simulator for physical devices and different scenarios such as card and PIN entry have to be tested. Example test cases can be things like insufficient funds to dispense or it does not have the required bills. Another might be that the printer raises a hardware error. There are approximately 500 scenarios to test and in some, it will reject the transaction.

We have UFT deployed on a TFS server and the test agents are running the scenarios on virtual machines.

The most valuable feature is the automation of test cases.

UFT is sometimes difficult to run. For example, the customer application is represented by an embedded browser control, waiting for input. If I want to recognize the browser then I need to first start the UFT Pro environment. This can be done from Visual Studio or the management console. The problem is that UFT is not able to identify the object that is inside the browser. In one of my test cases where I have to select the card, I need to right-click on a picture and then select an item from a drop-down menu. I had opened a ticket in version 14.02 and I spent two weeks speaking with people from Nigeria, trying to convince them that there is a bug in the software. I was finally redirected to the engineers who solved the bug, but they sent me a DLL patch as opposed to an official update.

The support from Micro Focus needs a lot of improvement.

My simulator is able to create a receipt as if it were printed from the ATM. However, in the current version of UFT, I am not able to perform an OCR on it correctly. The accuracy is about 20%. When I told support that our code was written in C#, they showed us some Java code and were convinced that it would work simply by using Java instead of C#.

I would like the Object Finder Application Center to be improved. It is a plugin that is used to recognize the object on the screen, but it runs very slowly and crashes often.

We have been working with UFT since 2017, almost three years.

I am currently having some issues with stability, although I'm not sure if it can be attributed to UFT Pro or the virtual machine. The errors require me to restart. It may have to do with the simulated environment being 32-bit where the maximum memory is four gigabytes. It is possible that there is an error in the configuration of our virtual machine.

I think that this solution is scalable.

All of our test cases run automatically and this solution is used by our entire team, which is about 15 people.

I would rate technical support a one out of five.

When I ask for something on the Micro Focus page, I never get a reply. It also took me a long time to get a reply and the answers that I received did not always fit my inquiry.

Prior to my work with UFT Pro and C#, two others had been writing tests using UFT Basic. This requires that the tests be written in Visual Basic. They are very slow and the Visual Basic version generates a lot of duplicate code. The C# version allows me to use a special library that helps to avoid code duplication.

The initial setup is straightforward. The deployment took about two hours.

The only issue we had is that the ACL needed to be configured with the firewall.

I deployed UFT Pro on my own.

I did evaluate other options in the interest of changing solutions.

I tried UFT Testpack, which is a library for testing but it isn't very scalable. I also tried Atrium from Selenium, but it only works on Windows 10 and it is unable to automate Java Swing applications. There is a software application from SmarteSoft that is written in Java, but I didn't find a tool that was capable of automating this application.

I requested a trial of the most recent version and I have not yet received a response.

The biggest lesson that I have learned from using this solution is that I cannot automate everything. That had been my initial goal.

Even with the problems that I have mentioned, I think that this is one of the best solutions on the market right now. I tried changing solutions but I was not able to fully automate my application. If they just improve the support then it would be great.

I would rate this solution an eight out of ten.

We use UFT Pro together with other test organization tools. There are many testers or developers that are not used to UFT. They haven't been using it in many other places. But when they've been working with it for a while and they see the complexity when you're doing real and tough test situations, then they see that this kind of tool is very, very good.

The benefit is the ability to find and create different objects.

The tool is not the problem. The problem is that we can't get the tool working, because there are other issues. We had a meeting with all the banks and several customers had the same problems. There should be a smarter and quicker way to upgrade UFT Pro.

It must be on the roadmap now, because they really lost with Mobile Center when they released a new version and it was not backwards compatible. It's not very easy for big companies to provision new versions. We have 38,000 PCs in organization, and we're not allowed to do anything on them. Everything has to be taken step-by-step. It does have a learning curve.

The stability of UFT Pro is much better now. It was a little bit slow with hanging on with your techniques, with your browsers and all of that. Very often, they opened a browser, and suddenly UFT didn't work. 

We are not allowed to be admin on our machines. We have to distribute out applications and that's a problem every time there is a new version of UFT. How do we do an MSI patch and what are they writing in that register? What is needed to be opened in that directory? And so on.

We bought small, five-license versions of Test Director from Mercury in 2007 and it has continuously grown since then. Today, we have 600 users and 130 active projects. The environment gets bigger and bigger all of the time.

The first time we installed was a long, long time ago. It's complicated to upgrade.

We use UFT Pro for all user testing platforms. We use the standard installation but we use UFT in two models. One is used for testing all functionalities in our environment and the second is one we are developing to use as a solution to test the availability of the environment in production. So UFT will check out the performance of the production environment every 12 minutes to be sure that the entire environment is stable. If we don't have any problem, the information is stored in a database and we do a BVD (Bank Vault Drawer) analysis of the information in the database for checking all banking applications.

The application we are developing is J2EE (Jave Enterprise Edition) and we will have the information about the functionality. If we have a problem we call a team to send issues to them so they will work on this application to correct the problem in production. Using the same of monitoring, we will be able to monitor all availability and all access to an application really using only UFT.

We use UFT to model for testing functionality in environmental tests, and after that, we use UFT to check and monitor all access and all applications to be sure these things are correctly functioning or not.

It gives us the opportunity to serve banking clients while conforming to industry regulations. 

The ability to evaluate live applications in our production environment for unusual behavior and determine problem areas and solutions is the most valuable aspect of this solution.

As far as things that can be improved, it is a good solution so I think I can only do a comparison. We also use QC/ALM (Application Lifecycle Management [Quality Center]). It's a global solution that is managed with information from UFC from all over the environment. It has to be integrated with UFT. Really UFT could have this functionality built-in.

We have 40% advantages and 60% disadvantages in our setup of UFT. This is because with UFT, we also have the problem that we have to use Windows Server and I would like to use Linux. For Selenium, we can use Linux so we have good performance. But we can't use UFT with Linux.

It is impossible because in UFT we have to develop for UFT with VBScript and VBScript is only for windows and not for Linux. Another problem currently with the UFT — I think it is resolved in the new generation of UFT — is that we can't run tasks in parallel. In the new version, we can improve our workflow if we can choose to allow multiple tasks at runtime. So there is a problem with that currently. 

In Selenium, our development is done with Java technology — J2EE. So if we have an online community and we have a Selenium grid, we can run multiple tasks in realtime. We can't do that in UFT now because of its requirements, so it's a problem for us. When they come out with a solution for this issue, the product can be more flexible like Selenium and it will be a great benefit to us.

To make UFT better, Micro Focus has to make UFT work in a stable environment. Right now, UFT is a problem all the time. It would help to have a community and a special forum for UFT, and even that is missing. We have good forums in Java and for Selenium, so it is possible to get solutions easily for those products. I think it would not be hard to do for UFT, and it would be better for UFT users if we had a good website. Users could help themselves and share knowledge and address problems and make up for the lack of support. We also don't have training for UFT. It is like they just made a product and don't care to support it. It is a good product, but not so perfect that it doesn't need support. I have to go to France to get certified. We don't have that ability here in Morocco. We cannot send everyone there, so it is a problem.

The UFT product is not stable. We often have issues in production that we have to deal with. We have specific people who are our support connections at UFT. If we need to report an issue we send an email to support and wait. After that, we correct the problem with their instructions or we install patches that they send. Patches are not a real solution. Because of this, the support does not seem very good to me in making the product stable. Patches do not make an application stable and may not be widely tested. They may cause other issues.

For comparison, for insurance clients, we use Selenium which is always stable or we fix it quickly ourselves.  We can't do the same with UFT. 

Actually, we communicate with our DevOps (Development and Operations). So, I integrated UFT with Jenkins for testing and better communications. But the integration is not stable. Because it is not stable and does not function well, we have an extra nightly job to use Jenkins for checking in if all the environment is okay with tests created in UFT. Some days this tests okay. Some days it does not test okay. If it is not okay we need to reboot the system and generate a new job. It has a problem 50% of the time. So, it's a problem. It's not stable.

You can scale the product in some ways by integration. You must purchase expensive licenses which they have two kinds: seat licensing and concurrent licenses that can be shared. Each license is expensive, so scaling is expansive.

The support for UFT is not good. When we send email to forums or support, we may get a response, and maybe we won't. When we do, the solution is not always good.

I switched from development to quality testing. Since that time, I used many products including UFT. We had some solutions in basic. After that, I used several products for testing including UFT, Selenium, Cucumber, QCALM (also known as just QC), Dynatrace and more to check on the environment that things like memory and CPU were functioning as expected. Some of these things I would still use depending on the situation. It is not necessarily the product that made us need to switch to UFT. It is the business need and regulations.

Our installation was straightforward. We install the instances ourselves.

We use our own team who works to do the installation and maintenance.

It works as a solution to serve a certain clientele that we cannot serve with other products.

I think the cost of UFT is too high and obviously expensive, especially if you consider that there are other even better products, in my opinion, that are open-source. Because of the expense, we use UFT only with big companies. For a small company with a smaller budget, we can't choose UFT because UFT is very expensive.

Because we need to properly support people in banking and follow regulations, we use UFT. It is really more of a political decision than a proper choice as to the products we would prefer to use.

We had Selenium first because it runs on Java — which is a stable language — we could use it and adapt it for all we needed to do. As a developer in Java with 10 years of experience, I could resolve our problem myself and not need any help. If I have a problem, I check the internet, I go to stackoverflow.com or visit one of the many forums for Java. So I guess my problem is that with Selenium I can check the problem, fix it myself, and I can do it right away without having to wait for a response from support. 

A second benefit to Selenium is that it is open-source. It's not a costly choice. We have the opportunity to install in whatever platform we want, and that is good for us — It could be Unix, Windows — It doesn't matter. It is good as a more flexible solution. 

Third, we use the platform for continuous integration. We have Dockers which we use for all containers and helps us prepare all our environments in simple ways. It's very easy to use, very easy to deploy, it's very easy to install and very easy to understand. The framework we use with Selenium is something we can use for all the functional testing for insurance products. Selenium would be what I would use for banking if it were possible.

I prefer other products like Selenium to UFT, but each product has its advantages. For example, in UFT we can test HTML protocol for the web applications and also desktop applications. Selenium is for web applications only. That is its limitation. If you have to test both and want to install only one product, UFT has an advantage.

Because of all the problems and limitations of the UTF product, I would rate it at only a four out of ten (where ten is the best and one is the worst). By comparison, I would give Selenium an eight out of ten. You can see I think UFT is not my favorite product and it is not good for everyone.

I would say the most valuable is that we can get people started off really quickly on solutions because we've been partners with HPE for a long time and it helps us tailor the product to ours needs. When we have issues with something we can get support directly from HPE since we paid for it.

The fact that it works with a vast number of technologies works for us because our internal customers use the tool for testing a lot of different applications. That's probably the best feature that it has for us.

There's a lot of centralized testing from some perspectives and our main goal is to provide for a bunch of different groups at a lower cost so we centralize licensing and distribute it to various people. The biggest benefit of that is that it allows us to empower the people that need the solutions instead of manually having them develop the solutions on their own.

LeanFT could support additional technologies because we use it for a lot more than just web and Java and some Windows apps. Further support for other technologies would be nice. I can't rattle any off the top of my head but ones that we use internally.

We don't scale it out on as large of a basis as ALM.

Our biggest issue was in the switch over from HP Inc. to HPE. I think we had some trouble getting in touch with higher level support so we spent a lot of time going through basic support where the people that work with the tools have a lot of experience with the tools. We think that it would be better if we could bypass the lowest levels of support on some issues. I can understand the process that we usually have to go through but more recently our reps have been helpful in getting us to the people that we need quicker so we can get a resolution.

I'd say to set it up it's pretty easy. Defining a standardized way that everyone could use it is a little bit harder. It's a very complex tool, there's a lot of ways to use it so I don't know if it's a limitation of the tool per say as just a common industry problem. I wouldn't say that there's anything that made it hard to get to the customers and to start utilizing it.

It's newer so it doesn't support as many technologies which makes the investment a little bit harder for us to absorb more licenses than we currently have or to justify buying any more licenses than we currently have because it only supports a certain subset of our customers.

We primarily use the solution for automation testing.

The test data management is very easy to use. It is a very valuable feature. The client application testing is relatively easy in UFT as well.

The parallel execution of the tests needs improvement. When we are running tests in LeanFT, there are some limitations in terms of running the same tests simultaneously across different browsers. If I'm running a test, let's say to log in, I should be able to execute it through IE, Microsoft Edge, Chrome, Mozilla, etc. This capability doesn't exist in LeanFT. Parallel execution of the test cases across different browsers needs to be added.

The default activation of the services should be reduced to a bare minimum. When you install it out of the box, it enables everything and slows down the system. This needs to be adjusted to improve performance.

The solution should have better integration with the test management tool.

The solution is slightly buggy, but there are certain workarounds. It's a maturing product that's still being developed. That means there are certain bugs we have to deal with. For example, we have to restart the machines where the tests had been running for a sustained period because the solution crashes. This happens occasionally, not every time. 

The solution is quite scalable. You can go to thousands of developers because it works on the client-side. UFT itself has limitations, but when you move to UFT Pro, which is now called LeanFT, it is moved to the client-side. Scalability has improved significantly.

We have about 40 developers on the solution currently. We use it extensively as part of continuous testing and we intend to do have 100 people for automation testing. This wasn't possible earlier because it was not at the developer end. 

Since LeanFT gets pushed to the developer, it's on the same IDE, and it always has the developers developing the code. Alongside co-development deal, the same developer also develops the test scripts. We are using it extensively and we intend to achieve 100% coverage for automation testing. 

Technical support is not good.

It's a new product and the developer community's using it aggressively and it's fitting in well with the dev-ops life cycle as part of continuous testing. The demand is high, the product is new, but the product support team is not able to cope with the dynamic requirements from different customer segments. Support is very slow in addressing issues because of these dynamic requirements.

In our case, eventually, the company arranged for the LeanFT project manager and global project manager to come to our office to spend two days and listen to our concerns and to prioritize addressing those concerns. I think that until the product is matured, the support will take time to stabilize.

No other product has been able to provide continuous testing and to make a developer responsible for automation testing and all the tools needed except the LeanFT. Mainly, there was only one competitor, Selenium, which is open-source. Since it's open-source, it has its own limitations, which is why we did not choose them.

The initial setup was very straightforward.

We implemented the solution on our own.

We use the on-premises deployment model.

I would recommend the solution. I don't think there is any substitute for LeanFT as of now. Some users may be charmed by Selenium because it is open-source, but there is a good part of that community which has gone through the Selenium curve and they know how much time it takes to develop the test scripts with Selenium.

If they were to evaluate LeanFT, they would easily see the difference. One of the important features, which speeds up the automation testing development with LeanFT, is its object repository functions. Object identification is the most time-consuming aspect of building automation tests. LeanFT offers that out of the box. It helps you identify the objects. After that, once you got the object in place, then it's just about building the test scripts. So it reduces your development time significantly.

The most important thing we learned is that it really fits into the continuous testing model. There are many products out there which promise you continuous testing, but it can't be continuous unless it's with the developer. If it's with a developer you can be much more agile, you can be much more continuous, and have faster and shorter delivery times.

Other than LeanFT, we didn't find any other product delivering that. There are many others, like Tricentis, etc. But all of these are independent tools and independent applications.  Tricentis themselves said that they're supposed to be used by the quality testers and not the developers. Our approach was to have dev testers on the team, not quality testers.

We have eradicated the QA role in our organization. Developers are testers. That's why we call them dev testers. They develop the code and then test it themselves and they are responsible for that. The accountability increases, the code quality increases and you have better productivity.

I would rate this solution 8.5 out of ten.