OpenCBS Testing

Hari Mahesh

OpenCBS, or Open Source Core Banking System, is a free and open-source alternative to proprietary core baking systems. It is developed primarily for microfinance and smaller financial institutions. OpenCBS was introduced in 2013 as a continuation of Octopus Microfinance software.

OpenCBS core functionalities include client management, loan and savings management, financial management customization, reporting and analytics, customizable workflows, cloud-based and on-premises deployment, etc. Additionally, OpenCBS’s extensibility through plugins and its cloud-based solutions, such as digital KYC, field applications, and loan origination systems.

OpenCBS has multiple components written in different languages, depending on the specific part:

• OpenCBS Cloud: This cloud-based version is primarily written in TypeScript, a superset of JavaScript.
• OpenCBS Desktop: This older desktop version is mainly written in C#.
• Loan Origination Solution: This standalone application uses HTML for the user interface and JavaScript for some functionality.

When it comes to testing openCBS, it plays a critical role because of its extensive domain. Banking software must be tested thoroughly and correctly, as any minor issue can affect many customers and their accounts. So, let’s go through the three main areas of testing and review which tools are best suited for each type of testing.

Unit Testing

As the word implies, we test the application as independent units. These can be modules, functions, or parts of the code itself. We isolate the unit from the application and test it. Unit testing is considered the first step of the testing process. Though usually done by developers, now, in many organizations, it is performed by testers as part of continuous testing.

Let’s see how we can perform unit testing in OpenCBS. For OpenCBS Cloud, we can use the following tools:

• Jest
• Mocha

Jest

Jest is a robust and most-used JavaScript testing framework, making it a perfect choice for OpenCBS unit testing. It has many features and plugins offering code coverage, snapshot testing, and mocking. Jest provides a clean and concise syntax, allowing us to write clear and readable tests that focus on the specific functionality of each code unit.

Imagine it like having X-ray vision for our code, spotting any potential bugs before they cause problems. Performing unit testing in OpenCBS Cloud with Jest is straightforward:

• Set up Jest: Install and configure Jest within the OpenCBS Cloud project. This involves specifying the test files and directories and any additional options.
• Write our tests: Create files for each code unit you want to test. Each test describes the expected behavior of a specific function or component. Jest provides various matchers and assertions to help us verify the code’s outputs and side effects.
• Run the tests: Use Jest’s command-line interface or integrate it into the development workflow to run the tests automatically. Jest provides transparent feedback on each test’s outcome, including error messages and code coverage reports.
• Fix and repeat: If any tests fail, fix the identified issues in the code and rerun the tests. This iterative process ensures the OpenCBS Cloud code remains robust and reliable.

Mocha

Mocha is a robust JavaScript testing framework that helps us write clean and practical unit tests for the OpenCBS Cloud code. Imagine it as a meticulous detective scrutinizing each piece of the code for potential bugs. With Mocha, we can:

• Write clear and concise tests: Mocha’s syntax is straightforward, making it easy to describe the expected behavior of the code functions. Think of it as writing detailed instructions for the detective to follow.
• Isolate and test individual units: Mocha lets us focus on testing specific parts of the code, ensuring they work as intended before integrating them into larger systems. It’s like having the detective examine each room in a house separately before declaring it safe.
• Get detailed reports: Mocha provides comprehensive reports highlighting issues after running the tests. This helps us to pinpoint bugs quickly and efficiently.

For OpenCBS desktop application unit testing, we can use the following tools:

• MSTest
• NUnit

MSTest

MSTest, or Microsoft Unit Testing Framework, is a free and open-source unit testing framework designed specifically for the .NET platform. It’s built-in with Visual Studio, making it a popular choice for developers working in that environment. With MSTest, we can write concise tests focusing on individual code units, ensuring they function as expected. It provides assertions to verify outputs, test runners to execute the tests, and code coverage reports to show which parts of our code are tested.

We can use MSTest for unit testing OpenCBS Desktop:

• Deploy the inspectors: Install MSTest and integrate it into our Visual Studio project. This prepares the inspection team with the necessary tools and protocols.
• Craft inspection checklists: Write individual tests for each code unit, specifying the expected behavior under various conditions. Consider these as detailed instructions for each inspector, outlining what each code section should do in different scenarios.
• Conduct the inspection: Run the tests using Visual Studio’s Test Explorer. MSTest will meticulously analyze the code, providing detailed reports on any discrepancies.
• Fix and re-inspect: If the test fails, identify the root cause and fix the failure. Once rectified, rerun the tests to ensure the code meets inspection standards. Remember, even the best inspectors might miss something initially, so re-inspection is crucial.

NUnit

It is a free and open-source unit testing framework designed specifically for the .NET platform, making it a perfect companion for unit testing OpenCBS Desktop. NUnit offers advanced features and flexibility, complementing MSTest to provide a robust testing experience. NUnit is packed with many features like:

• Cross-platform compatibility: Works seamlessly on various .NET platforms (C#, VB.NET, F#), making it adaptable to different development environments within OpenCBS.
• Extensibility: Supports a rich ecosystem of add-ons and extensions, allowing you to tailor NUnit to your specific testing needs within OpenCBS.
• Flexibility: Offers multiple test writing styles (attribute-based, fixture-based) and assertion options, allowing you to choose the approach that best suits your OpenCBS testing workflow.
• Clear reporting: Generates detailed test results with helpful stack traces and error messages, aiding in efficient debugging and pinpointing issues within your OpenCBS code.
• Open-source: Freely available and backed by a large community, providing access to extensive documentation, resources, and support for your OpenCBS testing endeavors.

Integration Testing

Here, we integrate multiple units to check how they perform when integrated. Here, the interaction between the two modules is taken into account. So, testing mainly includes testing interfaces, the flow of data between modules, etc. Integration testing comes right after unit testing.

For integration testing in the OpenCBS application, we can use the following:

• Postman
• Selenium
• Cypress

In the ‘End-to-End Testing’ section, we have discussed about Selenium and Cypress. So, for now, let’s learn more about Postman.

Postman

For integration testing, just like how important it is to test the UI part, API testing holds a similar criticality. As we mentioned about data flow between two modules, API testing is the best thing to validate that. Postman is a popular API (Application Programming Interface) development tool that allows developers to create, share, test, and document APIs. It provides a user-friendly graphical interface for sending requests to APIs, viewing responses, and debugging.

Postman supports various HTTP requests (GET, POST, PUT, DELETE, etc.) and is widely used for testing RESTful APIs. The tool facilitates automated testing with scripting and collection runs, enhancing the efficiency of testing processes. Additionally, Postman offers collaboration features, allowing teams to work together on API development and testing projects.

Here’s how Postman helps you perform integration testing in OpenCBS:

• Building Requests:
  • Define different types of requests like GET, POST, PUT, and DELETE to interact with various OpenCBS APIs.
  • Set up request headers, body parameters, and authentication details based on your API specifications.
  • Organize requests into collections for specific functionalities or modules within OpenCBS.
• Sending Requests and Analyzing Responses:
• Trigger your requests to the OpenCBS APIs and observe the real-time responses.
• Inspect the response body, headers, and status codes to ensure they align with your expectations.
• Use Postman’s built-in testing capabilities to write assertions and verify specific data points in the responses.

End-to-End Testing

E2E testing focuses on testing a software application’s workflow from beginning to end. This approach replicates real user scenarios to ensure the system behaves as intended in a fully integrated environment. E2E testing verifies not only the functionality and performance of the application but also its interaction with external interfaces, databases, networks, and other applications.

For OpenCBS applications, we can perform E2E testing with the below tools:

• Selenium
• Cypress
• testRigor

Selenium

There is no need for any introduction to Selenium, as it is one of the legacy tools used in web automation. Selenium supports programming languages like Java, Python, C#, etc. Moreover, Selenium is open-source and comes with minimal integrations; however, we can integrate many third-party plugins with Selenium. Anyway, we are not going into much detail about building Selenium tests, as there are many tutorials available over the internet; also, you can refer to this blog post.

But there are many reasons for Selenium not being a favorite tool for testers. One of the primary reasons is its code complexity; as the code repository grows, debugging the code in case of failures becomes challenging. Another major drawback is the dependency on DOM element properties; any change in property can lead to false positive bugs, making untrustworthy results. Hence, Selenium isn’t a preferred tool for E2E testing today.

Cypress

It is an open-source test automation tool supporting JavaScript language. Cypress is very easy to use and has a better execution speed. It can also be used for integration and end-to-end testing.

Though widely used, Cypress has many disadvantages, like browser support limitations. Cypress is good with Chrome, even though it supports Firefox and Edge, but it is still not as extensive as Chrome. Also, with Cypress, we won’t be able to test in different domains.

Mobile testing support is not added with Cypress. Therefore, we may have to use Appium or any other framework for mobile testing. Finally, we can say that even though it became popular, Cypress is dead now.

testRigor

The automation tool is pivotal in E2E testing, especially for banking applications. Whether it comes to the browser and device coverage or the test case coverage, the tool must be smart enough.

We mentioned many drawbacks Selenium and Cypress put forward; most codeless automation tools claim they have overcome those limitations. However, if we review those tools, they are not even close enough to what they claim. One tool that stands out in codeless automation testing is testRigor.

testRigor is packed with many features that are crucial for E2E testing. Let’s go through a few of them.

• Never miss any scenario: testRigor helps to create test scripts in parsed plain English, thereby eliminating programming language dependency. This means any business or management vertical stakeholder can quickly create new test cases, increasing the test case coverage.
• Create test data automatically: Using testRigor’s generative AI, we can generate tests or test data based on the requirements or descriptions we provide. So, we no longer need to worry about the tedious test data creation process.
• Test on any browser: Supports web testing on desktop/mobile across 3,000+ browser, device, and OS combinations. For instance, run tests using Internet Explorer on Windows and Safari on Mac and iOS.
• No More False Positive Bugs: testRigor doesn’t rely on flaky XPath or DOM properties; it has its own method of element locators. You just need to mention what text you see on the screen for the element; AI takes care of the rest.
• Integrations: testRigor has inbuilt integration with most market-leading tools in areas like test management, CI/CD, infra management, etc.

open url "https://www.mybank.com"
click "Sign In"
enter stored value "email" into "email"
click "Continue"
enter stored value "password" into "password"
click "Login"
enter "Bills" roughly to the left of "search"
click "Search"
click on image from stored value "Mobile Bill Payment" with less than "10" % discrepancy
click "Pay Now"

Read more about testRigor’s features here.

Conclusion

Due to the critical nature of banking applications, ensuring security and robustness is paramount. This necessitates comprehensive testing, including thorough coverage of edge cases. However, frequent releases driven by updates demand efficient testing tools with minimal manual intervention. By leveraging intelligent automation tools such as testRigor, we can confidently assure our customers of a bug-free experience and instill trust in our banking application.