This can't be answered in general because it is perfectly possible to write well-designed code without having unit tests. If the code already has those qualities, adding unit tests would not in itself change the quality of the tested code. And design principles like SOLID does not in themselves eliminate bugs (although they might make bugs easier to detect and fix).

It is also problematic to rely on refactoring to support test-ability to improve the quality of the code because any refactoring carries the risk of introducing errors. Indeed, a major purpose of unit tests is to make refactoring safer. So if you refactor before adding tests, you are missing the point of testing.

The correct way to approach legacy code is to add automated tests before refactoring.

The primary benefit of unit tests is to allow safe refactoring without introducing bugs or unexpected changes in behavior. Safe refactoring is crucial to allow a codebase to change and grow while remaining maintainable.

But the process of adding tests to existing code is unlikely to find many bugs because unless you have a very detailed specification you would probably end up assuming the existing behavior is the expected behavior. The benefit comes after the tests have been added and you start refactoring.

It is sometimes argued that making code testable in itself will improve code quality. This is a dubious argument for several reasons:

• It is quite possible to have code following good design principles without having tests. So the argument would imply that adding unit tests to code which is already well-designed would not provide value.
• While testability implies some aspects of code quality there are many aspects which is not affected. So testability is not sufficient as a driver of code quality.
• If making the code testable requires refactoring, those refactorings are likely to introduce bugs which will negate the purported benefit.

If you have low code quality and code not amenable to unit tests, you need a different approach: You should add integration tests or end-to-end tests which verify the behavior of the system before you do any refactoring to support unit tests.