Testing interaction with proprietary software without a license

Question

First a bit of context:

My company develops a software and middlewares to make our software interacts with other software.

One of a client has a proprietary software we should interact with, he gave us the .h/hpp and the .def file which are needed for the interaction. He has some dlls that are used when our software is started on his computers.

We can not have the software because:

• The software by itself has a really expensive license
• The client has a custom version of the software he can not redistribute
• The IT of the client doesn't want to give us remote access to one of their computer or a virtual machine for safety reason

For the moment when developing the middleware, we write the code, compile it and send it to the client and ask him to tell us if he finds any bug. This really annoys me because we deliver untested software (and this has caused me to deliver the middleware with blatant bug I could not see on my side).

What I have thought of:

We could use the .h/hpp to create a custom dll (this should work thanks to the dynamic linkage) implementing only the method we need and then create a basic custom software to do the tests.

My issue with that are:

• it might take a good amount of time to do it (especially if want to ensure that the software and dll we use for the testing are working correctly)
• I will only test against what I think the software is doing. We have no real documentation, just comments above the functions in the header files. I don't know how functionalities are implemented (and no legal way of reverse engineering the existing software)

Is there any other way to test our software ?

Answer 1

There's not much else that you can do on your own, but you may be able to get additional support from your client. In my experience, software vendors may offer licenses designed to support development. Your client may be able to obtain these licenses, either as part of their existing agreement or at a lower cost than a full production use license and provide them to your team to perform development and testing.

Otherwise, your best option would be to make sure that your client is fully aware of the limitations on what you are capable of doing and the risks with accepting and using your software and middleware. You may be able to build some error detection and handling into your software, but you are limited to building against a document rather than your integration target.

Answer 2

Realistically, what you have described is all you can do.

But there's no need to try to reverse engineer the whole of an application that you don't have access to anyway.

All your functions need to is behave as if they were doing something, and then return some appropriate responses. You could add instrumentation or logging too if it helps your testing.

If your interactions with the external software are complex and multi stage, then maybe implement some kind of state machine in the test software so that it responds appropriately to each step.