Writing Test Cases in Golang
Unit testing is a software testing method where individual components of software are tested. Developers write unit tests for their code to make sure that the code works correctly. This helps to detect and protect against bugs in the future. It also helps in ensuring that the software functions as intended.
Writing new features and building frameworks is pretty exciting for a software developer but we would all concur that we do not appreciate writing unit tests (at least in the initial days as a software developer :D).
This blog will focus on making it easy for you to write unit tests.
Unit Testing in Golang
Unit testing in Go is easy. There is a built-in package for writing unit tests called testing.
Create a file called foo.go
Create a test file by adding _test to the corresponding file.
So our file would be called foo_test.go
This test case will pass only when the function RemoveNonAlphaNumeric removes all the non alpha numeric characters from the string.
If some developer makes changes to the RemoveNonAlphaNumeric function which breaks causes some undesirable alterations to it then the Test Case would fail. In this way, unit test cases prevent bugs from creeping in to production.
Test ≠ Unit Test if :-
It interacts with a database
It performs some form of network communication
It can’t run in parallel with any other unit tests
However we cannot prevent external calls in our code.
So then how do we write unit tests for these functions ?
We use Mocks.
How to perform testing using mocks ?
Let’s understand this using an example.
Consider we are using an external package called database which is defined as follows :-
Now let’s create another package called user that has a dependency on the database package.
Now let’s try to create test cases for it
As you can see that theRegisterUser function makes call to database.AddUserand database.FetchUserID but ideally a unit test case should not make external calls.
This can be fixed using Mocks.
First create an interface for database package call it database_interface.go
Now modify user.go
As you can see that we passed the interface of the database to the RegisterUser function.
We can now do a mock implementation on the interface
In this way, we write test cases for functions that make external calls.
PS :- If you are facing problems in writing mocks, there is a high probability that you haven’t structured the interface properly.
There is a small problem in this approach. Can you find it out ? Let me know in the comments section.
Hint :- It has something to do with UserID
