How to Create Bug-Free Blockchain Apps
While all developers strive for bug-free code, it’s particularly crucial in a blockchain deployment where sensitive data or other confidential info is being exchanged, such as in health care or finance. However, some businesses have learned that lesson the hard way. Cryptocurrency exchange Binance recently revealed a devastating security breach that resulted in a loss of more than $40 million. While this is a large sum, a security breach could be even more costly for businesses that lose private messages, confidential contracts, and more.
Rebuilding (and regaining customer trust) is not where organizations should be spending their time. A better way forward is for company leadership to mandate a blockchain Test Automation strategy from the very beginning.
While most Software Testers are familiar with testing web applications, they may not be sure how to approach blockchain testing. The good news is, some of the same focus areas of web testing apply to blockchain testing, too (functional, performance, and security). However, blockchain involves a greater number of tests, effort, and focus areas, such as infrastructure orchestration, staging, and simulating scenarios in a distributed environment, which requires an even greater level of expertise.
Because of these additions, fixing a bug in a blockchain app requires several extra steps and, as a result, it is more time-consuming and costly than fixing bugs in other apps. For example, to reproduce bugs or verify code, developers should perform these steps multiple times:
- Form a new endpoint.
- Deploy new code to the new endpoint.
- Migrate the current data to the new back-end.
- Suspend the old back-end.
- Update all front ends to the current version.
After that, verifying the bug-fix performed by testers or Continuous Integration (CI) tools will require these steps again. This complexity makes it difficult to release bug-free blockchain applications, yet doing so puts organizations and their customers at risk of financial harm. Due to the high-risk nature of deploying blockchain applications, it’s critical that testing is included in the managerial vision and strategy.
To release blockchain apps with bug-free code, businesses should follow these guidelines:
Integrate Test Automation Into Your Blockchain Testing Strategy
Test Automation can relieve testers from performing thousands of orchestrating tests manually, which is both difficult and inefficient. A good system architecture should be scalable, maintainable and testable, so teams can test components independently along with mocked components. If a test requires a different environment or infrastructure, infrastructure as code (IaC), such as Puppet, Chef, Ansible and AWS is invaluable in setting up appropriate test environments. Another crucial part of the strategy is to provide the infrastructure with declarative definitions and allow developers to implement codes that support Test Automation.
Run Unit and Integration Tests to Cover Both Back-End and Front-End Code
Blockchain applications contain at least a back-end (a set of smart contracts or chain codes running on a blockchain) and a front-end (where users can interact with data stored in the blockchain). Performing unit tests will cover both back-end and front-end code, and, because of its critical role to blockchain apps, its primary focus should be on the chain codes. Integration testing, however, should cover the various types of oracles and front-end applications. Performing additional tests will eliminate any holes that can threaten the back-end by verifying the integration between the UI and chain codes.
Perform Tests in a Local Infrastructure
Though public blockchains (such as Bitcoin or Ethereum) have several test-nets, it’s optimal to perform the tests in a local infrastructure. Local infrastructures are lightweight, faster, and more stable for unit and integration tests. For example, in a Ganache local infrastructure, it’s possible to run more than 1,000 unit tests on 5 Ethereum smart contracts with approximately 3,000 deployments in an hour or less.
Continuously Update Security System Test Suites
Blockchain is a multi-party infrastructure and in some cases, it is a public network. As a result, these applications will be visible to many stakeholders and may even be open-sourced to the world. This level of transparency means that hackers are able to study the programs and plan attacks based on a particular system. Continuously updating security system test suites will ensure applications are protected against all common security vulnerabilities.
Minimize Continuous Testing Pipelines for Each Phase of the Development Process
Layering integration and unit tests in a local infrastructure with continuous updates to the security system test suites creates a Continuous Testing pipeline that is essential to high-quality blockchain code. Continuously verifying code changes in multiple environments, such as local blockchain and test-net, ensures high-quality code is delivered to the production blockchain. These tests, however, can last hours or days for each code change, so it’s important for teams to minimize and create lean pipelines that focus on test stages, test types and test environments, and develop multiple pipelines for code at each phase of the development process.
Build Customized Tests Suites to Eliminate Prospective Cheating Holes
Test teams also need to customize test suites in the pipelines to cover both functional and security testing. Covering security cases is important, but unit test modules should also exercise smart-contract-unit potential security threats, such as overflow and re-entrancy, to eliminate as many prospective cheating holes as possible.
Due to the nature of decentralization and orchestration of underlying infrastructure, developing bug-free code for blockchain applications presents many more challenges than other applications. By taking best practices from traditional Software Testing, especially Test Automation, and customizing them for blockchain development, businesses can achieve bug-free blockchain coding and protect their most vulnerable applications.
Article written by Thong Nguyen.
You can read more here.