What are the differences between testing normal code vs. no-code?
To answer the question precisely, we need to take a look at how software is tested nowadays. It is usually done on different levels.
- Unit testing: Deals with the very basic building blocks of the code
- Integration testing: Deals with testing the communication between the basic building blocks
- End-to-end testing: Deals with testing the application from the perspective of a user. Everything is involved: The user interface, the whole communication flow between UI, business logic, down to the database. However: The tester often just deals with the user interface. That’s why it’s often also referred to as “UI testing”. End-to-end testing can be executed manually by the way.
What are the implications for no-coded software testing?
No-code development tools usually provide some visual interfaces with simple logic or drag-and-drop features. Under the hood those tools generate code, so the developer doesn’t have to deal with the complexity of the programming language.
That also implies that the developer is unaware of the underlying generated source code or doesn’t even have access to it, so testing methods 1 and 2 are not viable.
There is still option number 3. End-to-end testing, will in most cases be the only option you have for testing no-coded software. Testing on fewer levels will result in less control over your software product quality.
Does no-code add more testing effort or does it make it easier?
As outlined above, there are fewer possibilities to test no-coded applications. Does it become easier? Probably not, you could even run into a situation where testing a certain use case becomes really difficult because of the missing access to the underlying code of your application. There might even be use cases that can’t be tested at all.
On a side note, I think the following question could be interesting too:
Does no-coded software require less testing?
That might indeed be the case, depending on the no-code dev tool you use. If the no-code dev tool is generating high-quality code (which has been already tested by the manufacturer of the tool), there might not even be a need for doing unit testing or integration testing after all.
How does the process of resolving bugs compare?
No-code tools usually just let you access the user interface, not the code below or very little of it. This results in fewer possibilities to test the code and therefore less confidence in your product quality. On a side note: It’s quite rare that companies are testing their software on every level and it’s most often impossible to test 100% of the software anyway.
A plus for no-code: Testing no-coded software can be quick if you just have to focus on a single testing method and rely on the generated code’s quality.